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


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

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

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r851 r900  
    2323#include <pthread.h>
    2424#endif
     25#include "mr_mem.h"
    2526
    2627extern void twenty_seconds_til_yikes(void);
    … …  
    160161    assert(raidlist != NULL);
    161162    if (!bkpinfo->disaster_recovery) {
    162         paranoid_alloc(g_mountlist_fname, "/tmp/mountlist.txt");
     163        mr_allocstr(g_mountlist_fname, "/tmp/mountlist.txt");
    163164        log_msg(2, "I guess you're testing edit_mountlist()");
    164165    }
    … …  
    274275        }
    275276        if (g_ISO_restore_mode) {
    276             asprintf(&tmp, "umount %s", bkpinfo->isodir);
     277            mr_asprintf(&tmp, "umount %s", bkpinfo->isodir);
    277278            run_program_and_log_output(tmp, FALSE);
    278             paranoid_free(tmp);
     279            mr_free(tmp);
    279280        }
    280281        paranoid_MR_finish(0);
    … …  
    386387            save_mountlist_to_disk(mountlist, g_mountlist_fname);
    387388            tmp1 = find_my_editor();
    388             asprintf(&tmp, "%s %s", tmp1, g_mountlist_fname);
    389             paranoid_free(tmp1);
     389            mr_asprintf(&tmp, "%s %s", tmp1, g_mountlist_fname);
     390            mr_free(tmp1);
    390391
    391392            res = system(tmp);
    392             paranoid_free(tmp);
     393            mr_free(tmp);
    393394            load_mountlist(mountlist, g_mountlist_fname);
    394395        } else {
    … …  
    500501             ask_me_yes_or_no
    501502             (_("Do you want me to restore _some_ of your data?")))) {
    502         asprintf(&old_restpath,bkpinfo->restore_path);
     503        mr_asprintf(&old_restpath,bkpinfo->restore_path);
    503504        for (done = FALSE; !done;) {
    504505            unlink("/tmp/filelist.full");
    … …  
    514515                    if (!strcmp(bkpinfo->restore_path, "/")) {
    515516                        if (!ask_me_yes_or_no(_("Are you sure?"))) {
    516                             paranoid_alloc(bkpinfo->restore_path, old_restpath);
     517                            mr_allocstr(bkpinfo->restore_path, old_restpath);
    517518                            goto gotos_suck;
    518519                        }
    519                         paranoid_alloc(bkpinfo->restore_path, "");  // so we restore to [blank]/file/name :)
     520                        mr_allocstr(bkpinfo->restore_path, ""); // so we restore to [blank]/file/name :)
    520521                    }
    521522                    log_msg(1, "Restoring subset");
    … …  
    523524                    free_filelist(filelist);
    524525                } else {
    525                     paranoid_alloc(bkpinfo->restore_path,old_restpath);
     526                    mr_allocstr(bkpinfo->restore_path,old_restpath);
    526527                    free_filelist(filelist);
    527528                }
    … …  
    534535            }
    535536        }
    536         paranoid_free(old_restpath);
     537        mr_free(old_restpath);
    537538    } else {
    538539        mvaddstr_and_log_it(g_currentY++,
    … …  
    567568                            ("Using e2label to label your ext2,3 partitions"));
    568569        if (does_file_exist("/tmp/fstab.new")) {
    569             asprintf(&fstab_fname, "/tmp/fstab.new");
     570            mr_asprintf(&fstab_fname, "/tmp/fstab.new");
    570571        } else {
    571             asprintf(&fstab_fname, "/tmp/fstab");
    572         }
    573         asprintf(&tmp,
     572            mr_asprintf(&fstab_fname, "/tmp/fstab");
     573        }
     574        mr_asprintf(&tmp,
    574575                "label-partitions-as-necessary %s < %s >> %s 2>> %s",
    575576                g_mountlist_fname, fstab_fname, MONDO_LOGFILE,
    576577                MONDO_LOGFILE);
    577         paranoid_free(fstab_fname);
     578        mr_free(fstab_fname);
    578579
    579580        res = system(tmp);
    580         paranoid_free(tmp);
     581        mr_free(tmp);
    581582        if (res) {
    582583            log_to_screen
    … …  
    679680            (strstr(tmp1,"RESTORE") == NULL)) {
    680681                /* -H option */
    681                 asprintf(&tmp,
     682                mr_asprintf(&tmp,
    682683                    _
    683684                    (" Mondo has restored your system. Please remove the backup media and reboot.\n\nPlease visit our website at http://www.mondorescue.org for more information."));
    684685                popup_and_OK(tmp);
    685                 paranoid_free(tmp);
    686         }
    687         paranoid_free(tmp1);
     686                mr_free(tmp);
     687        }
     688        mr_free(tmp1);
    688689
    689690        log_to_screen(_
    … …  
    739740        resize_mountlist_proportionately_to_suit_new_drives(mountlist);
    740741    }
    741     paranoid_free(tmp);
     742    mr_free(tmp);
    742743
    743744    if (!evaluate_mountlist(mountlist, tmpA, tmpB, tmpC)) {
    744         asprintf(&tmp,
     745        mr_asprintf(&tmp,
    745746                _
    746747                ("Mountlist analyzed. Result: \"%s %s %s\" Switch to Interactive Mode?"),
    747748                tmpA, tmpB, tmpC);
    748749        if (ask_me_yes_or_no(tmp)) {
    749             paranoid_free(tmp);
     750            mr_free(tmp);
    750751            retval = interactive_mode(bkpinfo, mountlist, raidlist);
    751752            goto after_the_nuke;
    752753        } else {
    753             paranoid_free(tmp);
     754            mr_free(tmp);
    754755            fatal_error("Nuke Mode aborted. ");
    755756        }
    … …  
    787788                }
    788789            }
    789             paranoid_free(tmp);
     790            mr_free(tmp);
    790791
    791792            retval += res;
    … …  
    840841                        ("Using e2label to label your ext2,3 partitions"));
    841842
    842     asprintf(&tmp, "label-partitions-as-necessary %s < /tmp/fstab",
     843    mr_asprintf(&tmp, "label-partitions-as-necessary %s < /tmp/fstab",
    843844            g_mountlist_fname);
    844845    res = run_program_and_log_output(tmp, TRUE);
    845     paranoid_free(tmp);
     846    mr_free(tmp);
    846847
    847848    if (res) {
    … …  
    916917    }
    917918
    918     paranoid_alloc(bkpinfo->restore_path, "/");
     919    mr_allocstr(bkpinfo->restore_path, "/");
    919920    if (!g_restoring_live_from_cd) {
    920921        popup_and_OK
    … …  
    945946    if (filelist) {
    946947        save_filelist(filelist, "/tmp/selected-files.txt");
    947         asprintf(&old_restpath,bkpinfo->restore_path);
     948        mr_asprintf(&old_restpath,bkpinfo->restore_path);
    948949        if (popup_and_get_string(_("Restore path"),
    949950                                 _("Restore files to where? )"),
    … …  
    953954        }
    954955        free_filelist(filelist);
    955         paranoid_alloc(bkpinfo->restore_path,old_restpath);
     956        mr_allocstr(bkpinfo->restore_path,old_restpath);
    956957    }
    957958    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
    … …  
    10341035    if (!(fin = fopen(tmp,"r"))) {
    10351036        log_to_screen(_("Cannot even open bigfile's info file"));
    1036         paranoid_free(tmp);
     1037        mr_free(tmp);
    10371038        return (pathname_of_last_file_restored);
    10381039    }
    1039     paranoid_free(tmp);
     1040    mr_free(tmp);
    10401041
    10411042    memset((void *) &biggiestruct, 0, sizeof(biggiestruct));
    … …  
    10471048    paranoid_fclose(fin);
    10481049
    1049     asprintf(&checksum, biggiestruct.checksum);
     1050    mr_asprintf(&checksum, biggiestruct.checksum);
    10501051
    10511052    if (!checksum[0]) {
    1052         asprintf(&tmp, "Warning - bigfile %ld does not have a checksum",
     1053        mr_asprintf(&tmp, "Warning - bigfile %ld does not have a checksum",
    10531054                bigfileno + 1);
    10541055        log_msg(3, tmp);
    1055         paranoid_free(tmp);
     1056        mr_free(tmp);
    10561057        /* BERLIOS : Useless ???
    10571058        p = checksum;
    10581059        */
    10591060    }
    1060     paranoid_free(checksum);
     1061    mr_free(checksum);
    10611062
    10621063    if (!strncmp(biggiestruct.filename, "/dev/", 5))    // Whether NTFS or not :)
    10631064    {
    1064         asprintf(&outfile_fname, biggiestruct.filename);
     1065        mr_asprintf(&outfile_fname, biggiestruct.filename);
    10651066    } else {
    1066         asprintf(&outfile_fname, "%s/%s", bkpinfo->restore_path,
     1067        mr_asprintf(&outfile_fname, "%s/%s", bkpinfo->restore_path,
    10671068                biggiestruct.filename);
    10681069    }
    … …  
    11011102                "Calling ntfsclone in background because %s is an NTFS /dev entry",
    11021103                outfile_fname);
    1103         asprintf(&ntfsprog_fifo, "/tmp/%d.%d.000", (int) (random() % 32768),
     1104        mr_asprintf(&ntfsprog_fifo, "/tmp/%d.%d.000", (int) (random() % 32768),
    11041105                (int) (random() % 32768));
    11051106        mkfifo(ntfsprog_fifo, 0x770);
    … …  
    11251126        }
    11261127        // BERLIOS: Is it the right place ??
    1127         paranoid_free(ntfsprog_fifo);
     1128        mr_free(ntfsprog_fifo);
    11281129    } else {
    11291130        use_ntfsprog_hack = FALSE;
    … …  
    11351136    }
    11361137
    1137     asprintf(&tmp, "Reassembling big file %ld (%s)", bigfileno + 1,
     1138    mr_asprintf(&tmp, "Reassembling big file %ld (%s)", bigfileno + 1,
    11381139            outfile_fname);
    11391140    log_msg(2, tmp);
    1140     paranoid_free(tmp);
     1141    mr_free(tmp);
    11411142
    11421143    /*
    … …  
    11461147     */
    11471148
    1148     asprintf(&pathname_of_last_file_restored, biggiestruct.filename);
     1149    mr_asprintf(&pathname_of_last_file_restored, biggiestruct.filename);
    11491150
    11501151    log_msg(3, "file_to_openout = %s", file_to_openout);
    … …  
    11651166                    g_current_media_number);
    11661167            g_current_media_number++;
    1167             asprintf(&tmp3,
     1168            mr_asprintf(&tmp3,
    11681169                    "Asking for %s #%d so that I may read slice #%ld\n",
    11691170                    bkpinfo->backup_media_string,
    11701171                    g_current_media_number, sliceno);
    11711172            log_msg(2, tmp3);
    1172             paranoid_free(tmp3);
    1173 
    1174             asprintf(&tmp3, _("Restoring from %s #%d"),
     1173            mr_free(tmp3);
     1174
     1175            mr_asprintf(&tmp3, _("Restoring from %s #%d"),
    11751176                    bkpinfo->backup_media_string,
    11761177                    g_current_media_number);
    11771178            log_to_screen(tmp3);
    1178             paranoid_free(tmp3);
     1179            mr_free(tmp3);
    11791180
    11801181            insist_on_this_cd_number(bkpinfo, g_current_media_number);
    … …  
    11891190            } else {
    11901191                if (does_file_exist(tmp1)) {
    1191                     asprintf(&bzip2_command, "lzop -dc %s 2>> %s",tmp1, MONDO_LOGFILE);
     1192                    mr_asprintf(&bzip2_command, "lzop -dc %s 2>> %s",tmp1, MONDO_LOGFILE);
    11921193                } else if (does_file_exist(tmp2)) {
    1193                         asprintf(&bzip2_command, "bzip2 -dc %s 2>> %s",tmp2, MONDO_LOGFILE);
     1194                        mr_asprintf(&bzip2_command, "bzip2 -dc %s 2>> %s",tmp2, MONDO_LOGFILE);
    11941195                } else if (does_file_exist(tmp)) {
    1195                         asprintf(&bzip2_command, "%s", "");
     1196                        mr_asprintf(&bzip2_command, "%s", "");
    11961197                } else {
    11971198                    log_to_screen(_("OK, that's pretty fsck0red..."));
    … …  
    12011202
    12021203            if (bzip2_command == NULL) {
    1203                 asprintf(&bzip2_command, "cat %s 2>> %s", tmp, MONDO_LOGFILE);
    1204             }
    1205             asprintf(&tmp3, "Working on %s #%d, file #%ld, slice #%ld ",
     1204                mr_asprintf(&bzip2_command, "cat %s 2>> %s", tmp, MONDO_LOGFILE);
     1205            }
     1206            mr_asprintf(&tmp3, "Working on %s #%d, file #%ld, slice #%ld ",
    12061207                    bkpinfo->backup_media_string,
    12071208                    g_current_media_number, bigfileno + 1, sliceno);
    … …  
    12121213                update_progress_form(tmp3);
    12131214            }
    1214             paranoid_free(tmp3);
     1215            mr_free(tmp3);
    12151216
    12161217            if (!(fbzip2 = popen(bzip2_command, "r"))) {
    12171218                fatal_error("Can't run popen command");
    12181219            }
    1219             paranoid_free(bzip2_command);
     1220            mr_free(bzip2_command);
    12201221
    12211222            while (!feof(fbzip2)) {
    … …  
    12231224                if (siz > 0) {
    12241225                    siz1 = fwrite(bigblk, 1, siz, fout);
    1225                     asprintf(&sz_msg, "Read %ld from fbzip2; written %ld to fout", siz, siz1);
     1226                    mr_asprintf(&sz_msg, "Read %ld from fbzip2; written %ld to fout", siz, siz1);
    12261227                    log_it(sz_msg);
    1227                     paranoid_free(sz_msg);
     1228                    mr_free(sz_msg);
    12281229                }
    12291230            }
    … …  
    12341235            g_current_progress++;
    12351236        }
    1236         paranoid_free(tmp);
    1237         paranoid_free(tmp1);
    1238         paranoid_free(tmp2);
     1237        mr_free(tmp);
     1238        mr_free(tmp1);
     1239        mr_free(tmp2);
    12391240    }
    12401241    paranoid_fclose(fout);
    … …  
    12431244    if (use_ntfsprog_hack) {
    12441245        log_msg(3, "Waiting for ntfsclone to finish");
    1245         asprintf(&tmp,
     1246        mr_asprintf(&tmp,
    12461247                " ps | grep \" ntfsclone \" | grep -v grep > /dev/null 2> /dev/null");
    12471248        while (system(tmp) == 0) {
    12481249            sleep(1);
    12491250        }
    1250         paranoid_free(tmp);
     1251        mr_free(tmp);
    12511252        log_it("OK, ntfsclone has really finished");
    12521253    }
    … …  
    12601261        utime(outfile_fname, ubuf);
    12611262    }
    1262     paranoid_free(outfile_fname);
    1263     paranoid_free(bigblk);
     1263    mr_free(outfile_fname);
     1264    mr_free(bigblk);
    12641265
    12651266    return (pathname_of_last_file_restored);
    … …  
    13291330    }
    13301331
    1331     asprintf(&pathname_of_last_file_restored, orig_bf_fname);
     1332    mr_asprintf(&pathname_of_last_file_restored, orig_bf_fname);
    13321333
    13331334    /* open out to biggiefile to be restored (or /dev/null if biggiefile is not to be restored) */
    … …  
    13591360    if (use_ntfsprog) {
    13601361        g_loglevel = 4;
    1361         asprintf(&outfile_fname, orig_bf_fname);
     1362        mr_asprintf(&outfile_fname, orig_bf_fname);
    13621363        use_ntfsprog_hack = TRUE;
    13631364        log_msg(2,
    13641365                "Calling ntfsclone in background because %s is a /dev entry",
    13651366                outfile_fname);
    1366         asprintf(&ntfsprog_fifo, "%s/%d.%d.000",
     1367        mr_asprintf(&ntfsprog_fifo, "%s/%d.%d.000",
    13671368                bkpinfo->tmpdir,
    13681369                (int) (random() % 32768),
    … …  
    13871388                    (long int) (pid));
    13881389        }
    1389         paranoid_free(ntfsprog_fifo);
     1390        mr_free(ntfsprog_fifo);
    13901391    } else {
    13911392        if (!strncmp(orig_bf_fname, "/dev/", 5))    // non-NTFS partition
    13921393        {
    1393             asprintf(&outfile_fname, orig_bf_fname);
     1394            mr_asprintf(&outfile_fname, orig_bf_fname);
    13941395        } else                  // biggiefile
    13951396        {
    1396             asprintf(&outfile_fname, "%s/%s", bkpinfo->restore_path,
     1397            mr_asprintf(&outfile_fname, "%s/%s", bkpinfo->restore_path,
    13971398                    orig_bf_fname);
    13981399        }
    … …  
    14031404            make_hole_for_file(outfile_fname);
    14041405        }
    1405         asprintf(&tmp1, "Reassembling big file %ld (%s)",
     1406        mr_asprintf(&tmp1, "Reassembling big file %ld (%s)",
    14061407                biggiefile_number + 1, orig_bf_fname);
    14071408        log_msg(2, tmp1);
    1408         paranoid_free(tmp1);
     1409        mr_free(tmp1);
    14091410    }
    14101411
    14111412    if (dummy_restore) {
    1412         paranoid_free(outfile_fname);
    1413         asprintf(&outfile_fname, "/dev/null");
     1413        mr_free(outfile_fname);
     1414        mr_asprintf(&outfile_fname, "/dev/null");
    14141415    }
    14151416
    14161417    if (bkpinfo->zip_exe == NULL) {
    1417         asprintf(&command, "cat > \"%s\"", file_to_openout);
     1418        mr_asprintf(&command, "cat > \"%s\"", file_to_openout);
    14181419    } else {
    1419         asprintf(&command, "%s -dc > \"%s\" 2>> %s", bkpinfo->zip_exe,
     1420        mr_asprintf(&command, "%s -dc > \"%s\" 2>> %s", bkpinfo->zip_exe,
    14201421                file_to_openout, MONDO_LOGFILE);
    14211422    }
    1422     asprintf(&tmp1, "Pipe command = '%s'", command);
     1423    mr_asprintf(&tmp1, "Pipe command = '%s'", command);
    14231424    log_msg(3, tmp1);
    1424     paranoid_free(tmp1);
     1425    mr_free(tmp1);
    14251426
    14261427    /* restore biggiefile, one slice at a time */
    … …  
    14281429        fatal_error("Cannot pipe out");
    14291430    }
    1430     paranoid_free(command);
     1431    mr_free(command);
    14311432
    14321433    for (res = read_header_block_from_stream(&slice_siz, tmp, &ctrl_chr);
    … …  
    14361437            wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
    14371438        }
    1438         asprintf(&tmp1, "Working on file #%ld, slice #%ld    ",
     1439        mr_asprintf(&tmp1, "Working on file #%ld, slice #%ld    ",
    14391440                biggiefile_number + 1, current_slice_number);
    14401441        log_msg(2, tmp1);
    … …  
    14461447        strip_spaces(tmp1);
    14471448        update_progress_form(tmp1);
    1448         paranoid_free(tmp1);
     1449        mr_free(tmp1);
    14491450
    14501451        if (current_slice_number == 0) {
    … …  
    14771478        g_current_progress++;
    14781479    }
    1479     paranoid_free(tmp);
     1480    mr_free(tmp);
    14801481    paranoid_pclose(pout);
    14811482
    … …  
    14851486    if (use_ntfsprog_hack) {
    14861487        log_msg(3, "Waiting for ntfsclone to finish");
    1487         asprintf(&tmp,
     1488        mr_asprintf(&tmp,
    14881489                " ps | grep \" ntfsclone \" | grep -v grep > /dev/null 2> /dev/null");
    14891490        while (system(tmp) == 0) {
    14901491            sleep(1);
    14911492        }   
    1492         paranoid_free(tmp);
     1493        mr_free(tmp);
    14931494        log_msg(3, "OK, ntfsclone has really finished");
    14941495    }
    … …  
    15051506    }
    15061507
    1507     paranoid_free(outfile_fname);
     1508    mr_free(outfile_fname);
    15081509    g_loglevel = old_loglevel;
    15091510    return (pathname_of_last_file_restored);
    … …  
    15511552    log_msg(5, "Entering");
    15521553    use_star = (strstr(tarball_fname, ".star")) ? TRUE : FALSE;
    1553     asprintf(&command, "mkdir -p %s/tmp", MNT_RESTORING);
     1554    mr_asprintf(&command, "mkdir -p %s/tmp", MNT_RESTORING);
    15541555    run_program_and_log_output(command, 9);
    1555     paranoid_free(command);
    1556 
    1557     asprintf(&filelist_name, MNT_CDROM "/archives/filelist.%ld",
     1556    mr_free(command);
     1557
     1558    mr_asprintf(&filelist_name, MNT_CDROM "/archives/filelist.%ld",
    15581559            current_tarball_number);
    15591560    if (length_of_file(filelist_name) <= 2) {
    … …  
    15721573        log_msg(3, "length_of_file(%s) = %llu", tarball_fname,
    15731574                length_of_file(tarball_fname));
    1574         asprintf(&tmp, "Unable to restore fileset #%ld (CD I/O error)",
     1575        mr_asprintf(&tmp, "Unable to restore fileset #%ld (CD I/O error)",
    15751576                current_tarball_number);
    15761577        log_to_screen(tmp);
    1577         paranoid_free(tmp);
     1578        mr_free(tmp);
    15781579        retval = 1;
    15791580        log_msg(5, "Leaving");
    … …  
    15821583
    15831584    if (filelist) {
    1584         asprintf(&filelist_subset_fname, "/tmp/filelist-subset-%ld.tmp",
     1585        mr_asprintf(&filelist_subset_fname, "/tmp/filelist-subset-%ld.tmp",
    15851586                current_tarball_number);
    15861587        if ((matches =
    … …  
    15891590                                             use_star))
    15901591            <= 0) {
    1591             asprintf(&tmp, "Skipping fileset %ld", current_tarball_number);
     1592            mr_asprintf(&tmp, "Skipping fileset %ld", current_tarball_number);
    15921593            log_msg(1, tmp);
    1593             paranoid_free(tmp);
     1594            mr_free(tmp);
    15941595        } else {
    15951596            log_msg(3, "Saved fileset %ld's subset to %s",
    15961597                    current_tarball_number, filelist_subset_fname);
    15971598        }
    1598         asprintf(&tmp, "Tarball #%ld --- %ld matches",
     1599        mr_asprintf(&tmp, "Tarball #%ld --- %ld matches",
    15991600                current_tarball_number, matches);
    16001601        log_to_screen(tmp);
    1601         paranoid_free(tmp);
     1602        mr_free(tmp);
    16021603    } else {
    16031604        filelist_subset_fname = NULL;
    16041605    }
    1605     paranoid_free(filelist_name);
     1606    mr_free(filelist_name);
    16061607
    16071608    if (filelist == NULL || matches > 0) {
    1608         asprintf(&xattr_fname, XATTR_LIST_FNAME_RAW_SZ,
     1609        mr_asprintf(&xattr_fname, XATTR_LIST_FNAME_RAW_SZ,
    16091610                MNT_CDROM "/archives", current_tarball_number);
    1610         asprintf(&acl_fname, ACL_LIST_FNAME_RAW_SZ, MNT_CDROM "/archives",
     1611        mr_asprintf(&acl_fname, ACL_LIST_FNAME_RAW_SZ, MNT_CDROM "/archives",
    16111612                current_tarball_number);
    16121613        if (strstr(tarball_fname, ".bz2")) {
    1613             asprintf(&executable, "bzip2");
     1614            mr_asprintf(&executable, "bzip2");
    16141615        } else if (strstr(tarball_fname, ".lzo")) {
    1615             asprintf(&executable, "lzop");
     1616            mr_asprintf(&executable, "lzop");
    16161617        } else {
    16171618            executable = NULL;
    … …  
    16191620
    16201621        if (executable == NULL) {
    1621             asprintf(&tmp, "which %s > /dev/null 2> /dev/null", executable);
     1622            mr_asprintf(&tmp, "which %s > /dev/null 2> /dev/null", executable);
    16221623            if (run_program_and_log_output(tmp, FALSE)) {
    16231624                log_to_screen
    … …  
    16261627                paranoid_MR_finish(1);
    16271628            }
    1628             paranoid_free(tmp);
    1629 
    1630             asprintf(&tmp, executable);
    1631             asprintf(&executable, "-P %s -Z", tmp);
    1632             paranoid_free(tmp);
     1629            mr_free(tmp);
     1630
     1631            mr_asprintf(&tmp, executable);
     1632            mr_asprintf(&executable, "-P %s -Z", tmp);
     1633            mr_free(tmp);
    16331634        }
    16341635#ifdef __FreeBSD__
    … …  
    16381639#endif
    16391640
    1640         asprintf(&temp_log, "/tmp/%d.%d", (int) (random() % 32768),
     1641        mr_asprintf(&temp_log, "/tmp/%d.%d", (int) (random() % 32768),
    16411642            (int) (random() % 32768));
    16421643
    16431644        if (use_star) {
    16441645            if (strstr(tarball_fname, ".bz2")) {
    1645                 asprintf(&tmp, " -bz");
     1646                mr_asprintf(&tmp, " -bz");
    16461647            } else {
    1647                 asprintf(&tmp, "%s", "");
    1648             }
    1649             asprintf(&command,
     1648                mr_asprintf(&tmp, "%s", "");
     1649            }
     1650            mr_asprintf(&command,
    16501651                    "star -x -force-remove -U " STAR_ACL_SZ
    16511652                    " errctl= file=%s %s 2>> %s >> %s", tarball_fname, tmp, temp_log, temp_log);
    1652             paranoid_free(tmp);
     1653            mr_free(tmp);
    16531654        } else {
    16541655            if (filelist_subset_fname != NULL) {
    1655                 asprintf(&command,
     1656                mr_asprintf(&command,
    16561657                        "afio -i -M 8m -b %ld -c %ld %s -w '%s' %s 2>> %s >> %s",
    16571658                        TAPE_BLOCK_SIZE,
    … …  
    16601661                        tarball_fname, temp_log, temp_log);
    16611662            } else {
    1662                 asprintf(&command,
     1663                mr_asprintf(&command,
    16631664                        "afio -i -b %ld -c %ld -M 8m %s %s 2>> %s >> %s",
    16641665                        TAPE_BLOCK_SIZE,
    … …  
    16661667            }
    16671668        }
    1668         paranoid_free(executable);
     1669        mr_free(executable);
    16691670
    16701671#undef BUFSIZE
    … …  
    16801681            }
    16811682        }
    1682         paranoid_free(command);
     1683        mr_free(command);
    16831684
    16841685        if (res && length_of_file(temp_log) < 5) {
    … …  
    17111712        }
    17121713        if (retval) {
    1713             asprintf(&command, "cat %s >> %s", temp_log, MONDO_LOGFILE);
     1714            mr_asprintf(&command, "cat %s >> %s", temp_log, MONDO_LOGFILE);
    17141715            system(command);
    1715             paranoid_free(command);
     1716            mr_free(command);
    17161717            log_msg(2, "Errors occurred while processing fileset #%d",
    17171718                    current_tarball_number);
    … …  
    17201721        }
    17211722        unlink(xattr_fname);
    1722         paranoid_free(xattr_fname);
     1723        mr_free(xattr_fname);
    17231724    }
    17241725    if (does_file_exist("/PAUSE")) {
    … …  
    17311732    unlink(temp_log);
    17321733
    1733     paranoid_free(filelist_subset_fname);
    1734     paranoid_free(acl_fname);
    1735     paranoid_free(temp_log);
     1734    mr_free(filelist_subset_fname);
     1735    mr_free(acl_fname);
     1736    mr_free(temp_log);
    17361737
    17371738    log_msg(5, "Leaving");
    … …  
    17851786    /* to do it with a file... */
    17861787    use_star = (strstr(tarball_fname, ".star")) ? TRUE : FALSE;
    1787     asprintf(&tmp,
     1788    mr_asprintf(&tmp,
    17881789            "Restoring from fileset #%ld (%ld KB) on %s #%d",
    17891790            current_tarball_number, (long) size >> 10,
    … …  
    17911792            g_current_media_number);
    17921793    log_msg(2, tmp);
    1793     paranoid_free(tmp);
     1794    mr_free(tmp);
    17941795    run_program_and_log_output("mkdir -p " MNT_RESTORING "/tmp", FALSE);
    17951796
    … …  
    17991800   * in afio or someting; oh darn.. OK, use tmpfs :-)                         *
    18001801   ****************************************************************************/
    1801     asprintf(&afio_fname, "/tmp/tmpfs/archive.tmp.%ld",
     1802    mr_asprintf(&afio_fname, "/tmp/tmpfs/archive.tmp.%ld",
    18021803            current_tarball_number);
    1803     asprintf(&filelist_fname, "%s/filelist.%ld", bkpinfo->tmpdir,
     1804    mr_asprintf(&filelist_fname, "%s/filelist.%ld", bkpinfo->tmpdir,
    18041805            current_tarball_number);
    1805     asprintf(&filelist_subset_fname, "%s/filelist-subset-%ld.tmp",
     1806    mr_asprintf(&filelist_subset_fname, "%s/filelist-subset-%ld.tmp",
    18061807            bkpinfo->tmpdir, current_tarball_number);
    18071808    res = read_file_from_stream_to_file(bkpinfo, afio_fname, size);
    … …  
    18141815    if (bkpinfo->compression_level != 0) {
    18151816        if (bkpinfo->use_star) {
    1816             asprintf(&executable, " -bz");
     1817            mr_asprintf(&executable, " -bz");
    18171818        } else {
    1818             asprintf(&executable, "-P %s -Z", bkpinfo->zip_exe);
     1819            mr_asprintf(&executable, "-P %s -Z", bkpinfo->zip_exe);
    18191820        }
    18201821    }
    … …  
    18271828        if (strstr(tarball_fname, ".star.")) {
    18281829            use_star = TRUE;
    1829             asprintf(&command, "star -t file=%s %s > %s 2>> %s", afio_fname, executable, filelist_fname, MONDO_LOGFILE);
     1830            mr_asprintf(&command, "star -t file=%s %s > %s 2>> %s", afio_fname, executable, filelist_fname, MONDO_LOGFILE);
    18301831        } else {
    18311832            use_star = FALSE;
    1832             asprintf(&command, "afio -t -M 8m -b %ld %s %s > %s 2>> %s", TAPE_BLOCK_SIZE,
     1833            mr_asprintf(&command, "afio -t -M 8m -b %ld %s %s > %s 2>> %s", TAPE_BLOCK_SIZE,
    18331834                    executable, afio_fname, filelist_fname, MONDO_LOGFILE);
    18341835        }
    … …  
    18371838            log_msg(4, "Warning - error occurred while retrieving TOC");
    18381839        }
    1839         paranoid_free(command);
     1840        mr_free(command);
    18401841        if ((matches =
    18411842             save_filelist_entries_in_common(filelist_fname, filelist,
    … …  
    18471848                        current_tarball_number);
    18481849            }
    1849             asprintf(&tmp, "Skipping fileset %ld", current_tarball_number);
     1850            mr_asprintf(&tmp, "Skipping fileset %ld", current_tarball_number);
    18501851            log_msg(2, tmp);
    1851             paranoid_free(tmp);
     1852            mr_free(tmp);
    18521853            restore_this_fileset = FALSE;
    18531854        } else {
    … …  
    18591860    }
    18601861    unlink(filelist_fname);
    1861     paranoid_free(filelist_fname);
     1862    mr_free(filelist_fname);
    18621863
    18631864// Concoct the call to star/afio to restore files
    … …  
    18651866        // star
    18661867        if (filelist) {
    1867             asprintf(&command, "star -x file=%s %s list=%s 2>> %s", afio_fname, executable,
     1868            mr_asprintf(&command, "star -x file=%s %s list=%s 2>> %s", afio_fname, executable,
    18681869                    filelist_subset_fname,MONDO_LOGFILE);
    18691870        } else {
    1870             asprintf(&command,"star -x file=%s %s 2>> %s", afio_fname, executable,MONDO_LOGFILE);
     1871            mr_asprintf(&command,"star -x file=%s %s 2>> %s", afio_fname, executable,MONDO_LOGFILE);
    18711872        }
    18721873    } else {
    18731874        // afio
    18741875        if (filelist) {
    1875             asprintf(&command, "afio -i -M 8m -b %ld %s -w %s %s 2>> %s", TAPE_BLOCK_SIZE, executable, filelist_subset_fname,afio_fname,MONDO_LOGFILE);
     1876            mr_asprintf(&command, "afio -i -M 8m -b %ld %s -w %s %s 2>> %s", TAPE_BLOCK_SIZE, executable, filelist_subset_fname,afio_fname,MONDO_LOGFILE);
    18761877        } else {
    1877             asprintf(&command, "afio -i -M 8m -b %ld %s %s 2>> %s", TAPE_BLOCK_SIZE, executable,afio_fname,MONDO_LOGFILE);
    1878         }
    1879     }
    1880     paranoid_free(executable);
     1878            mr_asprintf(&command, "afio -i -M 8m -b %ld %s %s 2>> %s", TAPE_BLOCK_SIZE, executable,afio_fname,MONDO_LOGFILE);
     1879        }
     1880    }
     1881    mr_free(executable);
    18811882
    18821883    // Call if IF there are files to restore (selectively/unconditionally)
    … …  
    19051906        log_msg(1, "NOT CALLING '%s'", command);
    19061907    }
    1907     paranoid_free(command);
     1908    mr_free(command);
    19081909
    19091910    if (does_file_exist("/PAUSE") && current_tarball_number >= 50) {
    … …  
    19151916    unlink(afio_fname);
    19161917
    1917     paranoid_free(filelist_subset_fname);
    1918     paranoid_free(afio_fname);
     1918    mr_free(filelist_subset_fname);
     1919    mr_free(afio_fname);
    19191920    return (retval);
    19201921}
    … …  
    19521953    assert(bkpinfo != NULL);
    19531954
    1954     asprintf(&biggies_whose_EXATs_we_should_set,
     1955    mr_asprintf(&biggies_whose_EXATs_we_should_set,
    19551956            "%s/biggies-whose-EXATs-we-should-set", bkpinfo->tmpdir);
    19561957    if (!(fbw = fopen(biggies_whose_EXATs_we_should_set, "w"))) {
    … …  
    19611962    read_cfg_var(g_mondo_cfg_file, "total-slices", tmp);
    19621963    total_slices = atol(tmp);
    1963     paranoid_free(tmp);
    1964 
    1965     asprintf(&tmp, _("Reassembling large files      "));
     1964    mr_free(tmp);
     1965
     1966    mr_asprintf(&tmp, _("Reassembling large files      "));
    19661967    mvaddstr_and_log_it(g_currentY, 0, tmp);
    1967     paranoid_free(tmp);
     1968    mr_free(tmp);
    19681969
    19691970    if (length_of_file(BIGGIELIST) < 6) {
    … …  
    19771978        return (0);
    19781979    }
    1979     asprintf(&tmp, "OK, there are %ld biggiefiles in the archives",
     1980    mr_asprintf(&tmp, "OK, there are %ld biggiefiles in the archives",
    19801981            noof_biggiefiles);
    19811982    log_msg(2, tmp);
    1982     paranoid_free(tmp);
     1983    mr_free(tmp);
    19831984
    19841985    open_progress_form(_("Reassembling large files"),
    … …  
    19981999            tmp1 = slice_fname(bigfileno + 1, 0, ARCHIVES_PATH, "");
    19992000            log_msg(3, "Slicename would have been %s", tmp1);
    2000             paranoid_free(tmp1);
     2001            mr_free(tmp1);
    20012002
    20022003            // I'm not positive 'just_changed_cds' is even necessary...
    … …  
    20082009                insist_on_this_cd_number(bkpinfo,
    20092010                                         ++g_current_media_number);
    2010                 asprintf(&tmp, _("Restoring from %s #%d"),
     2011                mr_asprintf(&tmp, _("Restoring from %s #%d"),
    20112012                        bkpinfo->backup_media_string,
    20122013                        g_current_media_number);
    20132014                log_to_screen(tmp);
    2014                 paranoid_free(tmp);
     2015                mr_free(tmp);
    20152016
    20162017                just_changed_cds = TRUE;
    … …  
    20232024        } else {
    20242025            just_changed_cds = FALSE;
    2025             asprintf(&tmp, _("Restoring big file %ld"), bigfileno + 1);
     2026            mr_asprintf(&tmp, _("Restoring big file %ld"), bigfileno + 1);
    20262027            update_progress_form(tmp);
    2027             paranoid_free(tmp);
     2028            mr_free(tmp);
    20282029
    20292030            pathname_of_last_biggie_restored =
    … …  
    20332034                fprintf(fbw, "%s\n", pathname_of_last_biggie_restored);
    20342035            }
    2035             paranoid_free(pathname_of_last_biggie_restored);
     2036            mr_free(pathname_of_last_biggie_restored);
    20362037            retval += res;
    20372038            bigfileno++;
    20382039
    20392040        }
    2040         paranoid_free(tmp);
     2041        mr_free(tmp);
    20412042    }
    20422043
    20432044    if (fbw) {
    20442045        fclose(fbw);
    2045         asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
    2046         asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
     2046        mr_asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
     2047        mr_asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
    20472048        tmp = find_home_of_exe("setfacl");
    20482049        if (length_of_file(acl_fname) > 0 && tmp) {
    20492050            set_acl_list(biggies_whose_EXATs_we_should_set, acl_fname);
    20502051        }
    2051         paranoid_free(tmp);
     2052        mr_free(tmp);
    20522053
    20532054        tmp = find_home_of_exe("setfattr");
    … …  
    20552056            set_fattr_list(biggies_whose_EXATs_we_should_set, xattr_fname);
    20562057        }
    2057         paranoid_free(tmp);
    2058         paranoid_free(acl_fname);
    2059         paranoid_free(xattr_fname);
    2060     }
    2061     paranoid_free(biggies_whose_EXATs_we_should_set);
     2058        mr_free(tmp);
     2059        mr_free(acl_fname);
     2060        mr_free(xattr_fname);
     2061    }
     2062    mr_free(biggies_whose_EXATs_we_should_set);
    20622063
    20632064    if (does_file_exist("/PAUSE")) {
    … …  
    21172118    read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
    21182119    max_val = atol(tmp) + 1;
    2119     paranoid_free(tmp);
    2120 
    2121     asprintf(&progress_str, _("Restoring from %s #%d"),
     2120    mr_free(tmp);
     2121
     2122    mr_asprintf(&progress_str, _("Restoring from %s #%d"),
    21222123            bkpinfo->backup_media_string,
    21232124            g_current_media_number);
    … …  
    21312132        update_progress_form(progress_str);
    21322133
    2133         asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.bz2",
     2134        mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.bz2",
    21342135                current_tarball_number);
    21352136        if (!does_file_exist(tarball_fname)) {
    2136             paranoid_free(tarball_fname);
    2137             asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.lzo",
     2137            mr_free(tarball_fname);
     2138            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.lzo",
    21382139                    current_tarball_number);
    21392140        }
    21402141        if (!does_file_exist(tarball_fname)) {
    2141             paranoid_free(tarball_fname);
    2142             asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.",
     2142            mr_free(tarball_fname);
     2143            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.",
    21432144                    current_tarball_number);
    21442145        }
    21452146        if (!does_file_exist(tarball_fname)) {
    2146             paranoid_free(tarball_fname);
    2147             asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.star.bz2",
     2147            mr_free(tarball_fname);
     2148            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.star.bz2",
    21482149                    current_tarball_number);
    21492150        }
    21502151        if (!does_file_exist(tarball_fname)) {
    2151             paranoid_free(tarball_fname);
    2152             asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.star.",
     2152            mr_free(tarball_fname);
     2153            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.star.",
    21532154                    current_tarball_number);
    21542155        }
    21552156        if (!does_file_exist(tarball_fname)) {
    2156             paranoid_free(tarball_fname);
     2157            mr_free(tarball_fname);
    21572158            if (current_tarball_number == 0) {
    21582159                log_to_screen
    … …  
    21682169            }
    21692170            g_current_media_number++;
    2170             paranoid_free(progress_str);
    2171             asprintf(&progress_str, _("Restoring from %s #%d"),
     2171            mr_free(progress_str);
     2172            mr_asprintf(&progress_str, _("Restoring from %s #%d"),
    21722173                    bkpinfo->backup_media_string,
    21732174                    g_current_media_number);
    21742175            log_to_screen(progress_str);
    21752176        } else {
    2176             paranoid_free(progress_str);
    2177             asprintf(&progress_str,
     2177            mr_free(progress_str);
     2178            mr_asprintf(&progress_str,
    21782179                    _("Restoring from fileset #%ld on %s #%d"),
    21792180                    current_tarball_number,
    … …  
    21892190            }
    21902191            if (res) {
    2191                 asprintf(&tmp1, _("reported errors"));
     2192                mr_asprintf(&tmp1, _("reported errors"));
    21922193            } else {
    2193                 asprintf(&tmp1, _("succeeded"));
    2194             }
    2195             asprintf(&tmp, _("%s #%d, fileset #%ld - restore %s"),
     2194                mr_asprintf(&tmp1, _("succeeded"));
     2195            }
     2196            mr_asprintf(&tmp, _("%s #%d, fileset #%ld - restore %s"),
    21962197                    bkpinfo->backup_media_string,
    21972198                    g_current_media_number, current_tarball_number,tmp1);
    2198             paranoid_free(tmp1);
     2199            mr_free(tmp1);
    21992200           
    22002201            if (attempts > 1) {
    2201                 asprintf(&tmp1, _(" (%d attempts) - review logs"), attempts);
    2202             }
    2203             asprintf(&comment, "%s%s", tmp, tmp1);
    2204             paranoid_free(tmp);
    2205             paranoid_free(tmp1);
     2202                mr_asprintf(&tmp1, _(" (%d attempts) - review logs"), attempts);
     2203            }
     2204            mr_asprintf(&comment, "%s%s", tmp, tmp1);
     2205            mr_free(tmp);
     2206            mr_free(tmp1);
    22062207            if (attempts > 1) {
    22072208                log_to_screen(comment);
    22082209            }
    2209             paranoid_free(comment);
     2210            mr_free(comment);
    22102211
    22112212            retval += res;
    … …  
    22132214            g_current_progress++;
    22142215        }
    2215         paranoid_free(tarball_fname);
    2216     }
    2217     paranoid_free(progress_str);
     2216        mr_free(tarball_fname);
     2217    }
     2218    mr_free(progress_str);
    22182219    close_progress_form();
    22192220
    … …  
    22652266    read_cfg_var(g_mondo_cfg_file, "total-slices", tmp);
    22662267    total_slices = atol(tmp);
    2267     paranoid_free(tmp);
    2268 
    2269     asprintf(&tmp, "Reassembling large files      ");
    2270     asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
    2271     asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
     2268    mr_free(tmp);
     2269
     2270    mr_asprintf(&tmp, "Reassembling large files      ");
     2271    mr_asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
     2272    mr_asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
    22722273    mvaddstr_and_log_it(g_currentY, 0, tmp);
    2273     paranoid_free(tmp);
    2274 
    2275     asprintf(&biggies_whose_EXATs_we_should_set,
     2274    mr_free(tmp);
     2275
     2276    mr_asprintf(&biggies_whose_EXATs_we_should_set,
    22762277            "%s/biggies-whose-EXATs-we-should-set", bkpinfo->tmpdir);
    22772278    if (!(fbw = fopen(biggies_whose_EXATs_we_should_set, "w"))) {
    … …  
    22902291
    22912292    noof_biggiefiles = atol(biggie_fname);
    2292     asprintf(&tmp, "OK, there are %ld biggiefiles in the archives",
     2293    mr_asprintf(&tmp, "OK, there are %ld biggiefiles in the archives",
    22932294            noof_biggiefiles);
    22942295    log_msg(2, tmp);
    2295     paranoid_free(tmp);
     2296    mr_free(tmp);
    22962297
    22972298    open_progress_form(_("Reassembling large files"),
    … …  
    23192320        }
    23202321        */
    2321         asprintf(&tmp, _("Restoring big file %ld (%lld K)"),
     2322        mr_asprintf(&tmp, _("Restoring big file %ld (%lld K)"),
    23222323                current_bigfile_number + 1, biggie_size / 1024);
    23232324        update_progress_form(tmp);
    2324         paranoid_free(tmp);
     2325        mr_free(tmp);
    23252326
    23262327        pathname_of_last_biggie_restored = restore_a_biggiefile_from_stream(bkpinfo, biggie_fname,
    … …  
    23322333            fprintf(fbw, "%s\n", pathname_of_last_biggie_restored);
    23332334        }
    2334         paranoid_free(pathname_of_last_biggie_restored);
     2335        mr_free(pathname_of_last_biggie_restored);
    23352336
    23362337        retval += res;
    … …  
    23402341    if (current_bigfile_number != noof_biggiefiles
    23412342        && noof_biggiefiles != 0) {
    2342         asprintf(&tmp, "Warning - bigfileno=%ld but noof_biggiefiles=%ld\n",
     2343        mr_asprintf(&tmp, "Warning - bigfileno=%ld but noof_biggiefiles=%ld\n",
    23432344                current_bigfile_number, noof_biggiefiles);
    23442345    } else {
    2345         asprintf(&tmp,
     2346        mr_asprintf(&tmp,
    23462347                "%ld biggiefiles in biggielist.txt; %ld biggiefiles processed today.",
    23472348                noof_biggiefiles, current_bigfile_number);
    23482349    }
    23492350    log_msg(1, tmp);
    2350     paranoid_free(tmp);
     2351    mr_free(tmp);
    23512352
    23522353    if (fbw) {
    … …  
    23702371        }
    23712372    }
    2372     paranoid_free(xattr_fname);
    2373     paranoid_free(acl_fname);
    2374     paranoid_free(biggies_whose_EXATs_we_should_set);
     2373    mr_free(xattr_fname);
     2374    mr_free(acl_fname);
     2375    mr_free(biggies_whose_EXATs_we_should_set);
    23752376
    23762377    if (does_file_exist("/PAUSE")) {
    … …  
    23862387        mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
    23872388    }
    2388     paranoid_free(biggie_fname);
     2389    mr_free(biggie_fname);
    23892390    return (retval);
    23902391}
    … …  
    24282429    read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
    24292430    max_val = atol(tmp) + 1;
    2430     paranoid_free(tmp);
     2431    mr_free(tmp);
    24312432
    24322433    chdir(bkpinfo->restore_path);   /* I don't know why this is needed _here_ but it seems to be. -HR, 02/04/2002 */
    … …  
    24342435    run_program_and_log_output("pwd", 5);
    24352436
    2436     asprintf(&progress_str, _("Restoring from media #%d"),
     2437    mr_asprintf(&progress_str, _("Restoring from media #%d"),
    24372438            g_current_media_number);
    24382439    log_to_screen(progress_str);
    … …  
    24562457    while (ctrl_chr != BLK_STOP_AFIOBALLS) {
    24572458        update_progress_form(progress_str);
    2458         asprintf(&xattr_fname, "%s/xattr-subset-%ld.tmp", bkpinfo->tmpdir,
     2459        mr_asprintf(&xattr_fname, "%s/xattr-subset-%ld.tmp", bkpinfo->tmpdir,
    24592460                current_afioball_number);
    2460         asprintf(&acl_fname, "%s/acl-subset-%ld.tmp", bkpinfo->tmpdir,
     2461        mr_asprintf(&acl_fname, "%s/acl-subset-%ld.tmp", bkpinfo->tmpdir,
    24612462                current_afioball_number);
    24622463        unlink(xattr_fname);
    … …  
    24732474        }
    24742475        /* BERLIOS: useless ?
    2475         asprintf(&tmp,
     2476        mr_asprintf(&tmp,
    24762477                _("Restoring from fileset #%ld (name=%s, size=%ld K)"),
    24772478                current_afioball_number, tmp_fname, (long) tmp_size >> 10);
    … …  
    24842485        retval += res;
    24852486        if (res) {
    2486             asprintf(&tmp, _("Fileset %ld - errors occurred"),
     2487            mr_asprintf(&tmp, _("Fileset %ld - errors occurred"),
    24872488                    current_afioball_number);
    24882489            log_to_screen(tmp);
    2489             paranoid_free(tmp);
     2490            mr_free(tmp);
    24902491        }
    24912492        res =
    … …  
    24982499        g_current_progress++;
    24992500
    2500         paranoid_free(progress_str);
    2501         asprintf(&progress_str, _("Restoring from fileset #%ld on %s #%d"),
     2501        mr_free(progress_str);
     2502        mr_asprintf(&progress_str, _("Restoring from fileset #%ld on %s #%d"),
    25022503                current_afioball_number,
    25032504                bkpinfo->backup_media_string,
    … …  
    25072508        unlink(xattr_fname);
    25082509        unlink(acl_fname);
    2509         paranoid_free(xattr_fname);
    2510         paranoid_free(acl_fname);
     2510        mr_free(xattr_fname);
     2511        mr_free(acl_fname);
    25112512    }                           // next
    2512     paranoid_free(progress_str);
    2513     paranoid_free(tmp_fname);
     2513    mr_free(progress_str);
     2514    mr_free(tmp_fname);
    25142515
    25152516    log_msg(1, "All done with afioballs");
    … …  
    25552556    /* BERLIOS: should test return value, or better change the function */
    25562557    getcwd(cwd, MAX_STR_LEN - 1);
    2557     asprintf(&tmp, "mkdir -p %s", bkpinfo->restore_path);
     2558    mr_asprintf(&tmp, "mkdir -p %s", bkpinfo->restore_path);
    25582559    run_program_and_log_output(tmp, FALSE);
    2559     paranoid_free(tmp);
     2560    mr_free(tmp);
    25602561
    25612562    log_msg(1, "Changing dir to %s", bkpinfo->restore_path);
    … …  
    25722573        newtRefresh();
    25732574    }
    2574     paranoid_free(tmp);
     2575    mr_free(tmp);
    25752576
    25762577    mvaddstr_and_log_it(g_currentY, 0,
    … …  
    26132614    kill_petris();
    26142615    log_msg(2, "restore_everything() --- leaving");
    2615     paranoid_free(cwd);
    2616     paranoid_free(newpath);
     2616    mr_free(cwd);
     2617    mr_free(newpath);
    26172618    return (resA + resB);
    26182619}
    … …  
    27152716        g_text_mode = FALSE;
    27162717    }                           // newt :-)
    2717     paranoid_free(tmp);
     2718    mr_free(tmp);
    27182719
    27192720    if (!
    … …  
    27322733
    27332734    g_mondo_home = call_program_and_get_last_line_of_output("which mondorestore");
    2734     paranoid_alloc(g_tmpfs_mountpt, "/tmp/tmpfs");
     2735    mr_allocstr(g_tmpfs_mountpt, "/tmp/tmpfs");
    27352736    make_hole_for_dir(g_tmpfs_mountpt);
    27362737    g_current_media_number = 1; // precaution
    … …  
    27572758
    27582759/* Backup original mountlist.txt */
    2759     asprintf(&tmp, "%s.orig", g_mountlist_fname);
     2760    mr_asprintf(&tmp, "%s.orig", g_mountlist_fname);
    27602761    if (!does_file_exist(g_mountlist_fname)) {
    27612762        log_msg(2,
    … …  
    27632764                __LINE__, g_mountlist_fname);
    27642765    } else if (!does_file_exist(tmp)) {
    2765         paranoid_free(tmp);
    2766         asprintf(&tmp, "cp -f %s %s.orig", g_mountlist_fname,
     2766        mr_free(tmp);
     2767        mr_asprintf(&tmp, "cp -f %s %s.orig", g_mountlist_fname,
    27672768                g_mountlist_fname);
    27682769        run_program_and_log_output(tmp, FALSE);
    27692770    }
    2770     paranoid_free(tmp);
     2771    mr_free(tmp);
    27712772
    27722773/* Init directories */
    27732774    make_hole_for_dir(bkpinfo->tmpdir);
    2774     asprintf(&tmp, "mkdir -p %s", bkpinfo->tmpdir);
     2775    mr_asprintf(&tmp, "mkdir -p %s", bkpinfo->tmpdir);
    27752776    run_program_and_log_output(tmp, FALSE);
    2776     paranoid_free(tmp);
     2777    mr_free(tmp);
    27772778
    27782779    make_hole_for_dir("/var/log");
    … …  
    28052806        load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
    28062807        if (!does_file_exist(g_mountlist_fname)) {
    2807             paranoid_alloc(g_mountlist_fname, "/tmp/mountlist.txt");
     2808            mr_allocstr(g_mountlist_fname, "/tmp/mountlist.txt");
    28082809        }
    28092810        res = let_user_edit_the_mountlist(bkpinfo, mountlist, raidlist);
    … …  
    28322833        bkpinfo->compression_level = 1;
    28332834        g_current_media_number = 2;
    2834         paranoid_alloc(bkpinfo->restore_path, "/tmp/TESTING");
     2835        mr_allocstr(bkpinfo->restore_path, "/tmp/TESTING");
    28352836        bkpinfo->backup_media_type = dvd;
    2836         paranoid_free(bkpinfo->backup_media_string);
     2837        mr_free(bkpinfo->backup_media_string);
    28372838        bkpinfo->backup_media_string = bkptype_to_string(bkpinfo->backup_media_type);
    28382839        open_progress_form(_("Reassembling /dev/hda1"),
    … …  
    28592860//      finish(0);
    28602861//      toggle_path_selection (filelist, "/root/stuff", TRUE);
    2861         asprintf(&a, argv[3]);
    2862         asprintf(&b, argv[4]);
     2862        mr_asprintf(&a, argv[3]);
     2863        mr_asprintf(&b, argv[4]);
    28632864
    28642865        res = save_filelist_entries_in_common(a, filelist, b, FALSE);
    28652866        free_filelist(filelist);
    2866         paranoid_free(a);
    2867         paranoid_free(b);
     2867        mr_free(a);
     2868        mr_free(b);
    28682869        printf("res = %d", res);
    28692870        finish(0);
    … …  
    29442945        log_msg(2, "Still here. Yay.");
    29452946        if (strlen(bkpinfo->tmpdir) > 0) {
    2946             asprintf(&tmp, "rm -Rf %s/*", bkpinfo->tmpdir);
     2947            mr_asprintf(&tmp, "rm -Rf %s/*", bkpinfo->tmpdir);
    29472948            run_program_and_log_output(tmp, FALSE);
    2948             paranoid_free(tmp);
     2949            mr_free(tmp);
    29492950        }
    29502951        unmount_boot_if_necessary();    /* for Gentoo users */
    … …  
    29602961
    29612962        iamhere("About to call load_mountlist and load_raidtab");
    2962         paranoid_alloc(bkpinfo->restore_path, MNT_RESTORING);
     2963        mr_allocstr(bkpinfo->restore_path, MNT_RESTORING);
    29632964        read_cfg_file_into_bkpinfo(g_mondo_cfg_file, bkpinfo);
    29642965        retval = load_mountlist(mountlist, g_mountlist_fname);
    … …  
    29732974                && !is_this_device_mounted(bkpinfo->nfs_mount)) {
    29742975                log_msg(1, "Mounting nfs dir");
    2975                 paranoid_alloc(bkpinfo->isodir, "/tmp/isodir");
     2976                mr_allocstr(bkpinfo->isodir, "/tmp/isodir");
    29762977                run_program_and_log_output("mkdir -p /tmp/isodir", 5);
    2977                 asprintf(&tmp, "mount %s -t nfs -o nolock /tmp/isodir",
     2978                mr_asprintf(&tmp, "mount %s -t nfs -o nolock /tmp/isodir",
    29782979                        bkpinfo->nfs_mount);
    29792980                run_program_and_log_output(tmp, 1);
    2980                 paranoid_free(tmp);
     2981                mr_free(tmp);
    29812982            }
    29822983        }
    … …  
    29952996            log_msg(0, "Partitioning only.");
    29962997            load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
    2997             paranoid_alloc(g_mountlist_fname, "/tmp/mountlist.txt");
     2998            mr_allocstr(g_mountlist_fname, "/tmp/mountlist.txt");
    29982999            load_mountlist(mountlist, g_mountlist_fname);
    29993000            res = partition_everything(mountlist);
    … …  
    30043005            log_msg(0, "Formatting only.");
    30053006            load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
    3006             paranoid_alloc(g_mountlist_fname, "/tmp/mountlist.txt");
     3007            mr_allocstr(g_mountlist_fname, "/tmp/mountlist.txt");
    30073008            load_mountlist(mountlist, g_mountlist_fname);
    30083009            res = format_everything(mountlist, FALSE, raidlist);
    … …  
    30133014            log_msg(0, "Stopping LVM and RAID");
    30143015            load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
    3015             paranoid_alloc(g_mountlist_fname, "/tmp/mountlist.txt");
     3016            mr_allocstr(g_mountlist_fname, "/tmp/mountlist.txt");
    30163017            load_mountlist(mountlist, g_mountlist_fname);
    30173018            res = do_my_funky_lvm_stuff(TRUE, FALSE);
    … …  
    31393140    unlink("/tmp/mondo-run-prog.tmp");
    31403141    set_signals(FALSE);
    3141     asprintf(&tmp, "rm -Rf %s", bkpinfo->tmpdir);
     3142    mr_asprintf(&tmp, "rm -Rf %s", bkpinfo->tmpdir);
    31423143    run_program_and_log_output(tmp, FALSE);
    3143     paranoid_free(tmp);
     3144    mr_free(tmp);
    31443145
    31453146    log_to_screen
    31463147        (_
    31473148         ("Restore log copied to /tmp/mondo-restore.log on your hard disk"));
    3148     asprintf(&tmp,
     3149    mr_asprintf(&tmp,
    31493150            _
    31503151            ("Mondo-restore is exiting (retval=%d)                                      "),
    31513152            retval);
    31523153    log_to_screen(tmp);
    3153     paranoid_free(tmp);
    3154 
    3155     asprintf(&tmp, "umount %s", bkpinfo->isodir);
     3154    mr_free(tmp);
     3155
     3156    mr_asprintf(&tmp, "umount %s", bkpinfo->isodir);
    31563157    run_program_and_log_output(tmp, 5);
    3157     paranoid_free(tmp);
    3158 
    3159     paranoid_free(mountlist);
    3160     paranoid_free(raidlist);
     3158    mr_free(tmp);
     3159
     3160    mr_free(mountlist);
     3161    mr_free(raidlist);
    31613162    if (am_I_in_disaster_recovery_mode()) {
    31623163        run_program_and_log_output("mount / -o remount,rw", 2);
Note: See TracChangeset for help on using the changeset viewer.