Changeset 900 for trunk


Ignore:
Timestamp:
Oct 24, 2006, 8:49:18 AM (13 years ago)
Author:
bruno
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
Files:
8 added
1 deleted
43 edited
2 moved

Legend:

Unmodified
Added
Removed
  • trunk/mondo-doc/Makefile.man

    r588 r900  
    3838
    3939%.8.ps: %.8
    40     @man2dvi ./$< > $<.dvi
    41     @dvips -q $<.dvi -o $@
    42     @rm -f $<.dvi
     40    @groff -Tps -mandoc ./$< > $@
    4341
    4442%.8.pdf: %.8.ps
  • trunk/mondo/src/common/libmondo-archive.c

    r815 r900  
    99 * This is the main file (at least the longest one) in libmondo.
    1010 */
     11#include <sys/sem.h>
     12#include <sys/types.h>
     13#include <sys/ipc.h>
     14#include <stdarg.h>
     15#include <unistd.h>
    1116
    1217#include "my-stuff.h"
    1318#include "../common/mondostructures.h"
    1419#include "mr_conf.h"
     20#include "mr_mem.h"
     21#include "mr_err.h"
     22
    1523#include "libmondo-string-EXT.h"
    1624#include "libmondo-stream-EXT.h"
     
    2432#include "libmondo-verify-EXT.h"
    2533#include "libmondo-archive.h"
    26 #include <sys/sem.h>
    27 #include <sys/types.h>
    28 #include <sys/ipc.h>
    29 #include <stdarg.h>
    30 #include <unistd.h>
    3134#define DVDRWFORMAT 1
    3235
     
    201204
    202205    if (!does_file_exist(filelist)) {
    203         asprintf(&tmp,
     206        mr_asprintf(&tmp,
    204207                 "(archive_this_fileset) - filelist %s does not exist",
    205208                 filelist);
    206209        log_to_screen(tmp);
    207         paranoid_free(tmp);
     210        mr_free(tmp);
    208211        return (1);
    209212    }
    210213
    211     asprintf(&tmp, "echo hi > %s 2> /dev/null", fname);
     214    mr_asprintf(&tmp, "echo hi > %s 2> /dev/null", fname);
    212215    if (system(tmp)) {
    213216        fatal_error("Unable to write tarball to scratchdir");
    214217    }
    215     paranoid_free(tmp);
    216 
    217     asprintf(&command, "star H=star list=%s -c " STAR_ACL_SZ " file=%s",
     218    mr_free(tmp);
     219
     220    mr_asprintf(&command, "star H=star list=%s -c " STAR_ACL_SZ " file=%s",
    218221             filelist, fname);
    219222    if (bkpinfo->use_lzo) {
     
    221224    }
    222225    if (bkpinfo->compression_level > 0) {
    223         asprintf(&tmp, "%s -bz", command);
    224         paranoid_free(command);
     226        mr_asprintf(&tmp, "%s -bz", command);
     227        mr_free(command);
    225228        command = tmp;
    226229    }
    227     asprintf(&tmp, "%s 2>> %s", command, MONDO_LOGFILE);
    228     paranoid_free(command);
     230    mr_asprintf(&tmp, "%s 2>> %s", command, MONDO_LOGFILE);
     231    mr_free(command);
    229232    command = tmp;
    230233    log_msg(4, "command = '%s'", command);
     
    241244            res = 0;
    242245        }
    243         paranoid_free(tmp);
     246        mr_free(tmp);
    244247        if (res) {
    245248            log_OS_error(command);
     
    256259        }
    257260    }
    258     paranoid_free(command);
     261    mr_free(command);
    259262
    260263    retval += res;
     
    314317
    315318    if (!does_file_exist(filelist)) {
    316         asprintf(&tmp,
     319        mr_asprintf(&tmp,
    317320                 "(archive_this_fileset) - filelist %s does not exist",
    318321                 filelist);
    319322        log_to_screen(tmp);
    320         paranoid_free(tmp)
     323        mr_free(tmp);
    321324            return (1);
    322325    }
    323     asprintf(&tmp, "echo hi > %s 2> /dev/null", fname);
     326    mr_asprintf(&tmp, "echo hi > %s 2> /dev/null", fname);
    324327    if (system(tmp)) {
    325328        fatal_error("Unable to write tarball to scratchdir");
    326329    }
    327     paranoid_free(tmp)
     330    mr_free(tmp);
    328331
    329332
    330333    if (bkpinfo->compression_level > 0) {
    331         asprintf(&tmp, "%s/do-not-compress-these", g_mondo_home);
     334        mr_asprintf(&tmp, "%s/do-not-compress-these", g_mondo_home);
    332335        //       -b %ld, TAPE_BLOCK_SIZE
    333         asprintf(&zipparams, "-Z -P %s -G %d -T 3k", bkpinfo->zip_exe,
     336        mr_asprintf(&zipparams, "-Z -P %s -G %d -T 3k", bkpinfo->zip_exe,
    334337                 bkpinfo->compression_level);
    335338        if (does_file_exist(tmp)) {
    336             asprintf(&tmp1, "%s -E %s", zipparams, tmp);
    337             paranoid_free(zipparams)
     339            mr_asprintf(&tmp1, "%s -E %s", zipparams, tmp);
     340            mr_free(zipparams);
    338341            zipparams = tmp1;
    339342        } else {
    340             asprintf(&zipparams, " ");
     343            mr_asprintf(&zipparams, " ");
    341344            log_msg(3, "%s not found. Cannot exclude zipfiles, etc.", tmp);
    342345        }
    343         paranoid_free(tmp)
     346        mr_free(tmp);
    344347    } else {
    345         asprintf(&zipparams, " ");
     348        mr_asprintf(&zipparams, " ");
    346349    }
    347350
     
    356359        fatal_error("scratchdir not found");
    357360    }
    358     asprintf(&command, "rm -f %s %s. %s.gz %s.%s", fname, fname, fname,
     361    mr_asprintf(&command, "rm -f %s %s. %s.gz %s.%s", fname, fname, fname,
    359362             fname, bkpinfo->zip_suffix);
    360363    paranoid_system(command);
    361     paranoid_free(command);
    362 
    363     asprintf(&command, "afio -o -b %ld -M 16m %s %s < %s 2>> %s",
     364    mr_free(command);
     365
     366    mr_asprintf(&command, "afio -o -b %ld -M 16m %s %s < %s 2>> %s",
    364367             TAPE_BLOCK_SIZE, zipparams, fname, filelist, MONDO_LOGFILE);
    365     paranoid_free(zipparams);
    366 
    367     asprintf(&tmp, "echo hi > %s 2> /dev/null", fname);
     368    mr_free(zipparams);
     369
     370    mr_asprintf(&tmp, "echo hi > %s 2> /dev/null", fname);
    368371    if (system(tmp)) {
    369372        fatal_error("Unable to write tarball to scratchdir");
    370373    }
    371     paranoid_free(tmp);
     374    mr_free(tmp);
    372375
    373376    for (res = 99, tries = 0; tries < 3 && res != 0; tries++) {
     
    382385        }
    383386    }
    384     paranoid_free(command);
     387    mr_free(command);
    385388
    386389    retval += res;
     
    396399                 ("df -m -P | grep dev/shm | grep -v none | tr -s ' ' '\t' | cut -f4");
    397400        i = atoi(tmp);
    398         paranoid_free(tmp);
     401        mr_free(tmp);
    399402
    400403        if (i > 0) {
     
    440443                ("Cannot find dvd+rw-format. Please install it or fix your PATH.");
    441444        }
    442         paranoid_free(tmp);
     445        mr_free(tmp);
    443446#endif
    444447        tmp = find_home_of_exe("growisofs");
     
    447450                ("Cannot find growisofs. Please install it or fix your PATH.");
    448451        }
    449         paranoid_free(tmp);
     452        mr_free(tmp);
    450453    }
    451454
     
    458461
    459462/*
    460       asprintf(&tmp, "wc -l %s/archives/filelist.full > %s/archives/filelist.count",bkpinfo->scratchdir, bkpinfo->scratchdir);
     463      mr_asprintf(&tmp, "wc -l %s/archives/filelist.full > %s/archives/filelist.count",bkpinfo->scratchdir, bkpinfo->scratchdir);
    461464      if (run_program_and_log_output(tmp, 2))
    462465        { fatal_error("Failed to count filelist.full"); }
    463466*/
    464     asprintf(&tmp, "gzip -9 %s/archives/filelist.full",
     467    mr_asprintf(&tmp, "gzip -9 %s/archives/filelist.full",
    465468             bkpinfo->scratchdir);
    466469    if (run_program_and_log_output(tmp, 2)) {
    467470        fatal_error("Failed to gzip filelist.full");
    468471    }
    469     paranoid_free(tmp);
    470     asprintf(&tmp, "cp -f %s/archives/*list*.gz %s", bkpinfo->scratchdir,
     472    mr_free(tmp);
     473    mr_asprintf(&tmp, "cp -f %s/archives/*list*.gz %s", bkpinfo->scratchdir,
    471474             bkpinfo->tmpdir);
    472475    if (run_program_and_log_output(tmp, 2)) {
    473476        fatal_error("Failed to copy to tmpdir");
    474477    }
    475     paranoid_free(tmp);
     478    mr_free(tmp);
    476479
    477480    copy_mondo_and_mindi_stuff_to_scratchdir(bkpinfo);  // payload, too, if it exists
    478481#if __FreeBSD__ == 5
    479     paranoid_alloc(bkpinfo->kernel_path, "/boot/kernel/kernel");
     482    mr_allocstr(bkpinfo->kernel_path, "/boot/kernel/kernel");
    480483#elif __FreeBSD__ == 4
    481     paranoid_alloc(bkpinfo->kernel_path, "/kernel");
     484    mr_allocstr(bkpinfo->kernel_path, "/kernel");
    482485#elif linux
    483486    if (figure_out_kernel_path_interactively_if_necessary
     
    493496    }
    494497    retval += do_that_initial_phase(bkpinfo);   // prepare
    495     asprintf(&tmp, "rm -f %s/images/*.iso", bkpinfo->scratchdir);
     498    mr_asprintf(&tmp, "rm -f %s/images/*.iso", bkpinfo->scratchdir);
    496499    run_program_and_log_output(tmp, 1);
    497     paranoid_free(tmp);
     500    mr_free(tmp);
    498501    retval += make_those_slices_phase(bkpinfo); // backup BIG files
    499502    retval += do_that_final_phase(bkpinfo); // clean up
     
    564567    assert(bkpinfo != NULL);
    565568
    566     asprintf(&tmp,
     569    mr_asprintf(&tmp,
    567570             "echo '%s' | tr -s ' ' '\n' | grep -x '/dev/.*' | tr -s '\n' ' ' | awk '{print $0\"\\n\";}'",
    568571             bkpinfo->exclude_paths);
    569572    devs_to_exclude = call_program_and_get_last_line_of_output(tmp);
    570     paranoid_free(tmp);
    571     asprintf(&tmp, "devs_to_exclude = '%s'", devs_to_exclude);
     573    mr_free(tmp);
     574    mr_asprintf(&tmp, "devs_to_exclude = '%s'", devs_to_exclude);
    572575    log_msg(2, tmp);
    573     paranoid_free(tmp);
     576    mr_free(tmp);
    574577    mvaddstr_and_log_it(g_currentY, 0,
    575578                        "Calling MINDI to create boot+data disks");
    576     asprintf(&tmp, "%s/filelist.full", bkpinfo->tmpdir);
     579    mr_asprintf(&tmp, "%s/filelist.full", bkpinfo->tmpdir);
    577580    if (!does_file_exist(tmp)) {
    578         paranoid_free(tmp);
    579         asprintf(&tmp, "%s/tmpfs/filelist.full", bkpinfo->tmpdir);
     581        mr_free(tmp);
     582        mr_asprintf(&tmp, "%s/tmpfs/filelist.full", bkpinfo->tmpdir);
    580583        if (!does_file_exist(tmp)) {
    581584            fatal_error
     
    584587    }
    585588    lines_in_filelist = count_lines_in_file(tmp);
    586     paranoid_free(tmp);
    587     asprintf(&tmp, "%s/LAST-FILELIST-NUMBER", bkpinfo->tmpdir);
     589    mr_free(tmp);
     590    mr_asprintf(&tmp, "%s/LAST-FILELIST-NUMBER", bkpinfo->tmpdir);
    588591    last_filelist_number = last_line_of_file(tmp);
    589     paranoid_free(tmp);
     592    mr_free(tmp);
    590593    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
    591         asprintf(&tape_size_sz, "%ld", bkpinfo->media_size[1]);
    592         asprintf(&tape_device, bkpinfo->media_device);
     594        mr_asprintf(&tape_size_sz, "%ld", bkpinfo->media_size[1]);
     595        mr_asprintf(&tape_device, bkpinfo->media_device);
    593596    } else {
    594         asprintf(&tape_size_sz, " ");
    595         asprintf(&tape_device, " ");
     597        mr_asprintf(&tape_size_sz, " ");
     598        mr_asprintf(&tape_device, " ");
    596599    }
    597600    if (bkpinfo->use_lzo) {
    598         asprintf(&use_lzo_sz, "yes");
     601        mr_asprintf(&use_lzo_sz, "yes");
    599602    } else {
    600         asprintf(&use_lzo_sz, "no");
     603        mr_asprintf(&use_lzo_sz, "no");
    601604    }
    602605    if (bkpinfo->use_star) {
    603         asprintf(&use_star_sz, "yes");
     606        mr_asprintf(&use_star_sz, "yes");
    604607    } else {
    605         asprintf(&use_star_sz, "no");
     608        mr_asprintf(&use_star_sz, "no");
    606609    }
    607610
    608611    if (bkpinfo->compression_level > 0) {
    609         asprintf(&use_comp_sz, "yes");
     612        mr_asprintf(&use_comp_sz, "yes");
    610613    } else {
    611         asprintf(&use_comp_sz, "no");
    612     }
    613 
    614     asprintf(&broken_bios_sz, "yes");   /* assume so */
     614        mr_asprintf(&use_comp_sz, "no");
     615    }
     616
     617    mr_asprintf(&broken_bios_sz, "yes");    /* assume so */
    615618    if (g_cd_recovery) {
    616         asprintf(&cd_recovery_sz, "yes");
     619        mr_asprintf(&cd_recovery_sz, "yes");
    617620    } else {
    618         asprintf(&cd_recovery_sz, "no");
     621        mr_asprintf(&cd_recovery_sz, "no");
    619622    }
    620623    /* Field shared between LILO/ELILO */
    621624    if (bkpinfo->make_cd_use_lilo) {
    622         asprintf(&use_lilo_sz, "yes");
     625        mr_asprintf(&use_lilo_sz, "yes");
    623626    } else {
    624         asprintf(&use_lilo_sz, "no");
     627        mr_asprintf(&use_lilo_sz, "no");
    625628    }
    626629
     
    644647        }
    645648        if ((bootdev) && (strstr(bootdev, "/dev/cciss/"))) {
    646             paranoid_free(bootdev);
     649            mr_free(bootdev);
    647650            bootdev = call_program_and_get_last_line_of_output
    648651                     ("mount | grep ' /boot ' | head -1 | cut -d' ' -f1 | cut -dp -f1");
     
    655658
    656659        if (bkpinfo->boot_loader != '\0') {
    657             asprintf(&tmp, "User specified boot loader. It is '%c'.",
     660            mr_asprintf(&tmp, "User specified boot loader. It is '%c'.",
    658661                     bkpinfo->boot_loader);
    659662            log_msg(2, tmp);
    660             paranoid_free(tmp);
     663            mr_free(tmp);
    661664        } else {
    662665            bkpinfo->boot_loader = ch;
    663666        }
    664667        if (bkpinfo->boot_device != NULL) {
    665             asprintf(&tmp, "User specified boot device. It is '%s'.",
     668            mr_asprintf(&tmp, "User specified boot device. It is '%s'.",
    666669                     bkpinfo->boot_device);
    667670            log_msg(2, tmp);
    668             paranoid_free(tmp);
    669             paranoid_free(bootdev);
     671            mr_free(tmp);
     672            mr_free(bootdev);
    670673        } else {
    671674            bkpinfo->boot_device = bootdev;
     
    687690    }
    688691    if (bkpinfo->boot_loader == 'L') {
    689         asprintf(&bootldr_str, "LILO");
     692        mr_asprintf(&bootldr_str, "LILO");
    690693        if (!does_file_exist("/etc/lilo.conf")) {
    691694            fatal_error
     
    693696        }
    694697    } else if (bkpinfo->boot_loader == 'G') {
    695         asprintf(&bootldr_str, "GRUB");
     698        mr_asprintf(&bootldr_str, "GRUB");
    696699        if (!does_file_exist("/etc/grub.conf")
    697700            && does_file_exist("/boot/grub/grub.conf")) {
     
    710713        }
    711714    } else if (bkpinfo->boot_loader == 'E') {
    712         asprintf(&bootldr_str, "ELILO");
     715        mr_asprintf(&bootldr_str, "ELILO");
    713716        /* BERLIOS: fix it for SuSE, Debian, Mandrake, ... */
    714717        if (!does_file_exist("/etc/elilo.conf")
     
    723726        }
    724727    } else if (bkpinfo->boot_loader == 'R') {
    725         asprintf(&bootldr_str, "RAW");
     728        mr_asprintf(&bootldr_str, "RAW");
    726729    }
    727730#ifdef __FreeBSD__
    728731    else if (bkpinfo->boot_loader == 'D') {
    729         asprintf(&bootldr_str, "DD");
     732        mr_asprintf(&bootldr_str, "DD");
    730733    }
    731734
    732735    else if (bkpinfo->boot_loader == 'B') {
    733         asprintf(&bootldr_str, "BOOT0");
     736        mr_asprintf(&bootldr_str, "BOOT0");
    734737    }
    735738#endif
    736739    else {
    737         asprintf(&bootldr_str, "unknown");
    738     }
    739     asprintf(&tmp, "Your boot loader is %s and it boots from %s",
     740        mr_asprintf(&bootldr_str, "unknown");
     741    }
     742    mr_asprintf(&tmp, "Your boot loader is %s and it boots from %s",
    740743             bootldr_str, bkpinfo->boot_device);
    741744    log_to_screen(tmp);
    742     paranoid_free(tmp);
    743     asprintf(&tmp, "%s/BOOTLOADER.DEVICE", bkpinfo->tmpdir);
     745    mr_free(tmp);
     746    mr_asprintf(&tmp, "%s/BOOTLOADER.DEVICE", bkpinfo->tmpdir);
    744747    if (write_one_liner_data_file(tmp, bkpinfo->boot_device)) {
    745748        log_msg(1, "%ld: Unable to write one-liner boot device", __LINE__);
    746749    }
    747     paranoid_free(tmp);
     750    mr_free(tmp);
    748751    /* BERLIOS: Use bkptype_to_string without LANG */
    749752    switch (bkpinfo->backup_media_type) {
    750753    case cdr:
    751         asprintf(&value, "cdr");
     754        mr_asprintf(&value, "cdr");
    752755        break;
    753756    case cdrw:
    754         asprintf(&value, "cdrw");
     757        mr_asprintf(&value, "cdrw");
    755758        break;
    756759    case cdstream:
    757         asprintf(&value, "cdstream");
     760        mr_asprintf(&value, "cdstream");
    758761        break;
    759762    case tape:
    760         asprintf(&value, "tape");
     763        mr_asprintf(&value, "tape");
    761764        break;
    762765    case udev:
    763         asprintf(&value, "udev");
     766        mr_asprintf(&value, "udev");
    764767        break;
    765768    case iso:
    766         asprintf(&value, "iso");
     769        mr_asprintf(&value, "iso");
    767770        break;
    768771    case nfs:
    769         asprintf(&value, "nfs");
     772        mr_asprintf(&value, "nfs");
    770773        break;
    771774    case dvd:
    772         asprintf(&value, "dvd");
     775        mr_asprintf(&value, "dvd");
    773776        break;
    774777    default:
    775778        fatal_error("Unknown backup_media_type");
    776779    }
    777     asprintf(&tmp, "%s/BACKUP-MEDIA-TYPE", bkpinfo->tmpdir);
     780    mr_asprintf(&tmp, "%s/BACKUP-MEDIA-TYPE", bkpinfo->tmpdir);
    778781    if (write_one_liner_data_file(tmp, value)) {
    779782        res++;
     
    781784                __LINE__);
    782785    }
    783     paranoid_free(value);
    784     paranoid_free(tmp);
     786    mr_free(value);
     787    mr_free(tmp);
    785788    log_to_screen(bkpinfo->tmpdir);
    786     asprintf(&tmp, "%s/BOOTLOADER.NAME", bkpinfo->tmpdir);
     789    mr_asprintf(&tmp, "%s/BOOTLOADER.NAME", bkpinfo->tmpdir);
    787790    if (write_one_liner_data_file(tmp, bootldr_str)) {
    788791        res++;
     
    790793                __LINE__);
    791794    }
    792     paranoid_free(bootldr_str);
    793     paranoid_free(tmp);
    794     asprintf(&tmp, "%s/DIFFERENTIAL", bkpinfo->tmpdir);
     795    mr_free(bootldr_str);
     796    mr_free(tmp);
     797    mr_asprintf(&tmp, "%s/DIFFERENTIAL", bkpinfo->tmpdir);
    795798    if (bkpinfo->differential) {
    796799        res += write_one_liner_data_file(tmp, "1");
     
    798801        res += write_one_liner_data_file(tmp, "0");
    799802    }
    800     paranoid_free(tmp);
     803    mr_free(tmp);
    801804
    802805    estimated_total_noof_slices =
    803806        size_of_all_biggiefiles_K(bkpinfo) / bkpinfo->optimal_set_size + 1;
    804     asprintf(&command, "mkdir -p %s/images", bkpinfo->scratchdir);
     807    mr_asprintf(&command, "mkdir -p %s/images", bkpinfo->scratchdir);
    805808    if (system(command)) {
    806809        res++;
    807810        log_OS_error("Unable to make images directory");
    808811    }
    809     paranoid_free(command);
    810 
    811     asprintf(&command, "mkdir -p %s%s", bkpinfo->scratchdir, MNT_FLOPPY);
     812    mr_free(command);
     813
     814    mr_asprintf(&command, "mkdir -p %s%s", bkpinfo->scratchdir, MNT_FLOPPY);
    812815    if (system(command)) {
    813816        res++;
    814817        log_OS_error("Unable to make mnt floppy directory");
    815818    }
    816     paranoid_free(command);
    817 
    818     asprintf(&tmp, "BTW, I'm telling Mindi your kernel is '%s'",
     819    mr_free(command);
     820
     821    mr_asprintf(&tmp, "BTW, I'm telling Mindi your kernel is '%s'",
    819822             bkpinfo->kernel_path);
    820823    log_to_screen(tmp);
    821     paranoid_free(tmp);
     824    mr_free(tmp);
    822825
    823826    log_msg(1, "lines_in_filelist = %ld", lines_in_filelist);
     
    825828    // Watch it! This next line adds a parameter...
    826829    if (bkpinfo->nonbootable_backup) {
    827         asprintf(&tmp, " NONBOOTABLE");
     830        mr_asprintf(&tmp, " NONBOOTABLE");
    828831    } else {
    829         asprintf(&tmp, " ");
    830     }
    831 
    832     asprintf(&command,
     832        mr_asprintf(&tmp, " ");
     833    }
     834
     835    mr_asprintf(&command,
    833836/*     "mindi --custom 2=%s 3=%s/images 4=\"%s\" 5=\"%s\" \
    8348376=\"%s\" 7=%ld 8=\"%s\" 9=\"%s\" 10=\"%s\" \
     
    855858             bkpinfo->differential, // parameter #19 (INT)
    856859             tmp);
    857     paranoid_free(tmp);
    858     paranoid_free(tape_size_sz);
    859     paranoid_free(use_lzo_sz);
    860     paranoid_free(tape_device);
    861     paranoid_free(use_star_sz);
    862     paranoid_free(use_comp_sz);
    863     paranoid_free(broken_bios_sz);
    864     paranoid_free(cd_recovery_sz);
    865     paranoid_free(last_filelist_number);
    866     paranoid_free(devs_to_exclude);
    867     paranoid_free(use_lilo_sz);
     860    mr_free(tmp);
     861    mr_free(tape_size_sz);
     862    mr_free(use_lzo_sz);
     863    mr_free(tape_device);
     864    mr_free(use_star_sz);
     865    mr_free(use_comp_sz);
     866    mr_free(broken_bios_sz);
     867    mr_free(cd_recovery_sz);
     868    mr_free(last_filelist_number);
     869    mr_free(devs_to_exclude);
     870    mr_free(use_lilo_sz);
    868871
    869872    log_msg(2, command);
     
    872875    res = run_program_and_log_to_screen(command,
    873876                                        "Generating boot+data disks");
    874     paranoid_free(command);
     877    mr_free(command);
    875878
    876879    if (bkpinfo->nonbootable_backup) {
     
    879882    if (!res) {
    880883        log_to_screen("Boot+data disks were created OK");
    881         asprintf(&command, "mkdir -p /var/cache/mindi/");
     884        mr_asprintf(&command, "mkdir -p /var/cache/mindi/");
    882885        log_msg(2, command);
    883886        run_program_and_log_output(command, FALSE);
    884         paranoid_free(command);
    885 
    886         asprintf(&command,
     887        mr_free(command);
     888
     889        mr_asprintf(&command,
    887890                 "cp -f %s/images/mindi.iso /var/cache/mindi/mondorescue.iso",
    888891                 bkpinfo->scratchdir);
    889892        log_msg(2, command);
    890893        run_program_and_log_output(command, FALSE);
    891         paranoid_free(command);
     894        mr_free(command);
    892895
    893896        if (bkpinfo->nonbootable_backup) {
    894             asprintf(&command, "cp -f %s/all.tar.gz %s/images",
     897            mr_asprintf(&command, "cp -f %s/all.tar.gz %s/images",
    895898                     bkpinfo->tmpdir, bkpinfo->scratchdir);
    896899            if (system(command)) {
    897900                fatal_error("Unable to create temporary duff tarball");
    898                 paranoid_free(command);
    899             }
    900         }
    901         asprintf(&command, "cp -f %s/mindi-*oot*.img %s/images",
     901                mr_free(command);
     902            }
     903        }
     904        mr_asprintf(&command, "cp -f %s/mindi-*oot*.img %s/images",
    902905                 bkpinfo->tmpdir, bkpinfo->scratchdir);
    903906        log_msg(2, command);
    904907        run_program_and_log_output(command, FALSE);
    905         paranoid_free(command);
    906 
    907         asprintf(&tmp, "cp -f %s/images/all.tar.gz %s",
     908        mr_free(command);
     909
     910        mr_asprintf(&tmp, "cp -f %s/images/all.tar.gz %s",
    908911                 bkpinfo->scratchdir, bkpinfo->tmpdir);
    909912        if (system(tmp)) {
    910913            fatal_error("Cannot find all.tar.gz in tmpdir");
    911914        }
    912         paranoid_free(tmp);
     915        mr_free(tmp);
    913916
    914917        if (res) {
     
    919922    } else {
    920923        log_to_screen("Mindi failed to create your boot+data disks.");
    921         asprintf(&command, "grep 'Fatal error' /var/log/mindi.log");
     924        mr_asprintf(&command, "grep 'Fatal error' /var/log/mindi.log");
    922925        tmp = call_program_and_get_last_line_of_output(command);
    923         paranoid_free(command);
     926        mr_free(command);
    924927        if (strlen(tmp) > 1) {
    925928            popup_and_OK(tmp);
    926929        }
    927         paranoid_free(tmp);
     930        mr_free(tmp);
    928931    }
    929932    return (res);
     
    990993    bkpinfo = (struct s_bkpinfo *) (inbuf + BKPINFO_LOC_OFFSET);
    991994
    992     asprintf(&archiving_filelist_fname, FILELIST_FNAME_RAW_SZ,
     995    mr_asprintf(&archiving_filelist_fname, FILELIST_FNAME_RAW_SZ,
    993996             bkpinfo->tmpdir, 0L);
    994997    archiving_set_no = 0;
    995998    while (does_file_exist(archiving_filelist_fname)) {
    996         paranoid_free(archiving_filelist_fname);
     999        mr_free(archiving_filelist_fname);
    9971000        if (g_exiting) {
    9981001            fatal_error("Execution run aborted (pthread)");
     
    10151018
    10161019        /* backup this set of files */
    1017         asprintf(&archiving_afioball_fname, AFIOBALL_FNAME_RAW_SZ,
     1020        mr_asprintf(&archiving_afioball_fname, AFIOBALL_FNAME_RAW_SZ,
    10181021                 bkpinfo->tmpdir, archiving_set_no, bkpinfo->zip_suffix);
    1019         asprintf(&archiving_filelist_fname, FILELIST_FNAME_RAW_SZ,
     1022        mr_asprintf(&archiving_filelist_fname, FILELIST_FNAME_RAW_SZ,
    10201023                 bkpinfo->tmpdir, archiving_set_no);
    10211024        if (!does_file_exist(archiving_filelist_fname)) {
     
    10241027                    FORTY_SPACES, getpid(), this_thread_no,
    10251028                    archiving_set_no);
    1026             paranoid_free(archiving_filelist_fname);
    1027             paranoid_free(archiving_afioball_fname);
     1029            mr_free(archiving_filelist_fname);
     1030            mr_free(archiving_afioball_fname);
    10281031            break;
    10291032        }
    10301033
    1031         asprintf(&tmp, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir,
     1034        mr_asprintf(&tmp, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir,
    10321035                 archiving_set_no - ARCH_BUFFER_NUM, bkpinfo->zip_suffix);
    10331036        if (does_file_exist(tmp)) {
     
    10391042            log_msg(4, "[%d] - continuing", getpid());
    10401043        }
    1041         paranoid_free(tmp);
     1044        mr_free(tmp);
    10421045
    10431046        log_msg(4, "%s[%d:%d] - EXATing %d...", FORTY_SPACES, getpid(),
    10441047                this_thread_no, archiving_set_no);
    1045         asprintf(&curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
     1048        mr_asprintf(&curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
    10461049                 bkpinfo->tmpdir, archiving_set_no);
    1047         asprintf(&curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ,
     1050        mr_asprintf(&curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ,
    10481051                 bkpinfo->tmpdir, archiving_set_no);
    10491052        get_fattr_list(archiving_filelist_fname, curr_xattr_list_fname);
    1050         paranoid_free(curr_xattr_list_fname);
     1053        mr_free(curr_xattr_list_fname);
    10511054        get_acl_list(archiving_filelist_fname, curr_acl_list_fname);
    1052         paranoid_free(curr_acl_list_fname);
     1055        mr_free(curr_acl_list_fname);
    10531056
    10541057        log_msg(4, "%s[%d:%d] - archiving %d...", FORTY_SPACES, getpid(),
     
    10571060                                   archiving_afioball_fname,
    10581061                                   archiving_set_no);
    1059         paranoid_free(archiving_afioball_fname);
    1060         paranoid_free(archiving_filelist_fname);
     1062        mr_free(archiving_afioball_fname);
     1063        mr_free(archiving_filelist_fname);
    10611064        retval += res;
    10621065
    10631066        if (res) {
    1064             asprintf(&tmp,
     1067            mr_asprintf(&tmp,
    10651068                     "Errors occurred while archiving set %ld. Please review logs.",
    10661069                     archiving_set_no);
    10671070            log_to_screen(tmp);
    1068             paranoid_free(tmp);
     1071            mr_free(tmp);
    10691072        }
    10701073        if (!semaphore_p()) {
     
    10841087                this_thread_no, archiving_set_no);
    10851088        archiving_set_no++;
    1086         asprintf(&archiving_filelist_fname, FILELIST_FNAME_RAW_SZ,
     1089        mr_asprintf(&archiving_filelist_fname, FILELIST_FNAME_RAW_SZ,
    10871090                 bkpinfo->tmpdir, archiving_set_no);
    10881091    }
     
    10961099    log_msg(3, "%s[%d:%d] - exiting", FORTY_SPACES, getpid(),
    10971100            this_thread_no);
    1098     paranoid_free(archiving_filelist_fname);
     1101    mr_free(archiving_filelist_fname);
    10991102    pthread_exit(NULL);
    11001103}
     
    11781181
    11791182    assert(bkpinfo != NULL);
    1180     asprintf(&data_disks_file, "%s/all.tar.gz", bkpinfo->tmpdir);
     1183    mr_asprintf(&data_disks_file, "%s/all.tar.gz", bkpinfo->tmpdir);
    11811184
    11821185    g_serial_string = call_program_and_get_last_line_of_output("dd \
    11831186if=/dev/urandom bs=16 count=1 2> /dev/null | \
    11841187hexdump | tr -s ' ' '0' | head -n1");
    1185     asprintf(&tmp, "%s...word.", g_serial_string);
    1186     paranoid_free(g_serial_string);
     1188    mr_asprintf(&tmp, "%s...word.", g_serial_string);
     1189    mr_free(g_serial_string);
    11871190    g_serial_string = tmp;
    11881191    log_msg(2, "g_serial_string = '%s'", g_serial_string);
    11891192
    1190     asprintf(&tmpfile, "%s/archives/SERIAL-STRING", bkpinfo->scratchdir);
     1193    mr_asprintf(&tmpfile, "%s/archives/SERIAL-STRING", bkpinfo->scratchdir);
    11911194    if (write_one_liner_data_file(tmpfile, g_serial_string)) {
    11921195        log_msg(1, "%ld: Failed to write serial string", __LINE__);
    11931196    }
    1194     paranoid_free(g_serial_string);
    1195     paranoid_free(tmpfile);
     1197    mr_free(g_serial_string);
     1198    mr_free(tmpfile);
    11961199
    11971200    mvaddstr_and_log_it(g_currentY, 0, "Preparing to archive your data");
     
    12101213        log_msg(1, "Backing up to CD's");
    12111214    }
    1212     paranoid_free(data_disks_file);
    1213 
    1214     asprintf(&command, "rm -f %s/%s/%s-[1-9]*.iso", bkpinfo->isodir,
     1215    mr_free(data_disks_file);
     1216
     1217    mr_asprintf(&command, "rm -f %s/%s/%s-[1-9]*.iso", bkpinfo->isodir,
    12151218             bkpinfo->nfs_remote_dir, bkpinfo->prefix);
    12161219    paranoid_system(command);
    1217     paranoid_free(command);
     1220    mr_free(command);
    12181221    wipe_archives(bkpinfo->scratchdir);
    12191222    mvaddstr_and_log_it(g_currentY++, 74, "Done.");
     
    12741277/* if not Debian then go ahead & use fdformat */
    12751278    tempfile = call_program_and_get_last_line_of_output("mktemp -q /tmp/mondo.XXXXXXXX");
    1276     asprintf(&command, "%s >> %s 2>> %s; rm -f %s", cmd, tempfile,
     1279    mr_asprintf(&command, "%s >> %s 2>> %s; rm -f %s", cmd, tempfile,
    12771280             tempfile, tempfile);
    12781281    log_msg(3, command);
     
    12871290        maxtracks = 80;
    12881291    }
    1289     paranoid_free(command);
     1292    mr_free(command);
    12901293
    12911294    for (sleep(1); does_file_exist(tempfile); sleep(1)) {
     
    13091312    }
    13101313    unlink(tempfile);
    1311     paranoid_free(tempfile);
     1314    mr_free(tempfile);
    13121315    return (res);
    13131316}
     
    13381341    assert_string_is_neither_NULL_nor_zerolength(device);
    13391342    if (!system("which superformat > /dev/null 2> /dev/null")) {
    1340         asprintf(&command, "superformat %s", device);
     1343        mr_asprintf(&command, "superformat %s", device);
    13411344    } else {
    13421345#ifdef __FreeBSD__
    1343         asprintf(&command, "fdformat -y %s", device);
     1346        mr_asprintf(&command, "fdformat -y %s", device);
    13441347#else
    1345         asprintf(&command, "fdformat %s", device);
     1348        mr_asprintf(&command, "fdformat %s", device);
    13461349#endif
    13471350    }
    1348     asprintf(&title, "Formatting disk %s", device);
     1351    mr_asprintf(&title, "Formatting disk %s", device);
    13491352    while ((res = format_disk_SUB(command, title))) {
    13501353        if (!ask_me_yes_or_no("Failed to format disk. Retry?")) {
     
    13521355        }
    13531356    }
    1354     paranoid_free(title);
    1355     paranoid_free(command);
     1357    mr_free(title);
     1358    mr_free(command);
    13561359    return (res);
    13571360}
     
    15021505            /* maybe  */
    15031506            tmp = percent_media_full_comment(bkpinfo);
    1504             asprintf(&media_usage_comment, "%s", tmp);
    1505             paranoid_free(tmp);
     1507            mr_asprintf(&media_usage_comment, "%s", tmp);
     1508            mr_free(tmp);
    15061509            if (!misc_counter_that_is_not_important) {
    15071510                update_progress_form(media_usage_comment);
    15081511            }
    1509             paranoid_free(media_usage_comment);
     1512            mr_free(media_usage_comment);
    15101513            sleep(1);
    15111514        } else {
    15121515            // store set N
    1513             asprintf(&storing_filelist_fname, FILELIST_FNAME_RAW_SZ,
     1516            mr_asprintf(&storing_filelist_fname, FILELIST_FNAME_RAW_SZ,
    15141517                     bkpinfo->tmpdir, storing_set_no);
    1515             asprintf(&storing_afioball_fname, AFIOBALL_FNAME_RAW_SZ,
     1518            mr_asprintf(&storing_afioball_fname, AFIOBALL_FNAME_RAW_SZ,
    15161519                     bkpinfo->tmpdir, storing_set_no, bkpinfo->zip_suffix);
    1517             asprintf(&curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
     1520            mr_asprintf(&curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
    15181521                     bkpinfo->tmpdir, storing_set_no);
    1519             asprintf(&curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ,
     1522            mr_asprintf(&curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ,
    15201523                     bkpinfo->tmpdir, storing_set_no);
    15211524
     
    15291532            }
    15301533            tmp = percent_media_full_comment(bkpinfo);
    1531             asprintf(&media_usage_comment, "%s", tmp);
    1532             paranoid_free(tmp);
     1534            mr_asprintf(&media_usage_comment, "%s", tmp);
     1535            mr_free(tmp);
    15331536            /* copy to CD (scratchdir) ... and an actual CD-R if necessary */
    15341537            if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
     
    15521555                                     storing_afioball_fname, NULL);
    15531556            }
    1554             paranoid_free(storing_filelist_fname);
    1555             paranoid_free(storing_afioball_fname);
    1556             paranoid_free(curr_xattr_list_fname);
    1557             paranoid_free(curr_acl_list_fname);
     1557            mr_free(storing_filelist_fname);
     1558            mr_free(storing_afioball_fname);
     1559            mr_free(curr_xattr_list_fname);
     1560            mr_free(curr_acl_list_fname);
    15581561            retval += res;
    15591562            g_current_progress++;
    15601563            update_progress_form(media_usage_comment);
    1561             paranoid_free(media_usage_comment);
     1564            mr_free(media_usage_comment);
    15621565
    15631566            if (res) {
    1564                 asprintf(&tmp,
     1567                mr_asprintf(&tmp,
    15651568                         "Failed to add archive %ld's files to CD dir\n",
    15661569                         storing_set_no);
    15671570                log_to_screen(tmp);
    1568                 paranoid_free(tmp);
     1571                mr_free(tmp);
    15691572                fatal_error
    15701573                    ("Is your hard disk full? If not, please send the author the logfile.");
     
    15841587    log_msg(2, "Done.");
    15851588    if (retval) {
    1586         asprintf(&tmp,
     1589        mr_asprintf(&tmp,
    15871590                 "Your regular files have been archived (with errors).");
    15881591    } else {
    1589         asprintf(&tmp,
     1592        mr_asprintf(&tmp,
    15901593                 "Your regular files have been archived successfully");
    15911594    }
    15921595    log_to_screen(tmp);
    1593     paranoid_free(tmp);
    1594     paranoid_free(transfer_block);
    1595     paranoid_free(result_str);
     1596    mr_free(tmp);
     1597    mr_free(transfer_block);
     1598    mr_free(result_str);
    15961599    return (retval);
    15971600}
     
    16471650    assert_string_is_neither_NULL_nor_zerolength(destfile);
    16481651
    1649     asprintf(&tmp, "%s/isolinux.bin", bkpinfo->scratchdir);
    1650     asprintf(&tmp2, "%s/isolinux.bin", bkpinfo->tmpdir);
     1652    mr_asprintf(&tmp, "%s/isolinux.bin", bkpinfo->scratchdir);
     1653    mr_asprintf(&tmp2, "%s/isolinux.bin", bkpinfo->tmpdir);
    16511654    if (does_file_exist(tmp)) {
    1652         asprintf(&tmp3, "cp -f %s %s", tmp, tmp2);
     1655        mr_asprintf(&tmp3, "cp -f %s %s", tmp, tmp2);
    16531656        paranoid_system(tmp3);
    1654         paranoid_free(tmp3);
     1657        mr_free(tmp3);
    16551658    }
    16561659    if (!does_file_exist(tmp) && does_file_exist(tmp2)) {
    1657         asprintf(&tmp3, "cp -f %s %s", tmp2, tmp);
     1660        mr_asprintf(&tmp3, "cp -f %s %s", tmp2, tmp);
    16581661        paranoid_system(tmp3);
    1659         paranoid_free(tmp3);
    1660     }
    1661     paranoid_free(tmp2);
    1662     paranoid_free(tmp);
     1662        mr_free(tmp3);
     1663    }
     1664    mr_free(tmp2);
     1665    mr_free(tmp);
    16631666
    16641667    if (bkpinfo->backup_media_type == iso && bkpinfo->manual_cd_tray) {
     
    16701673    /* BERLIOS: Do not ignore getcwd result */
    16711674    (void) getcwd(old_pwd, MAX_STR_LEN - 1);
    1672     asprintf(&tmp, "chmod 755 %s", bkpinfo->scratchdir);
     1675    mr_asprintf(&tmp, "chmod 755 %s", bkpinfo->scratchdir);
    16731676    run_program_and_log_output(tmp, FALSE);
    1674     paranoid_free(tmp);
     1677    mr_free(tmp);
    16751678    chdir(bkpinfo->scratchdir);
    16761679
    16771680    if (bkpinfo->call_before_iso != NULL) {
    1678         asprintf(&message_to_screen, "Running pre-ISO call for CD#%d",
     1681        mr_asprintf(&message_to_screen, "Running pre-ISO call for CD#%d",
    16791682                 g_current_media_number);
    16801683        res = eval_call_to_make_ISO(bkpinfo, bkpinfo->call_before_iso,
     
    16861689            log_to_screen("%s...OK", message_to_screen);
    16871690        }
    1688         paranoid_free(message_to_screen);
     1691        mr_free(message_to_screen);
    16891692        retval += res;
    16901693    }
     
    16921695    if (bkpinfo->call_make_iso != NULL) {
    16931696        log_msg(2, "bkpinfo->call_make_iso = %s", bkpinfo->call_make_iso);
    1694         asprintf(&tmp, "%s/archives/NOT-THE-LAST", bkpinfo->scratchdir);
    1695         asprintf(&message_to_screen, "Making an ISO (%s #%d)",
     1697        mr_asprintf(&tmp, "%s/archives/NOT-THE-LAST", bkpinfo->scratchdir);
     1698        mr_asprintf(&message_to_screen, "Making an ISO (%s #%d)",
    16961699                 bkpinfo->backup_media_string,
    16971700                 g_current_media_number);
     
    17201723            retval += res;
    17211724#ifdef DVDRWFORMAT
    1722             asprintf(&tmp,
     1725            mr_asprintf(&tmp,
    17231726                     "tail -n8 %s | grep 'blank=full.*dvd-compat.*DAO'",
    17241727                     MONDO_LOGFILE);
     
    17381741                }
    17391742                pause_for_N_seconds(5, "Letting DVD drive settle");
    1740                 asprintf(&sz_blank_disk, "dvd+rw-format %s",
     1743                mr_asprintf(&sz_blank_disk, "dvd+rw-format %s",
    17411744                         bkpinfo->media_device);
    17421745                log_msg(3, "sz_blank_disk = '%s'", sz_blank_disk);
     
    17571760                        ("Format succeeded. Sleeping for 5 seconds to take a breath...");
    17581761                }
    1759                 paranoid_free(sz_blank_disk);
     1762                mr_free(sz_blank_disk);
    17601763                pause_for_N_seconds(5, "Letting DVD drive settle");
    17611764                if (!bkpinfo->please_dont_eject) {
     
    17831786                }
    17841787            }
    1785             paranoid_free(tmp);
     1788            mr_free(tmp);
    17861789#endif
    17871790            if (g_backup_media_type == dvd && !bkpinfo->please_dont_eject) {
     
    17891792            }
    17901793        }
    1791         paranoid_free(message_to_screen);
     1794        mr_free(message_to_screen);
    17921795    } else {
    1793         asprintf(&message_to_screen, "Running mkisofs to make %s #%d",
     1796        mr_asprintf(&message_to_screen, "Running mkisofs to make %s #%d",
    17941797                 bkpinfo->backup_media_string,
    17951798                 g_current_media_number);
    17961799        log_msg(1, message_to_screen);
    1797         asprintf(&result_sz, "Call to mkisofs to make ISO (%s #%d) ",
     1800        mr_asprintf(&result_sz, "Call to mkisofs to make ISO (%s #%d) ",
    17981801                 bkpinfo->backup_media_string,
    17991802                 g_current_media_number);
     
    18211824#ifdef __IA64__
    18221825                log_msg(1, "IA64 --> elilo");
    1823                 asprintf(&tmp2,"mkisofs -no-emul-boot -b images/mindi-bootroot.%s.img -c boot.cat -o _ISO_ -J -r -p MondoRescue -publisher www.mondorescue.org -A Mondo_Rescue_GPL -V _CD#_ .", bkpinfo->mrconf->mindi_ia64_boot_size);
     1826                mr_asprintf(&tmp2,"mkisofs -no-emul-boot -b images/mindi-bootroot.%s.img -c boot.cat -o _ISO_ -J -r -p MondoRescue -publisher www.mondorescue.org -A Mondo_Rescue_GPL -V _CD#_ .", bkpinfo->mrconf->mindi_ia64_boot_size);
    18241827                res = eval_call_to_make_ISO(bkpinfo,
    18251828                                            tmp2,
     
    18311834// FIXME --- change mkisofs string to MONDO_MKISOFS_REGULAR_SYSLINUX/LILO depending on bkpinfo->make_cd_usE_lilo
    18321835// and add ' .' at end
    1833                 paranoid_free(tmp2);
     1836                mr_free(tmp2);
    18341837                log_msg(1, "Non-ia64 --> lilo");
    18351838                res = eval_call_to_make_ISO(bkpinfo,
     
    18571860        }
    18581861        retval += res;
    1859         paranoid_free(message_to_screen);
    1860         paranoid_free(result_sz);
     1862        mr_free(message_to_screen);
     1863        mr_free(result_sz);
    18611864    }
    18621865
     
    18671870                    "Warning - %s mounted. I'm unmounting it before I burn to it.",
    18681871                    bkpinfo->media_device);
    1869             asprintf(&tmp, "umount %s", bkpinfo->media_device);
     1872            mr_asprintf(&tmp, "umount %s", bkpinfo->media_device);
    18701873            run_program_and_log_output(tmp, FALSE);
    1871             paranoid_free(tmp);
     1874            mr_free(tmp);
    18721875        }
    18731876    }
     
    18751878    if (bkpinfo->call_burn_iso != NULL) {
    18761879        log_msg(2, "bkpinfo->call_burn_iso = %s", bkpinfo->call_burn_iso);
    1877         asprintf(&message_to_screen, "Burning %s #%d",
     1880        mr_asprintf(&message_to_screen, "Burning %s #%d",
    18781881                 bkpinfo->backup_media_string,
    18791882                 g_current_media_number);
     
    18871890            log_to_screen("%s...OK", message_to_screen);
    18881891        }
    1889         paranoid_free(message_to_screen);
     1892        mr_free(message_to_screen);
    18901893        retval += res;
    18911894    }
    18921895
    18931896    if (bkpinfo->call_after_iso != NULL) {
    1894         asprintf(&message_to_screen, "Running post-ISO call (%s #%d)",
     1897        mr_asprintf(&message_to_screen, "Running post-ISO call (%s #%d)",
    18951898                 bkpinfo->backup_media_string,
    18961899                 g_current_media_number);
     
    19031906            log_to_screen("%s...OK", message_to_screen);
    19041907        }
    1905         paranoid_free(message_to_screen);
     1908        mr_free(message_to_screen);
    19061909        retval += res;
    19071910    }
     
    19111914        log_msg(1, "WARNING - make_iso_fs returned an error");
    19121915    }
    1913     paranoid_free(old_pwd);
     1916    mr_free(old_pwd);
    19141917    return (retval);
    19151918}
     
    19211924    char *command;
    19221925    bool ret = TRUE;
    1923     asprintf(&command,
     1926    mr_asprintf(&command,
    19241927             "dd if=%s bs=512 count=1 2> /dev/null | strings | head -n1",
    19251928             bigfile_fname);
     
    19271930    tmp = call_program_and_get_last_line_of_output(command);
    19281931    log_msg(1, "--> tmp = '%s'", tmp);
    1929     paranoid_free(command);
     1932    mr_free(command);
    19301933    if (strstr(tmp, "NTFS")) {
    19311934        iamhere("TRUE");
     
    19341937        ret = FALSE;
    19351938    }
    1936     paranoid_free(tmp);
     1939    mr_free(tmp);
    19371940    return(ret);
    19381941}
     
    19972000        return (0);
    19982001    }
    1999     asprintf(&tmp, "I am now backing up all large files.");
     2002    mr_asprintf(&tmp, "I am now backing up all large files.");
    20002003    log_to_screen(tmp);
    20012004    noof_biggie_files = count_lines_in_file(biggielist_fname);
     
    20032006                       "Please wait. This may take some time.", "",
    20042007                       estimated_total_noof_slices);
    2005     paranoid_free(tmp);
     2008    mr_free(tmp);
    20062009
    20072010    if (!(fin = fopen(biggielist_fname, "r"))) {
     
    20092012        return (1);
    20102013    }
    2011     for (getline(&bigfile_fname, &n, fin); !feof(fin);
    2012          getline(&bigfile_fname, &n, fin), biggie_file_number++) {
     2014    for (mr_getline(&bigfile_fname, &n, fin); !feof(fin);
     2015         mr_getline(&bigfile_fname, &n, fin), biggie_file_number++) {
    20132016        use_ntfsprog = FALSE;
    20142017        if (bigfile_fname[strlen(bigfile_fname) - 1] < 32) {
     
    20212024            ftmp = fopen(bigfile_fname, "w");
    20222025            paranoid_fclose(ftmp);
    2023             asprintf(&tmp, "bigfile %s was deleted - creating a dummy",
     2026            mr_asprintf(&tmp, "bigfile %s was deleted - creating a dummy",
    20242027                     bigfile_fname);
    20252028            delete_when_done = TRUE;
     
    20352038                        "Calling ntfsclone in background because %s is an NTFS partition",
    20362039                        bigfile_fname);
    2037                 asprintf(&sz_devfile, "%s/%d.%d.000",
     2040                mr_asprintf(&sz_devfile, "%s/%d.%d.000",
    20382041                        bkpinfo->tmpdir,
    20392042                         (int) (random() % 32768),
     
    20562059                            (long int) (pid));
    20572060
    2058                     paranoid_free(sz_devfile);
     2061                    mr_free(sz_devfile);
    20592062                }
    20602063            }
     
    20812084                tmp = calc_checksum_of_file(bigfile_fname);
    20822085                write_header_block_to_stream((off_t)0, tmp, BLK_STOP_A_BIGGIE);
    2083                 paranoid_free(tmp);
     2086                mr_free(tmp);
    20842087            }
    20852088            retval += res;
     
    20912094            }
    20922095            if (res) {
    2093                 asprintf(&tmp, "Archiving %s ... Failed!", bigfile_fname);
     2096                mr_asprintf(&tmp, "Archiving %s ... Failed!", bigfile_fname);
    20942097            } else {
    2095                 asprintf(&tmp, "Archiving %s ... OK!", bigfile_fname);
     2098                mr_asprintf(&tmp, "Archiving %s ... OK!", bigfile_fname);
    20962099            }
    20972100
     
    21082111#endif
    21092112    }
    2110     paranoid_free(tmp);
    2111     paranoid_free(bigfile_fname);
     2113    mr_free(tmp);
     2114    mr_free(bigfile_fname);
    21122115    paranoid_fclose(fin);
    21132116
     
    21412144
    21422145    /* BERLIOS: Useless ?
    2143        asprintf(&tmp, "%s/archives/filelist.full", bkpinfo->scratchdir);
     2146       mr_asprintf(&tmp, "%s/archives/filelist.full", bkpinfo->scratchdir);
    21442147     */
    21452148
     
    21522155                       get_last_filelist_number(bkpinfo) + 1);
    21532156
    2154     asprintf(&curr_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir,
     2157    mr_asprintf(&curr_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir,
    21552158             0L);
    21562159
     
    21582161    while (does_file_exist(curr_filelist_fname)) {
    21592162        /* backup this set of files */
    2160         asprintf(&curr_afioball_fname, AFIOBALL_FNAME_RAW_SZ,
     2163        mr_asprintf(&curr_afioball_fname, AFIOBALL_FNAME_RAW_SZ,
    21612164                 bkpinfo->tmpdir, curr_set_no, bkpinfo->zip_suffix);
    21622165
    21632166        log_msg(1, "EXAT'g set %ld", curr_set_no);
    2164         asprintf(&curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
     2167        mr_asprintf(&curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
    21652168                 bkpinfo->tmpdir, curr_set_no);
    2166         asprintf(&curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ,
     2169        mr_asprintf(&curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ,
    21672170                 bkpinfo->tmpdir, curr_set_no);
    21682171        get_fattr_list(curr_filelist_fname, curr_xattr_list_fname);
     
    21742177        retval += res;
    21752178        if (res) {
    2176             asprintf(&tmp,
     2179            mr_asprintf(&tmp,
    21772180                     "Errors occurred while archiving set %ld. Perhaps your live filesystem changed?",
    21782181                     curr_set_no);
    21792182            log_to_screen(tmp);
    2180             paranoid_free(tmp);
     2183            mr_free(tmp);
    21812184        }
    21822185
    21832186        tmp = percent_media_full_comment(bkpinfo);
    2184         asprintf(&media_usage_comment, "%s", tmp);
    2185         paranoid_free(tmp);
     2187        mr_asprintf(&media_usage_comment, "%s", tmp);
     2188        mr_free(tmp);
    21862189
    21872190        /* copy to CD (scratchdir) ... and an actual CD-R if necessary */
     
    22062209        g_current_progress++;
    22072210        update_progress_form(media_usage_comment);
    2208         paranoid_free(media_usage_comment);
     2211        mr_free(media_usage_comment);
    22092212
    22102213        if (res) {
    2211             asprintf(&tmp, "Failed to add archive %ld's files to CD dir\n",
     2214            mr_asprintf(&tmp, "Failed to add archive %ld's files to CD dir\n",
    22122215                     curr_set_no);
    22132216            log_to_screen(tmp);
    2214             paranoid_free(tmp);
     2217            mr_free(tmp);
    22152218            fatal_error
    22162219                ("Is your hard disk is full? If not, please send the author the logfile.");
    22172220        }
    2218         paranoid_free(curr_filelist_fname);
    2219         paranoid_free(curr_afioball_fname);
    2220         paranoid_free(curr_xattr_list_fname);
    2221         paranoid_free(curr_acl_list_fname);
    2222         asprintf(&curr_filelist_fname, FILELIST_FNAME_RAW_SZ,
     2221        mr_free(curr_filelist_fname);
     2222        mr_free(curr_afioball_fname);
     2223        mr_free(curr_xattr_list_fname);
     2224        mr_free(curr_acl_list_fname);
     2225        mr_asprintf(&curr_filelist_fname, FILELIST_FNAME_RAW_SZ,
    22232226                 bkpinfo->tmpdir, ++curr_set_no);
    22242227    }
    2225     paranoid_free(curr_filelist_fname);
     2228    mr_free(curr_filelist_fname);
    22262229    close_progress_form();
    22272230    if (retval) {
     
    23102313    mvaddstr_and_log_it(g_currentY, 0,
    23112314                        "Archiving large files to media           ");
    2312     asprintf(&biggielist, "%s/archives/biggielist.txt",
     2315    mr_asprintf(&biggielist, "%s/archives/biggielist.txt",
    23132316             bkpinfo->scratchdir);
    2314     asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
    2315     asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
    2316 
    2317     asprintf(&command, "cp %s/biggielist.txt %s", bkpinfo->tmpdir,
     2317    mr_asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
     2318    mr_asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
     2319
     2320    mr_asprintf(&command, "cp %s/biggielist.txt %s", bkpinfo->tmpdir,
    23182321             biggielist);
    23192322    paranoid_system(command);
    2320     paranoid_free(command);
    2321 
    2322     asprintf(&blah, "biggielist = %s", biggielist);
     2323    mr_free(command);
     2324
     2325    mr_asprintf(&blah, "biggielist = %s", biggielist);
    23232326    log_msg(2, blah);
    2324     paranoid_free(blah);
     2327    mr_free(blah);
    23252328
    23262329    if (!does_file_exist(biggielist)) {
     
    23302333    get_fattr_list(biggielist, xattr_fname);
    23312334    get_acl_list(biggielist, acl_fname);
    2332     asprintf(&command, "cp %s %s/archives/", xattr_fname,
     2335    mr_asprintf(&command, "cp %s %s/archives/", xattr_fname,
    23332336             bkpinfo->scratchdir);
    23342337    paranoid_system(command);
    2335     paranoid_free(command);
    2336 
    2337     asprintf(&command, "cp %s %s/archives/", acl_fname,
     2338    mr_free(command);
     2339
     2340    mr_asprintf(&command, "cp %s %s/archives/", acl_fname,
    23382341             bkpinfo->scratchdir);
    23392342    paranoid_system(command);
    2340     paranoid_free(command);
     2343    mr_free(command);
    23412344
    23422345    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
    23432346        res += write_EXAT_files_to_tape(bkpinfo, xattr_fname, acl_fname);
    2344         asprintf(&blah, "%ld", count_lines_in_file(biggielist));
     2347        mr_asprintf(&blah, "%ld", count_lines_in_file(biggielist));
    23452348        write_header_block_to_stream((off_t)0, blah, BLK_START_BIGGIEFILES);
    2346         paranoid_free(blah);
    2347     }
    2348     paranoid_free(xattr_fname);
    2349     paranoid_free(acl_fname);
     2349        mr_free(blah);
     2350    }
     2351    mr_free(xattr_fname);
     2352    mr_free(acl_fname);
    23502353
    23512354    res = make_slices_and_images(bkpinfo, biggielist);
    2352     paranoid_free(biggielist);
     2355    mr_free(biggielist);
    23532356
    23542357    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
     
    24182421            continue;
    24192422        }
    2420         asprintf(&curr_file, "%s", cf);
     2423        mr_asprintf(&curr_file, "%s", cf);
    24212424        if (!does_file_exist(curr_file)) {
    24222425            log_msg(1,
     
    24272430            would_occupy += length_of_file(curr_file) / 1024;
    24282431        }
    2429         paranoid_free(curr_file);
     2432        mr_free(curr_file);
    24302433    }
    24312434    va_end(ap);
     
    24482451            continue;
    24492452        }
    2450         asprintf(&curr_file, "%s", cf);
    2451 
    2452         asprintf(&tmp, "mv -f %s %s/archives/", curr_file,
     2453        mr_asprintf(&curr_file, "%s", cf);
     2454
     2455        mr_asprintf(&tmp, "mv -f %s %s/archives/", curr_file,
    24532456                 bkpinfo->scratchdir);
    24542457        res = run_program_and_log_output(tmp, 5);
     
    24592462            log_msg(8, "Moved %s to CD OK", tmp);
    24602463        }
    2461         paranoid_free(tmp);
    2462         paranoid_free(curr_file);
     2464        mr_free(tmp);
     2465        mr_free(curr_file);
    24632466        //      unlink (curr_file);
    24642467    }
     
    25182521        system("/usr/sbin/fdcontrol -F 1722 /dev/fd0.1722");
    25192522#endif
    2520         asprintf(&bootdisk_dev, "%s", DEFAULT_1722MB_DISK);
     2523        mr_asprintf(&bootdisk_dev, "%s", DEFAULT_1722MB_DISK);
    25212524    } else if (does_device_exist(BACKUP_1722MB_DISK)) {
    2522         asprintf(&bootdisk_dev, "/dev/fd0H1722");
     2525        mr_asprintf(&bootdisk_dev, "/dev/fd0H1722");
    25232526    } else {
    25242527        log_msg(1, "Warning - can't find a 1.72MB floppy device *sigh*");
    2525         asprintf(&bootdisk_dev, DEFAULT_1722MB_DISK);
    2526     }
    2527     asprintf(&datadisk_dev, "%s", "/dev/fd0");
     2528        mr_asprintf(&bootdisk_dev, DEFAULT_1722MB_DISK);
     2529    }
     2530    mr_asprintf(&datadisk_dev, "%s", "/dev/fd0");
    25282531    if (!does_device_exist(datadisk_dev)) {
    25292532        log_msg(1, "Warning - can't find a 1.44MB floppy device *sigh*");
    2530         paranoid_free(datadisk_dev);
    2531         asprintf(&datadisk_dev, "%s", "/dev/fd0");
     2533        mr_free(datadisk_dev);
     2534        mr_asprintf(&datadisk_dev, "%s", "/dev/fd0");
    25322535    }
    25332536    format_first = ask_me_yes_or_no
     
    25382541        log_to_screen("Writing boot floppy");
    25392542#ifdef __FreeBSD__
    2540         asprintf(&tmp, "%s/mindi-kern.1722.img", imagesdir);
     2543        mr_asprintf(&tmp, "%s/mindi-kern.1722.img", imagesdir);
    25412544        if (format_first) {
    25422545            format_disk(bootdisk_dev);
    25432546        }
    25442547        res += write_image_to_floppy(bootdisk_dev, tmp);
    2545         paranoid_free(tmp);
     2548        mr_free(tmp);
    25462549
    25472550        if (ask_me_OK_or_cancel("About to write 1.44MB mfsroot disk")) {
     
    25502553                format_disk(datadisk_dev);
    25512554            }
    2552             asprintf(&tmp, "%s/mindi-mfsroot.1440.img", imagesdir);
     2555            mr_asprintf(&tmp, "%s/mindi-mfsroot.1440.img", imagesdir);
    25532556            write_image_to_floppy(datadisk_dev, tmp);
    2554             paranoid_free(tmp);
     2557            mr_free(tmp);
    25552558        }
    25562559#else
    2557         asprintf(&bootdisk_file, "%s/mindi-bootroot.1722.img", imagesdir);
     2560        mr_asprintf(&bootdisk_file, "%s/mindi-bootroot.1722.img", imagesdir);
    25582561        if (does_file_exist(bootdisk_file)) {
    25592562            if (format_first) {
     
    25622565            res += write_image_to_floppy(bootdisk_dev, bootdisk_file);
    25632566        } else {
    2564             paranoid_free(bootdisk_file);
    2565             asprintf(&bootdisk_file, "%s/mindi-boot.1440.img", imagesdir);
    2566             asprintf(&rootdisk_file, "%s/mindi-root.1440.img", imagesdir);
     2567            mr_free(bootdisk_file);
     2568            mr_asprintf(&bootdisk_file, "%s/mindi-boot.1440.img", imagesdir);
     2569            mr_asprintf(&rootdisk_file, "%s/mindi-root.1440.img", imagesdir);
    25672570            root_disk_exists = TRUE;
    25682571            if (!does_file_exist(rootdisk_file)
     
    25722575                log_to_screen
    25732576                    ("Failed to find boot/root floppy images. Oh dear.");
    2574                 paranoid_free(bootdisk_file);
    2575                 paranoid_free(rootdisk_file);
    2576                 paranoid_free(bootdisk_dev);
     2577                mr_free(bootdisk_file);
     2578                mr_free(rootdisk_file);
     2579                mr_free(bootdisk_dev);
    25772580                return (1);
    25782581            }
     
    25862589                    format_disk(datadisk_dev);
    25872590                }
    2588                 asprintf(&tmp, "cat %s > %s", rootdisk_file, datadisk_dev);
     2591                mr_asprintf(&tmp, "cat %s > %s", rootdisk_file, datadisk_dev);
    25892592                log_msg(1, "tmp = '%s'", tmp);
    25902593                res +=
     
    25922595                    ("Writing root floppy", tmp);
    25932596//              res += write_image_to_floppy (datadisk_dev, rootdisk_file);
    2594                 paranoid_free(tmp);
    2595             }
    2596             paranoid_free(rootdisk_file);
    2597             paranoid_free(bootdisk_file);
     2597                mr_free(tmp);
     2598            }
     2599            mr_free(rootdisk_file);
     2600            mr_free(bootdisk_file);
    25982601        }
    25992602#endif
    26002603    }
    2601     paranoid_free(bootdisk_dev);
     2604    mr_free(bootdisk_dev);
    26022605
    26032606    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
     
    26072610    }
    26082611    for (i = 1; i < 99; i++) {
    2609         asprintf(&tmp, "%s/mindi-data-%d.img", imagesdir, i);
     2612        mr_asprintf(&tmp, "%s/mindi-data-%d.img", imagesdir, i);
    26102613        log_msg(3, tmp);
    26112614        if (!does_file_exist(tmp)) {
     
    26132616            break;
    26142617        }
    2615         asprintf(&comment, "About to write data disk #%d", i);
     2618        mr_asprintf(&comment, "About to write data disk #%d", i);
    26162619        if (ask_me_OK_or_cancel(comment)) {
    2617             paranoid_free(comment);
    2618             asprintf(&comment, "Writing data disk #%3d", i);
     2620            mr_free(comment);
     2621            mr_asprintf(&comment, "Writing data disk #%3d", i);
    26192622            log_to_screen(comment);
    2620             paranoid_free(comment);
     2623            mr_free(comment);
    26212624            if (format_first) {
    26222625                res += format_disk(datadisk_dev);
     
    26252628        }
    26262629    }
    2627     paranoid_free(tmp);
    2628     paranoid_free(datadisk_dev);
     2630    mr_free(tmp);
     2631    mr_free(datadisk_dev);
    26292632    return (res);
    26302633}
     
    27292732            continue;
    27302733        }
    2731         asprintf(&curr_file, "%s", cf);
     2734        mr_asprintf(&curr_file, "%s", cf);
    27322735        if (!does_file_exist(curr_file)) {
    27332736            log_msg(1,
     
    27522755        retval += res;
    27532756        unlink(curr_file);
    2754         paranoid_free(curr_file);
     2757        mr_free(curr_file);
    27552758        /* write closing header */
    27562759        write_header_block_to_stream((off_t)0, "finished-writing-file", stop_chr);
     
    27862789    if ((cdrw_device = find_cdrw_device()) != NULL) {
    27872790        if (!system("which cdrecord > /dev/null 2> /dev/null")) {
    2788             asprintf(&cdrecord, "cdrecord dev=%s -atip", cdrw_device);
     2791            mr_asprintf(&cdrecord, "cdrecord dev=%s -atip", cdrw_device);
    27892792        } else if (!system("which dvdrecord > /dev/null 2> /dev/null")) {
    2790             asprintf(&cdrecord, "cdrecord dev=%s -atip", cdrw_device);
     2793            mr_asprintf(&cdrecord, "cdrecord dev=%s -atip", cdrw_device);
    27912794        } else {
    2792             asprintf(&cdrecord, " ");
     2795            mr_asprintf(&cdrecord, " ");
    27932796            log_msg(2, "Found no cdrecord nor dvdrecord in path.");
    27942797        }
     
    27972800                run_program_and_log_output(cdrecord, 5);
    27982801        }
    2799         paranoid_free(cdrecord);
     2802        mr_free(cdrecord);
    28002803    }
    28012804    return(cdrw_device);
     
    28272830    char *szunmount;
    28282831
    2829     asprintf(&szmsg, "I am about to burn %s #%d",
     2832    mr_asprintf(&szmsg, "I am about to burn %s #%d",
    28302833             g_backup_media_string,
    28312834             g_current_media_number);
    28322835    log_to_screen(szmsg);
    2833     paranoid_free(szmsg);
     2836    mr_free(szmsg);
    28342837    if (g_current_media_number < ask_for_one_if_more_than_this) {
    28352838        return;
    28362839    }
    28372840    log_to_screen("Scanning CD-ROM drive...");
    2838     asprintf(&mtpt, "/tmp/cd.mtpt.%ld.%ld", (long int) random(),
     2841    mr_asprintf(&mtpt, "/tmp/cd.mtpt.%ld.%ld", (long int) random(),
    28392842             (long int) random());
    28402843    make_hole_for_dir(mtpt);
     
    28482851      retract_CD_tray_and_defeat_autorun();
    28492852*/
    2850         asprintf(&tmp, "umount %s", cdrom_dev);
     2853        mr_asprintf(&tmp, "umount %s", cdrom_dev);
    28512854        run_program_and_log_output(tmp, 1);
    2852         paranoid_free(tmp);
    2853         asprintf(&szcdno, "%s/archives/THIS-CD-NUMBER", mtpt);
    2854         asprintf(&szserfname, "%s/archives/SERIAL-STRING", mtpt);
    2855         asprintf(&szunmount, "umount %s", mtpt);
     2855        mr_free(tmp);
     2856        mr_asprintf(&szcdno, "%s/archives/THIS-CD-NUMBER", mtpt);
     2857        mr_asprintf(&szserfname, "%s/archives/SERIAL-STRING", mtpt);
     2858        mr_asprintf(&szunmount, "umount %s", mtpt);
    28562859        cd_number = -1;
    2857         asprintf(&tmp, "mount %s %s", cdrom_dev, mtpt);
     2860        mr_asprintf(&tmp, "mount %s %s", cdrom_dev, mtpt);
    28582861        if ((attempt_to_mount_returned_this =
    28592862             run_program_and_log_output(tmp, 1))) {
    28602863            log_msg(4, "Failed to mount %s at %s", cdrom_dev, mtpt);
    28612864            log_to_screen("If there's a CD/DVD in the drive, it's blank.");
    2862             asprintf(&our_serial_str, "%s", "");
     2865            mr_asprintf(&our_serial_str, "%s", "");
    28632866        } else if (!does_file_exist(szcdno)
    28642867                   || !does_file_exist(szserfname)) {
     
    28662869                ("%s has data on it but it's probably not a Mondo CD.",
    28672870                 g_backup_media_string);
    2868             asprintf(&our_serial_str, "%s", "");
     2871            mr_asprintf(&our_serial_str, "%s", "");
    28692872        } else {
    28702873            log_to_screen("%s found in drive. It's a Mondo disk.",
     
    28722875            tmp1 = last_line_of_file(szcdno);
    28732876            cd_number = atoi(tmp1);
    2874             paranoid_free(tmp1);
    2875             asprintf(&tmp1, "cat %s 2> /dev/null", szserfname);
     2877            mr_free(tmp1);
     2878            mr_asprintf(&tmp1, "cat %s 2> /dev/null", szserfname);
    28762879            our_serial_str = call_program_and_get_last_line_of_output(tmp1);
    2877             paranoid_free(tmp1);
     2880            mr_free(tmp1);
    28782881            // FIXME - should be able to use last_line_of_file(), surely?
    28792882        }
    2880         paranoid_free(szcdno);
    2881         paranoid_free(szserfname);
    2882         paranoid_free(tmp);
     2883        mr_free(szcdno);
     2884        mr_free(szserfname);
     2885        mr_free(tmp);
    28832886
    28842887        run_program_and_log_output(szunmount, 1);
    2885         paranoid_free(szunmount);
     2888        mr_free(szunmount);
    28862889
    28872890        log_msg(2, "paafcd: cd_number = %d", cd_number);
     
    29042907            log_to_screen("...but not part of _our_ backup set.");
    29052908        }
    2906         paranoid_free(our_serial_str);
     2909        mr_free(our_serial_str);
    29072910    } else {
    29082911        log_msg(2,
     
    29142917                          g_backup_media_string);
    29152918        }
    2916         paranoid_free(cdrw_device);
    2917     }
    2918     paranoid_free(mtpt);
     2919        mr_free(cdrw_device);
     2920    }
     2921    mr_free(mtpt);
    29192922
    29202923    if (!ok_go_ahead_burn_it) {
    29212924        eject_device(cdrom_dev);
    2922         asprintf(&tmp,
     2925        mr_asprintf(&tmp,
    29232926                 "I am about to burn %s #%d of the backup set. Please insert %s and press Enter.",
    29242927                 g_backup_media_string,
     
    29262929                 g_backup_media_string);
    29272930        popup_and_OK(tmp);
    2928         paranoid_free(tmp);
     2931        mr_free(tmp);
    29292932        goto gotos_make_me_puke;
    29302933    } else {
    29312934        log_msg(2, "paafcd: OK, going ahead and burning it.");
    29322935    }
    2933     paranoid_free(cdrom_dev);
     2936    mr_free(cdrom_dev);
    29342937
    29352938    log_msg(2,
     
    30483051    if (is_this_file_compressed(biggie_filename)
    30493052        || bkpinfo->compression_level == 0) {
    3050         asprintf(&suffix, "%s", "");
     3053        mr_asprintf(&suffix, "%s", "");
    30513054        //      log_it("%s is indeed compressed :-)", filename);
    30523055        should_I_compress_slices = FALSE;
    30533056    } else {
    3054         asprintf(&suffix, "%s", bkpinfo->zip_suffix);
     3057        mr_asprintf(&suffix, "%s", bkpinfo->zip_suffix);
    30553058        should_I_compress_slices = TRUE;
    30563059    }
     
    30613064    if (ntfsprog_fifo) {
    30623065        file_to_openin = ntfsprog_fifo;
    3063         asprintf(&checksum_line, "IGNORE");
     3066        mr_asprintf(&checksum_line, "IGNORE");
    30643067        log_msg(2,
    30653068                "Not calculating checksum for %s: it would take too long",
     
    30693072            fatal_error("ntfsresize not found");
    30703073        }
    3071         paranoid_free(tmp);
    3072 
    3073         asprintf(&command, "ntfsresize --force --info %s|grep '^You might resize at '|cut -d' ' -f5", biggie_filename);
     3074        mr_free(tmp);
     3075
     3076        mr_asprintf(&command, "ntfsresize --force --info %s|grep '^You might resize at '|cut -d' ' -f5", biggie_filename);
    30743077        log_it("command = %s", command);
    30753078        tmp = call_program_and_get_last_line_of_output(command);
    3076         paranoid_free(command);
     3079        mr_free(command);
    30773080
    30783081        log_it("res of it = %s", tmp);
    30793082        totallength = (off_t)atoll(tmp);
    3080         paranoid_free(tmp);
     3083        mr_free(tmp);
    30813084    } else {
    30823085        file_to_openin = biggie_filename;
    30833086        if (strchr(biggie_filename,'\'') != NULL) {
    3084             asprintf(&command, "md5sum \"%s\"", biggie_filename);
     3087            mr_asprintf(&command, "md5sum \"%s\"", biggie_filename);
    30853088        } else {
    3086             asprintf(&command, "md5sum '%s'", biggie_filename);
     3089            mr_asprintf(&command, "md5sum '%s'", biggie_filename);
    30873090        }
    30883091        if (!(fin = popen(command, "r"))) {
    30893092            log_OS_error("Unable to popen-in command");
    3090             paranoid_free(command);
     3093            mr_free(command);
    30913094            return (1);
    30923095        }
    3093         paranoid_free(command);
    3094         (void) getline(&checksum_line, &n, fin);
     3096        mr_free(command);
     3097        mr_getline(&checksum_line, &n, fin);
    30953098        pclose(fin);
    30963099        totallength = length_of_file (biggie_filename);
     
    31143117        fatal_error("checksum_line too big");
    31153118    }
    3116     paranoid_free(checksum_line);
     3119    mr_free(checksum_line);
    31173120
    31183121    tmp = slice_fname(biggie_file_number, 0, bkpinfo->tmpdir, "");
    31193122    fout = fopen(tmp, "w");
    3120     paranoid_free(tmp);
     3123    mr_free(tmp);
    31213124    (void) fwrite((void *) &biggiestruct, 1, sizeof(biggiestruct), fout);
    31223125    paranoid_fclose(fout);
     
    31263129    if (!(fin = fopen(file_to_openin, "r"))) {
    31273130        log_OS_error("Unable to openin biggie_filename");
    3128         asprintf(&tmp, "Cannot archive bigfile '%s': not found",
     3131        mr_asprintf(&tmp, "Cannot archive bigfile '%s': not found",
    31293132                 biggie_filename);
    31303133        log_to_screen(tmp);
    3131         paranoid_free(tmp);
    3132 
    3133         paranoid_free(suffix);
     3134        mr_free(tmp);
     3135
     3136        mr_free(suffix);
    31343137        return (1);
    31353138    }
     
    31403143        res = move_files_to_cd(bkpinfo, tmp, NULL);
    31413144    }
    3142     paranoid_free(tmp);
     3145    mr_free(tmp);
    31433146    i = bkpinfo->optimal_set_size / 256;
    31443147    for (slice_num = 1; !finished; slice_num++) {
     
    31483151        tmp = percent_media_full_comment(bkpinfo);
    31493152        update_progress_form(tmp);
    3150         paranoid_free(tmp);
     3153        mr_free(tmp);
    31513154
    31523155        if (!(fout = fopen(curr_slice_fname_uncompressed, "w"))) {
    31533156            log_OS_error(curr_slice_fname_uncompressed);
    31543157
    3155             paranoid_free(curr_slice_fname_uncompressed);
    3156             paranoid_free(curr_slice_fname_compressed);
    3157             paranoid_free(suffix);
     3158            mr_free(curr_slice_fname_uncompressed);
     3159            mr_free(curr_slice_fname_compressed);
     3160            mr_free(suffix);
    31583161            return (1);
    31593162        }
     
    31753178            i = 0;
    31763179        }
    3177         paranoid_free(tempblock);
     3180        mr_free(tempblock);
    31783181        paranoid_fclose(fout);
    31793182        if (i > 0)              // length_of_file (curr_slice_fname_uncompressed)
     
    31853188            }
    31863189            if (should_I_compress_slices && bkpinfo->compression_level > 0) {
    3187                 asprintf(&command, "%s -%d %s", bkpinfo->zip_exe,
     3190                mr_asprintf(&command, "%s -%d %s", bkpinfo->zip_exe,
    31883191                         bkpinfo->compression_level,
    31893192                         curr_slice_fname_uncompressed);
     
    31953198            } else {
    31963199                /* BERLIOS: Useless
    3197                    asprintf(&command, "mv %s %s 2>> %s",
     3200                   mr_asprintf(&command, "mv %s %s 2>> %s",
    31983201                   curr_slice_fname_uncompressed,
    31993202                   curr_slice_fname_compressed, MONDO_LOGFILE);
     
    32123215            }
    32133216            if (res) {
    3214                 asprintf(&tmp, "Problem with slice # %ld", slice_num);
     3217                mr_asprintf(&tmp, "Problem with slice # %ld", slice_num);
    32153218            } else {
    3216                 asprintf(&tmp,
     3219                mr_asprintf(&tmp,
    32173220                         "%s - Bigfile #%ld, slice #%ld compressed OK          ",
    32183221                         biggie_filename, biggie_file_number + 1,
     
    32293232            log_msg(2, tmp);
    32303233#endif
    3231             paranoid_free(tmp);
    3232             asprintf(&file_to_archive, "%s", curr_slice_fname_compressed);
     3234            mr_free(tmp);
     3235            mr_asprintf(&file_to_archive, "%s", curr_slice_fname_compressed);
    32333236            g_current_progress++;
    32343237        } else {                /* if i==0 then ... */
    32353238
    32363239            finished = TRUE;
    3237             asprintf(&file_to_archive, "%s",
     3240            mr_asprintf(&file_to_archive, "%s",
    32383241                     curr_slice_fname_uncompressed);
    32393242            if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
     
    32513254            res = move_files_to_cd(bkpinfo, file_to_archive, NULL);
    32523255        }
    3253         paranoid_free(file_to_archive);
     3256        mr_free(file_to_archive);
    32543257        retval += res;
    32553258        if (res) {
    3256             asprintf(&tmp,
     3259            mr_asprintf(&tmp,
    32573260                     "Failed to add slice %ld of bigfile %ld to scratchdir",
    32583261                     slice_num, biggie_file_number + 1);
    32593262            log_to_screen(tmp);
    3260             paranoid_free(tmp);
     3263            mr_free(tmp);
    32613264            fatal_error
    32623265                ("Hard disk full. You should have bought a bigger one.");
    32633266        }
    3264         paranoid_free(curr_slice_fname_uncompressed);
    3265         paranoid_free(curr_slice_fname_compressed);
    3266     }
    3267     paranoid_free(suffix);
     3267        mr_free(curr_slice_fname_uncompressed);
     3268        mr_free(curr_slice_fname_compressed);
     3269    }
     3270    mr_free(suffix);
    32683271    paranoid_fclose(fin);
    32693272    if (retval) {
    3270         asprintf(&tmp, "Sliced bigfile #%ld...FAILED",
     3273        mr_asprintf(&tmp, "Sliced bigfile #%ld...FAILED",
    32713274                 biggie_file_number + 1);
    32723275    } else {
    3273         asprintf(&tmp, "Sliced bigfile #%ld...OK!",
     3276        mr_asprintf(&tmp, "Sliced bigfile #%ld...OK!",
    32743277                 biggie_file_number + 1);
    32753278    }
    32763279    log_msg(1, tmp);
    3277     paranoid_free(tmp);
     3280    mr_free(tmp);
    32783281    return (retval);
    32793282}
     
    33003303    assert_string_is_neither_NULL_nor_zerolength(d);
    33013304
    3302     asprintf(&dir, "%s/archives", d);
    3303     asprintf(&tmp, "find %s -name '*.afio*' -exec rm -f '{}' \\;", dir);
     3305    mr_asprintf(&dir, "%s/archives", d);
     3306    mr_asprintf(&tmp, "find %s -name '*.afio*' -exec rm -f '{}' \\;", dir);
    33043307    run_program_and_log_output(tmp, FALSE);
    3305     paranoid_free(tmp);
    3306 
    3307     asprintf(&tmp, "find %s -name '*list.[0-9]*' -exec rm -f '{}' \\;",
     3308    mr_free(tmp);
     3309
     3310    mr_asprintf(&tmp, "find %s -name '*list.[0-9]*' -exec rm -f '{}' \\;",
    33083311             dir);
    33093312    run_program_and_log_output(tmp, FALSE);
    3310     paranoid_free(tmp);
    3311 
    3312     asprintf(&tmp, "find %s -name 'slice*' -exec rm -f '{}' \\;", dir);
     3313    mr_free(tmp);
     3314
     3315    mr_asprintf(&tmp, "find %s -name 'slice*' -exec rm -f '{}' \\;", dir);
    33133316    run_program_and_log_output(tmp, FALSE);
    3314     paranoid_free(tmp);
    3315 
    3316     asprintf(&tmp, "rm -f %s/cklist*", dir);
     3317    mr_free(tmp);
     3318
     3319    mr_asprintf(&tmp, "rm -f %s/cklist*", dir);
    33173320    run_program_and_log_output(tmp, FALSE);
    3318     paranoid_free(tmp);
    3319 
    3320     asprintf(&tmp, "rm -f %s/zero", dir);
     3321    mr_free(tmp);
     3322
     3323    mr_asprintf(&tmp, "rm -f %s/zero", dir);
    33213324    run_program_and_log_output(tmp, FALSE);
    3322     paranoid_free(tmp);
     3325    mr_free(tmp);
    33233326
    33243327    log_msg(1, "Wiped %s's archives", dir);
    3325     asprintf(&tmp, "ls -l %s", dir);
     3328    mr_asprintf(&tmp, "ls -l %s", dir);
    33263329    run_program_and_log_output(tmp, FALSE);
    3327     paranoid_free(tmp);
    3328 
    3329     paranoid_free(dir);
     3330    mr_free(tmp);
     3331
     3332    mr_free(dir);
    33303333}
    33313334
     
    33573360// I should really check if there are any slices or tarballs to be copied to CD-R(W)'s; the odds are approx. 1 in a million that there are no files here, so I'll just go ahead & make one more CD anyway
    33583361
    3359     asprintf(&tmp, "Writing the final ISO");
     3362    mr_asprintf(&tmp, "Writing the final ISO");
    33603363    log_msg(2, tmp);
    33613364    /* BERLIOS: center_string is now broken
     
    33673370    }
    33683371#endif
    3369     paranoid_free(tmp);
     3372    mr_free(tmp);
    33703373    res = write_iso_and_go_on(bkpinfo, TRUE);
    33713374#ifndef _XWIN
     
    34323435    /* label the ISO with its number */
    34333436
    3434     asprintf(&cdno_fname, "%s/archives/THIS-CD-NUMBER",
     3437    mr_asprintf(&cdno_fname, "%s/archives/THIS-CD-NUMBER",
    34353438             bkpinfo->scratchdir);
    34363439    fout = fopen(cdno_fname, "w");
    34373440    fprintf(fout, "%d", g_current_media_number);
    34383441    paranoid_fclose(fout);
    3439     paranoid_free(cdno_fname);
    3440 
    3441     asprintf(&tmp, "cp -f %s/autorun %s/", g_mondo_home,
     3442    mr_free(cdno_fname);
     3443
     3444    mr_asprintf(&tmp, "cp -f %s/autorun %s/", g_mondo_home,
    34423445             bkpinfo->scratchdir);
    34433446    if (run_program_and_log_output(tmp, FALSE)) {
    34443447        log_msg(2, "Warning - unable to copy autorun to scratchdir");
    34453448    }
    3446     paranoid_free(tmp);
     3449    mr_free(tmp);
    34473450
    34483451    /* last CD or not? Label accordingly */
    3449     asprintf(&lastcd_fname, "%s/archives/NOT-THE-LAST",
     3452    mr_asprintf(&lastcd_fname, "%s/archives/NOT-THE-LAST",
    34503453             bkpinfo->scratchdir);
    34513454    if (last_cd) {
     
    34593462        paranoid_fclose(fout);
    34603463    }
    3461     paranoid_free(lastcd_fname);
     3464    mr_free(lastcd_fname);
    34623465
    34633466    if (space_occupied_by_cd(bkpinfo->scratchdir) / 1024 >
    34643467        bkpinfo->media_size[g_current_media_number]) {
    3465         asprintf(&tmp,
     3468        mr_asprintf(&tmp,
    34663469                 "Warning! CD is too big. It occupies %ld KB, which is more than the %ld KB allowed.",
    34673470                 (long) space_occupied_by_cd(bkpinfo->scratchdir),
    34683471                 (long) bkpinfo->media_size[g_current_media_number]);
    34693472        log_to_screen(tmp);
    3470         paranoid_free(tmp);
    3471     }
    3472     asprintf(&isofile, "%s/%s/%s-%d.iso", bkpinfo->isodir,
     3473        mr_free(tmp);
     3474    }
     3475    mr_asprintf(&isofile, "%s/%s/%s-%d.iso", bkpinfo->isodir,
    34733476             bkpinfo->nfs_remote_dir, bkpinfo->prefix,
    34743477             g_current_media_number);
     
    34853488            else {
    34863489                log_msg(3, "Great. Found Mike's CD-ROM drive.");
    3487                 paranoid_free(tmp);
     3490                mr_free(tmp);
    34883491            }
    34893492        }
     
    35003503            that_one_was_ok = TRUE;
    35013504        } else {
    3502             asprintf(&tmp, "Failed to burn %s #%d. Retry?",
     3505            mr_asprintf(&tmp, "Failed to burn %s #%d. Retry?",
    35033506                     bkpinfo->backup_media_string,
    35043507                     g_current_media_number);
    35053508            res = ask_me_yes_or_no(tmp);
    3506             paranoid_free(tmp);
     3509            mr_free(tmp);
    35073510            if (!res) {
    35083511                if (ask_me_yes_or_no("Abort the backup?")) {
     
    35203523  if (using_nfs)
    35213524    {
    3522       asprintf(&tmp,"mv -f %s %s/%s/", isofile, bkpinfo->isodir, bkpinfo->nfs_remote_dir);
     3525      mr_asprintf(&tmp,"mv -f %s %s/%s/", isofile, bkpinfo->isodir, bkpinfo->nfs_remote_dir);
    35233526      if (run_program_and_log_output(tmp, FALSE))
    35243527        { log_to_screen("Unable to move ISO to NFS dir"); }
    35253528    }
    35263529*/
    3527     paranoid_free(isofile);
     3530    mr_free(isofile);
    35283531
    35293532    g_current_media_number++;
     
    35323535    }
    35333536    wipe_archives(bkpinfo->scratchdir);
    3534     asprintf(&tmp, "rm -Rf %s/images/*gz %s/images/*data*img",
     3537    mr_asprintf(&tmp, "rm -Rf %s/images/*gz %s/images/*data*img",
    35353538             bkpinfo->scratchdir, bkpinfo->scratchdir);
    35363539    if (system(tmp)) {
     
    35383541                "Error occurred when I tried to delete the redundant IMGs and GZs");
    35393542    }
    3540     paranoid_free(tmp);
     3543    mr_free(tmp);
    35413544
    35423545    if (last_cd) {
     
    35763579                            "Verifying archives against live filesystem");
    35773580        if (bkpinfo->backup_media_type == cdstream) {
    3578             paranoid_alloc(bkpinfo->media_device,"/dev/cdrom");
     3581            mr_allocstr(bkpinfo->media_device,"/dev/cdrom");
    35793582        }
    35803583        verify_tape_backups(bkpinfo);
     
    36063609            retval += res;
    36073610            if (res) {
    3608                 asprintf(&tmp,
     3611                mr_asprintf(&tmp,
    36093612                         "Warnings/errors were reported while checking %s #%d",
    36103613                         bkpinfo->backup_media_string,
    36113614                         g_current_media_number);
    36123615                log_to_screen(tmp);
    3613                 paranoid_free(tmp);
    3614 
    3615             }
    3616         }
    3617         asprintf(&tmp,
     3616                mr_free(tmp);
     3617
     3618            }
     3619        }
     3620        mr_asprintf(&tmp,
    36183621                 "grep 'afio: ' %s | sed 's/afio: //' | grep -vx '/dev/.*' >> /tmp/changed.files",
    36193622                 MONDO_LOGFILE);
    36203623        system(tmp);
    3621         paranoid_free(tmp);
    3622 
    3623         asprintf(&tmp,
     3624        mr_free(tmp);
     3625
     3626        mr_asprintf(&tmp,
    36243627                 "grep 'star: ' %s | sed 's/star: //' | grep -vx '/dev/.*' >> /tmp/changed.files",
    36253628                 MONDO_LOGFILE);
    36263629        system(tmp);
    3627         paranoid_free(tmp);
     3630        mr_free(tmp);
    36283631
    36293632        run_program_and_log_output("umount " MNT_CDROM, FALSE);
     
    36763679        p++;
    36773680    }
    3678     asprintf(&title, "Writing %s to floppy", p);
     3681    mr_asprintf(&title, "Writing %s to floppy", p);
    36793682    open_evalcall_form(title);
    3680     paranoid_free(title);
     3683    mr_free(title);
    36813684
    36823685    /* functional stuff */
     
    36873690        maxblocks = 1440;
    36883691    }
    3689     asprintf(&tmp, "maxblocks = %d; p=%s", maxblocks, p);
     3692    mr_asprintf(&tmp, "maxblocks = %d; p=%s", maxblocks, p);
    36903693    log_msg(2, tmp);
    3691     paranoid_free(tmp);
     3694    mr_free(tmp);
    36923695
    36933696    /* copy data from image to floppy */
     
    37633766    char *param = NULL;
    37643767
    3765     mr_conf = (struct s_mr_conf *)malloc(sizeof(struct s_mr_conf));
    3766     if (mr_conf == NULL) {
    3767             fatal_error("Unable to malloc mr_conf");
    3768     }
    3769     /* Default for everything int : 0 char * : NULL */
     3768    mr_conf = (struct s_mr_conf *)mr_malloc(sizeof(struct s_mr_conf));
    37703769
    37713770    /* mindi conf parameters also needed in mondo */
    3772     mr_conf->mindi_ia64_boot_size = 0;
    3773 
    3774     asprintf(&command, "mindi -printvar IA64_BOOT_SIZE");
     3771    mr_asprintf(&command, "mindi -printvar IA64_BOOT_SIZE");
    37753772    fin = popen(command, "r");
    3776     getline(&param, &n, fin);
     3773    mr_getline(&param, &n, fin);
    37773774    pclose(fin);
    3778     paranoid_free(command);
     3775    mr_free(command);
     3776
    37793777    mr_conf->mindi_ia64_boot_size = atoi(param);
    3780     paranoid_free(param);
    3781 
    3782     mr_conf->mondo_iso_creation_cmd = NULL;
     3778    mr_free(param);
    37833779
    37843780    /* Finds mondo conf file */
     
    37863782
    37873783    /* mondo conf parameters needed */
    3788     mr_conf->mondo_iso_creation_cmd = mr_conf_sread("mondo_iso_creation_cmd");
     3784    if ((mr_conf->mondo_iso_creation_cmd = mr_conf_sread("mondo_iso_creation_cmd")) == NULL) {;
     3785        mr_log_exit(-1,"Unable to get mondo_iso_creation_cmd parameter from conf file\nAborting...\n");
     3786    }
     3787
     3788    if ((mr_conf->mondo_logfile = mr_conf_sread("mondo_logfile")) == NULL) {
     3789        mr_log_exit(-1,"Unable to get mondo_logfile parameter from conf file\nAborting...\n");
     3790    }
    37893791
    37903792    mr_conf_close();
  • 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);
  • trunk/mondo/src/common/libmondo-fifo.c

    r808 r900  
    2828#include "mondostructures.h"
    2929#include "libmondo.h"
     30#include "mr_mem.h"
    3031
    3132/**
     
    8283    assert_string_is_neither_NULL_nor_zerolength(device);
    8384    assert(direction == 'w' || direction == 'r');
    84     asprintf(&sz_dir, "%c", direction);
     85    mr_asprintf(&sz_dir, "%c", direction);
    8586    wise_upper_limit = (am_I_in_disaster_recovery_mode()? 8 : 32);
    8687    wise_lower_limit = 1;       // wise_upper_limit/2 + 1;
     
    8889    for (bufsize = wise_upper_limit, res = -1;
    8990         res != 0 && bufsize >= wise_lower_limit; bufsize--) {
    90         asprintf(&tmp,
     91        mr_asprintf(&tmp,
    9192                 "dd if=/dev/zero bs=1024 count=16k 2> /dev/null | buffer -o /dev/null -s %ld -m %d%c",
    9293                 internal_tape_block_size, bufsize, 'm');
    9394        res = run_program_and_log_output(tmp, 2);
    94         paranoid_free(tmp);
     95        mr_free(tmp);
    9596    }
    9697    if (!res) {
    9798        bufsize++;
    98         asprintf(&tmp, _("Negotiated max buffer of %d MB "), bufsize);
     99        mr_asprintf(&tmp, _("Negotiated max buffer of %d MB "), bufsize);
    99100        log_to_screen(tmp);
    100         paranoid_free(tmp);
     101        mr_free(tmp);
    101102    } else {
    102103        bufsize = 0;
     
    111112    }
    112113    if (bufsize) {
    113         asprintf(&g_sz_call_to_buffer,
     114        mr_asprintf(&g_sz_call_to_buffer,
    114115                 "buffer -m %d%c -p%d -B -s%ld -%c %s 2>> %s", bufsize,
    115116                 'm', (direction == 'r') ? 20 : 75,
    116117                 internal_tape_block_size, keych, device, MONDO_LOGFILE);
    117118    } else {
    118         asprintf(&g_sz_call_to_buffer, "dd bs=%ld %cf=%s",
     119        mr_asprintf(&g_sz_call_to_buffer, "dd bs=%ld %cf=%s",
    119120                 internal_tape_block_size, keych, device);
    120121    }
    121122    log_msg(2, "Calling buffer --- command = '%s'", g_sz_call_to_buffer);
    122123    fres = popen(g_sz_call_to_buffer, sz_dir);
    123     paranoid_free(sz_dir);
     124    mr_free(sz_dir);
    124125    if (fres) {
    125126        log_msg(2, "Successfully opened ('%c') tape device %s", direction,
     
    130131    }
    131132    sleep(2);
    132     asprintf(&tmp, "ps %s | grep \"%s\"", ps_options, g_sz_call_to_buffer);
     133    mr_asprintf(&tmp, "ps %s | grep \"%s\"", ps_options, g_sz_call_to_buffer);
    133134    if (run_program_and_log_output(tmp, 2)) {
    134135        log_msg(2, "Warning - I think I failed to open tape, actually.");
    135136    }
    136     paranoid_free(tmp);
     137    mr_free(tmp);
    137138    g_tape_buffer_size_MB = bufsize;
    138     asprintf(&tmp, "ps %s | grep buffer | grep -v grep", ps_options);
     139    mr_asprintf(&tmp, "ps %s | grep buffer | grep -v grep", ps_options);
    139140    if (run_program_and_log_output(tmp, 1)) {
    140141        fres = NULL;
     
    143144        log_to_screen(_("Buffer successfully started."));
    144145    }
    145     paranoid_free(tmp);
     146    mr_free(tmp);
    146147    return (fres);
    147148}
     
    157158
    158159    sync();
    159     asprintf(&command,
     160    mr_asprintf(&command,
    160161            "ps %s | grep -F \"%s\" | grep -Fv grep | awk '{print $1;}' | grep -v PID | tr -s '\n' ' ' | awk '{ print $1; }'", ps_options,
    161162            g_sz_call_to_buffer);
    162     paranoid_free(g_sz_call_to_buffer);
     163    mr_free(g_sz_call_to_buffer);
    163164    log_msg(2, "kill_buffer() --- command = %s", command);
    164165
    165166    tmp = call_program_and_get_last_line_of_output(command);
    166     paranoid_free(command);
     167    mr_free(command);
    167168
    168     asprintf(&command, "kill %s", tmp);
     169    mr_asprintf(&command, "kill %s", tmp);
    169170    log_msg(2, "kill_buffer() --- command = %s", command);
    170171
     
    172173        run_program_and_log_output(command, TRUE);
    173174    }
    174     paranoid_free(tmp);
    175     paranoid_free(command);
     175    mr_free(tmp);
     176    mr_free(command);
    176177}
    177178
  • trunk/mondo/src/common/libmondo-filelist.c

    r863 r900  
    1717#include "newt-specific-EXT.h"
    1818#include "libmondo-tools-EXT.h"
    19 #include "mr_string.h"
     19#include "mr_str.h"
     20#include "mr_mem.h"
    2021
    2122#include <time.h>
     
    102103    { i=0; log_to_screen ("This will take more time. Please be patient."); }
    103104*/
    104     asprintf(&filelist, "%s/archives/filelist.full", bkpinfo->scratchdir);
     105    mr_asprintf(&filelist, "%s/archives/filelist.full", bkpinfo->scratchdir);
    105106    if (!does_file_exist(filelist)) {
    106107        log_it("filelist %s not found", filelist);
     
    111112        chop_filelist(filelist, bkpinfo->tmpdir,
    112113                      bkpinfo->optimal_set_size);
    113     paranoid_free(filelist);
     114    mr_free(filelist);
    114115
    115116    estimate_noof_media_required(bkpinfo, noof_sets);   // for cosmetic purposes
    116117
    117     asprintf(&tempfile, "%s/biggielist.txt", bkpinfo->tmpdir);
     118    mr_asprintf(&tempfile, "%s/biggielist.txt", bkpinfo->tmpdir);
    118119    if (!(fout = fopen(tempfile, "a"))) {
    119120        log_OS_error("Cannot append to biggielist");
    120121        retval++;
    121122    }
    122     paranoid_free(tempfile);
     123    mr_free(tempfile);
    123124    log_it(bkpinfo->image_devs);
    124125
     
    126127
    127128    while (ptr && *ptr) {
    128         asprintf(&dev, ptr);
     129        mr_asprintf(&dev, ptr);
    129130        log_it("Examining imagedev %s", dev);
    130131        for (i = 0; i < (int) strlen(dev) && dev[i] != ' '; i++);
     
    135136        fprintf(fout, "%s\n", dev);
    136137        log_it("Adding '%s' to biggielist", dev);
    137         paranoid_free(dev);
     138        mr_free(dev);
    138139
    139140        if ((ptr = strchr(ptr, ' '))) {
     
    156157
    157158    log_msg(1, "Sorting file %s", orig_fname);
    158     asprintf(&tmp_fname, "/tmp/sort.%d.%d.%d", (int) (random() % 32768),
     159    mr_asprintf(&tmp_fname, "/tmp/sort.%d.%d.%d", (int) (random() % 32768),
    159160             (int) (random() % 32768), (int) (random() % 32768));
    160161
     
    163164    }                           // no sense in trying to sort an empty file
    164165
    165     asprintf(&command, "sort %s > %s 2>> %s", orig_fname, tmp_fname,
     166    mr_asprintf(&command, "sort %s > %s 2>> %s", orig_fname, tmp_fname,
    166167             MONDO_LOGFILE);
    167168    retval = system(command);
    168     paranoid_free(command);
     169    mr_free(command);
    169170
    170171    if (retval) {
     
    173174        log_msg(2, "Sorted %s --> %s OK. Copying it back to %s now",
    174175                orig_fname, tmp_fname, orig_fname);
    175         asprintf(&command, "mv -f %s %s", tmp_fname, orig_fname);
     176        mr_asprintf(&command, "mv -f %s %s", tmp_fname, orig_fname);
    176177        retval += run_program_and_log_output(command, 2);
    177         paranoid_free(command);
     178        mr_free(command);
    178179
    179180        if (retval) {
     
    184185        }
    185186    }
    186     paranoid_free(tmp_fname);
     187    mr_free(tmp_fname);
    187188    log_msg(1, "Finished sorting file %s", orig_fname);
    188189    return (retval);
     
    248249    curr_set_no = 0;
    249250    curr_set_size = 0;
    250     asprintf(&outfname, "%s/filelist.%ld", outdir, curr_set_no);
    251     asprintf(&biggie_fname, "%s/biggielist.txt", outdir);
     251    mr_asprintf(&outfname, "%s/filelist.%ld", outdir, curr_set_no);
     252    mr_asprintf(&biggie_fname, "%s/biggielist.txt", outdir);
    252253    log_it("outfname=%s; biggie_fname=%s", outfname, biggie_fname);
    253254    if (!(fbig = fopen(biggie_fname, "w"))) {
     
    259260        return (0);
    260261    }
    261     (void) getline(&incoming, &n, fin);
     262    mr_getline(&incoming, &n, fin);
    262263    while (!feof(fin)) {
    263264        lino++;
     
    286287                paranoid_fclose(fout);
    287288                sort_file(outfname);
    288                 paranoid_free(outfname);
     289                mr_free(outfname);
    289290
    290291                curr_set_no++;
    291292                curr_set_size = 0;
    292                 asprintf(&outfname, "%s/filelist.%ld", outdir,
     293                mr_asprintf(&outfname, "%s/filelist.%ld", outdir,
    293294                         curr_set_no);
    294295                if (!(fout = fopen(outfname, "w"))) {
     
    299300            }
    300301        }
    301         (void) getline(&incoming, &n, fin);
     302        mr_getline(&incoming, &n, fin);
    302303    }
    303304    paranoid_fclose(fin);
     
    312313    sort_file(outfname);
    313314    sort_file(biggie_fname);
    314     paranoid_free(biggie_fname);
    315     paranoid_free(outfname);
    316 
    317     asprintf(&outfname, "%s/LAST-FILELIST-NUMBER", outdir);
    318     asprintf(&tmp, "%ld", curr_set_no);
     315    mr_free(biggie_fname);
     316    mr_free(outfname);
     317
     318    mr_asprintf(&outfname, "%s/LAST-FILELIST-NUMBER", outdir);
     319    mr_asprintf(&tmp, "%ld", curr_set_no);
    319320    if (write_one_liner_data_file(outfname, tmp)) {
    320321        log_OS_error
     
    322323        return (0);
    323324    }
    324     paranoid_free(outfname);
    325     paranoid_free(tmp);
     325    mr_free(outfname);
     326    mr_free(tmp);
    326327
    327328    if (curr_set_no == 0) {
    328         asprintf(&tmp, "Only one fileset. Fine.");
     329        mr_asprintf(&tmp, "Only one fileset. Fine.");
    329330    } else {
    330         asprintf(&tmp, "Filelist divided into %ld sets", curr_set_no + 1);
     331        mr_asprintf(&tmp, "Filelist divided into %ld sets", curr_set_no + 1);
    331332    }
    332333    log_msg(1, tmp);
    333     paranoid_free(tmp);
     334    mr_free(tmp);
    334335    close_evalcall_form();
    335336    /* This is to work around an obscure bug in Newt; open a form, close it,
     
    391392    }
    392393    filelist->ch = '\0';
    393     paranoid_free(filelist);
     394    mr_free((void *)filelist);
    394395    depth--;
    395396    if (depth == 0) {
     
    416417        return (2);
    417418    }
    418     for (getline(&tmp, &n, pattr); !feof(pattr); getline(&tmp, &n, pattr)) {
     419    for (mr_getline(&tmp, &n, pattr); !feof(pattr); mr_getline(&tmp, &n, pattr)) {
    419420        fputs(tmp, pout);
    420421    }
    421422    paranoid_pclose(pattr);
    422     paranoid_free(tmp);
     423    mr_free(tmp);
    423424    return (0);
    424425}
     
    432433    char *pout_command;
    433434    char *syscall;
    434     char *tmp;
    435435    char *file_to_analyze = NULL;
    436436    int i;
     
    441441        return (1);
    442442    }
    443     asprintf(&pout_command, "gzip -c1 > %s", auxlist_fname);
     443    mr_asprintf(&pout_command, "gzip -c1 > %s", auxlist_fname);
    444444    if (!(pout = popen(pout_command, "w"))) {
    445445        log_msg(1, "Cannot openout auxlist_fname %s", auxlist_fname);
    446446        fclose(fin);
    447         paranoid_free(pout_command);
     447        mr_free(pout_command);
    448448        return (4);
    449449    }
    450     paranoid_free(pout_command);
    451 
    452     for (getline(&file_to_analyze, &n, fin); !feof(fin);
    453          getline(&file_to_analyze, &n, fin)) {
     450    mr_free(pout_command);
     451
     452    for (mr_getline(&file_to_analyze, &n, fin); !feof(fin);
     453         mr_getline(&file_to_analyze, &n, fin)) {
    454454        i = strlen(file_to_analyze);
    455455        if (i > 0 && file_to_analyze[i - 1] < 32) {
     
    458458        log_msg(8, "Analyzing %s", file_to_analyze);
    459459        /* BERLIOS : to be checked */
    460         asprintf(&syscall, "%s %s 2>> /dev/null", syscall_sprintf,mr_stresc(file_to_analyze, "`$\\\"", '\\'));
     460        mr_asprintf(&syscall, "%s %s 2>> /dev/null", syscall_sprintf,mr_stresc(file_to_analyze, "`$\\\"", '\\'));
    461461        call_exe_and_pipe_output_to_fd(syscall, pout);
    462         paranoid_free(syscall);
     462        mr_free(syscall);
    463463    }
    464464    paranoid_fclose(fin);
    465465    paranoid_pclose(pout);
    466     paranoid_free(file_to_analyze);
     466    mr_free(file_to_analyze);
    467467    return (0);
    468468}
     
    475475    int retval = 0;
    476476
    477     asprintf(&command, "touch %s", facl_fname);
     477    mr_asprintf(&command, "touch %s", facl_fname);
    478478    run_program_and_log_output(command, 8);
    479     paranoid_free(command);
     479    mr_free(command);
    480480
    481481    tmp = find_home_of_exe("getfacl");
    482482    if (tmp) {
    483483//      sort_file(filelist); // FIXME - filelist chopper sorts, so this isn't necessary
    484         asprintf(&command,
     484        mr_asprintf(&command,
    485485                 "getfacl --all-effective -P %s 2>> %s | gzip -c1 > %s 2>> %s",
    486486                 filelist, MONDO_LOGFILE, facl_fname, MONDO_LOGFILE);
    487487        iamhere(command);
    488488        retval = system(command);
    489         paranoid_free(command);
    490     }
    491     paranoid_free(tmp);
     489        mr_free(command);
     490    }
     491    mr_free(tmp);
    492492    return (retval);
    493493}
     
    500500    int retval = 0;
    501501
    502     asprintf(&command, "touch %s", fattr_fname);
     502    mr_asprintf(&command, "touch %s", fattr_fname);
    503503    run_program_and_log_output(command, 8);
    504     paranoid_free(command);
     504    mr_free(command);
    505505
    506506    tmp = find_home_of_exe("getfattr");
     
    511511                         fattr_fname);
    512512    }
    513     paranoid_free(tmp);
     513    mr_free(tmp);
    514514    return (retval);
    515515}
     
    531531      retval = system(command);
    532532    }
    533   paranoid_free(command);
     533  mr_free(command);
    534534  return(retval);
    535535}
     
    557557        log_msg(1,
    558558                "No masklist provided. I shall therefore set ALL attributes.");
    559         asprintf(&command, "gzip -dc %s | %s --restore - 2>> %s",
     559        mr_asprintf(&command, "gzip -dc %s | %s --restore - 2>> %s",
    560560                 original_exat_fname, executable, MONDO_LOGFILE);
    561561        log_msg(1, "command = %s", command);
    562562        retval = system(command);
    563         paranoid_free(command);
     563        mr_free(command);
    564564        log_msg(1, "Returning w/ retval=%d", retval);
    565565        return (retval);
     
    571571        return (0);
    572572    }
    573     asprintf(&masklist, "/tmp/%d.%d.mask", (int) (random() % 32768),
     573    mr_asprintf(&masklist, "/tmp/%d.%d.mask", (int) (random() % 32768),
    574574             (int) (random() % 32768));
    575     asprintf(&command, "cp -f %s %s", orig_msklist, masklist);
     575    mr_asprintf(&command, "cp -f %s %s", orig_msklist, masklist);
    576576    run_program_and_log_output(command, 1);
    577     paranoid_free(command);
     577    mr_free(command);
    578578
    579579    sort_file(masklist);
    580     asprintf(&syscall_pin, "gzip -dc %s", original_exat_fname);
    581     asprintf(&syscall_pout, "%s --restore - 2>> %s", executable,
     580    mr_asprintf(&syscall_pin, "gzip -dc %s", original_exat_fname);
     581    mr_asprintf(&syscall_pout, "%s --restore - 2>> %s", executable,
    582582             MONDO_LOGFILE);
    583583
     
    589589        return (1);
    590590    }
    591     paranoid_free(syscall_pout);
     591    mr_free(syscall_pout);
    592592
    593593    pin = popen(syscall_pin, "r");
     
    597597        return (1);
    598598    }
    599     paranoid_free(syscall_pin);
     599    mr_free(syscall_pin);
    600600
    601601    faclin = fopen(masklist, "r");
     
    608608//  printf("Hi there. Starting the loop\n");
    609609
    610     getline(&current_subset_file, &n, faclin);
    611     getline(&incoming, &n, pin);
     610    mr_getline(&current_subset_file, &n, faclin);
     611    mr_getline(&incoming, &n, pin);
    612612    while (!feof(pin) && !feof(faclin)) {
    613613//      printf("incoming = %s", incoming);
    614614
    615         asprintf(&current_master_file, incoming + 8);
     615        mr_asprintf(&current_master_file, incoming + 8);
    616616
    617617        p = current_subset_file;
     
    641641        if (i < 0) {            // read another subset file in.
    642642            log_msg(my_depth, "Reading next subset line in\n\n");
    643             getline(&current_subset_file, &n, faclin);
     643            mr_getline(&current_subset_file, &n, faclin);
    644644            continue;
    645645        }
     
    648648            fputs(incoming, pout);
    649649        }
    650         getline(&incoming, &n, pin);
     650        mr_getline(&incoming, &n, pin);
    651651        if (!i) {
    652652            log_msg(my_depth, "Copying master %s", q);
     
    661661                fputs(incoming, pout);
    662662            }
    663             getline(&incoming, &n, pin);
     663            mr_getline(&incoming, &n, pin);
    664664        }
    665665        if (!i) {
    666             getline(&current_subset_file, &n, faclin);
    667         }
    668         paranoid_free(current_master_file);
    669     }
    670     paranoid_free(current_subset_file);
     666            mr_getline(&current_subset_file, &n, faclin);
     667        }
     668        mr_free(current_master_file);
     669    }
     670    mr_free(current_subset_file);
    671671
    672672    while (!feof(pin)) {
    673         getline(&incoming, &n, pin);
    674     }
    675     paranoid_free(incoming);
     673        mr_getline(&incoming, &n, pin);
     674    }
     675    mr_free(incoming);
    676676    fclose(faclin);
    677677    pclose(pin);
     
    681681
    682682    unlink(masklist);
    683     paranoid_free(masklist);
     683    mr_free(masklist);
    684684
    685685    return (retval);
     
    719719    assert(bkpinfo != NULL);
    720720
    721     asprintf(&cfg_fname, "%s/mondo-restore.cfg", bkpinfo->tmpdir);
     721    mr_asprintf(&cfg_fname, "%s/mondo-restore.cfg", bkpinfo->tmpdir);
    722722    read_cfg_var(cfg_fname, "last-filelist-number", val_sz);
    723723    val_i = atoi(val_sz);
    724     paranoid_free(val_sz);
     724    mr_free(val_sz);
    725725
    726726    if (val_i <= 0) {
    727727        val_i = 500;
    728728    }
    729     paranoid_free(cfg_fname);
     729    mr_free(cfg_fname);
    730730    return (val_i);
    731731}
     
    866866    }
    867867    log_to_screen(_("Loading filelist"));
    868     asprintf(&command_to_open_fname, "gzip -dc %s", filelist_fname);
    869     asprintf(&tmp, "zcat %s | wc -l", filelist_fname);
     868    mr_asprintf(&command_to_open_fname, "gzip -dc %s", filelist_fname);
     869    mr_asprintf(&tmp, "zcat %s | wc -l", filelist_fname);
    870870    log_msg(6, "tmp = %s", tmp);
    871871    tmp1 = call_program_and_get_last_line_of_output(tmp);
    872     paranoid_free(tmp);
     872    mr_free(tmp);
    873873
    874874    lines_in_filelist = atol(tmp1);
    875     paranoid_free(tmp1);
     875    mr_free(tmp1);
    876876
    877877    if (lines_in_filelist < 3) {
     
    893893        return (NULL);
    894894    }
    895     paranoid_free(command_to_open_fname);
     895    mr_free(command_to_open_fname);
    896896
    897897    open_evalcall_form(_("Loading filelist from disk"));
    898     for (getline(&fname, &n, pin); !feof(pin); getline(&fname, &n, pin)) {
     898    for (mr_getline(&fname, &n, pin); !feof(pin); mr_getline(&fname, &n, pin)) {
    899899        if ((fname[strlen(fname) - 1] == 13
    900900             || fname[strlen(fname) - 1] == 10) && strlen(fname) > 0) {
     
    908908                continue;
    909909            }
    910             asprintf(&tmp, fname);
     910            mr_asprintf(&tmp, fname);
    911911            tmp[pos_in_fname] = '\0';
    912912            if (strlen(tmp)) {
    913913                add_string_at_node(filelist, tmp);
    914914            }
    915             paranoid_free(tmp);
     915            mr_free(tmp);
    916916        }
    917917        add_string_at_node(filelist, fname);
     
    921921        }
    922922    }
    923     paranoid_free(fname);
     923    mr_free(fname);
    924924    paranoid_pclose(pin);
    925925    close_evalcall_form();
     
    13521352    if (!depth) {
    13531353        malloc_string(find_skeleton_marker);
    1354         asprintf(&find_excludes, " ");
     1354        mr_asprintf(&find_excludes, " ");
    13551355        while((token = mr_strtok (sth, delims, &lastpos))) {
    1356           asprintf(&strtmp,"%s", find_excludes);
    1357           paranoid_free(find_excludes);
    1358           asprintf(&find_excludes,"%s -path %s -prune -o", strtmp, token);
    1359           paranoid_free(strtmp);
    1360           paranoid_free(token);
     1356          mr_asprintf(&strtmp,"%s", find_excludes);
     1357          mr_free(find_excludes);
     1358          mr_asprintf(&find_excludes,"%s -path %s -prune -o", strtmp, token);
     1359          mr_free(strtmp);
     1360          mr_free(token);
    13611361        }
    13621362#if linux
    13631363        // 2.6 has /sys as a proc-type thing -- must be excluded
    1364         asprintf(&strtmp,
     1364        mr_asprintf(&strtmp,
    13651365             "find %s -maxdepth %d -fstype mvfs -prune -o -path /dev/shm -prune -o %s -type d -print > %s 2> /dev/null",
    13661366             dir, MAX_SKEL_DEPTH, find_excludes, skeleton_filelist);
    13671367#else
    13681368        // On BSD, for example, /sys is the kernel sources -- don't exclude
    1369         asprintf(&strtmp,
     1369        mr_asprintf(&strtmp,
    13701370             "find %s -maxdepth %d -fstype mvfs -prune -o -path /proc -prune -o %s -type d -print > %s 2> /dev/null",
    13711371                dir, MAX_SKEL_DEPTH, find_excludes, skeleton_filelist);
    13721372#endif
    1373         paranoid_free(find_excludes);
     1373        mr_free(find_excludes);
    13741374        log_msg(5, "find command = %s", strtmp);
    13751375        system(strtmp);
    1376         paranoid_free(strtmp);
    1377         paranoid_free(tmp);
    1378 
    1379         asprintf(&tmp, "wc -l %s | awk '{print $1;}'", skeleton_filelist);
     1376        mr_free(strtmp);
     1377        mr_free(tmp);
     1378
     1379        mr_asprintf(&tmp, "wc -l %s | awk '{print $1;}'", skeleton_filelist);
    13801380        tmp1 = call_program_and_get_last_line_of_output(tmp);
    1381         paranoid_free(tmp);
     1381        mr_free(tmp);
    13821382
    13831383        g_skeleton_entries = 1 + atol(tmp1);
    1384         paranoid_free(tmp1);
    1385 
    1386         asprintf(&name_of_evalcall_form, "Making catalog of %s", dir);
     1384        mr_free(tmp1);
     1385
     1386        mr_asprintf(&name_of_evalcall_form, "Making catalog of %s", dir);
    13871387        open_evalcall_form(name_of_evalcall_form);
    13881388        find_skeleton_marker[0] = '\0';
     
    14101410#ifndef _XWIN
    14111411                if (!g_text_mode) {
    1412                     asprintf(&tmp, _("Reading %-68s"), dir);
     1412                    mr_asprintf(&tmp, _("Reading %-68s"), dir);
    14131413                    newtDrawRootText(0, g_noof_rows - 3, tmp);
    1414                     paranoid_free(tmp);
     1414                    mr_free(tmp);
    14151415                }
    14161416#endif
     
    14241424//  log_msg(0, "Cataloguing %s", dir);
    14251425    if (sth[0] == ' ') {
    1426         asprintf(&skip_these, "%s", sth);
     1426        mr_asprintf(&skip_these, "%s", sth);
    14271427    } else {
    1428         asprintf(&skip_these, " %s ", sth);
    1429     }
    1430     asprintf(&new_with_spaces, " %s ", dir);
     1428        mr_asprintf(&skip_these, " %s ", sth);
     1429    }
     1430    mr_asprintf(&new_with_spaces, " %s ", dir);
    14311431    if ((dip = opendir(dir)) == NULL) {
    14321432        log_OS_error("opendir");
     
    14381438            i++;
    14391439            if (strcmp(dir, "/")) {
    1440                 asprintf(&new, "%s/%s", dir, dit->d_name);
     1440                mr_asprintf(&new, "%s/%s", dir, dit->d_name);
    14411441            } else {
    1442                 asprintf(&new, "%s%s", dir, dit->d_name);
     1442                mr_asprintf(&new, "%s%s", dir, dit->d_name);
    14431443            }
    1444             paranoid_free(new_with_spaces);
    1445             asprintf(&new_with_spaces, " %s ", new);
     1444            mr_free(new_with_spaces);
     1445            mr_asprintf(&new_with_spaces, " %s ", new);
    14461446            /* BERLIOS: Old code
    14471447               new_with_spaces[0] = ' ';
     
    14661466                                counter = 0;
    14671467                                uberctr++;
    1468                                 asprintf(&tmp, " %c ",
     1468                                mr_asprintf(&tmp, " %c ",
    14691469                                         special_dot_char(uberctr));
    14701470#ifndef _XWIN
     
    14741474                                    newtRefresh();
    14751475                                }
    1476                                 paranoid_free(tmp);
     1476                                mr_free(tmp);
    14771477#endif
    14781478                            }
     
    14811481                }
    14821482            }
    1483             paranoid_free(new);
    1484         }
    1485     }
    1486     paranoid_free(new_with_spaces);
    1487     paranoid_free(skip_these);
     1483            mr_free(new);
     1484        }
     1485    }
     1486    mr_free(new_with_spaces);
     1487    mr_free(skip_these);
    14881488
    14891489    if (dip) {
     
    14951495    if (!depth) {
    14961496        close_evalcall_form();
    1497         paranoid_free(name_of_evalcall_form);
    1498         paranoid_free(find_skeleton_marker);
     1497        mr_free(name_of_evalcall_form);
     1498        mr_free(find_skeleton_marker);
    14991499        unlink(skeleton_filelist);
    15001500        log_msg(5, "g_skeleton_entries = %ld", g_skeleton_entries);
     
    15651565
    15661566    // The pathname to the skeleton filelist, used to give better progress reporting for mondo_makefilelist().
    1567     asprintf(&sz_datefile, sz_datefile_wildcard, 0);
     1567    mr_asprintf(&sz_datefile, sz_datefile_wildcard, 0);
    15681568    if (!include_paths && !userdef_filelist) {
    15691569        fatal_error
     
    15711571    }
    15721572// make hole for filelist
    1573     asprintf(&command, "mkdir -p %s/archives", scratchdir);
     1573    mr_asprintf(&command, "mkdir -p %s/archives", scratchdir);
    15741574    paranoid_system(command);
    1575     paranoid_free(command);
    1576 
    1577     asprintf(&sz_filelist, "%s/tmpfs/filelist.full", tmpdir);
     1575    mr_free(command);
     1576
     1577    mr_asprintf(&sz_filelist, "%s/tmpfs/filelist.full", tmpdir);
    15781578    make_hole_for_file(sz_filelist);
    15791579
    15801580    if (differential == 0) {
    15811581        // restore last good datefile if it exists
    1582         asprintf(&command, "cp -f %s.aborted %s", sz_datefile,
     1582        mr_asprintf(&command, "cp -f %s.aborted %s", sz_datefile,
    15831583                 sz_datefile);
    15841584        run_program_and_log_output(command, 3);
    1585         paranoid_free(command);
     1585        mr_free(command);
    15861586
    15871587        // backup last known good datefile just in case :)
    15881588        if (does_file_exist(sz_datefile)) {
    1589             asprintf(&command, "mv -f %s %s.aborted", sz_datefile,
     1589            mr_asprintf(&command, "mv -f %s %s.aborted", sz_datefile,
    15901590                     sz_datefile);
    15911591            paranoid_system(command);
    1592             paranoid_free(command);
     1592            mr_free(command);
    15931593        }
    15941594        make_hole_for_file(sz_datefile);
    15951595        tmp = call_program_and_get_last_line_of_output("date +%s");
    15961596        write_one_liner_data_file(sz_datefile, tmp);
    1597         paranoid_free(tmp);
     1597        mr_free(tmp);
    15981598    } else if (lstat(sz_datefile, &statbuf)) {
    15991599        log_msg(2,
     
    16051605        log_msg(2, "Differential backup. Yay.");
    16061606    }
    1607     paranoid_free(sz_datefile);
     1607    mr_free(sz_datefile);
    16081608
    16091609// use user-specified filelist (if specified)
     
    16121612                "Using the user-specified filelist - %s - instead of calculating one",
    16131613                userdef_filelist);
    1614         asprintf(&command, "cp -f %s %s", userdef_filelist, sz_filelist);
     1614        mr_asprintf(&command, "cp -f %s %s", userdef_filelist, sz_filelist);
    16151615        if (run_program_and_log_output(command, 3)) {
    16161616            fatal_error("Failed to copy user-specified filelist");
    16171617        }
    1618         paranoid_free(command);
     1618        mr_free(command);
    16191619    } else {
    16201620        log_msg(2, "include_paths = '%s'", include_paths);
     
    16231623        tmp1 = call_program_and_get_last_line_of_output("locate /hiberfil.sys 2> /dev/null");
    16241624        tmp2 = call_program_and_get_last_line_of_output("locate /pagefile.sys 2> /dev/null");
    1625         asprintf(&exclude_paths, " %s %s %s %s %s %s . .. \
     1625        mr_asprintf(&exclude_paths, " %s %s %s %s %s %s . .. \
    16261626" MNT_CDROM " " MNT_FLOPPY " /media/cdrom /media/cdrecorder \
    16271627/proc /sys /tmp /var/cache/mondo /var/cache/mindi", excp, tmp, tmp1, tmp2, (tmpdir[0] == '/' && tmpdir[1] == '/') ? (tmpdir + 1) : tmpdir, (scratchdir[0] == '/' && scratchdir[1] == '/') ? (scratchdir + 1) : scratchdir);
    1628         paranoid_free(tmp);
    1629         paranoid_free(tmp1);
    1630         paranoid_free(tmp2);
     1628        mr_free(tmp);
     1629        mr_free(tmp1);
     1630        mr_free(tmp2);
    16311631
    16321632        log_msg(2, "Excluding paths = '%s'", exclude_paths);
    16331633        log_msg(2,
    16341634                "Generating skeleton filelist so that we can track our progress");
    1635         asprintf(&skeleton_filelist, "%s/tmpfs/skeleton.txt", tmpdir);
     1635        mr_asprintf(&skeleton_filelist, "%s/tmpfs/skeleton.txt", tmpdir);
    16361636        make_hole_for_file(skeleton_filelist);
    16371637
     
    16611661        }
    16621662        paranoid_fclose(fout);
    1663         paranoid_free(skeleton_filelist);
    1664         paranoid_free(exclude_paths);
     1663        mr_free(skeleton_filelist);
     1664        mr_free(exclude_paths);
    16651665    }
    16661666    log_msg(2, "Copying new filelist to scratchdir");
    1667     asprintf(&command, "mkdir -p %s/archives", scratchdir);
     1667    mr_asprintf(&command, "mkdir -p %s/archives", scratchdir);
    16681668    paranoid_system(command);
    1669     paranoid_free(command);
    1670 
    1671     asprintf(&command, "cp -f %s %s/archives/", sz_filelist, scratchdir);
     1669    mr_free(command);
     1670
     1671    mr_asprintf(&command, "cp -f %s %s/archives/", sz_filelist, scratchdir);
    16721672    paranoid_system(command);
    1673     paranoid_free(command);
    1674 
    1675     asprintf(&command, "mv -f %s %s", sz_filelist, tmpdir);
     1673    mr_free(command);
     1674
     1675    mr_asprintf(&command, "mv -f %s %s", sz_filelist, tmpdir);
    16761676    paranoid_system(command);
    1677     paranoid_free(command);
    1678     paranoid_free(sz_filelist);
     1677    mr_free(command);
     1678    mr_free(sz_filelist);
    16791679
    16801680    log_msg(2, "Exiting");
     
    17771777    }
    17781778    while (!feof(fin)) {
    1779         getline(&fname, &len, fin);
     1779        mr_getline(&fname, &len, fin);
    17801780        if (!use_star) {
    17811781            if (fname[0] == '/') {
    1782                 asprintf(&tmp, fname);
     1782                mr_asprintf(&tmp, fname);
    17831783            } else {
    1784                 asprintf(&tmp, "/%s", fname);
     1784                mr_asprintf(&tmp, "/%s", fname);
    17851785            }
    1786             paranoid_free(fname);
     1786            mr_free(fname);
    17871787            fname = tmp;
    17881788        }
     
    17961796            if (found_node->selected) {
    17971797                if (fname[0] == '/') {
    1798                     asprintf(&tmp, fname + 1);
    1799                     paranoid_free(fname);
     1798                    mr_asprintf(&tmp, fname + 1);
     1799                    mr_free(fname);
    18001800                    fname = tmp;
    18011801                }
     
    18031803                turn_wildcard_chars_into_literal_chars(tmp, fname);
    18041804                fprintf(fout, "%s\n", tmp);
    1805                 paranoid_free(tmp);
     1805                mr_free(tmp);
    18061806                retval++;
    18071807            }
    18081808        }
    1809         paranoid_free(fname);
     1809        mr_free(fname);
    18101810    }
    18111811    paranoid_fclose(fout);
     
    18361836        return (1);
    18371837    }
    1838     for (getline(&tmp, &n, fin); !feof(fin); getline(&tmp, &n, fin)) {
     1838    for (mr_getline(&tmp, &n, fin); !feof(fin); mr_getline(&tmp, &n, fin)) {
    18391839        if (!tmp[0]) {
    18401840            continue;
     
    18611861    }
    18621862    paranoid_fclose(fin);
    1863     paranoid_free(tmp);
     1863    mr_free(tmp);
    18641864    return (0);
    18651865}
  • trunk/mondo/src/common/libmondo-files-EXT.h

    r783 r900  
    4848extern int read_one_liner_data_file(char *fname, char *contents);
    4949extern int mode_of_file(char *fname);
    50 extern void paranoid_alloc(char *alloc, char *orig);
  • trunk/mondo/src/common/libmondo-files.c

    r839 r900  
    1818#include "libmondo-fork-EXT.h"
    1919#include "libmondo-string-EXT.h"
     20#include "mr_mem.h"
    2021
    2122/*@unused@*/
     
    5960
    6061    if (does_file_exist(filename)) {
    61         asprintf(&command, "md5sum \"%s\"", filename);
     62        mr_asprintf(&command, "md5sum \"%s\"", filename);
    6263        fin = popen(command, "r");
    63         paranoid_free(command);
     64        mr_free(command);
    6465
    6566        if (fin) {
    66             (void) getline(&output, &n, fin);
     67            mr_getline(&output, &n, fin);
    6768            p = strchr(output, ' ');
    6869            paranoid_pclose(fin);
    6970        }
    7071    } else {
    71         asprintf(&tmp, "File '%s' not found; cannot calc checksum",
     72        mr_asprintf(&tmp, "File '%s' not found; cannot calc checksum",
    7273                filename);
    7374        log_it(tmp);
    74         paranoid_free(tmp);
     75        mr_free(tmp);
    7576    }
    7677    if (p) {
     
    106107    assert_string_is_neither_NULL_nor_zerolength(filename);
    107108    if (!does_file_exist(filename)) {
    108         asprintf(&tmp,
     109        mr_asprintf(&tmp,
    109110                "%s does not exist, so I cannot found the number of lines in it",
    110111                filename);
    111112        log_it(tmp);
    112         paranoid_free(tmp);
     113        mr_free(tmp);
    113114        return (0);
    114115    }
    115     asprintf(&command, "cat %s | wc -l", filename);
     116    mr_asprintf(&command, "cat %s | wc -l", filename);
    116117    if (!does_file_exist(filename)) {
    117118        return (-1);
    118119    }
    119120    fin = popen(command, "r");
    120     paranoid_free(command);
     121    mr_free(command);
    121122
    122123    if (fin) {
     
    124125            noof_lines = 0;
    125126        } else {
    126             (void) getline(&incoming, &n, fin);
     127            mr_getline(&incoming, &n, fin);
    127128            while (strlen(incoming) > 0
    128129                   && incoming[strlen(incoming) - 1] < 32) {
     
    130131            }
    131132            noof_lines = atol(incoming);
    132             paranoid_free(incoming);
     133            mr_free(incoming);
    133134        }
    134135        paranoid_pclose(fin);
     
    189190    assert_string_is_neither_NULL_nor_zerolength(inout);
    190191
    191     asprintf(&infname, "%s.in", inout);
    192 
    193     asprintf(&tmp, "cp -f %s %s", inout, infname);
     192    mr_asprintf(&infname, "%s.in", inout);
     193
     194    mr_asprintf(&tmp, "cp -f %s %s", inout, infname);
    194195    run_program_and_log_output(tmp, FALSE);
    195     paranoid_free(tmp);
     196    mr_free(tmp);
    196197
    197198    if (!(fin = fopen(infname, "r"))) {
    198199        log_OS_error("Unable to openin infname");
    199         paranoid_free(infname);
     200        mr_free(infname);
    200201        return;
    201202    }
    202203
    203     asprintf(&outfname, "%s", inout);
     204    mr_asprintf(&outfname, "%s", inout);
    204205    if (!(fout = fopen(outfname, "w"))) {
    205206        log_OS_error("Unable to openout outfname");
    206         paranoid_free(outfname);
     207        mr_free(outfname);
    207208        return;
    208209    }
    209     paranoid_free(outfname);
    210 
    211     for (getline(&incoming, &n, fin); !feof(fin);
    212          getline(&incoming, &n, fin)) {
     210    mr_free(outfname);
     211
     212    for (mr_getline(&incoming, &n, fin); !feof(fin);
     213         mr_getline(&incoming, &n, fin)) {
    213214        i = strlen(incoming) - 1;
    214215        if (i >= 0 && incoming[i] < 32) {
     
    218219            fprintf(fout, "%s\n", incoming);
    219220        } else {
    220             asprintf(&tmp, "Excluding '%s'-nonexistent\n", incoming);
     221            mr_asprintf(&tmp, "Excluding '%s'-nonexistent\n", incoming);
    221222            log_it(tmp);
    222             paranoid_free(tmp);
    223         }
    224     }
    225     paranoid_free(incoming);
     223            mr_free(tmp);
     224        }
     225    }
     226    mr_free(incoming);
    226227    paranoid_fclose(fout);
    227228    paranoid_fclose(fin);
    228229    unlink(infname);
    229     paranoid_free(infname);
     230    mr_free(infname);
    230231}
    231232
     
    249250    // If we didn't get anything back, check whether mindi raised a fatal error
    250251    if (kernel == NULL) {
    251         asprintf(&command, "grep 'Fatal error' /var/log/mindi.log");
     252        mr_asprintf(&command, "grep 'Fatal error' /var/log/mindi.log");
    252253        tmp = call_program_and_get_last_line_of_output(command);
    253254        if (strlen(tmp) > 1) {
     
    255256            fatal_error("Mindi gave a fatal error. Please check '/var/log/mindi.log'.");
    256257        }
    257         paranoid_free(command);
    258         paranoid_free(tmp);
     258        mr_free(command);
     259        mr_free(tmp);
    259260    }
    260261
     
    303304    assert_string_is_neither_NULL_nor_zerolength(fname);
    304305
    305     asprintf(&command, "which %s 2> /dev/null", fname);
     306    mr_asprintf(&command, "which %s 2> /dev/null", fname);
    306307    incoming = call_program_and_get_last_line_of_output(command);
    307     paranoid_free(command);
     308    mr_free(command);
    308309
    309310    if (incoming == NULL) {
     
    311312            return (NULL);      // forget it :)
    312313        }
    313         asprintf(&command,
     314        mr_asprintf(&command,
    314315                "file %s 2> /dev/null | cut -d':' -f1 2> /dev/null",
    315316                incoming);
    316         paranoid_free(incoming);
     317        mr_free(incoming);
    317318
    318319        incoming = call_program_and_get_last_line_of_output(command);
    319         paranoid_free(command);
     320        mr_free(command);
    320321    }
    321322    if (incoming == NULL)   // yes, it is == '\0' twice, not once :)
    322323    {
    323         asprintf(&command, "dirname %s 2> /dev/null", incoming);
    324         paranoid_free(incoming);
     324        mr_asprintf(&command, "dirname %s 2> /dev/null", incoming);
     325        mr_free(incoming);
    325326
    326327        incoming = call_program_and_get_last_line_of_output(command);
    327         paranoid_free(command);
     328        mr_free(command);
    328329    }
    329330    output = incoming;
     
    332333        log_msg(4, "find_home_of_exe () --- Found %s at %s", fname, output);
    333334    } else {
    334         paranoid_free(output);
     335        mr_free(output);
    335336        log_msg(4, "find_home_of_exe() --- Could not find %s", fname);
    336337    }
     
    395396         && !strstr(err_log_lines[i], "% done"); i--);
    396397    if (i < 0) {
    397         asprintf(&command,
     398        mr_asprintf(&command,
    398399                "tail -n3 %s | grep -Fi \"%c\" | tail -n1 | awk '{print $0;}'",
    399400                filename, '%');
    400401        lastline = call_program_and_get_last_line_of_output(command);
    401         paranoid_free(command);
     402        mr_free(command);
    402403        if (!lastline) {
    403404            return (0);
    404405        }
    405406    } else {
    406         asprintf(&lastline, err_log_lines[i]);
     407        mr_asprintf(&lastline, err_log_lines[i]);
    407408    }
    408409
     
    412413    }
    413414    if (!p) {
    414         paranoid_free(lastline);
     415        mr_free(lastline);
    415416        return (0);
    416417    }
     
    421422    }
    422423    i = atoi(p);
    423     paranoid_free(lastline);
     424    mr_free(lastline);
    424425
    425426    return (i);
     
    447448
    448449    if (!does_file_exist(filename)) {
    449         asprintf(&tmp, _("Tring to get last line of nonexistent file (%s)"),
     450        mr_asprintf(&tmp, _("Tring to get last line of nonexistent file (%s)"),
    450451                filename);
    451452        log_it(tmp);
    452         paranoid_free(tmp);
     453        mr_free(tmp);
    453454        return (NULL);
    454455    }
    455     asprintf(&command, "tail -n1 %s", filename);
     456    mr_asprintf(&command, "tail -n1 %s", filename);
    456457    fin = popen(command, "r");
    457     paranoid_free(command);
    458 
    459     getline(&output, &n, fin);
     458    mr_free(command);
     459
     460    mr_getline(&output, &n, fin);
    460461    paranoid_pclose(fin);
    461462    while (strlen(output) > 0 && output[strlen(output) - 1] < 32) {
     
    504505
    505506    assert_string_is_neither_NULL_nor_zerolength(outdir_fname);
    506     asprintf(&tmp, "mkdir -p %s", outdir_fname);
     507    mr_asprintf(&tmp, "mkdir -p %s", outdir_fname);
    507508    res = system(tmp);
    508     paranoid_free(tmp);
     509    mr_free(tmp);
    509510    return (res);
    510511}
     
    532533    assert(!strstr(outfile_fname, "/dev/cdrom"));
    533534
    534     asprintf(&command, "mkdir -p \"%s\" 2> /dev/null", outfile_fname);
     535    mr_asprintf(&command, "mkdir -p \"%s\" 2> /dev/null", outfile_fname);
    535536    res += system(command);
    536     paranoid_free(command);
    537 
    538     asprintf(&command, "rmdir \"%s\" 2> /dev/null", outfile_fname);
     537    mr_free(command);
     538
     539    mr_asprintf(&command, "rmdir \"%s\" 2> /dev/null", outfile_fname);
    539540    res += system(command);
    540     paranoid_free(command);
    541 
    542     asprintf(&command, "rm -f \"%s\" 2> /dev/null", outfile_fname);
     541    mr_free(command);
     542
     543    mr_asprintf(&command, "rm -f \"%s\" 2> /dev/null", outfile_fname);
    543544    res += system(command);
    544     paranoid_free(command);
     545    mr_free(command);
    545546    unlink(outfile_fname);
    546547    return (0);
     
    575576        return (0);
    576577    }
    577     (void) getline(&incoming, &n, fin);
     578    mr_getline(&incoming, &n, fin);
    578579    while (!feof(fin)) {
    579580        if (strstr(incoming, wildcard)) {
    580581            matches++;
    581582        }
    582         (void) getline(&incoming, &n, fin);
     583        mr_getline(&incoming, &n, fin);
    583584    }
    584585    paranoid_fclose(fin);
    585     paranoid_free(incoming);
     586    mr_free(incoming);
    586587    return (matches);
    587588}
     
    603604    FILE *fin;
    604605
    605     asprintf(&lockfile_fname, "/var/run/monitas-%s.pid", name_str);
     606    mr_asprintf(&lockfile_fname, "/var/run/monitas-%s.pid", name_str);
    606607    if (!pid) {
    607608        log_it("Unregistering PID");
     
    609610            log_it("Error unregistering PID");
    610611        }
    611         paranoid_free(lockfile_fname);
     612        mr_free(lockfile_fname);
    612613        return;
    613614    }
    614615    if (does_file_exist(lockfile_fname)) {
    615616        if ((fin = fopen(lockfile_fname, "r"))) {
    616             (void) getline(&tmp, &n, fin);
     617            mr_getline(&tmp, &n, fin);
    617618            paranoid_fclose(fin);
    618619        } else {
     
    620621        }
    621622        pid = (pid_t) atol(tmp);
    622         paranoid_free(tmp);
    623 
    624         asprintf(&tmp, "ps %ld > /dev/null 2> /dev/null", (long int) pid);
     623        mr_free(tmp);
     624
     625        mr_asprintf(&tmp, "ps %ld > /dev/null 2> /dev/null", (long int) pid);
    625626        res = system(tmp);
    626         paranoid_free(tmp);
     627        mr_free(tmp);
    627628        if (!res) {
    628629            log_it
     
    631632        }
    632633    }
    633     asprintf(&tmp, "echo %ld > %s 2> /dev/null", (long int) getpid(),
     634    mr_asprintf(&tmp, "echo %ld > %s 2> /dev/null", (long int) getpid(),
    634635            lockfile_fname);
    635     paranoid_free(lockfile_fname);
     636    mr_free(lockfile_fname);
    636637
    637638    if (system(tmp)) {
    638639        fatal_error("Cannot register PID");
    639640    }
    640     paranoid_free(tmp);
     641    mr_free(tmp);
    641642    return;
    642643}
     
    655656    long file_len_K = 0L;
    656657
    657     asprintf(&command,
     658    mr_asprintf(&command,
    658659            "grep '%s ' %s/mountlist.txt | head -n1 | awk '{print $4;}'",
    659660            dev, tmpdir);
     
    662663    file_len_K = atol(sz_res);
    663664    log_msg(4, "%s --> %s --> %ld", command, sz_res, file_len_K);
    664     paranoid_free(command);
    665     paranoid_free(sz_res);
     665    mr_free(command);
     666    mr_free(sz_res);
    666667    return (file_len_K);
    667668}
     
    692693
    693694    log_it("Calculating size of all biggiefiles (in total)");
    694     asprintf(&biggielist, "%s/biggielist.txt", bkpinfo->tmpdir);
     695    mr_asprintf(&biggielist, "%s/biggielist.txt", bkpinfo->tmpdir);
    695696    log_it("biggielist = %s", biggielist);
    696697    if (!(fin = fopen(biggielist, "r"))) {
     
    699700    } else {
    700701        log_msg(4, "Reading it...");
    701         for (getline(&fname, &n, fin); !feof(fin);
    702              getline(&fname, &n, fin)) {
     702        for (mr_getline(&fname, &n, fin); !feof(fin);
     703             mr_getline(&fname, &n, fin)) {
    703704            if (fname[strlen(fname) - 1] <= 32) {
    704705                fname[strlen(fname) - 1] = '\0';
     
    710711                        fatal_error("ntfsresize not found");
    711712                    }
    712                     paranoid_free(tmp);
    713 
    714                     asprintf(&command, "ntfsresize --force --info %s|grep '^You might resize at '|cut -d' ' -f5", fname);
     713                    mr_free(tmp);
     714
     715                    mr_asprintf(&command, "ntfsresize --force --info %s|grep '^You might resize at '|cut -d' ' -f5", fname);
    715716                    log_it("command = %s", command);
    716717                    tmp = call_program_and_get_last_line_of_output(command);
    717                     paranoid_free(command);
     718                    mr_free(command);
    718719
    719720                    log_it("res of it = %s", tmp);
    720721                    file_len_K = atoll(tmp) / 1024L;
    721                     paranoid_free(tmp);
     722                    mr_free(tmp);