Ignore:
Timestamp:
Jul 5, 2009, 2:42:06 AM (10 years ago)
Author:
bruno
Message:

r3148@localhost: bruno | 2009-06-30 14:26:19 +0200

  • Adds an example of valgrind call for testing mondarchive
  • Replace some malloc_strings with mr_asprintf
File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/2.2.9/mondo/src/common/libmondo-archive.c

    r2242 r2247  
    16861686    char *result_sz = NULL;
    16871687    char *message_to_screen = NULL;
    1688     char *sz_blank_disk;
     1688    char *sz_blank_disk = NULL;
    16891689    char *fnam;
    16901690    char *tmp2;
     
    16941694
    16951695    malloc_string(old_pwd);
    1696     malloc_string(sz_blank_disk);
    16971696    malloc_string(fnam);
    16981697    tmp = malloc(1200);
     
    17921791                }
    17931792                pause_for_N_seconds(5, "Letting DVD drive settle");
    1794                 sprintf(sz_blank_disk, "dvd+rw-format -force %s",
     1793                mr_asprintf(&sz_blank_disk, "dvd+rw-format -force %s",
    17951794                        bkpinfo->media_device);
    17961795                log_msg(3, "sz_blank_disk = '%s'", sz_blank_disk);
     
    18131812                        ("Format succeeded. Sleeping for 5 seconds to take a breath...");
    18141813                }
     1814                mr_free(sz_blank_disk);
    18151815                pause_for_N_seconds(5, "Letting DVD drive settle");
    18161816                if (!bkpinfo->please_dont_eject) {
     
    19681968    }
    19691969    paranoid_free(old_pwd);
    1970     paranoid_free(sz_blank_disk);
    19711970    paranoid_free(fnam);
    19721971    paranoid_free(tmp);
    19731972    return (retval);
    19741973}
    1975 
    1976 
    1977 
    1978 
    1979 
    1980 
    1981 
    19821974
    19831975
     
    22062198    /*@ int ************************************************** */
    22072199    int retval = 0;
    2208     long int curr_set_no = 0;
     2200    long int curr_set_no = 0L;
    22092201    int res = 0;
    22102202
    22112203    /*@ buffers ********************************************** */
    2212     char *curr_filelist_fname;
    2213     char *curr_afioball_fname;
    2214     char *curr_xattr_list_fname;
    2215     char *curr_acl_list_fname;
     2204    char *curr_filelist_fname = NULL;
     2205    char *curr_afioball_fname = NULL;
     2206    char *curr_xattr_list_fname = NULL;
     2207    char *curr_acl_list_fname = NULL;
    22162208    char *tmp = NULL;
    22172209    char *media_usage_comment = NULL;
    2218 
    2219     malloc_string(curr_afioball_fname);
    2220     malloc_string(curr_filelist_fname);
    2221     malloc_string(curr_xattr_list_fname);
    2222     malloc_string(curr_acl_list_fname);
    22232210
    22242211    log_to_screen("Archiving regular files");
     
    22302217                       get_last_filelist_number() + 1);
    22312218
    2232     sprintf(curr_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir,
    2233             0L);
    2234 
    2235     for (curr_set_no = 0; does_file_exist(curr_filelist_fname);
    2236          sprintf(curr_filelist_fname, FILELIST_FNAME_RAW_SZ,
    2237                  bkpinfo->tmpdir, ++curr_set_no)) {
     2219    for (; does_file_exist(curr_filelist_fname); curr_set_no++) {
    22382220        /* backup this set of files */
    2239         sprintf(curr_filelist_fname, FILELIST_FNAME_RAW_SZ,
    2240                 bkpinfo->tmpdir, curr_set_no);
    2241         sprintf(curr_afioball_fname, AFIOBALL_FNAME_RAW_SZ,
    2242                 bkpinfo->tmpdir, curr_set_no, bkpinfo->zip_suffix);
     2221        mr_asprintf(&curr_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, curr_set_no);
     2222        if (! does_file_exist(curr_filelist_fname)) {
     2223            mr_free(curr_filelist_fname);
     2224            break;
     2225        }
     2226
     2227        mr_asprintf(&curr_afioball_fname, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir, curr_set_no, bkpinfo->zip_suffix);
    22432228
    22442229        log_msg(1, "EXAT'g set %ld", curr_set_no);
    22452230        if (g_getfattr) {
    2246             sprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
     2231            mr_asprintf(&curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
    22472232                bkpinfo->tmpdir, curr_set_no);
    22482233            get_fattr_list(curr_filelist_fname, curr_xattr_list_fname);
    22492234        }
    22502235        if (g_getfacl) {
    2251             sprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ,
     2236            mr_asprintf(&curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ,
    22522237                bkpinfo->tmpdir, curr_set_no);
    22532238            get_acl_list(curr_filelist_fname, curr_acl_list_fname);
     
    22642249                    curr_set_no);
    22652250            log_to_screen(tmp);
    2266             paranoid_free(tmp);
     2251            mr_free(tmp);
    22672252        }
    22682253
     
    23022287                }
    23032288        }
     2289        if (g_getfattr) {
     2290            mr_free(curr_xattr_list_fname);
     2291        }
     2292        if (g_getfacl) {
     2293            mr_free(curr_acl_list_fname);
     2294        }
    23042295        retval += res;
    23052296        g_current_progress++;
     
    23112302                    curr_set_no);
    23122303            log_to_screen(tmp);
    2313             paranoid_free(tmp);
     2304            mr_free(tmp);
    23142305            fatal_error
    23152306                ("Is your hard disk is full? If not, please send the author the logfile.");
    23162307        }
     2308        mr_free(curr_filelist_fname);
     2309        mr_free(curr_afioball_fname);
    23172310    }
    23182311    close_progress_form();
     
    23242317    }
    23252318    log_to_screen(tmp);
    2326     paranoid_free(tmp);
    2327     paranoid_free(curr_filelist_fname);
    2328     paranoid_free(curr_afioball_fname);
    2329     paranoid_free(curr_xattr_list_fname);
    2330     paranoid_free(curr_acl_list_fname);
     2319    mr_free(tmp);
    23312320    return (retval);
    23322321}
     
    23972386
    23982387    /*@ buffers ************************************************** */
    2399     char *biggielist;
    2400     char *command;
    2401     char *blah;
    2402     char *xattr_fname;
    2403     char *acl_fname;
     2388    char *biggielist = NULL;
     2389    char *command = NULL;
     2390    char *blah = NULL;
     2391    char *xattr_fname = NULL;
     2392    char *acl_fname = NULL;
    24042393
    24052394    assert(bkpinfo != NULL);
    24062395    /* slice big files */
    2407     malloc_string(biggielist);
    2408     malloc_string(xattr_fname);
    2409     malloc_string(acl_fname);
    24102396    mvaddstr_and_log_it(g_currentY, 0,
    24112397                        "Archiving large files to media           ");
    2412     sprintf(biggielist, "%s/archives/biggielist.txt", bkpinfo->scratchdir);
     2398    mr_asprintf(&biggielist, "%s/archives/biggielist.txt", bkpinfo->scratchdir);
    24132399    if (g_getfattr) {
    2414         sprintf(xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
     2400        mr_asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
    24152401    }
    24162402    if (g_getfacl) {
    2417         sprintf(acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
     2403        mr_asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
    24182404    }
    24192405
     
    24212407            biggielist);
    24222408    paranoid_system(command);
    2423     paranoid_free(command);
     2409    mr_free(command);
    24242410
    24252411    mr_asprintf(&blah, "biggielist = %s", biggielist);
    24262412    log_msg(2, blah);
    2427     paranoid_free(blah);
     2413    mr_free(blah);
    24282414
    24292415    if (!does_file_exist(biggielist)) {
     
    24362422            bkpinfo->scratchdir);
    24372423        paranoid_system(command);
    2438         paranoid_free(command);
     2424        mr_free(command);
    24392425    }
    24402426    if (g_getfacl) {
    24412427        get_acl_list(biggielist, acl_fname);
    2442         mr_asprintf(&command, "cp %s %s/archives/", acl_fname,
    2443              bkpinfo->scratchdir);
     2428        mr_asprintf(&command, "cp %s %s/archives/", acl_fname, bkpinfo->scratchdir);
    24442429        paranoid_system(command);
    2445         paranoid_free(command);
     2430        mr_free(command);
    24462431    }
    24472432
     
    24502435        mr_asprintf(&blah, "%ld", count_lines_in_file(biggielist));
    24512436        write_header_block_to_stream((off_t)0, blah, BLK_START_BIGGIEFILES);
    2452         paranoid_free(blah);
     2437        mr_free(blah);
    24532438    }
    24542439    res = make_slices_and_images(biggielist);
     
    24642449        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
    24652450    }
    2466     paranoid_free(blah);
    2467     paranoid_free(biggielist);
    2468     paranoid_free(command);
    2469     paranoid_free(xattr_fname);
    2470     paranoid_free(acl_fname);
     2451    mr_free(biggielist);
     2452    mr_free(xattr_fname);
     2453    mr_free(acl_fname);
    24712454    return (retval);
    24722455}
     
    25802563
    25812564
    2582 
    2583 
    25842565/**
    25852566 * @addtogroup LLarchiveGroup
     
    26862667                                             bool keep_looping)
    26872668{
    2688     char *tmp;
    26892669    int res = 0;
    26902670    char *bkp = NULL;
    2691     char *cdrecord;
    2692 
    2693     malloc_string(tmp);
    2694     malloc_string(cdrecord);
     2671    char *cdrecord = NULL;
     2672
    26952673    mr_asprintf(&bkp, cdrw_dev);
    26962674    if (find_cdrw_device(cdrw_dev)) {
     
    26982676    } else {
    26992677        if (!system("which cdrecord > /dev/null 2> /dev/null")) {
    2700             sprintf(cdrecord, "cdrecord dev=%s -atip", cdrw_dev);
     2678            mr_asprintf(&cdrecord, "cdrecord dev=%s -atip", cdrw_dev);
    27012679        } else if (!system("which dvdrecord > /dev/null 2> /dev/null")) {
    2702             sprintf(cdrecord, "cdrecord dev=%s -atip", cdrw_dev);
     2680            mr_asprintf(&cdrecord, "cdrecord dev=%s -atip", cdrw_dev);
    27032681        } else {
    2704             cdrecord[0] = '\0';
    27052682            log_msg(2, "Oh well. I guess I'll just pray then.");
    27062683        }
    2707         if (cdrecord[0]) {
     2684        if (cdrecord != NULL) {
    27082685            if (!keep_looping) {
    27092686                retract_CD_tray_and_defeat_autorun();
     
    27242701    mr_free(bkp);
    27252702
    2726 //  retract_CD_tray_and_defeat_autorun();
    2727     paranoid_free(tmp);
    2728     paranoid_free(cdrecord);
     2703    mr_free(cdrecord);
    27292704    return (res);
    27302705}
    2731 
    2732 
    2733 
    2734 
    2735 
    2736 
    2737 
    27382706
    27392707
     
    27482716
    27492717    /*@ buffers ********************************************* */
    2750     char *tmp;
    2751     char *szmsg;
     2718    char *tmp = NULL;
    27522719    char *cdrom_dev;
    27532720    char *cdrw_dev;
     
    27562723    int cd_number = -1;
    27572724    int attempt_to_mount_returned_this = 999;
    2758     char *mtpt;
     2725    char *mtpt = NULL;
    27592726    char *szcdno;
    27602727    char *szserfname;
     
    27622729    char *mds = NULL;
    27632730
    2764     malloc_string(tmp);
    2765     malloc_string(szmsg);
    27662731    malloc_string(cdrom_dev);
    27672732    malloc_string(cdrw_dev);
    2768     malloc_string(mtpt);
    27692733    malloc_string(szcdno);
    27702734    malloc_string(szserfname);
     
    27722736
    27732737    mds = media_descriptor_string(g_backup_media_type);
    2774     sprintf(szmsg, "I am about to burn %s #%d", mds, g_current_media_number);
     2738    mr_asprintf(&tmp, "I am about to burn %s #%d", mds, g_current_media_number);
    27752739    mr_free(mds);
    2776     log_to_screen(szmsg);
     2740    log_to_screen(tmp);
     2741    mr_free(tmp);
    27772742    if (g_current_media_number < ask_for_one_if_more_than_this) {
    27782743        return;
     
    27892754      retract_CD_tray_and_defeat_autorun();
    27902755*/
    2791         sprintf(tmp, "umount %s", cdrom_dev);
     2756        mr_asprintf(&tmp, "umount %s", cdrom_dev);
    27922757        run_program_and_log_output(tmp, 1);
    27932758        sprintf(szcdno, "%s/archives/THIS-CD-NUMBER", mtpt);
     
    27952760        sprintf(szunmount, "umount %s", mtpt);
    27962761        cd_number = -1;
    2797         sprintf(tmp, "mount %s %s", cdrom_dev, mtpt);
     2762        mr_asprintf(&tmp, "mount %s %s", cdrom_dev, mtpt);
    27982763        mr_asprintf(&our_serial_str, "%s", "");
    2799         if ((attempt_to_mount_returned_this =
    2800              run_program_and_log_output(tmp, 1))) {
     2764        attempt_to_mount_returned_this = run_program_and_log_output(tmp, 1);
     2765        mr_free(tmp);
     2766        if (attempt_to_mount_returned_this) {
    28012767            log_msg(4, "Failed to mount %s at %s", cdrom_dev, mtpt);
    28022768            log_to_screen("If there's a CD/DVD in the drive, it's blank.");
     
    28242790
    28252791            cd_number = atoi(last_line_of_file(szcdno));
    2826             sprintf(tmp, "cat %s 2> /dev/null", szserfname);
     2792            mr_asprintf(&tmp, "cat %s 2> /dev/null", szserfname);
    28272793            mr_free(our_serial_str);
    28282794            mr_asprintf(&our_serial_str, "%s",
    28292795                   call_program_and_get_last_line_of_output(tmp));
     2796            mr_free(tmp);
    28302797            // FIXME - should be able to use last_line_of_file(), surely?
    28312798        }
     
    28632830        eject_device(cdrom_dev);
    28642831        mds = media_descriptor_string(g_backup_media_type);
    2865         sprintf(tmp,
     2832        mr_asprintf(&tmp,
    28662833                "I am about to burn %s #%d of the backup set. Please insert %s and press Enter.",
    28672834                mds, g_current_media_number, mds);
     
    28692836
    28702837        popup_and_OK(tmp);
     2838        mr_free(tmp);
    28712839        goto gotos_make_me_puke;
    28722840    } else {
     
    28782846            "paafcd: OK, I assume I have a blank/reusable %s in the drive...", mds);
    28792847
    2880     //  if (ask_for_one_if_more_than_this>1) { popup_and_OK(szmsg); }
    2881 
    28822848    log_to_screen("Proceeding w/ %s in drive.", mds);
    28832849    mr_free(mds);
    28842850
    2885     paranoid_free(tmp);
    2886     paranoid_free(szmsg);
    28872851    paranoid_free(cdrom_dev);
    28882852    paranoid_free(cdrw_dev);
     
    30072971    assert_string_is_neither_NULL_nor_zerolength(biggie_filename);
    30082972    malloc_string(checksum_line);
    3009     command = malloc(MAX_STR_LEN * 8);
    30102973
    30112974    biggiestruct.for_backward_compatibility = '\n';
    30122975    biggiestruct.use_ntfsprog = use_ntfsprog;
    3013     if (!(tempblock = (char *) malloc(256 * 1024))) {
    3014         fatal_error("malloc error 256*1024");
    3015     }
    30162976    optimal_set_size = bkpinfo->optimal_set_size;
    30172977    if (is_this_file_compressed(biggie_filename)
     
    30372997            fatal_error("ntfsresize not found");
    30382998        }
    3039         sprintf(command, "ntfsresize --force --info %s|grep '^You might resize at '|cut -d' ' -f5", biggie_filename);
     2999        mr_asprintf(&command, "ntfsresize --force --info %s|grep '^You might resize at '|cut -d' ' -f5", biggie_filename);
    30403000        log_it("command = %s", command);
    30413001        mr_asprintf(&tmp, call_program_and_get_last_line_of_output(command));
     3002        mr_free(command);
    30423003        log_it("res of it = %s", tmp);
    30433004        totallength = (off_t)atoll(tmp);
     
    30463007        file_to_openin = biggie_filename;
    30473008        if (strchr(biggie_filename,'\'') != NULL) {
    3048             sprintf(command, "md5sum \"%s\"", biggie_filename);
     3009            mr_asprintf(&command, "md5sum \"%s\"", biggie_filename);
    30493010        } else {
    3050             sprintf(command, "md5sum '%s'", biggie_filename);
     3011            mr_asprintf(&command, "md5sum '%s'", biggie_filename);
    30513012        }
    30523013        if (!(fin = popen(command, "r"))) {
     
    30553016            return (1);
    30563017        }
     3018        mr_free(command);
    30573019        (void) fgets(checksum_line, MAX_STR_LEN, fin);
    30583020        pclose(fin);
     
    30933055        paranoid_free(tmp);
    30943056
    3095         paranoid_free(tempblock);
    30963057        paranoid_free(checksum_line);
    3097         paranoid_free(command);
    30983058        mr_free(suffix);
    30993059        return (1);
     
    31093069    }
    31103070    i = bkpinfo->optimal_set_size / 256;
     3071    if (!(tempblock = (char *) malloc(256 * 1024))) {
     3072        fatal_error("malloc error 256*1024");
     3073    }
    31113074    for (slice_num = 1; !finished; slice_num++) {
    31123075        mr_asprintf(&curr_slice_fname_uncompressed, "%s",
     
    31493112            }
    31503113            if (should_I_compress_slices && bkpinfo->compression_level > 0) {
    3151                 sprintf(command, "%s -%d %s", bkpinfo->zip_exe,
     3114                mr_asprintf(&command, "%s -%d %s", bkpinfo->zip_exe,
    31523115                        bkpinfo->compression_level,
    31533116                        curr_slice_fname_uncompressed);
     
    31583121                //          did_I_compress_slice = TRUE;
    31593122            } else {
    3160                 sprintf(command, "mv %s %s 2>> %s",
     3123                mr_asprintf(&command, "mv %s %s 2>> %s",
    31613124                        curr_slice_fname_uncompressed,
    31623125                        curr_slice_fname_compressed, MONDO_LOGFILE);
     
    31643127                //          did_I_compress_slice = FALSE;
    31653128            }
     3129            mr_free(command);
     3130
    31663131            retval += res;
    31673132            if (res) {
     
    32283193        }
    32293194    }
     3195    mr_free(tempblock);
    32303196    mr_free(suffix);
    32313197    paranoid_fclose(fin);
     
    32393205    paranoid_free(tmp);
    32403206
    3241     paranoid_free(tempblock);
    32423207    paranoid_free(checksum_line);
    3243     paranoid_free(command);
    32443208    return (retval);
    32453209}
    3246 
    3247 
    3248 
    3249 
    32503210
    32513211
     
    32653225{
    32663226    /*@ buffers ********************************************* */
    3267     char *tmp;
    3268     char *dir;
    3269 
    3270     malloc_string(tmp);
    3271     malloc_string(dir);
     3227    char *tmp = NULL;
     3228    char *dir = NULL;
     3229
    32723230    assert_string_is_neither_NULL_nor_zerolength(d);
    32733231
    3274     sprintf(dir, "%s/archives", d);
    3275     sprintf(tmp, "find %s -name '*.afio*' -exec rm -f '{}' \\;", dir);
     3232    mr_asprintf(&dir, "%s/archives", d);
     3233    mr_asprintf(&tmp, "find %s -name '*.afio*' -exec rm -f '{}' \\;", dir);
    32763234    run_program_and_log_output(tmp, FALSE);
    3277     sprintf(tmp, "find %s -name '*list.[0-9]*' -exec rm -f '{}' \\;", dir);
     3235    mr_free(tmp);
     3236    mr_asprintf(&tmp, "find %s -name '*list.[0-9]*' -exec rm -f '{}' \\;", dir);
    32783237    run_program_and_log_output(tmp, FALSE);
    3279     sprintf(tmp, "find %s -name 'slice*' -exec rm -f '{}' \\;", dir);
     3238    mr_free(tmp);
     3239    mr_asprintf(&tmp, "find %s -name 'slice*' -exec rm -f '{}' \\;", dir);
    32803240    run_program_and_log_output(tmp, FALSE);
    3281     sprintf(tmp, "rm -f %s/cklist*", dir);
     3241    mr_free(tmp);
     3242    mr_asprintf(&tmp, "rm -f %s/cklist*", dir);
    32823243    run_program_and_log_output(tmp, FALSE);
    3283     sprintf(tmp, "rm -f %s/zero", dir);
     3244    mr_free(tmp);
     3245    mr_asprintf(&tmp, "rm -f %s/zero", dir);
    32843246    run_program_and_log_output(tmp, FALSE);
     3247    mr_free(tmp);
    32853248    log_msg(1, "Wiped %s's archives", dir);
    3286     sprintf(tmp, "ls -l %s", dir);
     3249    mr_asprintf(&tmp, "ls -l %s", dir);
     3250    mr_free(dir);
    32873251    run_program_and_log_output(tmp, FALSE);
    3288     paranoid_free(tmp);
    3289     paranoid_free(dir);
     3252    mr_free(tmp);
    32903253}
    3291 
    32923254
    32933255
     
    35233485{
    35243486    int res = 0, retval = 0, cdno = 0;
    3525     char *tmp;
     3487    char *tmp = NULL;
    35263488    char *mds = NULL;
    35273489    long diffs = 0;
    35283490
    3529     malloc_string(tmp);
    35303491    assert(bkpinfo != NULL);
    35313492    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
     
    35433504        log_msg(2,
    35443505                "Not verifying again. Per-CD/ISO verification already carried out.");
    3545         sprintf(tmp, "cat %s/changed.files > %s/changed.files 2> /dev/null",bkpinfo->tmpdir, MONDO_CACHE);
     3506        mr_asprintf(&tmp, "cat %s/changed.files > %s/changed.files 2> /dev/null",bkpinfo->tmpdir, MONDO_CACHE);
    35463507        paranoid_system(tmp);
     3508        mr_free(tmp);
    35473509    } else {
    35483510        g_current_media_number = cdno;
     
    35653527            if (res) {
    35663528                mds = media_descriptor_string(bkpinfo->backup_media_type);
    3567                 sprintf(tmp,
     3529                mr_asprintf(&tmp,
    35683530                        "Warnings/errors were reported while checking %s #%d", mds, g_current_media_number);
    35693531                mr_free(mds);
    35703532                log_to_screen(tmp);
     3533                mr_free(tmp);
    35713534
    35723535            }
    35733536        }
    3574 /*
    3575       sprintf (tmp,
    3576            "cat %s | grep \"afio: \" | cut -d'\"' -f2 | sort -u | awk '{print \"/\"$0;};' | tr -s '/' '/' | grep -vx \"/afio:.*\" > /tmp/changed.files",
    3577            MONDO_LOGFILE);
    3578       system (tmp);
    3579 */
    3580         sprintf(tmp,
     3537        mr_asprintf(&tmp,
    35813538                "grep 'afio: ' %s | sed 's/afio: //' | grep -vE '^/dev/.*$' >> %s/changed.files",
    35823539                MONDO_LOGFILE, MONDO_CACHE);
    35833540        (void)system(tmp);
    3584 
    3585         sprintf(tmp,
     3541        mr_free(tmp);
     3542
     3543        mr_asprintf(&tmp,
    35863544                "grep 'star: ' %s | sed 's/star: //' | grep -vE '^/dev/.*$' >> %s/changed.files",
    35873545                MONDO_LOGFILE, MONDO_CACHE);
    35883546        (void)system(tmp);
     3547        mr_free(tmp);
    35893548        run_program_and_log_output("umount " MNT_CDROM, FALSE);
    35903549//    if (bkpinfo->backup_media_type != iso && !bkpinfo->please_dont_eject_when_restoring)
     
    35933552//}
    35943553    }
    3595     sprintf(tmp, "%s/changed.files", MONDO_CACHE);
     3554    mr_asprintf(&tmp, "%s/changed.files", MONDO_CACHE);
    35963555    diffs = count_lines_in_file(tmp);
     3556    mr_free(tmp);
    35973557
    35983558    if (diffs > 0) {
     
    36013561        }
    36023562    }
    3603     paranoid_free(tmp);
    36043563    return (retval);
    36053564}
Note: See TracChangeset for help on using the changeset viewer.