Changeset 900 in MondoRescue for trunk/mondo/src/common/libmondo-filelist.c


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

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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/mondo/src/common/libmondo-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}
Note: See TracChangeset for help on using the changeset viewer.