Changeset 3192


Ignore:
Timestamp:
Sep 25, 2013, 9:03:25 AM (5 years ago)
Author:
bruno
Message:
  • revert r3188 & r3189 as I started to work on branch 3.0 before deciding it was much better to do it in 3.2. This will allow some small maintenance work on 3.0 if needed, while pushing all the rest to 3.2 and providing early access to it.
Location:
branches/3.0/mondo/src
Files:
23 edited

Legend:

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

    r3188 r3192  
    6464extern bool g_cd_recovery;
    6565extern char *g_mondo_home;
    66 
    67 /**
    68  * The serial string (used to differentiate between backups) of the current backup.
    69  */
    70 char *g_serial_string = NULL;
    71 
     66/*
     67extern char *g_tmpfs_mountpt;
     68*/
     69extern char *g_serial_string;
    7270extern char *g_getfacl;
    7371extern char *g_getfattr;
     
    202200
    203201    if (!does_file_exist(filelist)) {
    204         log_to_screen("(archive_this_fileset) - filelist %s does not exist", filelist);
     202        mr_asprintf(tmp, "(archive_this_fileset) - filelist %s does not exist", filelist);
     203        log_to_screen(tmp);
     204        paranoid_free(tmp);
    205205        return (1);
    206206    }
     
    208208    mr_asprintf(tmp, "echo hi > %s 2> /dev/null", fname);
    209209    if (system(tmp)) {
    210         mr_free(tmp);
     210        paranoid_free(tmp);
    211211        fatal_error("Unable to write tarball to scratchdir");
    212212    }
    213213    paranoid_free(tmp);
    214214
    215     mr_asprintf(command, "star H=exustar list=%s -c -sparse " STAR_ACL_SZ " file=%s", filelist, fname);
     215    mr_asprintf(command, "star H=exustar list=%s -c -sparse " STAR_ACL_SZ " file=%s",
     216            filelist, fname);
    216217    if (bkpinfo->use_lzo) {
    217         mr_free(command);
    218218        fatal_error("Can't use lzop");
    219219    }
     
    235235            res = 0;
    236236        }
    237         mr_free(tmp);
     237        paranoid_free(tmp);
    238238
    239239        if (res) {
     
    251251        }
    252252    }
    253     mr_free(command);
     253    paranoid_free(command);
    254254
    255255    retval += res;
     
    307307
    308308    if (!does_file_exist(filelist)) {
    309         log_to_screen("(archive_this_fileset) - filelist %s does not exist", filelist);
     309        mr_asprintf(tmp, "(archive_this_fileset) - filelist %s does not exist",
     310                filelist);
     311        log_to_screen(tmp);
     312        paranoid_free(tmp);
    310313        return (1);
    311314    }
    312315    mr_asprintf(tmp, "echo hi > %s 2> /dev/null", fname);
    313316    if (system(tmp)) {
    314         mr_free(tmp);
     317        paranoid_free(tmp);
    315318        fatal_error("Unable to write tarball to scratchdir");
    316319    }
    317     mr_free(tmp);
     320    paranoid_free(tmp);
    318321
    319322
     
    321324        mr_asprintf(tmp, "%s/do-not-compress-these", g_mondo_home);
    322325        //       -b %ld, TAPE_BLOCK_SIZE
    323         mr_asprintf(zipparams, "-Z -P %s -G %d -T 3k", bkpinfo->zip_exe, bkpinfo->compression_level);
     326        mr_asprintf(zipparams, "-Z -P %s -G %d -T 3k", bkpinfo->zip_exe,
     327                bkpinfo->compression_level);
    324328        if (does_file_exist(tmp)) {
    325329            mr_strcat(zipparams, " -E %s",tmp);
     
    327331            log_msg(3, "%s not found. Cannot exclude zipfiles, etc.", tmp);
    328332        }
    329         mr_free(tmp);
     333        paranoid_free(tmp);
    330334    } else {
    331335        mr_asprintf(zipparams, "");
    332336    }
     337
     338//  make_hole_for_file(fname);
    333339
    334340    if (!does_file_exist(bkpinfo->tmpdir)) {
     
    340346        fatal_error("scratchdir not found");
    341347    }
    342     mr_asprintf(command, "rm -f %s %s. %s.gz %s.%s", fname, fname, fname, fname, bkpinfo->zip_suffix);
     348    mr_asprintf(command, "rm -f %s %s. %s.gz %s.%s", fname, fname, fname,
     349            fname, bkpinfo->zip_suffix);
    343350    paranoid_system(command);
    344     mr_free(command);
    345 
    346     mr_asprintf(command, "afio -o -b %ld -M 16m %s %s < %s 2>> %s", TAPE_BLOCK_SIZE, zipparams, fname, filelist, MONDO_LOGFILE);
    347     mr_free(zipparams);
     351    paranoid_free(command);
     352
     353    mr_asprintf(command, "afio -o -b %ld -M 16m %s %s < %s 2>> %s",
     354            TAPE_BLOCK_SIZE, zipparams, fname, filelist, MONDO_LOGFILE);
     355    paranoid_free(zipparams);
    348356
    349357    mr_asprintf(tmp, "echo hi > %s 2> /dev/null", fname);
    350358    if (system(tmp)) {
    351         mr_free(tmp);
     359        paranoid_free(tmp);
    352360        fatal_error("Unable to write tarball to scratchdir");
    353361    }
    354     mr_free(tmp);
     362    paranoid_free(tmp);
    355363
    356364    for (res = 99, tries = 0; tries < 3 && res != 0; tries++) {
     
    398406{
    399407    int retval = 0, res = 0;
    400     char *tmp = NULL;
     408    char *tmp;
    401409
    402410    assert(bkpinfo != NULL);
    403411    set_g_cdrom_and_g_dvd_to_bkpinfo_value();
     412    malloc_string(tmp);
    404413    if (bkpinfo->backup_media_type == dvd) {
    405414#ifdef DVDRWFORMAT
     
    422431    }
    423432
    424     mr_asprintf(tmp, "gzip -9 %s/archives/filelist.full", bkpinfo->scratchdir);
     433/*
     434      sprintf(tmp, "wc -l %s/archives/filelist.full > %s/archives/filelist.count",bkpinfo->scratchdir, bkpinfo->scratchdir);
     435      if (run_program_and_log_output(tmp, 2))
     436        { fatal_error("Failed to count filelist.full"); }
     437*/
     438    sprintf(tmp, "gzip -9 %s/archives/filelist.full", bkpinfo->scratchdir);
    425439    if (run_program_and_log_output(tmp, 2)) {
    426         mr_free(tmp);
    427440        fatal_error("Failed to gzip filelist.full");
    428441    }
    429     mr_free(tmp);
    430 
    431     mr_asprintf(tmp, "cp -f %s/archives/*list*.gz %s", bkpinfo->scratchdir, bkpinfo->tmpdir);
     442    sprintf(tmp, "cp -f %s/archives/*list*.gz %s", bkpinfo->scratchdir,
     443            bkpinfo->tmpdir);
    432444    if (run_program_and_log_output(tmp, 2)) {
    433         mr_free(tmp);
    434445        fatal_error("Failed to copy to tmpdir");
    435446    }
    436     mr_free(tmp);
    437447
    438448    copy_mondo_and_mindi_stuff_to_scratchdir(); // payload, too, if it exists
     
    454464    }
    455465    retval += do_that_initial_phase();  // prepare
    456     mr_asprintf(tmp, "rm -f %s/images/*.iso", bkpinfo->scratchdir);
     466    sprintf(tmp, "rm -f %s/images/*.iso", bkpinfo->scratchdir);
    457467    run_program_and_log_output(tmp, 1);
    458     mr_free(tmp);
    459 
    460468    retval += make_those_afios_phase(); // backup regular files
    461469    retval += make_those_slices_phase();    // backup BIG files
     
    465473        sleep(2);
    466474    }
     475    paranoid_free(tmp);
    467476    return (retval);
    468477}
     
    505514    char *use_lzo_sz = NULL;
    506515    char *use_gzip_sz = NULL;
    507     char *use_lzma_sz = NULL;
    508516    char *use_comp_sz = NULL;
    509517    char *use_star_sz = NULL;
     
    534542    assert(bkpinfo != NULL);
    535543
    536     mvaddstr_and_log_it(g_currentY, 0, "Calling MINDI to create boot+data disks");
     544    mvaddstr_and_log_it(g_currentY, 0,
     545                        "Calling MINDI to create boot+data disks");
    537546    open_evalcall_form("Calling MINDI to create boot+data disks");
    538547    mr_asprintf(tmp, "%s/filelist.full", bkpinfo->tmpdir);
     
    541550        mr_asprintf(tmp, "%s/tmpfs/filelist.full", bkpinfo->tmpdir);
    542551        if (!does_file_exist(tmp)) {
    543             mr_free(tmp);
    544             fatal_error ("Cannot find filelist.full, so I cannot count its lines");
     552            fatal_error
     553                ("Cannot find filelist.full, so I cannot count its lines");
    545554        }
    546555    }
     
    562571            }
    563572        }
    564         mr_free(ntapedev);
     573        paranoid_free(ntapedev);
    565574        mr_asprintf(tape_device, "%s", bkpinfo->media_device);
    566575    } else {
     
    577586    } else {
    578587        mr_asprintf(use_gzip_sz, "no");
    579     }
    580     if (bkpinfo->use_lzma) {
    581         mr_asprintf(use_lzma_sz, "yes");
    582     } else {
    583         mr_asprintf(use_lzma_sz, "no");
    584588    }
    585589    if (bkpinfo->use_star) {
     
    656660            ch = 'U';
    657661        if (bkpinfo->boot_loader != '\0') {
    658             log_msg(2, "User specified boot loader. It is '%c'.", bkpinfo->boot_loader);
     662            mr_asprintf(tmp, "User specified boot loader. It is '%c'.", bkpinfo->boot_loader);
     663            log_msg(2, tmp);
     664            mr_free(tmp);
    659665        } else {
    660666            bkpinfo->boot_loader = ch;
    661667        }
    662668        if (bkpinfo->boot_device[0] != '\0') {
    663             log_msg(2, "User specified boot device. It is '%s'.", bkpinfo->boot_device);
     669            mr_asprintf(tmp, "User specified boot device. It is '%s'.", bkpinfo->boot_device);
     670            log_msg(2, tmp);
     671            mr_free(tmp);
    664672        } else {
    665673            strcpy(bkpinfo->boot_device, bootdev);
     
    684692        mr_asprintf(bootldr_str, "LILO");
    685693        if (!does_file_exist("/etc/lilo.conf")) {
    686             fatal_error("The de facto standard location for your boot loader's config file is /etc/lilo.conf but I cannot find it there. What is wrong with your Linux distribution?");
     694            fatal_error
     695                ("The de facto standard location for your boot loader's config file is /etc/lilo.conf but I cannot find it there. What is wrong with your Linux distribution?");
    687696        }
    688697    } else if (bkpinfo->boot_loader == 'G') {
    689698        mr_asprintf(bootldr_str, "GRUB");
    690         if (!does_file_exist("/boot/grub/menu.lst") && does_file_exist("/boot/grub/grub.conf")) {
    691             run_program_and_log_output("ln -sf /boot/grub/grub.conf /boot/grub/menu.lst", 5);
     699        if (!does_file_exist("/boot/grub/menu.lst")
     700            && does_file_exist("/boot/grub/grub.conf")) {
     701            run_program_and_log_output
     702                ("ln -sf /boot/grub/grub.conf /boot/grub/menu.lst", 5);
    692703        }
    693704        if ((!does_file_exist("/boot/grub/menu.lst")) && (!does_file_exist("/boot/grub/grub.cfg")) && (!does_file_exist("/boot/grub2/grub.cfg"))) {
    694             fatal_error("The de facto standard location for your boot loader's config file is /boot/grub/menu.lst, /boot/grub/grub.cfg, or /boot/grub2/grub.cfg but I cannot find it there. What is wrong with your Linux distribution?");
     705            fatal_error
     706                ("The de facto standard location for your boot loader's config file is /boot/grub/menu.lst, /boot/grub/grub.cfg, or /boot/grub2/grub.cfg but I cannot find it there. What is wrong with your Linux distribution?");
    695707        }
    696708        mr_asprintf(bootldr_ver, "%s", call_program_and_get_last_line_of_output("grub --version"));
     
    698710        mr_asprintf(bootldr_str, "ELILO");
    699711        /* BCO: fix it for Debian, Mandrake, ... */
    700         if (!does_file_exist("/etc/elilo.conf") && does_file_exist("/boot/efi/efi/redhat/elilo.conf")) {
    701             run_program_and_log_output("ln -sf /boot/efi/efi/redhat/elilo.conf /etc/elilo.conf", 5);
    702         }
    703         if (!does_file_exist("/etc/elilo.conf") && does_file_exist("/boot/efi/efi/SuSE/elilo.conf")) {
    704             run_program_and_log_output("ln -sf /boot/efi/efi/SuSE/elilo.conf /etc/elilo.conf", 5);
    705         }
    706         if (!does_file_exist("/etc/elilo.conf") && does_file_exist("/boot/efi/efi/debian/elilo.conf")) {
    707             run_program_and_log_output ("ln -sf /boot/efi/efi/debian/elilo.conf /etc/elilo.conf", 5);
    708         }
    709         if (!does_file_exist("/etc/elilo.conf") && does_file_exist("/boot/efi/debian/elilo.conf")) {
    710             run_program_and_log_output ("ln -sf /boot/efi/debian/elilo.conf /etc/elilo.conf", 5);
     712        if (!does_file_exist("/etc/elilo.conf")
     713            && does_file_exist("/boot/efi/efi/redhat/elilo.conf")) {
     714            run_program_and_log_output
     715                ("ln -sf /boot/efi/efi/redhat/elilo.conf /etc/elilo.conf",
     716                 5);
     717        }
     718        if (!does_file_exist("/etc/elilo.conf")
     719            && does_file_exist("/boot/efi/efi/SuSE/elilo.conf")) {
     720            run_program_and_log_output
     721                ("ln -sf /boot/efi/efi/SuSE/elilo.conf /etc/elilo.conf",
     722                 5);
     723        }
     724        if (!does_file_exist("/etc/elilo.conf")
     725            && does_file_exist("/boot/efi/efi/debian/elilo.conf")) {
     726            run_program_and_log_output
     727                ("ln -sf /boot/efi/efi/debian/elilo.conf /etc/elilo.conf",
     728                 5);
     729        }
     730        if (!does_file_exist("/etc/elilo.conf")
     731            && does_file_exist("/boot/efi/debian/elilo.conf")) {
     732            run_program_and_log_output
     733                ("ln -sf /boot/efi/debian/elilo.conf /etc/elilo.conf",
     734                 5);
    711735        }
    712736        if (!does_file_exist("/etc/elilo.conf")) {
    713             fatal_error("The de facto mondo standard location for your boot loader's config file is /etc/elilo.conf but I cannot find it there. What is wrong with your Linux distribution? Try finding it under /boot/efi and do 'ln -s /boot/efi/..../elilo.conf /etc/elilo.conf'");
     737            fatal_error
     738                ("The de facto mondo standard location for your boot loader's config file is /etc/elilo.conf but I cannot find it there. What is wrong with your Linux distribution? Try finding it under /boot/efi and do 'ln -s /boot/efi/..../elilo.conf /etc/elilo.conf'");
    714739        }
    715740    } else if (bkpinfo->boot_loader == 'R') {
     
    728753        mr_asprintf(bootldr_str, "unknown");
    729754    }
    730     log_to_screen("Your boot loader is %s and it boots from %s", bootldr_str, bkpinfo->boot_device);
    731 
     755    mr_asprintf(tmp, "Your boot loader is %s and it boots from %s", bootldr_str, bkpinfo->boot_device);
     756    log_to_screen(tmp);
     757    mr_free(tmp);
    732758    if (bootldr_ver != NULL) {
    733         log_to_screen("Boot loader version string: %s", bootldr_ver);
     759        mr_asprintf(tmp, "Boot loader version string: %s", bootldr_ver);
     760        log_to_screen(tmp);
     761        mr_free(tmp);
    734762    }
    735763
     
    771799        fatal_error("Unknown backup_media_type");
    772800    }
    773 
    774     if ((bkpinfo->backup_media_type == usb) && (bkpinfo->media_device)) {
     801    if (bkpinfo->backup_media_type == usb) {
    775802        mr_asprintf(tmp2, "--usb %s", bkpinfo->media_device);
    776803    } else {
     
    781808    if (write_one_liner_data_file(tmp, value)) {
    782809        res++;
    783         log_msg(1, "%ld: Unable to write one-liner backup-media-type", __LINE__);
     810        log_msg(1, "%ld: Unable to write one-liner backup-media-type",
     811                __LINE__);
    784812    }
    785813    mr_free(value);
     
    789817    if (write_one_liner_data_file(tmp, bootldr_str)) {
    790818        res++;
    791         log_msg(1, "%ld: Unable to write one-liner bootloader.name", __LINE__);
     819        log_msg(1, "%ld: Unable to write one-liner bootloader.name",
     820                __LINE__);
    792821    }
    793822    mr_free(bootldr_str);
     
    836865    }
    837866
    838     estimated_total_noof_slices = size_of_all_biggiefiles_K(bkpinfo) / bkpinfo->optimal_set_size + 1;
    839 
    840     /* TODO: add netfs stuff here? */
     867    estimated_total_noof_slices =
     868        size_of_all_biggiefiles_K(bkpinfo) / bkpinfo->optimal_set_size + 1;
     869    /* add netfs stuff here? */
    841870    mr_asprintf(command, "mkdir -p %s/images", bkpinfo->scratchdir);
    842871    if (system(command)) {
     
    844873        log_OS_error("Unable to make images directory");
    845874    }
    846     mr_free(command);
     875    paranoid_free(command);
    847876    log_msg(1, "lines_in_filelist = %ld", lines_in_filelist);
    848877    update_evalcall_form(3);
     
    861890            use_lzo_sz,         // parameter #8
    862891            cd_recovery_sz,     // parameter #9
    863             (bkpinfo->image_devs == NULL) ? "\"\"" : bkpinfo->image_devs,   // parameter #10
     892            bkpinfo->image_devs,    // parameter #10
    864893            broken_bios_sz,     // parameter #11
    865894            last_filelist_number,   // parameter #12 (STRING)
     
    871900            bkpinfo->internal_tape_block_size,  // parameter #18 (LONG)
    872901            bkpinfo->differential,  // parameter #19 (INT)
    873             use_gzip_sz,        // parameter #19 (STRING)
    874             use_lzma_sz,        // parameter #20 (STRING)
    875             value,              // parameter #21 (STRING)
    876             MONDO_LOGFILE);
     902            use_gzip_sz);       // parameter #20 (STRING)
    877903
    878904    mr_free(last_filelist_number);
     
    880906    mr_free(use_lzo_sz);
    881907    mr_free(use_gzip_sz);
    882     mr_free(use_lzma_sz);
    883908    mr_free(use_star_sz);
    884909    mr_free(use_comp_sz);
     
    888913    mr_free(tape_size_sz);
    889914
    890     /* This parameter is always the last one and optional */
    891915    if (bkpinfo->nonbootable_backup) {
    892916        mr_strcat(command, " NONBOOTABLE");
     
    905929    if (!res) {
    906930        log_to_screen("Boot+data disks were created OK");
    907         mr_asprintf(command, "cp -f %s/images/mindi.iso %s/mondorescue.iso", bkpinfo->scratchdir, MINDI_CACHE);
     931        mr_asprintf(command, "cp -f %s/images/mindi.iso %s/mondorescue.iso",
     932                bkpinfo->scratchdir, MINDI_CACHE);
    908933        log_msg(2, command);
    909934        run_program_and_log_output(command, FALSE);
    910         mr_free(command);
     935        paranoid_free(command);
    911936
    912937        if (bkpinfo->nonbootable_backup) {
    913             mr_asprintf(command, "cp -f %s/all.tar.gz %s/images", bkpinfo->tmpdir, bkpinfo->scratchdir);
     938            mr_asprintf(command, "cp -f %s/all.tar.gz %s/images",
     939                    bkpinfo->tmpdir, bkpinfo->scratchdir);
    914940            if (system(command)) {
    915                 mr_free(command);
     941                paranoid_free(command);
    916942                fatal_error("Unable to create temporary all tarball");
    917943            }
    918             mr_free(command);
     944            paranoid_free(command);
    919945        }
    920946        /* For USB we already have everything on the key */
     
    922948            mr_asprintf(command, "rm -rf %s/images", bkpinfo->scratchdir);
    923949            run_program_and_log_output(command, FALSE);
    924             mr_free(command);
     950            paranoid_free(command);
    925951        } else {
    926             mr_asprintf(tmp, "cp -f %s/images/all.tar.gz %s", bkpinfo->scratchdir, bkpinfo->tmpdir);
     952            mr_asprintf(tmp, "cp -f %s/images/all.tar.gz %s", bkpinfo->scratchdir,
     953                bkpinfo->tmpdir);
    927954            if (system(tmp)) {
    928955                fatal_error("Cannot find all.tar.gz in tmpdir");
     
    939966        mr_asprintf(command, "grep 'Fatal error' /var/log/mindi.log");
    940967        mr_asprintf(tmp, "%s", call_program_and_get_last_line_of_output(command));
    941         mr_free(command);
     968        paranoid_free(command);
    942969
    943970        if (strlen(tmp) > 1) {
     
    9901017void *create_afio_files_in_background(void *inbuf)
    9911018{
    992     long int archiving_set_no = 0L;
    993     char *archiving_filelist_fname = NULL;
    994     char *archiving_afioball_fname = NULL;
     1019    long int archiving_set_no;
     1020    char *archiving_filelist_fname;
     1021    char *archiving_afioball_fname;
    9951022    char *curr_xattr_list_fname = NULL;
    996     char *curr_acl_list_fname = NULL;
    997 
    998     char *tmp = NULL;
     1023    char *curr_acl_list_fname;
     1024
     1025    char *tmp;
    9991026    int res = 0, retval = 0;
    10001027    int *p_archival_threads_running;
     
    10041031    int this_thread_no = g_current_thread_no++;
    10051032
     1033    malloc_string(curr_xattr_list_fname);
     1034    malloc_string(curr_acl_list_fname);
     1035    malloc_string(archiving_filelist_fname);
     1036    malloc_string(archiving_afioball_fname);
     1037    malloc_string(tmp);
    10061038    p_last_set_archived = (int *) inbuf;
    10071039    p_archival_threads_running = (int *) (inbuf + 4);
     
    10091041    p_list_of_fileset_flags = (char *) (inbuf + 12);
    10101042
    1011     mr_asprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, 0L);
    1012 
    1013     while (does_file_exist(archiving_filelist_fname)) {
     1043    sprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ,
     1044            bkpinfo->tmpdir, 0L);
     1045    for (archiving_set_no = 0L; does_file_exist(archiving_filelist_fname);
     1046         sprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ,
     1047                 bkpinfo->tmpdir, archiving_set_no)) {
    10141048        if (g_exiting) {
    1015             mr_free(archiving_filelist_fname);
    10161049            fatal_error("Execution run aborted (pthread)");
    10171050        }
    10181051        if (archiving_set_no >= MAX_NOOF_SETS_HERE) {
    1019             mr_free(archiving_filelist_fname);
    1020             fatal_error("Maximum number of filesets exceeded. Adjust MAX_NOOF_SETS_HERE, please.");
     1052            fatal_error
     1053                ("Maximum number of filesets exceeded. Adjust MAX_NOOF_SETS_HERE, please.");
    10211054        }
    10221055        if (!semaphore_p()) {
    10231056            log_msg(3, "P sem failed (pid=%d)", (int) getpid());
    1024             mr_free(archiving_filelist_fname);
    10251057            fatal_error("Cannot get semaphore P");
    10261058        }
     
    10301062        *p_next_set_to_archive = *p_next_set_to_archive + 1;
    10311063        if (!semaphore_v()) {
    1032             mr_free(archiving_filelist_fname);
    10331064            fatal_error("Cannot get semaphore V");
    10341065        }
    10351066
    10361067        /* backup this set of files */
    1037         mr_asprintf(archiving_afioball_fname, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no, bkpinfo->zip_suffix);
    1038         mr_free(archiving_filelist_fname);
    1039         mr_asprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
     1068        sprintf(archiving_afioball_fname, AFIOBALL_FNAME_RAW_SZ,
     1069                bkpinfo->tmpdir, archiving_set_no, bkpinfo->zip_suffix);
     1070        sprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ,
     1071                bkpinfo->tmpdir, archiving_set_no);
    10401072        if (!does_file_exist(archiving_filelist_fname)) {
    1041             log_msg(3, "%s[%d:%d] - well, I would archive %d, except that it doesn't exist. I'll stop now.", FORTY_SPACES, getpid(), this_thread_no, archiving_set_no);
    1042             mr_free(archiving_afioball_fname);
     1073            log_msg(3,
     1074                    "%s[%d:%d] - well, I would archive %d, except that it doesn't exist. I'll stop now.",
     1075                    FORTY_SPACES, getpid(), this_thread_no,
     1076                    archiving_set_no);
    10431077            break;
    10441078        }
    10451079
    1046         mr_asprintf(tmp, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no - ARCH_BUFFER_NUM, bkpinfo->zip_suffix);
     1080        sprintf(tmp, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir,
     1081                archiving_set_no - ARCH_BUFFER_NUM, bkpinfo->zip_suffix);
    10471082        if (does_file_exist(tmp)) {
    1048             log_msg(4, "%s[%d:%d] - waiting for storer", FORTY_SPACES, getpid(), this_thread_no);
     1083            log_msg(4, "%s[%d:%d] - waiting for storer", FORTY_SPACES,
     1084                    getpid(), this_thread_no);
    10491085            while (does_file_exist(tmp)) {
    10501086                sleep(1);
     
    10521088            log_msg(4, "[%d] - continuing", getpid());
    10531089        }
    1054         mr_free(tmp);
    1055 
    1056         log_msg(4, "%s[%d:%d] - EXATing %d...", FORTY_SPACES, getpid(), this_thread_no, archiving_set_no);
    1057 
     1090
     1091        log_msg(4, "%s[%d:%d] - EXATing %d...", FORTY_SPACES, getpid(),
     1092                this_thread_no, archiving_set_no);
    10581093        if (g_getfattr) {
    1059             mr_asprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
     1094            sprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
     1095                bkpinfo->tmpdir, archiving_set_no);
    10601096            get_fattr_list(archiving_filelist_fname, curr_xattr_list_fname);
    1061             mr_free(curr_xattr_list_fname);
    10621097        }
    10631098        if (g_getfacl) {
    1064             mr_asprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
     1099            sprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ,
     1100                bkpinfo->tmpdir, archiving_set_no);
    10651101            get_acl_list(archiving_filelist_fname, curr_acl_list_fname);
    1066             mr_free(curr_acl_list_fname);
    1067         }
    1068 
    1069         log_msg(4, "%s[%d:%d] - archiving %d...", FORTY_SPACES, getpid(), this_thread_no, archiving_set_no);
    1070         res = archive_this_fileset(archiving_filelist_fname, archiving_afioball_fname, archiving_set_no);
    1071         mr_free(archiving_afioball_fname);
    1072 
     1102        }
     1103
     1104        log_msg(4, "%s[%d:%d] - archiving %d...", FORTY_SPACES, getpid(),
     1105                this_thread_no, archiving_set_no);
     1106        res =
     1107            archive_this_fileset(archiving_filelist_fname,
     1108                                 archiving_afioball_fname,
     1109                                 archiving_set_no);
    10731110        retval += res;
    10741111
    10751112        if (res) {
    1076             log_to_screen("Errors occurred while archiving set %ld. Please review logs.", archiving_set_no);
    1077         }
    1078 
     1113            sprintf(tmp,
     1114                    "Errors occurred while archiving set %ld. Please review logs.",
     1115                    archiving_set_no);
     1116            log_to_screen(tmp);
     1117        }
    10791118        if (!semaphore_p()) {
    1080             mr_free(archiving_filelist_fname);
    10811119            fatal_error("Cannot get semaphore P");
    10821120        }
     
    10891127
    10901128        if (!semaphore_v()) {
    1091             mr_free(archiving_filelist_fname);
    10921129            fatal_error("Cannot get semaphore V");
    10931130        }
    1094         log_msg(4, "%s[%d:%d] - archived %d OK", FORTY_SPACES, getpid(), this_thread_no, archiving_set_no);
     1131        log_msg(4, "%s[%d:%d] - archived %d OK", FORTY_SPACES, getpid(),
     1132                this_thread_no, archiving_set_no);
    10951133        archiving_set_no++;
    1096 
    1097         mr_free(archiving_filelist_fname);
    1098         mr_asprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
    1099     }
    1100     mr_free(archiving_filelist_fname);
    1101 
     1134    }
    11021135    if (!semaphore_p()) {
    11031136        fatal_error("Cannot get semaphore P");
     
    11071140        fatal_error("Cannot get semaphore V");
    11081141    }
    1109     log_msg(3, "%s[%d:%d] - exiting", FORTY_SPACES, getpid(), this_thread_no);
     1142    log_msg(3, "%s[%d:%d] - exiting", FORTY_SPACES, getpid(),
     1143            this_thread_no);
     1144    paranoid_free(archiving_filelist_fname);
     1145    paranoid_free(archiving_afioball_fname);
     1146    paranoid_free(curr_xattr_list_fname);
     1147    paranoid_free(curr_acl_list_fname);
     1148    paranoid_free(tmp);
    11101149    pthread_exit(NULL);
    11111150}
     
    11891228
    11901229    /*@ buffers *********************************** */
    1191     char *command = NULL;
    1192     char *tmpfile = NULL;
    1193     char *data_disks_file = NULL;
     1230    char *command, *tmpfile, *data_disks_file;
    11941231
    11951232    assert(bkpinfo != NULL);
    1196     mr_asprintf(data_disks_file, "%s/all.tar.gz", bkpinfo->tmpdir);
    1197 
    1198     snprintf(g_serial_string, MAX_STR_LEN - 8, "%s", call_program_and_get_last_line_of_output("dd if=/dev/urandom bs=16 count=1 2> /dev/null | hexdump | tr -s ' ' '0' | head -n1"));
     1233    malloc_string(command);
     1234    malloc_string(tmpfile);
     1235    malloc_string(data_disks_file);
     1236    sprintf(data_disks_file, "%s/all.tar.gz", bkpinfo->tmpdir);
     1237
     1238    snprintf(g_serial_string, MAX_STR_LEN - 8, "%s",
     1239             call_program_and_get_last_line_of_output("dd \
     1240if=/dev/urandom bs=16 count=1 2> /dev/null | \
     1241hexdump | tr -s ' ' '0' | head -n1"));
    11991242    strip_spaces(g_serial_string);
    12001243    strcat(g_serial_string, "...word.");
     
    12021245    assert(strlen(g_serial_string) < MAX_STR_LEN);
    12031246
    1204     mr_asprintf(tmpfile, "%s/archives/SERIAL-STRING", bkpinfo->scratchdir);
     1247    sprintf(tmpfile, "%s/archives/SERIAL-STRING", bkpinfo->scratchdir);
    12051248    if (write_one_liner_data_file(tmpfile, g_serial_string)) {
    12061249        log_msg(1, "%ld: Failed to write serial string", __LINE__);
    12071250    }
    1208     mr_free(tmpfile);
    12091251
    12101252    mvaddstr_and_log_it(g_currentY, 0, "Preparing to archive your data");
     
    12271269        }
    12281270    }
    1229     mr_free(data_disks_file);
    1230 
    1231     mr_asprintf(command, "rm -f %s/%s/%s-[1-9]*.iso", bkpinfo->isodir, bkpinfo->netfs_remote_dir, bkpinfo->prefix);
     1271
     1272    sprintf(command, "rm -f %s/%s/%s-[1-9]*.iso", bkpinfo->isodir,
     1273            bkpinfo->netfs_remote_dir, bkpinfo->prefix);
    12321274    paranoid_system(command);
    1233     mr_free(command);
    1234 
    12351275    wipe_archives(bkpinfo->scratchdir);
    12361276    mvaddstr_and_log_it(g_currentY++, 74, "Done.");
     
    12411281                                     BLK_START_OF_BACKUP);
    12421282    }
     1283    paranoid_free(command);
     1284    paranoid_free(tmpfile);
     1285    paranoid_free(data_disks_file);
    12431286    return (retval);
    12441287}
     
    13131356
    13141357    /*@ buffers ********************************************** */
    1315     char *storing_filelist_fname = NULL;
    1316     char *storing_afioball_fname = NULL;
     1358    char *storing_filelist_fname;
     1359    char *storing_afioball_fname;
    13171360    char *tmp = NULL;
    13181361    char *media_usage_comment = NULL;
     
    13311374    assert(bkpinfo != NULL);
    13321375    malloc_string(result_str);
    1333     transfer_block = malloc(sizeof(struct s_bkpinfo) + BKPINFO_LOC_OFFSET + 64);
    1334     memset((void *) transfer_block, 0, sizeof(struct s_bkpinfo) + BKPINFO_LOC_OFFSET + 64);
     1376    malloc_string(curr_xattr_list_fname);
     1377    malloc_string(curr_acl_list_fname);
     1378    malloc_string(storing_filelist_fname);
     1379    malloc_string(storing_afioball_fname);
     1380    transfer_block =
     1381        malloc(sizeof(struct s_bkpinfo) + BKPINFO_LOC_OFFSET + 64);
     1382    memset((void *) transfer_block, 0,
     1383           sizeof(struct s_bkpinfo) + BKPINFO_LOC_OFFSET + 64);
    13351384    p_last_set_archived = (int *) transfer_block;
    13361385    p_archival_threads_running = (int *) (transfer_block + 4);
    13371386    p_next_set_to_archive = (int *) (transfer_block + 8);
    13381387    p_list_of_fileset_flags = (char *) (transfer_block + 12);
    1339     memcpy((void *) (transfer_block + BKPINFO_LOC_OFFSET), (void *) bkpinfo, sizeof(struct s_bkpinfo));
     1388    memcpy((void *) (transfer_block + BKPINFO_LOC_OFFSET),
     1389           (void *) bkpinfo, sizeof(struct s_bkpinfo));
    13401390    pvp = &vp;
    13411391    vp = (void *) result_str;
     
    13491399                       "Please wait. This may take a couple of hours.",
    13501400                       "Working...",
    1351                        (long)get_last_filelist_number() + 1L);
     1401                       get_last_filelist_number() + 1);
    13521402
    13531403    log_msg(5, "We're gonna party like it's your birthday.");
     
    13881438            if (!get_bit_N_of_array
    13891439                (p_list_of_fileset_flags, storing_set_no)) {
    1390             misc_counter_that_is_not_important = (misc_counter_that_is_not_important + 1) % 5;
     1440            misc_counter_that_is_not_important =
     1441                (misc_counter_that_is_not_important + 1) % 5;
    13911442            /* BCO the media_usage_comment is not really initialized there !
    13921443            if (!misc_counter_that_is_not_important) {
     
    13951446            */
    13961447            sleep(1);
    1397             } else {
     1448            } else
    13981449                // store set N
    1399                 mr_asprintf(storing_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, storing_set_no);
    1400                 mr_asprintf(storing_afioball_fname, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir, storing_set_no, bkpinfo->zip_suffix);
     1450            {
     1451                sprintf(storing_filelist_fname, FILELIST_FNAME_RAW_SZ,
     1452                        bkpinfo->tmpdir, storing_set_no);
     1453                sprintf(storing_afioball_fname, AFIOBALL_FNAME_RAW_SZ,
     1454                        bkpinfo->tmpdir, storing_set_no, bkpinfo->zip_suffix);
    14011455                if (g_getfattr) {
    1402                     mr_asprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, storing_set_no);
     1456                    sprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
     1457                        bkpinfo->tmpdir, storing_set_no);
    14031458                }
    14041459                if (g_getfacl) {
    1405                     mr_asprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, storing_set_no);
     1460                    sprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ,
     1461                        bkpinfo->tmpdir, storing_set_no);
    14061462                }
    14071463
     
    14141470                    sleep(5);
    14151471                }
     1472                mr_asprintf(media_usage_comment, "%s", percent_media_full_comment());
    14161473                /* copy to CD (scratchdir) ... and an actual CD-R if necessary */
    14171474                if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
    14181475                    register_in_tape_catalog(fileset, storing_set_no, -1,
    14191476                                         storing_afioball_fname);
    1420                     maintain_collection_of_recent_archives(bkpinfo->tmpdir, storing_afioball_fname);
     1477                    maintain_collection_of_recent_archives(bkpinfo->tmpdir,
     1478                                                       storing_afioball_fname);
    14211479                    log_it("Writing EXAT files");
    14221480                    res +=
     
    14521510                retval += res;
    14531511                g_current_progress++;
    1454                 mr_asprintf(media_usage_comment, "%s", percent_media_full_comment());
    14551512                update_progress_form(media_usage_comment);
    14561513                mr_free(media_usage_comment);
    14571514                if (res) {
    1458                     log_to_screen("Failed to add archive %ld's files to CD dir\n", storing_set_no);
    1459                     fatal_error("Is your hard disk full? If not, please send the author the logfile.");
     1515                    mr_asprintf(tmp, "Failed to add archive %ld's files to CD dir\n",
     1516                        storing_set_no);
     1517                    log_to_screen(tmp);
     1518                    paranoid_free(tmp);
     1519                    fatal_error
     1520                        ("Is your hard disk full? If not, please send the author the logfile.");
    14601521                }
    14611522                storing_set_no++;
    14621523                //      sleep(2);
    1463                 if (g_getfacl) {
    1464                     mr_free(curr_acl_list_fname);
    1465                 }
    1466                 if (g_getfattr) {
    1467                     mr_free(curr_xattr_list_fname);
    1468                 }
    1469                 mr_free(storing_filelist_fname);
    1470                 mr_free(storing_afioball_fname);
    14711524        }
    14721525    }
     
    14871540    }
    14881541    log_to_screen(tmp);
    1489     mr_free(tmp);
     1542    paranoid_free(tmp);
    14901543
    14911544    paranoid_free(transfer_block);
    14921545    paranoid_free(result_str);
     1546    paranoid_free(storing_filelist_fname);
     1547    paranoid_free(storing_afioball_fname);
     1548    paranoid_free(curr_xattr_list_fname);
     1549    paranoid_free(curr_acl_list_fname);
    14931550    return (retval);
    14941551}
     
    15411598    mr_asprintf(tmp, "chmod 700 %s", bkpinfo->scratchdir);
    15421599    run_program_and_log_output(tmp, FALSE);
    1543     mr_free(tmp);
     1600    paranoid_free(tmp);
    15441601    if (chdir(bkpinfo->scratchdir)) {
    15451602        // FIXME
     
    15511608    log_msg(1, message_to_screen);
    15521609
    1553     if (bkpinfo->media_device) {
    1554         mr_asprintf(tmp1, "%s1", bkpinfo->media_device);
    1555     } else {
    1556         mr_asprintf(tmp1, "");
    1557     }
     1610    mr_asprintf(tmp1, "%s1", bkpinfo->media_device);
    15581611    if (is_this_device_mounted(tmp1)) {
    15591612        log_msg(1, "USB device mounted. Remounting it at the right place");
    15601613        mr_asprintf(tmp, "umount %s", tmp1);
    15611614        run_program_and_log_output(tmp, FALSE);
    1562         mr_free(tmp);
    1563     }
    1564     mr_free(tmp1);
     1615        paranoid_free(tmp);
     1616    }
     1617    paranoid_free(tmp1);
    15651618
    15661619    log_msg(1, "Mounting USB device.");
     
    15681621    mr_asprintf(tmp, "mkdir -p %s", tmp1);
    15691622    run_program_and_log_output(tmp, FALSE);
    1570     mr_free(tmp);
    1571 
     1623    paranoid_free(tmp);
    15721624
    15731625    /* Mindi always create one single parition on the USB dev */
    15741626    mr_asprintf(tmp, "mount %s1 %s", bkpinfo->media_device, tmp1);
    15751627    run_program_and_log_output(tmp, FALSE);
    1576     mr_free(tmp);
     1628    paranoid_free(tmp);
    15771629
    15781630    if (bkpinfo->nonbootable_backup) {
     
    15901642        }
    15911643        log_to_screen(result_sz);
    1592         mr_free(result_sz);
    1593         mr_free(tmp);
     1644        paranoid_free(result_sz);
     1645        paranoid_free(tmp);
    15941646        retval += res;
    15951647
     
    15971649        mr_asprintf(tmp,"mkdir %s/archive", bkpinfo->scratchdir);
    15981650        run_program_and_log_output(tmp, FALSE);
    1599         mr_free(tmp);
     1651        paranoid_free(tmp);
    16001652    }
    16011653    paranoid_free(message_to_screen);
     
    16051657        mr_asprintf(tmp, "umount %s1", bkpinfo->media_device);
    16061658        run_program_and_log_output(tmp, FALSE);
    1607         mr_free(tmp);
     1659        paranoid_free(tmp);
    16081660    }
    16091661
     
    16431695
    16441696    /*@ buffers ****************************************** */
    1645     char *tmp = NULL;
    1646     char *tmp2 = NULL;
     1697    char *tmp;
    16471698    char *old_pwd;
    16481699    char *result_sz = NULL;
    16491700    char *message_to_screen = NULL;
    16501701    char *sz_blank_disk = NULL;
    1651     char *fnam = NULL;
    1652     char *tmp3 = NULL;
     1702    char *fnam;
     1703    char *tmp2;
     1704    char *tmp3;
    16531705    char *isofs_cmd = NULL;
    16541706    char *full_isofs_cmd = NULL;
     
    16581710    malloc_string(old_pwd);
    16591711    malloc_string(fnam);
     1712    tmp = malloc(1200);
     1713    tmp2 = malloc(1200);
     1714    tmp3 = malloc(1200);
    16601715    assert(bkpinfo != NULL);
    16611716    assert_string_is_neither_NULL_nor_zerolength(destfile);
    16621717
    1663     /* Copy the files needed by isolinux in the right dir */
    1664     mr_asprintf(tmp, "%s/isolinux.bin", bkpinfo->scratchdir);
    1665     mr_asprintf(tmp2, "%s/isolinux.bin", bkpinfo->tmpdir);
     1718    sprintf(tmp, "%s/isolinux.bin", bkpinfo->scratchdir);
     1719    sprintf(tmp2, "%s/isolinux.bin", bkpinfo->tmpdir);
    16661720    if (does_file_exist(tmp)) {
    1667         mr_asprintf(tmp3, "cp -f %s %s", tmp, tmp2);
     1721        sprintf(tmp3, "cp -f %s %s", tmp, tmp2);
    16681722        paranoid_system(tmp3);
    1669         mr_free(tmp3);
    16701723    }
    16711724    if (!does_file_exist(tmp) && does_file_exist(tmp2)) {
    1672         mr_asprintf(tmp3, "cp -f %s %s", tmp2, tmp);
     1725        sprintf(tmp3, "cp -f %s %s", tmp2, tmp);
    16731726        paranoid_system(tmp3);
    1674         mr_free(tmp3);
    1675     }
    1676     mr_free(tmp2);
    1677     mr_free(tmp3);
     1727    }
     1728    free(tmp2);
     1729    free(tmp3);
     1730    tmp2 = NULL;
     1731    tmp3 = NULL;
    16781732    if (bkpinfo->backup_media_type == iso && bkpinfo->manual_cd_tray) {
    16791733        popup_and_OK("Please insert new media and press Enter.");
    16801734    }
    16811735
    1682     log_msg(2, "make_iso_fs --- scratchdir=%s --- destfile=%s", bkpinfo->scratchdir, destfile);
     1736    log_msg(2, "make_iso_fs --- scratchdir=%s --- destfile=%s",
     1737            bkpinfo->scratchdir, destfile);
    16831738    tmp2 = getcwd(old_pwd, MAX_STR_LEN - 1);
    1684     if (! tmp2) {
    1685         //FIXME
    1686     }
    1687     mr_asprintf(tmp, "chmod 700 %s", bkpinfo->scratchdir);
     1739    sprintf(tmp, "chmod 700 %s", bkpinfo->scratchdir);
    16881740    run_program_and_log_output(tmp, FALSE);
    1689     mr_free(tmp);
    1690 
    16911741    if (chdir(bkpinfo->scratchdir)) {
    16921742        // FIXME
     
    16941744
    16951745    if (bkpinfo->call_before_iso[0] != '\0') {
    1696         mr_asprintf(message_to_screen, "Running pre-ISO call for CD#%d", g_current_media_number);
    1697         res = eval_call_to_make_ISO(bkpinfo->call_before_iso, destfile, g_current_media_number, MONDO_LOGFILE, message_to_screen);
     1746        mr_asprintf(message_to_screen, "Running pre-ISO call for CD#%d",
     1747                g_current_media_number);
     1748        res =
     1749            eval_call_to_make_ISO(bkpinfo->call_before_iso,
     1750                                  destfile, g_current_media_number,
     1751                                  MONDO_LOGFILE, message_to_screen);
    16981752        if (res) {
    16991753            mr_strcat(message_to_screen, "...failed");
     
    17091763    if (bkpinfo->call_make_iso[0] != '\0') {
    17101764        log_msg(2, "bkpinfo->call_make_iso = %s", bkpinfo->call_make_iso);
     1765        sprintf(tmp, "%s/archives/NOT-THE-LAST", bkpinfo->scratchdir);
    17111766        mds = media_descriptor_string(bkpinfo->backup_media_type);
    17121767        mr_asprintf(message_to_screen, "Making an ISO (%s #%d)", mds, g_current_media_number);
     
    17191774        } else {
    17201775            res =
    1721                 eval_call_to_make_ISO(bkpinfo->call_make_iso, bkpinfo->scratchdir, g_current_media_number, MONDO_LOGFILE, message_to_screen);
     1776                eval_call_to_make_ISO(bkpinfo->call_make_iso,
     1777                                      bkpinfo->scratchdir,
     1778                                      g_current_media_number,
     1779                                      MONDO_LOGFILE, message_to_screen);
    17221780            if (res) {
    17231781                log_to_screen("%s...failed to write", message_to_screen);
    17241782            } else {
    17251783                log_to_screen("%s...OK", message_to_screen);
    1726                 mr_asprintf(tmp, "tail -n10 %s | grep -F ':-('", MONDO_LOGFILE);
     1784                sprintf(tmp, "tail -n10 %s | grep -F ':-('", MONDO_LOGFILE);
    17271785                if (!run_program_and_log_output(tmp, 1)) {
    17281786                    log_to_screen
    17291787                        ("Despite nonfatal errors, growisofs confirms the write was successful.");
    17301788                }
    1731                 mr_free(tmp);
    17321789            }
    17331790            retval += res;
    17341791#ifdef DVDRWFORMAT
    1735             mr_asprintf(tmp, "tail -n8 %s | grep 'blank=full.*dvd-compat.*DAO'", MONDO_LOGFILE);
     1792            sprintf(tmp,
     1793                    "tail -n8 %s | grep 'blank=full.*dvd-compat.*DAO'",
     1794                    MONDO_LOGFILE);
    17361795            if (g_backup_media_type == dvd
    17371796                && (res || !run_program_and_log_output(tmp, 1))) {
     
    17411800                /* reset error counter before trying to blank DVD */
    17421801                retval -= res;
    1743                 sync();
     1802                paranoid_system("sync");
    17441803                pause_for_N_seconds(5, "Letting DVD drive settle");
    17451804
     
    17511810                }
    17521811                pause_for_N_seconds(5, "Letting DVD drive settle");
    1753                 if (bkpinfo->media_device) {
    1754                     mr_asprintf(sz_blank_disk, "dvd+rw-format -force %s", bkpinfo->media_device);
    1755                 } else {
    1756                     mr_asprintf(sz_blank_disk, "dvd+rw-format");
    1757                 }
     1812                mr_asprintf(sz_blank_disk, "dvd+rw-format -force %s", bkpinfo->media_device);
    17581813                log_msg(3, "sz_blank_disk = '%s'", sz_blank_disk);
    1759                 res = run_external_binary_with_percentage_indicator_NEW("Blanking DVD disk", sz_blank_disk);
     1814                res =
     1815                    run_external_binary_with_percentage_indicator_NEW
     1816                    ("Blanking DVD disk", sz_blank_disk);
    17601817                if (res) {
    1761                     log_to_screen("Warning - format failed. (Was it a DVD-R?) Sleeping for 5 seconds to take a breath...");
    1762                     pause_for_N_seconds(5, "Letting DVD drive settle... and trying again.");
    1763                     res = run_external_binary_with_percentage_indicator_NEW("Blanking DVD disk", sz_blank_disk);
     1818                    log_to_screen
     1819                        ("Warning - format failed. (Was it a DVD-R?) Sleeping for 5 seconds to take a breath...");
     1820                    pause_for_N_seconds(5,
     1821                                        "Letting DVD drive settle... and trying again.");
     1822                    res =
     1823                        run_external_binary_with_percentage_indicator_NEW
     1824                        ("Blanking DVD disk", sz_blank_disk);
    17641825                    if (res) {
    17651826                        log_to_screen("Format failed a second time.");
     
    17771838                }
    17781839                pause_for_N_seconds(5, "Letting DVD drive settle");
    1779                 res = eval_call_to_make_ISO(bkpinfo->call_make_iso, bkpinfo->scratchdir, g_current_media_number, MONDO_LOGFILE, message_to_screen);
     1840                res =
     1841                    eval_call_to_make_ISO(bkpinfo->call_make_iso,
     1842                                          bkpinfo->scratchdir,
     1843                                          g_current_media_number,
     1844                                          MONDO_LOGFILE,
     1845                                          message_to_screen);
    17801846                retval += res;
    17811847                if (!bkpinfo->please_dont_eject) {
     
    17901856                }
    17911857            }
    1792             mr_free(tmp);
    17931858#endif
    17941859            if (g_backup_media_type == dvd && !bkpinfo->please_dont_eject) {
     
    18111876            log_msg(1, "Making nonbootable backup");
    18121877            mr_asprintf(full_isofs_cmd, "%s%s-o '_ISO_' -V _CD#_ .",isofs_cmd,MONDO_MKISOFS);
    1813             res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, MONDO_LOGFILE, message_to_screen);
     1878            res = eval_call_to_make_ISO(full_isofs_cmd,
     1879                                      destfile, g_current_media_number,
     1880                                      MONDO_LOGFILE, message_to_screen);
    18141881            mr_free(full_isofs_cmd);
    18151882        } else {
     
    18211888
    18221889
    1823             log_msg(1, "make_cd_use_lilo is actually %d", bkpinfo->make_cd_use_lilo);
     1890            log_msg(1, "make_cd_use_lilo is actually %d",
     1891                    bkpinfo->make_cd_use_lilo);
    18241892            if (bkpinfo->make_cd_use_lilo) {
    18251893                log_msg(1, "make_cd_use_lilo = TRUE");
     
    18271895                log_msg(1, "IA64 --> elilo");
    18281896                mr_asprintf(full_isofs_cmd, "%s%s-o '_ISO_' -V _CD#_ .",isofs_cmd,MONDO_MKISOFS_REGULAR_ELILO);
    1829                 res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, MONDO_LOGFILE, message_to_screen);
     1897                res = eval_call_to_make_ISO(full_isofs_cmd,
     1898                                            destfile,
     1899                                            g_current_media_number,
     1900                                            MONDO_LOGFILE,
     1901                                            message_to_screen);
    18301902                mr_free(full_isofs_cmd);
    18311903#else
    18321904                log_msg(1, "Non-ia64 --> lilo");
    18331905                mr_asprintf(full_isofs_cmd, "%s%s-b images/mindi-bootroot.2880.img -c boot.cat -o '_ISO_' -J -V _CD#_ .",isofs_cmd,MONDO_MKISOFS);
    1834                 // FIXME: fixed boot size probably wrong. lilo to be removed
    1835                 res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, MONDO_LOGFILE, message_to_screen);
     1906                res =
     1907                    // FIXME: fixed boot size probably wrong. lilo to be removed
     1908                    eval_call_to_make_ISO(full_isofs_cmd,
     1909                                          destfile, g_current_media_number,
     1910                                          MONDO_LOGFILE,
     1911                                          message_to_screen);
    18361912                mr_free(full_isofs_cmd);
    18371913#endif
     
    18401916                log_msg(1, "Isolinux");
    18411917                mr_asprintf(full_isofs_cmd, "%s%s-o '_ISO_' -V _CD#_ .",isofs_cmd,MONDO_MKISOFS_REGULAR_SYSLINUX);
    1842                 res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, MONDO_LOGFILE, message_to_screen);
     1918                res =
     1919                    eval_call_to_make_ISO(full_isofs_cmd,
     1920                                          destfile, g_current_media_number,
     1921                                          MONDO_LOGFILE,
     1922                                          message_to_screen);
    18431923                mr_free(full_isofs_cmd);
    18441924            }
     
    18601940        || bkpinfo->backup_media_type == cdrw) {
    18611941        if (is_this_device_mounted(bkpinfo->media_device)) {
    1862             log_msg(2, "Warning - %s mounted. I'm unmounting it before I burn to it.", bkpinfo->media_device);
    1863             mr_asprintf(tmp, "umount %s", bkpinfo->media_device);
     1942            log_msg(2,
     1943                    "Warning - %s mounted. I'm unmounting it before I burn to it.",
     1944                    bkpinfo->media_device);
     1945            sprintf(tmp, "umount %s", bkpinfo->media_device);
    18641946            run_program_and_log_output(tmp, FALSE);
    1865             mr_free(tmp);
    18661947        }
    18671948    }
     
    18731954        mr_free(mds);
    18741955        pause_and_ask_for_cdr(2, &cd_is_mountable);
    1875         res = eval_call_to_make_ISO(bkpinfo->call_burn_iso, destfile, g_current_media_number, MONDO_LOGFILE, message_to_screen);
     1956        res =
     1957            eval_call_to_make_ISO(bkpinfo->call_burn_iso,
     1958                                  destfile, g_current_media_number,
     1959                                  MONDO_LOGFILE, message_to_screen);
    18761960        if (res) {
    18771961            mr_strcat(message_to_screen, "...failed");
     
    18891973        mr_asprintf(message_to_screen, "Running post-ISO call (%s #%d)", mds, g_current_media_number);
    18901974        mr_free(mds);
    1891         res = eval_call_to_make_ISO(bkpinfo->call_after_iso, destfile, g_current_media_number, MONDO_LOGFILE, message_to_screen);
     1975        res =
     1976            eval_call_to_make_ISO(bkpinfo->call_after_iso,
     1977                                  destfile, g_current_media_number,
     1978                                  MONDO_LOGFILE, message_to_screen);
    18921979        if (res) {
    18931980            mr_strcat(message_to_screen, "...failed");
     
    19572044
    19582045    /*@ pointers ******************************************* */
    1959     FILE *fin = NULL;
     2046    FILE *fin;
    19602047    char *p;
    19612048    char *q;
     
    19632050    /*@ buffers ******************************************** */
    19642051    char *tmp = NULL;
    1965     char *bigfile_fname = NULL;
     2052    char *bigfile_fname;
    19662053    char *sz_devfile = NULL;
    19672054    char *ntfsprog_fifo = NULL;
     
    19992086    log_to_screen(tmp);
    20002087    noof_biggie_files = count_lines_in_file(biggielist_fname);
    2001     open_progress_form("Backing up big files", tmp, "Please wait. This may take some time.", "", estimated_total_noof_slices);
    2002     mr_free(tmp);
     2088    open_progress_form("Backing up big files", tmp,
     2089                       "Please wait. This may take some time.", "",
     2090                       estimated_total_noof_slices);
     2091    paranoid_free(tmp);
    20032092
    20042093    if (!(fin = fopen(biggielist_fname, "r"))) {
     
    20322121            log_msg(2, "bigfile_fname = %s", bigfile_fname);
    20332122            use_ntfsprog = FALSE;
    2034             if (!strncmp(bigfile_fname, "/dev/", 5) && is_dev_an_NTFS_dev(bigfile_fname)) {
     2123            if (!strncmp(bigfile_fname, "/dev/", 5)
     2124                && is_dev_an_NTFS_dev(bigfile_fname)) {
    20352125                use_ntfsprog = TRUE;
    2036                 log_msg(2, "Calling ntfsclone in background because %s is an NTFS partition", bigfile_fname);
    2037                 mr_asprintf(sz_devfile, "%s/%d.%d.000", bkpinfo->tmpdir, (int) (random() % 32768), (int) (random() % 32768));
     2126                log_msg(2,
     2127                        "Calling ntfsclone in background because %s is an NTFS partition",
     2128                        bigfile_fname);
     2129                mr_asprintf(sz_devfile, "%s/%d.%d.000", bkpinfo->tmpdir,
     2130                        (int) (random() % 32768),
     2131                        (int) (random() % 32768));
    20382132                mkfifo(sz_devfile, 0x770);
    20392133                ntfsprog_fifo = sz_devfile;
     
    20432137                    fatal_error("Fork failure");
    20442138                case 0:
    2045                     log_msg(2, "CHILD - fip - calling feed_into_ntfsprog(%s, %s)", bigfile_fname, sz_devfile);
     2139                    log_msg(2,
     2140                            "CHILD - fip - calling feed_into_ntfsprog(%s, %s)",
     2141                            bigfile_fname, sz_devfile);
    20462142                    res = feed_into_ntfsprog(bigfile_fname, sz_devfile);
    20472143                    /* BCO/BERLIOS Does the child need to unalocate memory as well ?
    2048                     mr_free(bigfile_fname);
     2144                    paranoid_free(bigfile_fname);
    20492145                    mr_free(sz_devfile);
    20502146                    */
     
    20522148                    break;
    20532149                default:
    2054                     log_msg(2, "feed_into_ntfsprog() called in background --- pid=%ld", (long int) (pid));
     2150                    log_msg(2,
     2151                            "feed_into_ntfsprog() called in background --- pid=%ld",
     2152                            (long int) (pid));
    20552153                }
    20562154            }
     
    20622160            // Whether partition or biggiefile, just do your thang :-)
    20632161            if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
    2064                 write_header_block_to_stream(biggie_fsize, bigfile_fname, use_ntfsprog ?  BLK_START_A_PIHBIGGIE : BLK_START_A_NORMBIGGIE);
     2162                write_header_block_to_stream(biggie_fsize, bigfile_fname,
     2163                                             use_ntfsprog ?
     2164                                             BLK_START_A_PIHBIGGIE :
     2165                                             BLK_START_A_NORMBIGGIE);
    20652166            }
    2066             res = slice_up_file_etc(bigfile_fname, ntfsprog_fifo, biggie_file_number, noof_biggie_files, use_ntfsprog);
     2167            res =
     2168                slice_up_file_etc(bigfile_fname,
     2169                                  ntfsprog_fifo, biggie_file_number,
     2170                                  noof_biggie_files, use_ntfsprog);
    20672171
    20682172            /* Free it here as ntfsprog_fifo is not used anymore */
     
    20932197            }
    20942198        }
     2199#ifndef _XWIN
    20952200        if (!g_text_mode) {
    20962201            newtDrawRootText(0, g_noof_rows - 2, tmp);
    20972202            newtRefresh();
    20982203        }
    2099         mr_free(tmp);
    2100     }
    2101     mr_free(bigfile_fname);
    2102 
     2204#endif
     2205        paranoid_free(tmp);
     2206    }
    21032207    log_msg(1, "Finished backing up bigfiles");
    21042208    log_msg(1, "estimated slices = %ld; actual slices = %ld",
     
    21062210    close_progress_form();
    21072211    paranoid_fclose(fin);
     2212    paranoid_free(bigfile_fname);
    21082213    return (retval);
    21092214}
     
    21662271        retval += res;
    21672272        if (res) {
    2168             log_to_screen("Errors occurred while archiving set %ld. Perhaps your live filesystem changed?", curr_set_no);
    2169         }
     2273            mr_asprintf(tmp, "Errors occurred while archiving set %ld. Perhaps your live filesystem changed?", curr_set_no);
     2274            log_to_screen(tmp);
     2275            mr_free(tmp);
     2276        }
     2277
     2278        mr_asprintf(media_usage_comment, "%s", percent_media_full_comment());
    21702279
    21712280        /* copy to CD (scratchdir) ... and an actual CD-R if necessary */
     
    22102319        retval += res;
    22112320        g_current_progress++;
    2212 
    2213         mr_asprintf(media_usage_comment, "%s", percent_media_full_comment());
    22142321        update_progress_form(media_usage_comment);
    22152322        mr_free(media_usage_comment);
    22162323
    22172324        if (res) {
    2218             log_to_screen("Failed to add archive %ld's files to CD dir\n", curr_set_no);
    2219             fatal_error("Is your hard disk is full? If not, please send the author the logfile.");
     2325            mr_asprintf(tmp, "Failed to add archive %ld's files to CD dir\n", curr_set_no);
     2326            log_to_screen(tmp);
     2327            mr_free(tmp);
     2328            fatal_error
     2329                ("Is your hard disk is full? If not, please send the author the logfile.");
    22202330        }
    22212331        mr_free(curr_filelist_fname);
     
    23182428    }
    23192429
    2320     mr_asprintf(command, "cp %s/biggielist.txt %s", bkpinfo->tmpdir, biggielist);
     2430    mr_asprintf(command, "cp %s/biggielist.txt %s", bkpinfo->tmpdir,
     2431            biggielist);
    23212432    paranoid_system(command);
    23222433    mr_free(command);
     
    23322443    if (g_getfattr) {
    23332444        get_fattr_list(biggielist, xattr_fname);
    2334         mr_asprintf(command, "cp %s %s/archives/", xattr_fname, bkpinfo->scratchdir);
     2445        mr_asprintf(command, "cp %s %s/archives/", xattr_fname,
     2446            bkpinfo->scratchdir);
    23352447        paranoid_system(command);
    23362448        mr_free(command);
     
    26212733    /*@ buffers ********************************************* */
    26222734    char *tmp = NULL;
    2623     char *cdrom_dev = NULL;
    2624     char *cdrw_dev = NULL;
     2735    char *cdrom_dev;
     2736    char *cdrw_dev;
    26252737    char *our_serial_str = NULL;
    26262738    bool ok_go_ahead_burn_it;
     
    26282740    int attempt_to_mount_returned_this = 999;
    26292741    char *mtpt = NULL;
    2630     char *szcdno = NULL;
    2631     char *szserfname = NULL;
    2632     char *szunmount = NULL;
     2742    char *szcdno;
     2743    char *szserfname;
     2744    char *szunmount;
    26332745    char *mds = NULL;
    26342746
    26352747    malloc_string(cdrom_dev);
    26362748    malloc_string(cdrw_dev);
     2749    malloc_string(szcdno);
     2750    malloc_string(szserfname);
     2751    malloc_string(szunmount);
     2752    malloc_string(mtpt);
    26372753
    26382754    mds = media_descriptor_string(g_backup_media_type);
    2639     log_to_screen("I am about to burn %s #%d", mds, g_current_media_number);
     2755    mr_asprintf(tmp, "I am about to burn %s #%d", mds, g_current_media_number);
    26402756    mr_free(mds);
     2757    log_to_screen(tmp);
     2758    mr_free(tmp);
    26412759    if (g_current_media_number < ask_for_one_if_more_than_this) {
    26422760        return;
    26432761    }
    26442762    log_to_screen("Scanning CD-ROM drive...");
    2645     mr_asprintf(mtpt, "%s/cd.mtpt", bkpinfo->tmpdir);
     2763    sprintf(mtpt, "%s/cd.mtpt", bkpinfo->tmpdir);
    26462764    make_hole_for_dir(mtpt);
    26472765
     
    26492767    ok_go_ahead_burn_it = TRUE;
    26502768    if (!find_cdrom_device(cdrom_dev, FALSE)) {
    2651         /* When enabled, it made CD eject-and-retract when wrong CD inserted.. Weird
    2652         log_msg(2, "paafcd: Retracting CD-ROM drive if possible" );
    2653         retract_CD_tray_and_defeat_autorun();
    2654         */
     2769/* When enabled, it made CD eject-and-retract when wrong CD inserted.. Weird
     2770      log_msg(2, "paafcd: Retracting CD-ROM drive if possible" );
     2771      retract_CD_tray_and_defeat_autorun();
     2772*/
    26552773        mr_asprintf(tmp, "umount %s", cdrom_dev);
    26562774        run_program_and_log_output(tmp, 1);
    2657         mr_asprintf(szcdno, "%s/archives/THIS-CD-NUMBER", mtpt);
    2658         mr_asprintf(szserfname, "%s/archives/SERIAL-STRING", mtpt);
    2659         mr_asprintf(szunmount, "umount %s", mtpt);
     2775        sprintf(szcdno, "%s/archives/THIS-CD-NUMBER", mtpt);
     2776        sprintf(szserfname, "%s/archives/SERIAL-STRING", mtpt);
     2777        sprintf(szunmount, "umount %s", mtpt);
    26602778        cd_number = -1;
    26612779        mr_asprintf(tmp, "mount %s %s", cdrom_dev, mtpt);
     
    26632781        attempt_to_mount_returned_this = run_program_and_log_output(tmp, 1);
    26642782        mr_free(tmp);
    2665 
    26662783        if (attempt_to_mount_returned_this) {
    26672784            log_msg(4, "Failed to mount %s at %s", cdrom_dev, mtpt);
    26682785            log_to_screen("If there's a CD/DVD in the drive, it's blank.");
    2669         } else if (!does_file_exist(szcdno) || !does_file_exist(szserfname)) {
     2786            /*
     2787               if (interrogate_disk_currently_in_cdrw_drive(cdrw_dev, FALSE))
     2788               {
     2789               ok_go_ahead_burn_it = FALSE;
     2790               log_to_screen("There isn't a writable CD/DVD in the drive.");
     2791               }
     2792               else
     2793               {
     2794               log_to_screen("Confirmed. There is a blank CD/DVD in the drive.");
     2795               }
     2796             */
     2797        } else if (!does_file_exist(szcdno)
     2798                   || !does_file_exist(szserfname)) {
    26702799            mds = media_descriptor_string(g_backup_media_type);
    2671             log_to_screen("%s has data on it but it's probably not a Mondo CD.", mds);
     2800            log_to_screen
     2801                ("%s has data on it but it's probably not a Mondo CD.", mds);
    26722802            mr_free(mds);
    26732803        } else {
     
    26792809            mr_asprintf(tmp, "cat %s 2> /dev/null", szserfname);
    26802810            mr_free(our_serial_str);
    2681             mr_asprintf(our_serial_str, "%s", call_program_and_get_last_line_of_output(tmp));
     2811            mr_asprintf(our_serial_str, "%s",
     2812                   call_program_and_get_last_line_of_output(tmp));
    26822813            mr_free(tmp);
    26832814            // FIXME - should be able to use last_line_of_file(), surely?
    26842815        }
    2685         mr_free(szcdno);
    2686         mr_free(szserfname);
    2687 
    26882816        run_program_and_log_output(szunmount, 1);
    2689         mr_free(szunmount);
    2690 
    26912817        log_msg(2, "paafcd: cd_number = %d", cd_number);
    2692         log_msg(2, "our serial str = %s; g_serial_string = %s", our_serial_str, g_serial_string);
     2818        log_msg(2, "our serial str = %s; g_serial_string = %s",
     2819                our_serial_str, g_serial_string);
    26932820        if (cd_number > 0 && !strcmp(our_serial_str, g_serial_string)) {
    26942821            mds = media_descriptor_string(g_backup_media_type);
     
    27222849        }
    27232850        mds = media_descriptor_string(g_backup_media_type);
    2724         mr_asprintf(tmp, "I am about to burn %s #%d of the backup set. Please insert %s and press Enter.", mds, g_current_media_number, mds);
     2851        mr_asprintf(tmp, "I am about to burn %s #%d of the backup set. Please insert %s and press Enter.",
     2852                mds, g_current_media_number, mds);
    27252853        mr_free(mds);
    27262854
     
    27332861
    27342862    mds = media_descriptor_string(g_backup_media_type);
    2735     log_msg(2, "paafcd: OK, I assume I have a blank/reusable %s in the drive...", mds);
     2863    log_msg(2,
     2864            "paafcd: OK, I assume I have a blank/reusable %s in the drive...", mds);
    27362865
    27372866    log_to_screen("Proceeding w/ %s in drive.", mds);
     
    27402869    paranoid_free(cdrom_dev);
    27412870    paranoid_free(cdrw_dev);
    2742     mr_free(mtpt);
     2871    paranoid_free(mtpt);
     2872    paranoid_free(szcdno);
     2873    paranoid_free(szserfname);
     2874    paranoid_free(szunmount);
    27432875    if (pmountable) {
    27442876        if (attempt_to_mount_returned_this) {
     
    27502882
    27512883}
     2884
     2885
     2886
     2887
     2888
     2889
    27522890
    27532891
     
    27792917
    27802918/* @} - end of utilityGroup */
     2919
     2920
     2921
     2922
     2923
     2924
    27812925
    27822926
     
    28012945 */
    28022946int
    2803 slice_up_file_etc(char *biggie_filename, char *ntfsprog_fifo, long biggie_file_number, long noof_biggie_files, bool use_ntfsprog) {
     2947slice_up_file_etc(char *biggie_filename,
     2948                  char *ntfsprog_fifo, long biggie_file_number,
     2949                  long noof_biggie_files, bool use_ntfsprog)
     2950{
    28042951
    28052952    /*@ buffers ************************************************** */
    28062953    char *tmp = NULL;
    2807     char *checksum_line = NULL;
    2808     char *command = NULL;
    2809     char *tempblock = NULL;
     2954    char *checksum_line, *command;
     2955    char *tempblock;
    28102956    char *curr_slice_fname_uncompressed = NULL;
    28112957    char *curr_slice_fname_compressed = NULL;
    28122958    char *file_to_archive = NULL;
    2813     char *file_to_openin = NULL;
     2959    char *file_to_openin;
    28142960    /*@ pointers ************************************************** */
    2815     char *pB = NULL;
    2816     FILE *fin = NULL;
    2817     FILE *fout = NULL;
     2961    char *pB;
     2962    FILE *fin = NULL, *fout = NULL;
    28182963
    28192964    /*@ bool ****************************************************** */
     
    28212966
    28222967    /*@ long ****************************************************** */
    2823     size_t blksize = (size_t)0;
    2824     long slice_num = 0L;
    2825     long i = 0L;
    2826     bool should_I_compress_slices = TRUE;
     2968    size_t blksize = 0;
     2969    long slice_num = 0;
     2970    long i;
     2971    long optimal_set_size;
     2972    bool should_I_compress_slices;
    28272973    char *suffix = NULL;                // for compressed slices
    28282974
     
    28372983    /*@ structures ************************************************** */
    28382984    struct s_filename_and_lstat_info biggiestruct;
     2985//  struct stat statbuf;
    28392986
    28402987    assert(bkpinfo != NULL);
    28412988    assert_string_is_neither_NULL_nor_zerolength(biggie_filename);
     2989    malloc_string(checksum_line);
    28422990
    28432991    biggiestruct.for_backward_compatibility = '\n';
    28442992    biggiestruct.use_ntfsprog = use_ntfsprog;
    2845     if (is_this_file_compressed(biggie_filename) || bkpinfo->compression_level == 0) {
     2993    optimal_set_size = bkpinfo->optimal_set_size;
     2994    if (is_this_file_compressed(biggie_filename)
     2995        || bkpinfo->compression_level == 0) {
    28462996        mr_asprintf(suffix, "%s", "");
     2997        //      log_it("%s is indeed compressed :-)", filename);
    28472998        should_I_compress_slices = FALSE;
    28482999    } else {
     
    28513002    }
    28523003
    2853     if (bkpinfo->optimal_set_size < 999L) {
     3004    if (optimal_set_size < 999) {
    28543005        fatal_error("bkpinfo->optimal_set_size is insanely small");
    28553006    }
    2856 
    28573007    if (ntfsprog_fifo) {
    28583008        file_to_openin = ntfsprog_fifo;
    2859         mr_asprintf(checksum_line, "IGNORE");
    2860         log_msg(2, "Not calculating checksum for %s: it would take too long", biggie_filename);
     3009        strcpy(checksum_line, "IGNORE");
     3010        log_msg(2,
     3011                "Not calculating checksum for %s: it would take too long",
     3012                biggie_filename);
    28613013        if ( !find_home_of_exe("ntfsresize")) {
    28623014            fatal_error("ntfsresize not found");
     
    28683020        log_it("res of it = %s", tmp);
    28693021        totallength = (off_t)atoll(tmp);
    2870         mr_free(tmp);
     3022        paranoid_free(tmp);
    28713023    } else {
    28723024        file_to_openin = biggie_filename;
     
    28823034        }
    28833035        mr_free(command);
    2884         mr_getline(checksum_line, fin);
     3036        tmp = fgets(checksum_line, MAX_STR_LEN, fin);
    28853037        pclose(fin);
    28863038        totallength = length_of_file (biggie_filename);
     
    28963048    }
    28973049    strcpy(biggiestruct.checksum, checksum_line);
    2898     mr_free(checksum_line);
    28993050
    29003051    mr_asprintf(tmp, "%s", slice_fname(biggie_file_number, 0, bkpinfo->tmpdir, ""));
     
    29023053    if (fout == NULL) {
    29033054        log_msg(1, "Unable to open and write to %s\n", tmp);
    2904         mr_free(tmp);
     3055        paranoid_free(tmp);
    29053056        mr_free(suffix);
    29063057        return (1);
    29073058    }
    2908     mr_free(tmp);
     3059    paranoid_free(tmp);
    29093060
    29103061    res = fwrite((void *) &biggiestruct, 1, sizeof(biggiestruct), fout);
     
    29123063        paranoid_fclose(fout);
    29133064    }
    2914     log_msg(1, "Opening in %s; slicing it and writing to CD/tape", file_to_openin);
     3065    log_msg(1, "Opening in %s; slicing it and writing to CD/tape",
     3066            file_to_openin);
    29153067    if (!(fin = fopen(file_to_openin, "r"))) {
    29163068        log_OS_error("Unable to openin biggie_filename");
    2917         log_to_screen("Cannot archive bigfile '%s': not found", biggie_filename);
    2918 
     3069        mr_asprintf(tmp, "Cannot archive bigfile '%s': not found", biggie_filename);
     3070        log_to_screen(tmp);
     3071        paranoid_free(tmp);
     3072
     3073        paranoid_free(checksum_line);
    29193074        mr_free(suffix);
    29203075        return (1);
     
    29393094        mr_asprintf(tmp, "%s", percent_media_full_comment());
    29403095        update_progress_form(tmp);
    2941         mr_free(tmp);
     3096        paranoid_free(tmp);
    29423097
    29433098        if (!(fout = fopen(curr_slice_fname_uncompressed, "w"))) {
     
    29463101            return (1);
    29473102        }
    2948         if ((i == bkpinfo->optimal_set_size / 256) && (totalread < 1.1 * totallength)) {
    2949             for (i = 0L; i < bkpinfo->optimal_set_size / 256; i++) {
     3103        if ((i == bkpinfo->optimal_set_size / 256)
     3104            && (totalread < 1.1 * totallength)) {
     3105            for (i = 0; i < bkpinfo->optimal_set_size / 256; i++) {
    29503106                blksize = fread(tempblock, 1, 256 * 1024, fin);
    29513107                if (blksize > 0) {
     
    29563112                }
    29573113            }
    2958             mr_free(tempblock);
    29593114        } else {
    2960             i = 0L;
     3115            i = 0;
    29613116        }
    29623117        paranoid_fclose(fout);
    2963         if (i > 0L)             // length_of_file (curr_slice_fname_uncompressed)
     3118        if (i > 0)              // length_of_file (curr_slice_fname_uncompressed)
    29643119        {
    29653120            if (!does_file_exist(curr_slice_fname_uncompressed)) {
    2966                 log_msg(2, "Warning - '%s' doesn't exist. How can I compress slice?", curr_slice_fname_uncompressed);
     3121                log_msg(2,
     3122                        "Warning - '%s' doesn't exist. How can I compress slice?",
     3123                        curr_slice_fname_uncompressed);
    29673124            }
    29683125            if (should_I_compress_slices && bkpinfo->compression_level > 0) {
     
    29843141                log_msg(2, "Failed to compress the slice");
    29853142            }
    2986             if (bkpinfo->use_lzo && strcmp(curr_slice_fname_compressed, curr_slice_fname_uncompressed)) {
     3143            if (bkpinfo->use_lzo
     3144                && strcmp(curr_slice_fname_compressed,
     3145                          curr_slice_fname_uncompressed)) {
    29873146                unlink(curr_slice_fname_uncompressed);
    29883147            }
     
    29903149                mr_asprintf(tmp, "Problem with slice # %ld", slice_num);
    29913150            } else {
    2992                 mr_asprintf(tmp, "%s - Bigfile #%ld, slice #%ld compressed OK          ", biggie_filename, biggie_file_number + 1, slice_num);
     3151                mr_asprintf(tmp, "%s - Bigfile #%ld, slice #%ld compressed OK          ", biggie_filename, biggie_file_number + 1,
     3152                        slice_num);
    29933153            }
     3154#ifndef _XWIN
    29943155            if (!g_text_mode) {
    29953156                newtDrawRootText(0, g_noof_rows - 2, tmp);
     
    29983159                log_msg(2, tmp);
    29993160            }
    3000             mr_free(tmp);
     3161#else
     3162            log_msg(2, tmp);
     3163#endif
     3164            paranoid_free(tmp);
    30013165
    30023166            mr_asprintf(file_to_archive, "%s", curr_slice_fname_compressed);
     
    30143178
    30153179        if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
    3016             register_in_tape_catalog(biggieslice, biggie_file_number, slice_num, file_to_archive);
    3017             maintain_collection_of_recent_archives(bkpinfo->tmpdir, file_to_archive);
     3180            register_in_tape_catalog(biggieslice, biggie_file_number,
     3181                                     slice_num, file_to_archive);
     3182            maintain_collection_of_recent_archives(bkpinfo->tmpdir,
     3183                                                   file_to_archive);
    30183184            res = move_files_to_stream(file_to_archive, NULL);
    30193185        } else {
     
    30243190        retval += res;
    30253191        if (res) {
    3026             log_to_screen("Failed to add slice %ld of bigfile %ld to scratchdir", slice_num, biggie_file_number + 1);
    3027             fatal_error("Hard disk full. You should have bought a bigger one.");
    3028         }
    3029     }
     3192            mr_asprintf(tmp, "Failed to add slice %ld of bigfile %ld to scratchdir", slice_num, biggie_file_number + 1);
     3193            log_to_screen(tmp);
     3194            paranoid_free(tmp);
     3195            fatal_error
     3196                ("Hard disk full. You should have bought a bigger one.");
     3197        }
     3198    }
     3199    mr_free(tempblock);
    30303200    mr_free(suffix);
    30313201    paranoid_fclose(fin);
     
    30373207    }
    30383208    log_msg(1, tmp);
    3039     mr_free(tmp);
    3040 
     3209    paranoid_free(tmp);
     3210
     3211    paranoid_free(checksum_line);
    30413212    return (retval);
    30423213}
     
    31173288    log_msg(2, tmp);
    31183289    center_string(tmp, 80);
     3290#ifndef _XWIN
    31193291    if (!g_text_mode) {
    31203292        newtPushHelpLine(tmp);
    31213293    }
     3294#endif
    31223295    res = write_iso_and_go_on(TRUE);
     3296#ifndef _XWIN
    31233297    if (!g_text_mode) {
    31243298        newtPopHelpLine();
    31253299    }
     3300#endif
    31263301    log_msg(2, "Returning from writing final ISO (res=%d)", res);
    31273302    paranoid_free(tmp);
     
    31523327
    31533328    /*@ buffers ***************************************************** */
    3154     char *tmp = NULL;
    3155     char *tmp1 = NULL;
    3156     char *cdno_fname = NULL;
    3157     char *lastcd_fname = NULL;
    3158     char *isofile = NULL;
     3329    char *tmp;
     3330    char *cdno_fname;
     3331    char *lastcd_fname;
     3332    char *isofile;
    31593333    char *mds = NULL;
    31603334
     
    31673341
    31683342    malloc_string(tmp);
     3343    malloc_string(cdno_fname);
     3344    malloc_string(lastcd_fname);
     3345    malloc_string(isofile);
    31693346
    31703347    assert(bkpinfo != NULL);
     
    31803357    /* label the ISO with its number */
    31813358
    3182     mr_asprintf(cdno_fname, "%s/archives/THIS-CD-NUMBER", bkpinfo->scratchdir);
     3359    sprintf(cdno_fname, "%s/archives/THIS-CD-NUMBER", bkpinfo->scratchdir);
    31833360    fout = fopen(cdno_fname, "w");
    3184     mr_free(cdno_fname);
    3185 
    31863361    fprintf(fout, "%d", g_current_media_number);
    31873362    paranoid_fclose(fout);
    31883363
    3189     mr_asprintf(tmp1, "cp -f %s/autorun %s/", g_mondo_home, bkpinfo->scratchdir);
    3190     if (run_program_and_log_output(tmp1, FALSE)) {
     3364    sprintf(tmp, "cp -f %s/autorun %s/", g_mondo_home,
     3365            bkpinfo->scratchdir);
     3366    if (run_program_and_log_output(tmp, FALSE)) {
    31913367        log_msg(2, "Warning - unable to copy autorun to scratchdir");
    31923368    }
    3193     mr_free(tmp1);
    31943369
    31953370    /* last CD or not? Label accordingly */
    3196     mr_asprintf(lastcd_fname, "%s/archives/NOT-THE-LAST", bkpinfo->scratchdir);
     3371    sprintf(lastcd_fname, "%s/archives/NOT-THE-LAST", bkpinfo->scratchdir);
    31973372    if (last_cd) {
    31983373        unlink(lastcd_fname);
     
    32053380        paranoid_fclose(fout);
    32063381    }
    3207     mr_free(lastcd_fname);
    3208 
    32093382    if (space_occupied_by_cd(bkpinfo->scratchdir) / 1024 > bkpinfo->media_size) {
    3210         log_to_screen("Warning! CD is too big. It occupies %ld KB, which is more than the %ld KB allowed.",(long) space_occupied_by_cd(bkpinfo->scratchdir),(long) bkpinfo->media_size);
    3211     }
    3212     mr_asprintf(isofile, "%s/%s/%s-%d.iso", bkpinfo->isodir,
     3383        sprintf(tmp,
     3384                "Warning! CD is too big. It occupies %ld KB, which is more than the %ld KB allowed.",
     3385                (long) space_occupied_by_cd(bkpinfo->scratchdir),
     3386                (long) bkpinfo->media_size);
     3387        log_to_screen(tmp);
     3388    }
     3389    sprintf(isofile, "%s/%s/%s-%d.iso", bkpinfo->isodir,
    32133390            bkpinfo->netfs_remote_dir, bkpinfo->prefix,
    32143391            g_current_media_number);
     
    32253402            {
    32263403                log_msg(3, "*Sigh* Mike, I hate your computer.");
    3227                 // if it can't be found then force pausing
    32283404                bkpinfo->manual_cd_tray = TRUE;
    3229             } else {
     3405            }                   // if it can't be found then force pausing
     3406            else {
    32303407                log_msg(3, "Great. Found Mike's CD-ROM drive.");
    32313408            }
     
    32333410        if (bkpinfo->verify_data && !res) {
    32343411            mds = media_descriptor_string(g_backup_media_type);
    3235             log_to_screen("Please reboot from the 1st %s in Compare Mode, as a precaution.", mds);
     3412            log_to_screen
     3413                ("Please reboot from the 1st %s in Compare Mode, as a precaution.", mds);
    32363414            mr_free(mds);
    32373415            if (chdir("/")) {
     
    32503428        } else {
    32513429            mds = media_descriptor_string(bkpinfo->backup_media_type);
    3252             mr_asprintf(tmp1, "Failed to create %s #%d. Retry?", mds, g_current_media_number);
     3430            sprintf(tmp, "Failed to create %s #%d. Retry?", mds, g_current_media_number);
    32533431            mr_free(mds);
    3254             res = ask_me_yes_or_no(tmp1);
    3255             mr_free(tmp1);
    3256 
     3432            res = ask_me_yes_or_no(tmp);
    32573433            if (!res) {
    32583434                if (ask_me_yes_or_no("Abort the backup?")) {
     
    32673443        }
    32683444    }
    3269     mr_free(isofile);
    3270 
    32713445    g_current_media_number++;
    32723446    wipe_archives(bkpinfo->scratchdir);
    3273     mr_asprintf(tmp1, "rm -Rf %s/images/*gz %s/images/*data*img", bkpinfo->scratchdir, bkpinfo->scratchdir);
    3274     if (system(tmp1)) {
    3275         log_msg(2, "Error occurred when I tried to delete the redundant IMGs and GZs");
    3276     }
    3277     mr_free(tmp1);
     3447    sprintf(tmp, "rm -Rf %s/images/*gz %s/images/*data*img",
     3448            bkpinfo->scratchdir, bkpinfo->scratchdir);
     3449    if (system(tmp)) {
     3450        log_msg
     3451            (2,
     3452             "Error occurred when I tried to delete the redundant IMGs and GZs");
     3453    }
    32783454
    32793455    if (last_cd) {
     
    32853461    bkpinfo->verify_data = orig_vfy_flag_val;
    32863462    paranoid_free(tmp);
     3463    paranoid_free(cdno_fname);
     3464    paranoid_free(lastcd_fname);
     3465    paranoid_free(isofile);
    32873466    return (0);
    32883467}
     
    33533532            if (res) {
    33543533                mds = media_descriptor_string(bkpinfo->backup_media_type);
    3355                 log_to_screen("Warnings/errors were reported while checking %s #%d", mds, g_current_media_number);
     3534                mr_asprintf(tmp, "Warnings/errors were reported while checking %s #%d", mds, g_current_media_number);
    33563535                mr_free(mds);
     3536                log_to_screen(tmp);
     3537                mr_free(tmp);
    33573538
    33583539            }
  • branches/3.0/mondo/src/common/libmondo-cli.c

    r3188 r3192  
    9797    for (i = 0; i < 128; i++) {
    9898        if (flag_set[i]) {
    99             log_msg(3, "-%c %s", i, flag_val[i]);
     99            mr_asprintf(tmp, "-%c %s", i, flag_val[i]);
     100            log_msg(3, tmp);
     101            mr_free(tmp);
    100102        }
    101103    }
     
    148150    char *tmp = NULL;
    149151    char *tmp1 = NULL;
    150     char *tmp2 = NULL;
    151152    char *psz = NULL;
    152153    char *p = NULL;
     
    207208            log_msg(1, "Using star instead of afio");
    208209        } else {
    209             fatal_error("Neither afio nor star is installed. Please install at least one.");
     210            fatal_error
     211                ("Neither afio nor star is installed. Please install at least one.");
    210212        }
    211213    }
     
    217219        }
    218220        if (!find_home_of_exe("star")) {
    219             fatal_error("Please install 'star' RPM or tarball if you are going to use -R. Thanks.");
     221            fatal_error
     222                ("Please install 'star' RPM or tarball if you are going to use -R. Thanks.");
    220223        }
    221224    }
     
    231234
    232235    if (flag_set['I']) {
    233         if (bkpinfo->include_paths && bkpinfo->include_paths[0] == '-') {
     236        if (bkpinfo->include_paths[0] == '-') {
    234237            retval++;
    235238            log_to_screen("Please supply a sensible value with '-I'\n");
     
    265268            }
    266269        }
    267         mr_free(tmp1);
     270        paranoid_free(tmp1);
    268271        mr_make_devlist_from_pathlist(flag_val['I'], 'I');
    269272        log_msg(4, "Finished with the -I option");
    270273    }
    271274
    272     if (g_kernel_version >= 2.6 && !flag_set['d'] && (flag_set['c'] || flag_set['w']) && (! bkpinfo->restore_data)) {
    273         fatal_error("If you are using the 2.6.x kernel, please specify the CD-R(W) device.");
     275    if (g_kernel_version >= 2.6 && !flag_set['d']
     276        && (flag_set['c'] || flag_set['w']) && (! bkpinfo->restore_data)) {
     277        fatal_error
     278            ("If you are using the 2.6.x kernel, please specify the CD-R(W) device.");
    274279    }
    275280
     
    278283        if (flag_set['I']) {
    279284            retval++;
    280             log_to_screen("Please do not use -J in combination with -I. If you want to make a list of files to backup, that's fine, use -J <filename> but please don't muddy the waters by combining -J with -I. Thanks. :-)");
     285            log_to_screen
     286                ("Please do not use -J in combination with -I. If you want to make a list of files to backup, that's fine, use -J <filename> but please don't muddy the waters by combining -J with -I. Thanks. :-)");
    281287        }
    282288        bkpinfo->make_filelist = FALSE;
    283         mr_asprintf(bkpinfo->include_paths, "%s", flag_val['J']);
     289        strcpy(bkpinfo->include_paths, flag_val['J']);
    284290    }
    285291
    286292    if ((flag_set['c'] || flag_set['w'] || flag_set['C'] || flag_set['r']) && (! bkpinfo->restore_data)) {
    287         if (!flag_set['r'] && g_kernel_version <= 2.5 && strstr(flag_val['d'], "/dev/")) {
    288             fatal_error("Please don't give a /dev entry. Give a SCSI node for the parameter of the -d flag.");
    289         }
    290         if (flag_set['r'] && g_kernel_version <= 2.5 && !strstr(flag_val['d'], "/dev/")) {
    291             fatal_error("Please give a /dev entry, not a SCSI node, as the parameter of the -d flag.");
     293        if (!flag_set['r'] && g_kernel_version <= 2.5
     294            && strstr(flag_val['d'], "/dev/")) {
     295            fatal_error
     296                ("Please don't give a /dev entry. Give a SCSI node for the parameter of the -d flag.");
     297        }
     298        if (flag_set['r'] && g_kernel_version <= 2.5
     299            && !strstr(flag_val['d'], "/dev/")) {
     300            fatal_error
     301                ("Please give a /dev entry, not a SCSI node, as the parameter of the -d flag.");
    292302        }
    293303        if (g_kernel_version >= 2.6 && !strstr(flag_val['d'], "/dev/")) {
    294             log_to_screen("Linus says 2.6 has a broken ide-scsi module. Proceed at your own risk...");
    295         }
    296 
    297         if (system("which cdrecord > /dev/null 2> /dev/null") && system("which dvdrecord > /dev/null 2> /dev/null")) {
    298             fatal_error("Please install dvdrecord/cdrecord and try again.");
     304            log_to_screen
     305                ("Linus says 2.6 has a broken ide-scsi module. Proceed at your own risk...");
     306        }
     307
     308        if (system("which cdrecord > /dev/null 2> /dev/null")
     309            && system("which dvdrecord > /dev/null 2> /dev/null")) {
     310            fatal_error
     311                ("Please install dvdrecord/cdrecord and try again.");
    299312        }
    300313        if (flag_set['C']) {
    301314            bkpinfo->cdrw_speed = atoi(flag_val['C']);
    302315            if (bkpinfo->cdrw_speed < 1) {
    303                 fatal_error("You specified a silly speed for a CD-R[W] drive");
     316                fatal_error
     317                    ("You specified a silly speed for a CD-R[W] drive");
    304318            }
    305319            if (!flag_set['L']) {
    306                 log_to_screen("You must use -L with -C. Therefore I am setting it for you.");
     320                log_to_screen
     321                    ("You must use -L with -C. Therefore I am setting it for you.");
    307322                flag_set['L'] = 1;
    308323                flag_val['L'][0] = '\0';
     
    311326            log_msg(3, "flag_val['c'] = %s", flag_val['c']);
    312327            log_msg(3, "flag_val['w'] = %s", flag_val['w']);
     328//    log_msg(3, "flag_set['r'] = %i", flag_set['r'] );
    313329            if (flag_set['c']) {
    314330                bkpinfo->cdrw_speed = atoi(flag_val['c']);
     
    320336
    321337            if (bkpinfo->cdrw_speed < 1) {
    322                 fatal_error("You specified a silly speed for a CD-R[W] drive");
     338                fatal_error
     339                    ("You specified a silly speed for a CD-R[W] drive");
    323340            }
    324341        }
     
    328345        log_it("Hmm! No tape drive specified. Let's see what we can do.");
    329346        if (find_tape_device_and_size(flag_val['d'], tmp)) {
    330             fatal_error("Tape device not specified. I couldn't find it either.");
     347            fatal_error
     348                ("Tape device not specified. I couldn't find it either.");
    331349        }
    332350        flag_set['d'] = TRUE;
    333         log_to_screen("You didn't specify a tape streamer device. I'm assuming %s", flag_val['d']);
     351        sprintf(tmp,
     352                "You didn't specify a tape streamer device. I'm assuming %s",
     353                flag_val['d']);
     354        log_to_screen(tmp);
    334355    }
    335356
     
    337358    {
    338359        if (! flag_set['d']) {
    339             fatal_error("You need to specify a device file with -d for bootable USB device usage");
     360            fatal_error
     361                ("You need to specify a device file with -d for bootable USB device usage");
    340362        }
    341363        if ((!flag_set['s']) && (! bkpinfo->restore_data)) {
     
    347369    {
    348370        if (flag_set['m']) {
    349             fatal_error("Manual CD tray (-m) not yet supported in conjunction w/ DVD drives. Drop -m.");
     371            fatal_error
     372                ("Manual CD tray (-m) not yet supported in conjunction w/ DVD drives. Drop -m.");
    350373        }
    351374        if (!flag_set['d']) {
     
    356379        }
    357380        if (strchr(flag_val['d'], ',')) {
    358             fatal_error("Please don't give a SCSI node. Give a _device_, preferably a /dev entry, for the parameter of the -d flag.");
     381            fatal_error
     382                ("Please don't give a SCSI node. Give a _device_, preferably a /dev entry, for the parameter of the -d flag.");
    359383        }
    360384        if (! bkpinfo->restore_data) {
    361385            if (!find_home_of_exe("growisofs")) {
    362                 fatal_error("Please install growisofs (probably part of dvd+rw-tools). If you want DVD support, you need it.");
     386                fatal_error
     387                    ("Please install growisofs (probably part of dvd+rw-tools). If you want DVD support, you need it.");
    363388            }
    364389            if (!find_home_of_exe("dvd+rw-format")) {
    365                 fatal_error("Please install dvd+rw-format (probably part of dvd+rw-tools). If you want DVD support, you need it.");
     390                fatal_error
     391                    ("Please install dvd+rw-format (probably part of dvd+rw-tools). If you want DVD support, you need it.");
    366392            }
    367393            if (!flag_set['s']) {
    368394                sprintf(flag_val['s'], "%d", DEFAULT_DVD_DISK_SIZE);    // 4.7 salesman's GB = 4.482 real GB = 4582 MB
    369395                strcat(flag_val['s'], "m");
    370                 log_to_screen("You did not specify a size (-s) for DVD. I'm guessing %s.", flag_val['s']);
     396                log_to_screen
     397                    ("You did not specify a size (-s) for DVD. I'm guessing %s.",
     398                    flag_val['s']);
    371399                flag_set['s'] = 1;
    372400            }
    373401        }
     402/*
     403      if (flag_set['Z']) {
     404      bkpinfo->blank_dvd_first = TRUE;
     405      }
     406*/
    374407    }
    375408
    376409    if (flag_set['t'] || flag_set['u']) {   /* tape size */
    377410        if (strchr(flag_val['d'], ',')) {
    378             fatal_error("Please don't give a SCSI node. Give a _device_, preferably a /dev entry, for the parameter of the -d flag.");
     411            fatal_error
     412                ("Please don't give a SCSI node. Give a _device_, preferably a /dev entry, for the parameter of the -d flag.");
    379413        }
    380414        if ((flag_set['O']) && (! bkpinfo->restore_data)) {
    381415            if (flag_set['s']) {
    382416                if (flag_set['t']) {
    383                     fatal_error("For the moment, please don't specify a tape size. Mondo should handle end-of-tape gracefully anyway.");
     417                    fatal_error
     418                        ("For the moment, please don't specify a tape size. Mondo should handle end-of-tape gracefully anyway.");
    384419                }
    385420                if (process_the_s_switch(flag_val['s'])) {
     
    405440
    406441    if (flag_set['n']) {
    407         mr_free(bkpinfo->netfs_mount);
    408         mr_asprintf(bkpinfo->netfs_mount, "%s", flag_val['n']);
     442        strncpy(bkpinfo->netfs_mount, flag_val['n'], MAX_STR_LEN);
    409443        if (!flag_set['d']) {
    410             mr_free(bkpinfo->netfs_remote_dir);
    411             mr_asprintf(bkpinfo->netfs_remote_dir, "/");
     444            strncpy(bkpinfo->netfs_remote_dir, "/", MAX_STR_LEN);
    412445        }
    413446        /* test for protocol */
     
    440473        /* Store the 2 values */
    441474        /*  using memmove instead of strcpy as per #584 */
    442         /* memmove(bkpinfo->netfs_mount, p, MAX_STR_LEN); */
    443         bkpinfo->netfs_mount = p;
     475        memmove(bkpinfo->netfs_mount, p, MAX_STR_LEN);
    444476
    445477        /* test if we specified a user */
     
    447479        if (p != NULL) {
    448480            /* User found. Store the 2 values */
    449             bkpinfo->netfs_user = bkpinfo->netfs_mount;
    450481            p++;
    451482            /* new netfs mount */
    452             mr_asprintf(bkpinfo->netfs_mount, "%s", p);
    453             /* now that user is computed, create the right value by removing end of string */
     483            strcpy(tmp,p);
    454484            p--;
    455485            *p = '\0';
    456         }
    457         mr_asprintf(tmp1, "mount | grep -E \"^[a-z]*#*[%s@]*%s[/]* .*\" | cut -d' ' -f3", bkpinfo->netfs_user, bkpinfo->netfs_mount);
    458         strncpy(bkpinfo->isodir, call_program_and_get_last_line_of_output(tmp), MAX_STR_LEN / 4);
    459         mr_free(tmp1);
    460 
     486            mr_asprintf(q,"%s",bkpinfo->netfs_mount);
     487            bkpinfo->netfs_user = q;
     488            strcpy(bkpinfo->netfs_mount,tmp);
     489        }
     490        sprintf(tmp, "mount | grep -E \"^[a-z]*#*[%s@]*%s[/]* .*\" | cut -d' ' -f3", bkpinfo->netfs_user,
     491                bkpinfo->netfs_mount);
     492        strncpy(bkpinfo->isodir,
     493                call_program_and_get_last_line_of_output(tmp),
     494                MAX_STR_LEN / 4);
    461495        if (strlen(bkpinfo->isodir) < 3) {
    462496            log_to_screen("Network share is not mounted. Trying to mount it for you.\n");
    463497            if (bkpinfo->netfs_user) {
    464498                if (strstr(bkpinfo->netfs_proto, "sshfs")) {
    465                     mr_asprintf(tmp1, "sshfs %s@%s", bkpinfo->netfs_user, bkpinfo->netfs_mount);
     499                    sprintf(tmp, "sshfs %s@%s", bkpinfo->netfs_user, bkpinfo->netfs_mount);
    466500                } else if (strstr(bkpinfo->netfs_proto, "smbfs")) {
    467                     mr_asprintf(tmp1, "mount -t cifs %s -o user=%s", bkpinfo->netfs_mount, bkpinfo->netfs_user);
     501                    sprintf(tmp, "mount -t cifs %s -o user=%s", bkpinfo->netfs_mount, bkpinfo->netfs_user);
    468502                } else if (strstr(bkpinfo->netfs_proto, "nfs")) {
    469                     mr_asprintf(tmp1, "mount %s@%s", bkpinfo->netfs_user, bkpinfo->netfs_mount);
     503                    sprintf(tmp, "mount %s@%s", bkpinfo->netfs_user, bkpinfo->netfs_mount);
    470504                } else {
    471505                    log_to_screen("Protocol %s not supported yet for network backups.\n", bkpinfo->netfs_proto);
     
    474508            } else {
    475509                if (strstr(bkpinfo->netfs_proto, "sshfs")) {
    476                     mr_asprintf(tmp1, "sshfs %s", bkpinfo->netfs_mount);
     510                    sprintf(tmp, "sshfs %s", bkpinfo->netfs_mount);
    477511                } else if (strstr(bkpinfo->netfs_proto, "smbfs")) {
    478                     mr_asprintf(tmp1, "mount -t cifs %s", bkpinfo->netfs_mount);
     512                    sprintf(tmp, "mount -t cifs %s", bkpinfo->netfs_mount);
    479513                } else if (strstr(bkpinfo->netfs_proto, "nfs")) {
    480                     mr_asprintf(tmp1, "mount %s", bkpinfo->netfs_mount);
     514                    sprintf(tmp, "mount %s", bkpinfo->netfs_mount);
    481515                } else {
    482516                    log_to_screen("Protocol %s not supported yet for network backups.\n", bkpinfo->netfs_proto);
     
    484518                }
    485519            }
    486             i = system(tmp1);
    487             mr_free(tmp1);
    488 
    489             if (i) {
     520            if (system(tmp)) {
    490521                log_to_screen("Unable to mount Network share %s. Please mount manually.\n", bkpinfo->netfs_mount);
    491522                retval++;
    492523            } else {
    493524                if (bkpinfo->netfs_user) {
    494                     mr_asprintf(tmp1, "mount | grep -E \"^[%s@]*%s[/]* .*\" | cut -d' ' -f3", bkpinfo->netfs_user, bkpinfo->netfs_mount);
     525                    sprintf(tmp, "mount | grep -E \"^[%s@]*%s[/]* .*\" | cut -d' ' -f3", bkpinfo->netfs_user,
     526                        bkpinfo->netfs_mount);
    495527                } else {
    496                     mr_asprintf(tmp1, "mount | grep -E \"^%s[/]* .*\" | cut -d' ' -f3", bkpinfo->netfs_mount);
     528                    sprintf(tmp, "mount | grep -E \"^%s[/]* .*\" | cut -d' ' -f3", bkpinfo->netfs_mount);
    497529                }
    498                 strncpy(bkpinfo->isodir, call_program_and_get_last_line_of_output(tmp), MAX_STR_LEN / 4);
     530                strncpy(bkpinfo->isodir,
     531                        call_program_and_get_last_line_of_output(tmp),
     532                        MAX_STR_LEN / 4);
    499533                if (strlen(bkpinfo->isodir) < 3) {
    500534                    retval++;
     
    590624            }
    591625        }
    592         mr_free(tmp1);
     626        paranoid_free(tmp1);
    593627
    594628        mr_make_devlist_from_pathlist(flag_val['E'], 'E');
     
    634668        log_msg(1, "Internal tape block size is now %ld bytes", itbs);
    635669        if (itbs % 512 != 0 || itbs < 256 || itbs > 1024L * 1024) {
    636             fatal_error("Are you nuts? Silly, your internal tape block size is. Abort, I shall.");
     670            fatal_error
     671                ("Are you nuts? Silly, your internal tape block size is. Abort, I shall.");
    637672        }
    638673        bkpinfo->internal_tape_block_size = itbs;
     
    643678//      bkpinfo->differential = atoi (flag_val['D']);
    644679        if ((bkpinfo->differential < 1) || (bkpinfo->differential > 9)) {
    645             fatal_error("The D option should be between 1 and 9 inclusive");
     680            fatal_error
     681                ("The D option should be between 1 and 9 inclusive");
    646682        }
    647683    }
     
    666702            && !does_file_exist(bkpinfo->kernel_path)) {
    667703            retval++;
    668             log_to_screen("You specified kernel '%s', which does not exist\n", bkpinfo->kernel_path);
     704            sprintf(tmp,
     705                    "You specified kernel '%s', which does not exist\n",
     706                    bkpinfo->kernel_path);
     707            log_to_screen(tmp);
    669708        }
    670709    }
     
    684723            }
    685724        } else if (flag_set['n']) {
    686             mr_free(bkpinfo->netfs_remote_dir);
    687             mr_asprintf(bkpinfo->netfs_remote_dir, "%s", flag_val['d']);
     725            strncpy(bkpinfo->netfs_remote_dir, flag_val['d'], MAX_STR_LEN);
    688726        } else {                /* backup device (if tape/CD-R/CD-RW) */
    689727            strncpy(bkpinfo->media_device, flag_val['d'], MAX_STR_LEN / 4);
     
    694732        mr_asprintf(tmp1,"%s/%s/.dummy.txt", bkpinfo->isodir,bkpinfo->netfs_remote_dir);
    695733        if ((bkpinfo->netfs_user) && (strstr(bkpinfo->netfs_proto,"nfs"))) {
    696             mr_asprintf(tmp2, "su - %s -c \"echo hi > %s\"", bkpinfo->netfs_user, tmp1);
     734            sprintf(tmp, "su - %s -c \"echo hi > %s\"", bkpinfo->netfs_user, tmp1);
    697735        } else {
    698             mr_asprintf(tmp2, "echo hi > %s", tmp1);
    699         }
    700         i = run_program_and_log_output(tmp2, 2);
    701         mr_free(tmp2);
    702 
    703         if (i) {
    704             retval++;
    705             log_to_screen("Are you sure directory '%s' exists in remote dir '%s'?\nIf so, do you have rights to write to it?\n", bkpinfo->netfs_remote_dir, bkpinfo->netfs_mount);
     736            sprintf(tmp, "echo hi > %s", tmp1);
     737        }
     738        if (run_program_and_log_output(tmp, 2)) {
     739            retval++;
     740            sprintf(tmp,
     741                    "Are you sure directory '%s' exists in remote dir '%s'?\nIf so, do you have rights to write to it?\n",
     742                    bkpinfo->netfs_remote_dir, bkpinfo->netfs_mount);
     743            log_to_screen(tmp);
    706744        }
    707745        unlink(tmp1);
    708         mr_free(tmp1);
    709     }
    710 
    711     if (!flag_set['d'] && (flag_set['c'] || flag_set['w'] || flag_set['C'])) {
     746        paranoid_free(tmp1);
     747    }
     748
     749    if (!flag_set['d']
     750        && (flag_set['c'] || flag_set['w'] || flag_set['C'])) {
    712751        if (g_kernel_version >= 2.6) {
    713752            if (popup_and_get_string
     
    730769        retval++;
    731770        log_to_screen("Please specify the backup device/directory.\n");
    732         fatal_error("You didn't use -d to specify the backup device/directory.");
     771        fatal_error
     772            ("You didn't use -d to specify the backup device/directory.");
    733773    }
    734774
     
    741781    if (flag_set['S']) {
    742782        setup_scratchdir(flag_val['S']);
    743         mr_asprintf(tmp1, "touch %s/.foo.dat", bkpinfo->scratchdir);
    744         if (run_program_and_log_output(tmp1, 1)) {
    745             retval++;
    746             mr_free(tmp1);
     783        sprintf(tmp, "touch %s/.foo.dat", bkpinfo->scratchdir);
     784        if (run_program_and_log_output(tmp, 1)) {
     785            retval++;
    747786            log_to_screen("Please specify a scratchdir which I can write to. :)");
    748787            fatal_error("I cannot write to the scratchdir you specified.");
    749788        }
    750         mr_free(tmp1);
    751 
    752         mr_asprintf(tmp1, "ln -sf %s/.foo.dat %s/.bar.dat", bkpinfo->scratchdir, bkpinfo->scratchdir);
    753         if (run_program_and_log_output(tmp1, 1)) {
    754             retval++;
    755             mr_free(tmp1);
     789        sprintf(tmp, "ln -sf %s/.foo.dat %s/.bar.dat", bkpinfo->scratchdir, bkpinfo->scratchdir);
     790        if (run_program_and_log_output(tmp, 1)) {
     791            retval++;
    756792            log_to_screen("Please don't specify a SAMBA or VFAT or NFS scratchdir.");
    757793            fatal_error("I cannot write to the scratchdir you specified.");
    758794        }
    759         mr_free(tmp1);
    760795    }
    761796
    762797    if (flag_set['T']) {
    763798        setup_tmpdir(flag_val['T']);
    764         mr_asprintf(tmp1, "touch %s/.foo.dat", bkpinfo->tmpdir);
    765         i = run_program_and_log_output(tmp1, 1);
    766         mr_free(tmp1);
    767 
    768         if (i) {
     799        sprintf(tmp, "touch %s/.foo.dat", bkpinfo->tmpdir);
     800        if (run_program_and_log_output(tmp, 1)) {
    769801            retval++;
    770802            log_to_screen("Please specify a tempdir which I can write to. :)");
    771803            fatal_error("I cannot write to the tempdir you specified.");
    772804        }
    773         mr_asprintf(tmp1, "ln -sf %s/.foo.dat %s/.bar.dat", bkpinfo->tmpdir, bkpinfo->tmpdir);
    774         i = run_program_and_log_output(tmp1, 1);
    775         mr_free(tmp1);
    776 
    777         if (i) {
     805        sprintf(tmp, "ln -sf %s/.foo.dat %s/.bar.dat", bkpinfo->tmpdir, bkpinfo->tmpdir);
     806        if (run_program_and_log_output(tmp, 1)) {
    778807            retval++;
    779808            log_to_screen("Please don't specify a SAMBA or VFAT or NFS tmpdir.");
     
    804833#  endif
    805834#endif
    806         if (!strchr(BOOT_LOADER_CHARS, (bkpinfo->boot_loader = flag_val['l'][0]))) {
    807             log_msg(1, "%c? What is %c? I need G, L, E or R.", bkpinfo->boot_loader, bkpinfo->boot_loader);
    808             fatal_error("Please specify GRUB, LILO, ELILO  or RAW with the -l switch");
     835        if (!strchr
     836            (BOOT_LOADER_CHARS,
     837             (bkpinfo->boot_loader = flag_val['l'][0]))) {
     838            log_msg(1, "%c? WTF is %c? I need G, L, E or R.",
     839                    bkpinfo->boot_loader, bkpinfo->boot_loader);
     840            fatal_error
     841                ("Please specify GRUB, LILO, ELILO  or RAW with the -l switch");
    809842        }
    810843#undef BOOT_LOADER_CHARS
     
    812845
    813846    if (flag_set['f']) {
    814         strncpy(bkpinfo->boot_device, resolve_softlinks_to_get_to_actual_device_file(flag_val['f']),MAX_STR_LEN / 4);
     847        strncpy(bkpinfo->boot_device,
     848                resolve_softlinks_to_get_to_actual_device_file(flag_val
     849                                                               ['f']),
     850                MAX_STR_LEN / 4);
    815851    }
    816852
     
    830866        if (run_program_and_log_output("which lzop", 2)) {
    831867            retval++;
    832             log_to_screen("Please install LZOP. You can't use '-L' until you do.\n");
     868            log_to_screen
     869                ("Please install LZOP. You can't use '-L' until you do.\n");
    833870        }
    834871    }
     
    843880        if (run_program_and_log_output("which gzip", 2)) {
    844881            retval++;
    845             log_to_screen("Please install gzip. You can't use '-G' until you do.\n");
    846         }
    847     }
    848 
    849     if ((flag_set['Y']) && (! bkpinfo->restore_data)) {
    850         bkpinfo->use_lzma = TRUE;
    851         if (run_program_and_log_output("which lzma", 2)) {
    852             retval++;
    853             log_to_screen("Please install lzma. You can't use '-Y' until you do.\n");
     882            log_to_screen
     883                ("Please install gzip. You can't use '-G' until you do.\n");
    854884        }
    855885    }
     
    867897    if ((!is_this_a_valid_disk_format("vfat")) && (! bkpinfo->restore_data)) {
    868898        bkpinfo->make_cd_use_lilo = TRUE;
    869         log_to_screen("Your kernel appears not to support vfat filesystems. I am therefore");
    870         log_to_screen("using LILO instead of SYSLINUX as the media boot loader.");
     899        log_to_screen
     900            ("Your kernel appears not to support vfat filesystems. I am therefore");
     901        log_to_screen
     902            ("using LILO instead of SYSLINUX as the media boot loader.");
    871903    }
    872904    if ((run_program_and_log_output("which mkfs.vfat", 2)) && (! bkpinfo->restore_data)) {
    873905        bkpinfo->make_cd_use_lilo = TRUE;
    874906#ifdef __IA32__
    875         log_to_screen("Your filesystem is missing 'mkfs.vfat', so I cannot use SYSLINUX as");
    876         log_to_screen("your boot loader. I shall therefore use LILO instead.");
     907        log_to_screen
     908            ("Your filesystem is missing 'mkfs.vfat', so I cannot use SYSLINUX as");
     909        log_to_screen
     910            ("your boot loader. I shall therefore use LILO instead.");
    877911#endif
    878912#ifdef __IA64__
    879         log_to_screen("Your filesystem is missing 'mkfs.vfat', so I cannot prepare the EFI");
     913        log_to_screen
     914            ("Your filesystem is missing 'mkfs.vfat', so I cannot prepare the EFI");
    880915        log_to_screen("environment correctly. Please install it.");
    881916        fatal_error("Aborting");
     
    897932
    898933    if ((! bkpinfo->restore_data) && (flag_set['Z'])) {
    899             fatal_error("The -Z switch is only valid in restore mode");
     934            fatal_error
     935                ("The -Z switch is only valid in restore mode");
    900936    }
    901937
     
    937973 * @return The number of problems with the command line (0 for success).
    938974 */
    939 int retrieve_switches_from_command_line(int argc, char *argv[], char flag_val[128][MAX_STR_LEN], bool flag_set[128])
     975int
     976retrieve_switches_from_command_line(int argc, char *argv[],
     977                                    char flag_val[128][MAX_STR_LEN],
     978                                    bool flag_set[128])
    940979{
    941980    /*@ ints ** */
    942981    int opt = 0;
     982    char *tmp = NULL;
    943983    int i = 0;
    944984    int len;
     
    954994        flag_set[i] = FALSE;
    955995    }
    956     while ((opt = getopt(argc, argv, MONDO_OPTIONS)) != -1) {
     996    while ((opt =
     997            getopt(argc, argv, MONDO_OPTIONS))
     998           != -1) {
    957999        if (opt == '?') {
    9581000            bad_switches = TRUE;
     1001            /*log_it("Invalid option: %c\n",optopt); */
    9591002        } else {
    9601003            if (flag_set[opt]) {
    9611004                bad_switches = TRUE;
    962                 log_to_screen("Switch -%c previously defined as %s\n", opt, flag_val[opt]);
     1005                mr_asprintf(tmp, "Switch -%c previously defined as %s\n", opt, flag_val[opt]);
     1006                log_to_screen(tmp);
     1007                paranoid_free(tmp);
    9631008            } else {
    9641009                flag_set[opt] = TRUE;
     
    9741019                        if (strchr(flag_val[opt], '/')
    9751020                            && flag_val[opt][0] != '/') {
    976                             log_to_screen("-%c flag --- must be absolute path --- '%s' isn't absolute", opt, flag_val[opt]);
     1021                            mr_asprintf(tmp, "-%c flag --- must be absolute path --- '%s' isn't absolute", opt, flag_val[opt]);
     1022                            log_to_screen(tmp);
     1023                            paranoid_free(tmp);
    9771024                            bad_switches = TRUE;
    9781025                        }
     
    9851032    for (i = optind; i < argc; i++) {
    9861033        bad_switches = TRUE;
    987         log_to_screen("Invalid arg -- %s\n", argv[i]);
     1034        mr_asprintf(tmp, "Invalid arg -- %s\n", argv[i]);
     1035        log_to_screen(tmp);
     1036        paranoid_free(tmp);
    9881037    }
    9891038    return (bad_switches);
     
    10481097    mr_strcat(tmp, " signal received from OS");
    10491098    log_to_screen(tmp);
    1050     mr_free(tmp);
     1099    paranoid_free(tmp);
    10511100
    10521101    log_to_screen(tmp2);
    1053     mr_free(tmp2);
     1102    paranoid_free(tmp2);
    10541103    if (sig == SIGABRT) {
    10551104        sleep(10);
     
    10591108    free_MR_global_filenames();
    10601109
    1061     fatal_error("MondoRescue is terminating in response to a signal from the OS");
     1110    fatal_error
     1111        ("MondoRescue is terminating in response to a signal from the OS");
    10621112    finish(254);                // just in case
    10631113}
     
    10721122void set_signals(int on)
    10731123{
    1074     int signals[] = { SIGTERM, SIGHUP, SIGTRAP, SIGABRT, SIGINT, SIGKILL, SIGSTOP, 0 };
     1124    int signals[] =
     1125        { SIGTERM, SIGHUP, SIGTRAP, SIGABRT, SIGINT, SIGKILL, SIGSTOP, 0 };
    10751126    int i;
    10761127
  • branches/3.0/mondo/src/common/libmondo-devices-EXT.h

    r3188 r3192  
    1616extern int find_device_in_mountlist(struct mountlist_itself *mountlist,
    1717                                    char *device);
    18 extern int mount_CDROM_here(char *device, const char *mountpoint);
     18extern int mount_CDROM_here(char *device, char *mountpoint);
    1919extern long long size_of_specific_device_in_mountlist(struct
    2020                                                      mountlist_itself
     
    5757extern int inject_device(char *dev);
    5858extern bool does_nonMS_partition_exist(void);
    59 extern char *resolve_softlinks_to_get_to_actual_device_file(char *incoming);
     59extern char *resolve_softlinks_to_get_to_actual_device_file(char
     60                                                            *incoming);
    6061
    6162extern void set_g_cdrom_and_g_dvd_to_bkpinfo_value();
  • branches/3.0/mondo/src/common/libmondo-devices.c

    r3188 r3192  
    2121#include "libmondo-stream-EXT.h"
    2222
    23 extern void mr_strip_spaces(char *);
    24 
    2523#include <sys/types.h>
    2624#ifdef __FreeBSD__
     
    129127{
    130128    char *tmp = NULL;
     129    char *comment;
    131130    bool is_this_a_ramdisk = FALSE;
    132131
     132    malloc_string(comment);
    133133    mr_asprintf(tmp, "%s", where_is_root_mounted());
    134     log_msg(0, "root is mounted at %s\n", tmp);
    135     log_msg(0, "That doesn't mean %s is the root partition. It's just a debugging message. Relax. It's part of am_I_in_disaster_recovery_mode().", tmp);
     134    sprintf(comment, "root is mounted at %s\n", tmp);
     135    log_msg(0, comment);
     136    log_msg(0,
     137            "No, Schlomo, that doesn't mean %s is the root partition. It's just a debugging message. Relax. It's part of am_I_in_disaster_recovery_mode().",
     138            tmp);
    136139
    137140#ifdef __FreeBSD__
     
    153156    if (is_this_a_ramdisk) {
    154157        if (!does_file_exist("/THIS-IS-A-RAMDISK")) {
    155             log_to_screen("Using /dev/root is stupid of you but I'll forgive you.");
     158            log_to_screen
     159                ("Using /dev/root is stupid of you but I'll forgive you.");
    156160            is_this_a_ramdisk = FALSE;
    157161        }
     
    160164        is_this_a_ramdisk = TRUE;
    161165    }
    162 
    163     log_msg(1, "Is this a ramdisk? result = %s", (is_this_a_ramdisk) ? "TRUE" : "FALSE");
     166    paranoid_free(comment);
     167    log_msg(1, "Is this a ramdisk? result = %d", is_this_a_ramdisk);
    164168    return (is_this_a_ramdisk);
    165169}
     
    225229int eject_device(char *dev)
    226230{
    227     char *command = NULL;
     231    char *command;
    228232    int res1 = 0, res2 = 0;
    229233
    230     if (dev == NULL) {
    231         return (1);
    232     }
     234    malloc_string(command);
    233235
    234236    if (IS_THIS_A_STREAMING_BACKUP(g_backup_media_type)
    235237        && g_backup_media_type != udev) {
    236         mr_asprintf(command, "mt -f %s offline", dev);
     238        sprintf(command, "mt -f %s offline", dev);
    237239        res1 = run_program_and_log_output(command, 1);
    238         mr_free(command);
    239240    } else {
    240241        res1 = 0;
     
    243244#ifdef __FreeBSD__
    244245    if (strstr(dev, "acd")) {
    245         mr_asprintf(command, "cdcontrol -f %s eject", dev);
     246        sprintf(command, "cdcontrol -f %s eject", dev);
    246247    } else {
    247         mr_asprintf(command, "camcontrol eject `echo %s | sed 's|/dev/||'`", dev);
     248        sprintf(command, "camcontrol eject `echo %s | sed 's|/dev/||'`",
     249                dev);
    248250    }
    249251#else
    250     mr_asprintf(command, "eject %s", dev);
     252    sprintf(command, "eject %s", dev);
    251253#endif
    252254
    253255    log_msg(3, "Ejecting %s", dev);
    254256    res2 = run_program_and_log_output(command, 1);
    255     mr_free(command);
     257    paranoid_free(command);
    256258    if (res1 && res2) {
    257259        return (1);
     
    268270int inject_device(char *dev)
    269271{
    270     char *command = NULL;
     272    char *command;
    271273    int i;
    272274
    273     if (dev == NULL) {
    274         return (1);
    275     }
     275    malloc_string(command);
     276
    276277
    277278#ifdef __FreeBSD__
    278279    if (strstr(dev, "acd")) {
    279         mr_asprintf(command, "cdcontrol -f %s close", dev);
     280        sprintf(command, "cdcontrol -f %s close", dev);
    280281    } else {
    281         mr_asprintf(command, "camcontrol load `echo %s | sed 's|/dev/||'`", dev);
     282        sprintf(command, "camcontrol load `echo %s | sed 's|/dev/||'`",
     283                dev);
    282284    }
    283285#else
    284     mr_asprintf(command, "eject -t %s", dev);
     286    sprintf(command, "eject -t %s", dev);
    285287#endif
    286288    i = run_program_and_log_output(command, FALSE);
    287     mr_free(command);
     289    paranoid_free(command);
    288290    return (i);
    289291}
     
    299301
    300302    /*@ buffers *********************************************************** */
    301     char *tmp = NULL;
     303    char *tmp;
    302304    bool ret;
    303305
     306    malloc_string(tmp);
    304307    assert_string_is_neither_NULL_nor_zerolength(device);
    305308
    306     mr_asprintf(tmp, "ls %s > /dev/null 2> /dev/null", device);
     309    sprintf(tmp, "ls %s > /dev/null 2> /dev/null", device);
    307310
    308311    if (system(tmp)) {
     
    311314        ret = TRUE;
    312315    }
    313     mr_free(tmp);
     316    paranoid_free(tmp);
    314317    return (ret);
    315318}
     
    342345{
    343346    /*@ buffers **************************************************** */
    344     char *program = NULL;
    345     char *incoming = NULL;
     347    char *program;
     348    char *incoming;
    346349    char *searchstr = NULL;
     350    char *tmp;
     351    char *p;
    347352
    348353    /*@ ints ******************************************************* */
     
    351356    /*@ pointers *************************************************** */
    352357    FILE *fin;
     358
    353359
    354360    /*@ end vars *************************************************** */
     
    356362    assert(partno >= 0 && partno < 999);
    357363
     364    malloc_string(program);
     365    malloc_string(incoming);
    358366    malloc_string(searchstr);
     367    malloc_string(tmp);
    359368
    360369#ifdef __FreeBSD__
    361370    // We assume here that this is running from mondorestore. (It is.)
    362     mr_asprintf(program, "ls %s %s >/dev/null 2>&1", drive, build_partition_name(tmp, drive, partno));
    363     res = system(program);
    364     mr_free(program);
    365     return(res);
    366 #endif
    367 
    368     mr_asprintf(program, "parted2fdisk -l %s 2> /dev/null", drive);
     371    sprintf(program, "ls %s %s >/dev/null 2>&1", drive,
     372            build_partition_name(tmp, drive, partno));
     373    return system(program);
     374#else
     375    tmp[0] = '\0';
     376#endif
     377
     378    sprintf(program, "parted2fdisk -l %s 2> /dev/null", drive);
    369379    fin = popen(program, "r");
    370380    if (!fin) {
    371381        log_it("program=%s", program);
    372382        log_OS_error("Cannot popen-in program");
    373         mr_free(program);
    374383        return (0);
    375384    }
    376     mr_free(program);
    377 
    378385    (void) build_partition_name(searchstr, drive, partno);
    379386    strcat(searchstr, " ");
    380     for (res = 0, mr_getline(incoming, fin); !res && !feof(fin) ; mr_getline(incoming, fin)) {
     387    for (res = 0; !res && (p = fgets(incoming, MAX_STR_LEN - 1, fin));) {
    381388        if (strstr(incoming, searchstr)) {
    382389            res = 1;
    383390        }
    384         mr_free(incoming);
    385     }
    386     mr_free(incoming);
    387 
     391    }
    388392    if (pclose(fin)) {
    389393        log_OS_error("Cannot pclose fin");
    390394    }
     395    paranoid_free(program);
     396    paranoid_free(incoming);
    391397    paranoid_free(searchstr);
     398    paranoid_free(tmp);
    392399    return (res);
    393400}
     
    406413{
    407414    /*@ buffers **************************************************** */
    408     char *command = NULL;
     415    char *command;
    409416
    410417    /*@ end vars *************************************************** */
     
    414421    assert_string_is_neither_NULL_nor_zerolength(str);
    415422
    416     /* For UEFI detection, this should be extended to count=2 */
    417     mr_asprintf(command, "dd if=%s bs=446 count=1 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null", dev, str);
     423    malloc_string(command);
     424    sprintf(command,
     425            "dd if=%s bs=446 count=1 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null",
     426            dev, str);
    418427    i = system(command);
    419     mr_free(command);
     428    paranoid_free(command);
    420429    if (i) {
    421430        return (FALSE);
     
    435444{
    436445    /*@ buffers **************************************************** */
    437     char *command = NULL;
     446    char *command;
    438447    /*@ end vars *************************************************** */
    439448    int i;
    440449
    441     mr_asprintf(command, "dd if=%s bs=512 count=%i 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null", dev, n, str);
     450    malloc_string(command);
     451    sprintf(command,
     452            "dd if=%s bs=512 count=%i 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null",
     453            dev, n, str);
    442454    i = system(command);
    443     mr_free(command);
     455    paranoid_free(command);
    444456    if (i) {
    445457        return (FALSE);
     
    454466 * Try to mount CD-ROM at @p mountpoint. If the CD-ROM is not found or has
    455467 * not been specified, call find_cdrom_device() to find it.
     468 * @param bkpinfo The backup information structure. The only field used is @c bkpinfo->media_device.
    456469 * @param mountpoint Where to mount the CD-ROM.
    457470 * @return 0 for success, nonzero for failure.
    458471 * @see mount_CDROM_here
    459472 */
    460 int find_and_mount_actual_cd(char *mountpoint) {
    461 
     473int find_and_mount_actual_cd(char *mountpoint)
     474{
    462475    /*@ buffers ***************************************************** */
    463476
    464477    /*@ int's  ****************************************************** */
    465478    int res;
    466     char *dev = NULL;
     479    char *dev;
    467480
    468481    /*@ end vars **************************************************** */
     
    519532{
    520533    /*@ buffers ************************ */
     534    char *comment;
    521535    char *tmp = NULL;
    522536    char *cdr_exe = NULL;
    523     char *command = NULL;
    524 
     537    char *command;
     538
     539    malloc_string(comment);
     540    malloc_string(command);
    525541    if (g_cdrw_drive_is_here[0]) {
    526542        strcpy(cdrw_device, g_cdrw_drive_is_here);
    527543        log_msg(3, "Been there, done that. Returning %s", cdrw_device);
     544        paranoid_free(comment);
     545        paranoid_free(command);
    528546        return (0);
    529547    }
    530548    if (g_backup_media_type == dvd) {
    531         log_msg(1, "This is dumb. You're calling find_cdrw_device() but you're backing up to DVD. WTF?");
     549        log_msg(1,
     550                "This is dumb. You're calling find_cdrw_device() but you're backing up to DVD. WTF?");
     551        paranoid_free(comment);
     552        paranoid_free(command);
    532553        return (1);
    533554    }
     
    539560    }
    540561    if (find_home_of_exe(cdr_exe)) {
    541         mr_asprintf(command, "%s -scanbus 2> /dev/null | tr -s '\t' ' ' | grep \"[0-9]*,[0-9]*,[0-9]*\" | grep -v \"[0-9]*) \\*\" | grep -E '[D|C][V|D]' | cut -d' ' -f2 | head -n1", cdr_exe);
     562        sprintf(command,
     563                "%s -scanbus 2> /dev/null | tr -s '\t' ' ' | grep \"[0-9]*,[0-9]*,[0-9]*\" | grep -v \"[0-9]*) \\*\" | grep -E '[D|C][V|D]' | cut -d' ' -f2 | head -n1",
     564                cdr_exe);
    542565        mr_asprintf(tmp, "%s", call_program_and_get_last_line_of_output(command));
    543         mr_free(command);
    544566    }
    545567    if ((tmp == NULL) || (strlen(tmp) < 2)) {
     568        paranoid_free(comment);
    546569        mr_free(tmp);
    547570        mr_free(cdr_exe);
     571        paranoid_free(command);
    548572        return 1;
    549573    } else {
    550574        strcpy(cdrw_device, tmp);
    551         log_it("Found CDRW device - %s", cdrw_device);
     575        sprintf(comment, "Found CDRW device - %s", cdrw_device);
     576        log_it(comment);
    552577        strcpy(g_cdrw_drive_is_here, cdrw_device);
     578        paranoid_free(comment);
    553579        mr_free(tmp);
    554580        mr_free(cdr_exe);
     581        paranoid_free(command);
    555582        return (0);
    556583    }
    557584}
     585
     586
    558587
    559588
     
    580609
    581610    /*@ buffers ***************************************************** */
    582     char *tmp = NULL;
     611    char *tmp;
    583612    char *tmp1 = NULL;
    584613    char *cdr_exe = NULL;
    585614    char *phrase_one;
    586     char *phrase_two = NULL;
    587     char *command = NULL;
    588 #ifndef __FreeBSD__
    589     char *dvd_last_resort = NULL;
    590 #endif
    591     char *mountpoint = NULL;
     615    char *phrase_two;
     616    char *command;
     617    char *dvd_last_resort;
     618    char *mountpoint;
    592619    static char the_last_place_i_found_it[MAX_STR_LEN] = "";
    593620
     
    595622    malloc_string(tmp);
    596623    malloc_string(phrase_one);
     624    malloc_string(phrase_two);
     625    malloc_string(command);
     626    malloc_string(dvd_last_resort);
    597627    malloc_string(mountpoint);
    598628
    599629    output[0] = '\0';
    600630    phrase_one[0] = '\0';
     631    phrase_two[0] = '\0';
     632    dvd_last_resort[0] = '\0';
    601633
    602634    /*@ end vars **************************************************** */
     
    610642    if (the_last_place_i_found_it[0] != '\0' && !try_to_mount) {
    611643        strcpy(output, the_last_place_i_found_it);
    612         log_msg(3, "find_cdrom_device() --- returning last found location - '%s'", output);
     644        log_msg(3,
     645                "find_cdrom_device() --- returning last found location - '%s'",
     646                output);
    613647        retval = 0;
    614648        goto end_of_find_cdrom_device;
     
    637671    }
    638672
    639     mr_asprintf(command, "%s -scanbus 2> /dev/null", cdr_exe);
     673    sprintf(command, "%s -scanbus 2> /dev/null", cdr_exe);
    640674    fin = popen(command, "r");
    641675    if (!fin) {
     
    643677        log_OS_error("Cannot popen command");
    644678        mr_free(cdr_exe);
    645         mr_free(command);
    646679        return (1);
    647680    }
    648     mr_free(command);
    649 
    650681    for (tmp1 = fgets(tmp, MAX_STR_LEN, fin); !feof(fin) && (tmp1 != NULL);
    651682         tmp1 = fgets(tmp, MAX_STR_LEN, fin)) {
     
    665696                        }
    666697                        *q = '\0';
    667                         mr_asprintf(phrase_two, "%s", p);
     698                        strcpy(phrase_two, p);
    668699                    }
    669700                }
     
    674705
    675706#ifndef __FreeBSD__
    676     if (!phrase_two || strlen(phrase_two) == 0) {
     707    if (strlen(phrase_two) == 0) {
    677708        log_msg(4, "Not running phase two. String is empty.");
    678709    } else {
    679         mr_asprintf(command, "dmesg | grep \"%s\" 2> /dev/null", phrase_two);
     710        sprintf(command, "dmesg | grep \"%s\" 2> /dev/null", phrase_two);
    680711        fin = popen(command, "r");
    681         mr_free(command);
    682 
    683712        if (!fin) {
    684713            log_msg(4, "Cannot run 2nd command - non-fatal, fortunately");
     
    692721                        *p = '\0';
    693722                        if (strstr(tmp, "DVD")) {
    694                             mr_free(dvd_last_resort);
    695                             mr_asprintf(dvd_last_resort, "/dev/%s", tmp);
    696                             log_msg(4, "Ignoring '%s' because it's a DVD drive", tmp);
     723                            sprintf(dvd_last_resort, "/dev/%s", tmp);
     724                            log_msg(4,
     725                                    "Ignoring '%s' because it's a DVD drive",
     726                                    tmp);
    697727                        } else {
    698728                            sprintf(output, "/dev/%s", tmp);
     
    745775#else
    746776    if (!found_it && strlen(dvd_last_resort) > 0) {
    747         log_msg(4, "Well, I'll use the DVD - %s - as a last resort", dvd_last_resort);
     777        log_msg(4, "Well, I'll use the DVD - %s - as a last resort",
     778                dvd_last_resort);
    748779        strcpy(output, dvd_last_resort);
    749780        found_it = TRUE;
    750781    }
    751782    if (found_it) {
    752         sprintf(tmp, "grep \"%s=ide-scsi\" /proc/cmdline &> /dev/null", strrchr(output, '/') + 1);
     783        sprintf(tmp, "grep \"%s=ide-scsi\" /proc/cmdline &> /dev/null",
     784                strrchr(output, '/') + 1);
    753785        if (system(tmp) == 0) {
    754             log_msg(4, "%s is not right. It's being SCSI-emulated. Continuing.", output);
     786            log_msg(4,
     787                    "%s is not right. It's being SCSI-emulated. Continuing.",
     788                    output);
    755789            found_it = FALSE;
    756790            output[0] = '\0';
     
    818852                found_it = FALSE;
    819853            } else {
    820                 mr_asprintf(command, "umount %s", output);
     854                sprintf(command, "umount %s", output);
    821855                paranoid_system(command);
    822                 mr_free(command);
    823 
    824856                log_msg(4, "I'm confident the Mondo CD is in %s", output);
    825857            }
     
    840872    }
    841873
    842     mr_asprintf(command, "%s -scanbus | grep \"[0-9],[0-9],[0-9]\" | grep -E \"[D|C][V|D]\" | grep -n \"\" | grep \"%s\" | cut -d':' -f2", cdr_exe, g_cdrw_drive_is_here);
    843 
     874    sprintf(command,
     875            "%s -scanbus | grep \"[0-9],[0-9],[0-9]\" | grep -E \"[D|C][V|D]\" | grep -n \"\" | grep \"%s\" | cut -d':' -f2",
     876            cdr_exe, g_cdrw_drive_is_here);
    844877    log_msg(1, "command=%s", command);
    845878    mr_asprintf(tmp1, "%s", call_program_and_get_last_line_of_output(command));
    846     mr_free(command);
    847 
    848879    if (strlen(tmp1) > 0) {
    849880        strcpy(output, tmp1);
     
    857888
    858889  end_of_find_cdrom_device:
     890    paranoid_free(tmp);
    859891    mr_free(cdr_exe);
    860     mr_free(phrase_two);
    861     mr_free(dvd_last_resort);
    862 
    863     paranoid_free(tmp);
    864892    paranoid_free(phrase_one);
     893    paranoid_free(phrase_two);
     894    paranoid_free(command);
     895    paranoid_free(dvd_last_resort);
    865896    paranoid_free(mountpoint);
    866897    return (retval);
     
    868899
    869900
     901
     902
     903
    870904int find_dvd_device(char *output, bool try_to_mount)
    871905{
     906    char *command;
    872907    char *tmp;
    873908    int retval = 0, devno = -1;
     909
     910    malloc_string(command);
     911    malloc_string(tmp);
    874912
    875913    if (g_dvd_drive_is_here[0]) {
     
    879917    }
    880918
    881     malloc_string(tmp);
    882     mr_asprintf(tmp, "%s", call_program_and_get_last_line_of_output("dvdrecord -scanbus 2> /dev/null | grep -E '\)\ \'' | grep -n '' | grep -E '[D|C][V|D]' | cut -d':' -f1"));
     919    sprintf(tmp, "%s", call_program_and_get_last_line_of_output("dvdrecord -scanbus 2> /dev/null | grep -E '\)\ \'' | grep -n '' | grep -E '[D|C][V|D]' | cut -d':' -f1"));
    883920    log_msg(5, "tmp = '%s'", tmp);
    884     if (!tmp[0]) {
    885         mr_free(tmp);
    886         mr_asprintf(tmp, "%s", call_program_and_get_last_line_of_output("cdrecord -scanbus 2> /dev/null | grep \)\ \' | grep -n '' | grep -E '[D|C][V|D]' | cut -d':' -f1"));
    887     }
     921    if (!tmp[0])
     922        sprintf(tmp, "%s", call_program_and_get_last_line_of_output
     923                ("cdrecord -scanbus 2> /dev/null | grep \)\ \' | grep -n '' | grep -E '[D|C][V|D]' | cut -d':' -f1")
     924            );
    888925    if (tmp[0]) {
    889926        devno = atoi(tmp) - 1;
    890927    }
    891     mr_free(tmp);
    892 
    893928    if (devno >= 0) {
    894929        retval = 0;
     
    901936    }
    902937
     938    if (try_to_mount) {
     939        log_msg(1, "Ignoring the fact that try_to_mount==TRUE");
     940    }
    903941    return (retval);
    904942}
     
    10151053{
    10161054    char *good_formats = NULL;
    1017     char *command = NULL;
    1018     char *format_sz = NULL;
     1055    char *command;
     1056    char *format_sz;
    10191057    char *p;
    10201058
     
    10221060    int retval;
    10231061    malloc_string(good_formats);
     1062    malloc_string(command);
     1063    malloc_string(format_sz);
    10241064
    10251065    assert_string_is_neither_NULL_nor_zerolength(format);
    10261066
    1027     mr_asprintf(format_sz, "%s ", format);
     1067    sprintf(format_sz, "%s ", format);
    10281068
    10291069#ifdef __FreeBSD__
    1030     mr_asprintf(command, "lsvfs | tr -s '\t' ' ' | grep -v Filesys | grep -v -- -- | cut -d' ' -f1 | tr -s '\n' ' '");
     1070    sprintf(command,
     1071            "lsvfs | tr -s '\t' ' ' | grep -v Filesys | grep -v -- -- | cut -d' ' -f1 | tr -s '\n' ' '");
    10311072#else
    1032     mr_asprintf(command, "grep -v nodev /proc/filesystems | tr -s '\t' ' ' | cut -d' ' -f2 | tr -s '\n' ' '");
     1073    sprintf(command,
     1074            "grep -v nodev /proc/filesystems | tr -s '\t' ' ' | cut -d' ' -f2 | tr -s '\n' ' '");
    10331075#endif
    10341076
    10351077    pin = popen(command, "r");
    1036     mr_free(command);
    1037 
    10381078    if (!pin) {
    10391079        log_OS_error("Unable to read good formats");
     
    10541094    }
    10551095    paranoid_free(good_formats);
    1056     mr_free(format_sz);
    1057 
     1096    paranoid_free(command);
     1097    paranoid_free(format_sz);
    10581098    return (retval);
    10591099}
     
    10741114
    10751115    /*@ buffers ***************************************************** */
    1076     char *incoming = NULL;
     1116    char *incoming;
    10771117    char *device_with_tab = NULL;
    10781118    char *device_with_space = NULL;
     
    10881128    /*@ end vars **************************************************** */
    10891129
    1090     if (device_raw == NULL) {
    1091         return(FALSE);
    1092     }
    1093 
     1130    malloc_string(incoming);
     1131    assert(device_raw != NULL);
     1132//  assert_string_is_neither_NULL_nor_zerolength(device_raw);
    10941133    if (device_raw[0] != '/' && !strstr(device_raw, ":/")) {
    10951134        log_msg(1, "%s needs to have a '/' prefixed - I'll do it",
     
    11141153        return(FALSE);
    11151154    }
    1116 
    1117     for (mr_getline(incoming, fin); !feof(fin); mr_getline(incoming, fin)) {
    1118         if (strstr(incoming, device_with_space) || strstr(incoming, device_with_tab)) {
     1155    for (tmp = fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin) && (tmp != NULL);
     1156         tmp = fgets(incoming, MAX_STR_LEN - 1, fin)) {
     1157        if (strstr(incoming, device_with_space) //> incoming
     1158            || strstr(incoming, device_with_tab))   // > incoming)
     1159        {
    11191160            paranoid_pclose(fin);
    1120             mr_free(incoming);
     1161            paranoid_free(incoming);
    11211162            return(TRUE);
    11221163        }
    1123         mr_free(incoming);
    1124     }
    1125     mr_free(incoming);
     1164    }
    11261165    mr_free(device_with_tab);
    11271166    paranoid_pclose(fin);
     
    11331172    }
    11341173    mr_free(tmp);
     1174    paranoid_free(incoming);
    11351175    return(retval);
    11361176}
     
    11491189    char command[MAX_STR_LEN];
    11501190    int vndev = 2;
    1151     if (atoi(call_program_and_get_last_line_of_output("/sbin/sysctl -n kern.osreldate")) < 500000) {
     1191    if (atoi
     1192        (call_program_and_get_last_line_of_output
     1193         ("/sbin/sysctl -n kern.osreldate")) < 500000) {
    11521194        do {
    11531195            sprintf(mddevice, "vn%ic", vndev++);
     
    11811223int kick_vn(char *dname)
    11821224{
    1183     char *command = NULL;
    1184     int res = 0;
     1225    char command[MAX_STR_LEN];
    11851226
    11861227    if (strncmp(dname, "/dev/", 5) == 0) {
     
    11881229    }
    11891230
    1190     if (atoi(call_program_and_get_last_line_of_output("/sbin/sysctl -n kern.osreldate")) < 500000) {
    1191         mr_asprintf(command, "vnconfig -d %s", dname);
     1231    if (atoi
     1232        (call_program_and_get_last_line_of_output
     1233         ("/sbin/sysctl -n kern.osreldate")) < 500000) {
     1234        sprintf(command, "vnconfig -d %s", dname);
     1235        return system(command);
    11921236    } else {
    1193         mr_asprintf(command, "mdconfig -d -u %s", dname);
    1194     }
    1195     res = system(command);
    1196     mr_free(command);
    1197     return(res);
     1237        sprintf(command, "mdconfig -d -u %s", dname);
     1238        return system(command);
     1239    }
     1240     /*NOTREACHED*/ return 255;
    11981241}
    11991242#endif
     
    12091252{
    12101253    /*@ buffer ****************************************************** */
    1211     char *command = NULL;
     1254    char *command;
    12121255    int retval;
    12131256
     1257    malloc_string(command);
    12141258    assert_string_is_neither_NULL_nor_zerolength(device);
    12151259    assert_string_is_neither_NULL_nor_zerolength(mountpoint);
     
    12191263        return(1);
    12201264    }
    1221     log_msg(4, "(mount_USB_here --- device=%s, mountpoint=%s", device, mountpoint);
     1265    log_msg(4, "(mount_USB_here --- device=%s, mountpoint=%s", device,
     1266            mountpoint);
    12221267
    12231268#ifdef __FreeBSD__
    1224     mr_asprintf(command, "mount_vfat %s %s 2>> %s", device, mountpoint, MONDO_LOGFILE);
     1269    sprintf(command, "mount_vfat %s %s 2>> %s",
     1270            device, mountpoint, MONDO_LOGFILE);
    12251271
    12261272#else
    1227     mr_asprintf(command, "mount %s -t vfat %s 2>> %s", device, mountpoint, MONDO_LOGFILE);
     1273    sprintf(command, "mount %s -t vfat %s 2>> %s",
     1274            device, mountpoint, MONDO_LOGFILE);
    12281275#endif
    12291276
     
    12311278    retval = system(command);
    12321279    log_msg(1, "system(%s) returned %d", command, retval);
    1233     mr_free(command);
    1234 
     1280
     1281    paranoid_free(command);
    12351282    return (retval);
    12361283}
     
    12421289 * @return 0 for success, nonzero for failure.
    12431290 */
    1244 int mount_CDROM_here(char *device, const char *mountpoint)
     1291int mount_CDROM_here(char *device, char *mountpoint)
    12451292{
    12461293    /*@ buffer ****************************************************** */
     
    12801327
    12811328    }
    1282     log_msg(4, "(mount_CDROM_here --- device=%s, mountpoint=%s", device, mountpoint);
     1329    log_msg(4, "(mount_CDROM_here --- device=%s, mountpoint=%s", device,
     1330            mountpoint);
    12831331    /*@ end vars *************************************************** */
    12841332
     
    12971345    retval = system(command);
    12981346    log_msg(1, "system(%s) returned %d", command, retval);
    1299     mr_free(command);
     1347    paranoid_free(command);
    13001348
    13011349    return (retval);
     
    13141362int mount_media()
    13151363{
    1316 char *mount_cmd = NULL;
     1364char *mount_cmd;
    13171365char *mountdir = NULL;
    13181366int i, res;
    13191367#ifdef __FreeBSD__
    1320     char mdd[32];
    1321     char *mddev = mdd;
    1322 #endif
    1323 
    1324     if (bkpinfo->backup_media_type == tape || bkpinfo->backup_media_type == udev) {
     1368char mdd[32];
     1369char *mddev = mdd;
     1370#endif
     1371
     1372malloc_string(mount_cmd);
     1373assert(bkpinfo != NULL);
     1374
     1375    if (bkpinfo->backup_media_type == tape
     1376        || bkpinfo->backup_media_type == udev) {
    13251377        log_msg(8, "Tape/udev. Therefore, no need to mount a media.");
     1378        paranoid_free(mount_cmd);
    13261379        return 0;
    13271380    }
     
    13291382    if (!run_program_and_log_output("mount | grep -F " MNT_CDROM, FALSE)) {
    13301383        log_msg(2, "mount_media() - media already mounted. Fair enough.");
     1384        paranoid_free(mount_cmd);
    13311385        return (0);
    13321386    }
     
    13351389        log_msg(2, "Mounting for Network thingy");
    13361390        log_msg(2, "isodir = %s", bkpinfo->isodir);
    1337         if ((!bkpinfo->isodir[0] || !strcmp(bkpinfo->isodir, "/")) && am_I_in_disaster_recovery_mode()) {
     1391        if ((!bkpinfo->isodir[0] || !strcmp(bkpinfo->isodir, "/"))
     1392            && am_I_in_disaster_recovery_mode()) {
    13381393            strcpy(bkpinfo->isodir, "/tmp/isodir");
    13391394            log_msg(1, "isodir is being set to %s", bkpinfo->isodir);
    13401395        }
    13411396#ifdef __FreeBSD__
    1342         mr_asprintf(mount_cmd, "/mnt/isodir/%s/%s/%s-%d.iso", bkpinfo->isodir,
     1397        sprintf(mount_cmd, "/mnt/isodir/%s/%s/%s-%d.iso", bkpinfo->isodir,
    13431398            bkpinfo->netfs_remote_dir, bkpinfo->prefix, g_current_media_number);
    13441399        mddev = make_vn(mount_cmd);
    1345         mr_free(mount_cmd);
    1346 
    1347         mr_asprintf(mount_cmd, "mount_cd9660 -r %s " MNT_CDROM, mddev);
     1400        sprintf(mount_cmd, "mount_cd9660 -r %s " MNT_CDROM, mddev);
    13481401#else
    1349         mr_asprintf(mount_cmd, "mount %s/%s/%s-%d.iso -t iso9660 -o loop,ro %s", bkpinfo->isodir, bkpinfo->netfs_remote_dir, bkpinfo->prefix, g_current_media_number, MNT_CDROM);
     1402        sprintf(mount_cmd, "mount %s/%s/%s-%d.iso -t iso9660 -o loop,ro %s",
     1403            bkpinfo->isodir, bkpinfo->netfs_remote_dir,
     1404            bkpinfo->prefix, g_current_media_number, MNT_CDROM);
    13501405#endif
    13511406
     
    13571412        }
    13581413#ifdef __FreeBSD__
    1359         mr_asprintf(mount_cmd, "%s/%s-%d.iso", mountdir, bkpinfo->prefix, g_current_media_number);
     1414        sprintf(mount_cmd, "%s/%s-%d.iso", mountdir,
     1415            bkpinfo->prefix, g_current_media_number);
    13601416        mddev = make_vn(mount_cmd);
    1361         mr_free(mount_cmd);
    1362 
    1363         mr_asprintf(mount_cmd, "mount_cd9660 -r %s %s", mddev, MNT_CDROM);
     1417        sprintf(mount_cmd, "mount_cd9660 -r %s %s", mddev, MNT_CDROM);
    13641418#else
    1365         mr_asprintf(mount_cmd, "mount %s/%s-%d.iso -t iso9660 -o loop,ro %s", mountdir, bkpinfo->prefix, g_current_media_number, MNT_CDROM);
     1419        sprintf(mount_cmd, "mount %s/%s-%d.iso -t iso9660 -o loop,ro %s",
     1420            mountdir, bkpinfo->prefix, g_current_media_number, MNT_CDROM);
    13661421#endif
    13671422        mr_free(mountdir);
    13681423    } else if (bkpinfo->backup_media_type == usb) {
    1369         mr_asprintf(mount_cmd, "mount -t vfat %s %s", bkpinfo->media_device, MNT_CDROM);
     1424        sprintf(mount_cmd, "mount -t vfat %s %s", bkpinfo->media_device, MNT_CDROM);
    13701425    } else if (strstr(bkpinfo->media_device, "/dev/")) {
    13711426#ifdef __FreeBSD__
    1372         mr_asprintf(mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device, MNT_CDROM);
     1427        sprintf(mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
     1428        MNT_CDROM);
    13731429#else
    1374         mr_asprintf(mount_cmd, "mount %s -t iso9660 -o ro %s", bkpinfo->media_device, MNT_CDROM);
     1430        sprintf(mount_cmd, "mount %s -t iso9660 -o ro %s",
     1431        bkpinfo->media_device, MNT_CDROM);
    13751432#endif
    13761433    } else {
     
    13841441
    13851442#ifdef __FreeBSD__
    1386         mr_asprintf(mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device, MNT_CDROM);
     1443    sprintf(mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
     1444        MNT_CDROM);
    13871445#else
    1388         mr_asprintf(mount_cmd, "mount %s -t iso9660 -o ro %s", bkpinfo->media_device, MNT_CDROM);
     1446    sprintf(mount_cmd, "mount %s -t iso9660 -o ro %s",
     1447        bkpinfo->media_device, MNT_CDROM);
    13891448#endif
    13901449    }
     
    13981457            log_msg(2, "Failed to mount device.");
    13991458            sleep(5);
    1400             sync();
    1401         }
    1402     }
    1403     mr_free(mount_cmd);
     1459            run_program_and_log_output("sync", FALSE);
     1460        }
     1461    }
    14041462
    14051463    if (res) {
     
    14081466        log_msg(2, "Mounted media drive OK");
    14091467    }
     1468    paranoid_free(mount_cmd);
    14101469    return (res);
    14111470}
     
    14371496
    14381497    /*@ buffers ********************************************************* */
    1439     char *tmp = NULL;
     1498    char *tmp;
    14401499    char *mds = NULL;
    1441     char *request = NULL;
     1500    char *request;
    14421501
    14431502    assert(bkpinfo != NULL);
     
    14511510        return;
    14521511    }
    1453     mr_asprintf(tmp, "mkdir -p " MNT_CDROM);
     1512    if (g_ISO_restore_mode || bkpinfo->backup_media_type == iso
     1513        || bkpinfo->backup_media_type == netfs) {
     1514        g_ISO_restore_mode = TRUE;
     1515    }
     1516    malloc_string(tmp);
     1517    malloc_string(request);
     1518    sprintf(tmp, "mkdir -p " MNT_CDROM);
    14541519    run_program_and_log_output(tmp, 5);
    1455     mr_free(tmp);
    1456 
    1457     if (g_ISO_restore_mode || bkpinfo->backup_media_type == iso || bkpinfo->backup_media_type == netfs) {
    1458         g_ISO_restore_mode = TRUE;
    1459     }
    14601520    if ((res = what_number_cd_is_this()) != cd_number_i_want) {
    1461         log_msg(3, "Currently, we hold %d but we want %d", res, cd_number_i_want);
     1521        log_msg(3, "Currently, we hold %d but we want %d", res,
     1522                cd_number_i_want);
    14621523
    14631524        /* Now we need to umount the current media to have the next mounted after */
     
    14681529
    14691530        mds = media_descriptor_string(bkpinfo->backup_media_type);
    1470         log_msg(3, "Insisting on %s #%d", mds, cd_number_i_want);
    1471         mr_asprintf(request, "Please insert %s #%d and press Enter.", mds, cd_number_i_want);
     1531        sprintf(tmp, "Insisting on %s #%d", mds, cd_number_i_want);
     1532        sprintf(request, "Please insert %s #%d and press Enter.", mds, cd_number_i_want);
    14721533        mr_free(mds);
    1473 
     1534        log_msg(3, tmp);
    14741535        while (what_number_cd_is_this() != cd_number_i_want) {
    1475             sync();
     1536            paranoid_system("sync");
    14761537            if (is_this_device_mounted(MNT_CDROM)) {
    14771538                res =
     
    14951556                inject_device(bkpinfo->media_device);
    14961557            }
    1497             sync();
    1498         }
    1499         mr_free(request);
    1500 
     1558            paranoid_system("sync");
     1559        }
    15011560        log_msg(1, "Thankyou. Proceeding...");
    15021561        g_current_media_number = cd_number_i_want;
    15031562    }
     1563    paranoid_free(tmp);
     1564    paranoid_free(request);
    15041565}
    15051566
     
    16151676    log_msg(5, "Running: %s", command);
    16161677    mr_asprintf(mounted_file_system, "%s", call_program_and_get_last_line_of_output(command));
    1617     mr_free(command);
     1678    paranoid_free(command);
    16181679
    16191680    mount_cnt = atoi(mounted_file_system);
    16201681    log_msg (5, "mount_cnt: %d", mount_cnt);
    1621     mr_free(mounted_file_system);
     1682    paranoid_free(mounted_file_system);
    16221683
    16231684    for (i=mount_cnt; i > 0; i--) {
     
    16251686        log_msg(5, "Running: %s", command);
    16261687        mr_asprintf(mounted_file_system, "%s", call_program_and_get_last_line_of_output(command));
    1627         mr_free(command);
     1688        paranoid_free(command);
    16281689
    16291690        log_msg (5, "mounted_file_system: %s", mounted_file_system);
    16301691        if ((token = mr_strtok(mounted_file_system, token_chars, &lastpos)) == NULL) {
    16311692            log_msg (4, "Could not get the list of mounted file systems");
    1632             mr_free(mounted_file_system);
     1693            paranoid_free(mounted_file_system);
    16331694            mr_free(token);
    16341695            return (1);
     
    16581719        mr_free(mounted_file_system);
    16591720    }
     1721    /********
     1722    * DSFptr = DSF_Head;
     1723    * while (DSFptr != NULL) {
     1724    * printf ("Dev: %s  MP: %s  Check: %d\n", DSFptr->device, DSFptr->mount_point, DSFptr->check);
     1725    * DSFptr = DSFptr->next;
     1726    * }
     1727    ********/
    16601728    return (0);
    16611729}
     
    17051773    log_msg(5, "  Executing: %s", command);
    17061774    mr_asprintf(tmp, "%s", call_program_and_get_last_line_of_output(command));
    1707     mr_free(command);
     1775    paranoid_free(command);
    17081776
    17091777    log_msg(5, "  Return value: %s", tmp);
    17101778    c = atoi(tmp);
    1711     mr_free(tmp);
     1779    paranoid_free(tmp);
    17121780
    17131781    if (!c) {
     
    17311799    log_msg(5, "Executing: %s", command);
    17321800    mr_asprintf(partition_list, "%s", call_program_and_get_last_line_of_output(command));
    1733     mr_free(command);
     1801    paranoid_free(command);
    17341802    log_msg(4, "Partition list for %s: %s", dsf, partition_list);
    17351803    if (!strlen(partition_list)) {
     
    17941862        log_msg(4, "Processing partition: %s", partitions[i]);
    17951863        /* See if it's swap. If it is, ignore it. */
    1796         mr_asprintf(command, "parted2fdisk -l %s 2>/dev/null | awk '{if(($1==\"%s\")&&(toupper($0) ~ \"SWAP\")){print $1;exit}}'", ndsf, partitions[i]);
     1864        mr_asprintf(command, "parted2fdisk -l %s 2>/dev/null | awk '{if(($1==\"%s\")&&(toupper($0) ~ \"SWAP\")){print $1;exit}}'",
     1865          ndsf, partitions[i]);
    17971866        log_msg(5, "  Running: %s", command);
    17981867        mr_asprintf(tmp, "%s", call_program_and_get_last_line_of_output(command));
    1799         mr_free(command);
    1800 
     1868        paranoid_free(command);
    18011869        log_msg(5, "  Return value: %s", tmp);
    18021870        c = strlen(tmp);
    1803         mr_free(tmp);
    1804 
     1871        paranoid_free(tmp);
    18051872        if (c) {
    18061873            log_msg(4, "It's swap. Ignoring partition %s", partitions[i]);
    18071874            continue;
    18081875        }
    1809 
    18101876        /* It's not swap. See if we can find the mount point from the mount command. */
    18111877        mr_asprintf(command, "mount 2>/dev/null | awk '{if((NF>0)&&($1==\"%s\")){print $3}}'", partitions[i]);
    18121878        mr_asprintf(tmp, "%s", call_program_and_get_last_line_of_output(command));
    1813         mr_free(command);
    1814 
     1879        paranoid_free(command);
    18151880        if (strlen(tmp)) {
    18161881            log_msg(4, "  %s is mounted: %s", partitions[i], tmp);
    18171882            if ((DSFptr = find_mount_point_in_list(tmp)) == NULL) {
    18181883                log_msg (4, "Can't find mount point %s in mounted file systems list", tmp);
    1819                 mr_free(tmp);
     1884                paranoid_free(tmp);
    18201885                return (1);
    18211886            }
    18221887            DSFptr->check = 1;
    1823             mr_free(tmp);
     1888            paranoid_free(tmp);
    18241889            continue;
    18251890        }
    1826         mr_free(tmp);
    1827 
     1891        paranoid_free(tmp);
    18281892        /* It's not swap and it's not mounted. See if it's LVM */
    18291893        log_msg(4, "  It's not mounted. Checking to see if it's LVM...");
    1830 
    18311894        /* Check for LVM */
    18321895        mr_asprintf(command, "pvdisplay -c %s 2> /dev/null", partitions[i]);
    18331896        log_msg(5, "  Running: %s", command);
    18341897        mr_asprintf(tmp, "%s", call_program_and_get_last_line_of_output(command));
    1835         mr_free(command);
    1836 
     1898        paranoid_free(command);
    18371899        if (strlen(tmp)) {
    18381900            log_msg(4, "Found an LVM partition at %s. Find the VG it's in...", partitions[i]);
     
    18411903            log_msg(5, "  Running: %s", command);
    18421904            strcpy(VG, call_program_and_get_last_line_of_output(command));
    1843             mr_free(command);
    1844 
     1905            paranoid_free(command);
    18451906            log_msg(4, "  Volume Group: %s", VG);
    18461907            if (strlen(VG)) {
     
    18501911                log_msg(5, "  Running: %s", command);
    18511912                mr_asprintf(mount_list, "%s", call_program_and_get_last_line_of_output(command));
    1852                 mr_free(command);
    1853 
     1913                paranoid_free(command);
    18541914                log_msg(4, "  VG %s mount_list: %s", VG, mount_list);
    18551915                lastpos = 0;
     
    18581918                    if ((DSFptr = find_mount_point_in_list(token)) == NULL) {
    18591919                        log_msg (4, "Can't find mount point %s in mounted file systems list", token);
    1860                         mr_free(tmp);
     1920                        paranoid_free(tmp);
    18611921                        mr_free(token);
    18621922                        return (1);
     
    18691929                 * any of the Logical Volumes on the Volume Group.
    18701930                 *******/
    1871                 mr_free(mount_list);
     1931                paranoid_free(mount_list);
    18721932
    18731933                mr_asprintf(command, "%s", "cat /proc/mdstat|grep -iv Personal|awk '{if($0~\"^.*[ ]+:\"){printf(\"/dev/%s \", $1)}}END{print \"\"}'");
    18741934                log_msg (5, "Running: %s", command);
    18751935                mr_asprintf(mount_list, "%s", call_program_and_get_last_line_of_output(command));
    1876                 mr_free(command);
     1936                paranoid_free(command);
    18771937                log_msg(4, "  Software raid device list: %s", mount_list);
    18781938                lastpos = 0;
     
    18801940                    mr_asprintf(command, "mdadm --detail %s 2>/dev/null | grep -c %s", token, VG);
    18811941                    log_msg (5, "Running: %s", command);
    1882                     mr_free(tmp);
     1942                    paranoid_free(tmp);
    18831943                    mr_asprintf(tmp, "%s", call_program_and_get_last_line_of_output(command));
    1884                     mr_free(command);
     1944                    paranoid_free(command);
    18851945                    log_msg(4, "Number of Software raid device: %s", tmp);
    18861946                    if (atoi(tmp)) {
     
    18881948                        if ((DSFptr = find_device_in_list(token)) == NULL) {
    18891949                            log_msg (4, "Can't find device %s in mounted file systems list", token);
    1890                             mr_free(tmp);
     1950                            paranoid_free(tmp);
    18911951                            mr_free(token);
    18921952                            return (1);
     
    18991959            } else {
    19001960                log_msg (4, "Error finding Volume Group for partition %s", partitions[i]);
    1901                 mr_free(tmp);
     1961                paranoid_free(tmp);
    19021962                return (1);
    19031963            }
    1904             mr_free(tmp);
     1964            paranoid_free(tmp);
    19051965            continue;
    19061966        } else {
    19071967            log_msg (4, "Error finding partition type for the partition %s", partitions[i]);
    19081968        }
    1909         mr_free(tmp);
    1910 
     1969        paranoid_free(tmp);
    19111970        /********
    19121971         * It's not swap, mounted, or LVM. See if it's used in a software raid device.
     
    19161975        log_msg(4, "  Running: %s", command);
    19171976        mr_asprintf(tmp, "%s", call_program_and_get_last_line_of_output(command));
    1918         mr_free(command);
    1919 
     1977        paranoid_free(command);
    19201978        if (!strlen(tmp)) {
    19211979            log_msg(4, "  Partition %s is not used in a non-LVM software raid device", partitions[i]);
    1922             mr_free(tmp);
     1980            paranoid_free(tmp);
    19231981            continue;
    19241982        }
    19251983        log_msg (5, "  UUID: %s", tmp);
    1926 
    19271984        /* Get the Software raid device list */
    19281985        mr_asprintf(command, "%s", "cat /proc/mdstat|grep -iv Personal|awk '{if($0~\"^.*[ ]+:\"){printf(\"/dev/%s \", $1)}}END{print \"\"}'");
    19291986        log_msg (5, "  Running: %s", command);
    19301987        mr_asprintf(mount_list, "%s", call_program_and_get_last_line_of_output(command));
    1931         mr_free(command);
    1932 
     1988        paranoid_free(command);
    19331989        log_msg(4, "  Software raid device list: %s", mount_list);
    19341990        /* Loop through the software raid device list to see if we can find the partition */
     
    19371993            mr_asprintf(command, "mdadm --detail %s 2>/dev/null | grep -c %s", token, tmp);
    19381994            log_msg(4, "  Running: %s", command);
    1939             mr_free(tmp);
     1995            paranoid_free(tmp);
    19401996            mr_asprintf(tmp, "%s", call_program_and_get_last_line_of_output(command));
    1941             mr_free(command);
    1942 
     1997            paranoid_free(command);
    19431998            if (!atoi(tmp)) {
    19441999                log_msg (4,"  Didn't find partition %s in software raid device %s", partitions[i], token);
     
    19462001                if ((DSFptr = find_device_in_list(token)) == NULL) {
    19472002                    log_msg (4, "Can't find device %s in mounted file systems list", token);
    1948                     mr_free(tmp);
     2003                    paranoid_free(tmp);
    19492004                    mr_free(token);
    19502005                    return (1);
     
    19552010            mr_free(token);
    19562011        }
    1957         mr_free(tmp);
    1958         mr_free(mount_list);
     2012        paranoid_free(tmp);
     2013        paranoid_free(mount_list);
    19592014    }
    19602015
     
    19922047    return (0);
    19932048}
     2049
     2050
     2051
    19942052
    19952053
     
    20412099            log_to_screen("Archiving only the following file systems on %s:", token);
    20422100            log_to_screen("==> %s", mounted_on_dsf);
    2043             mr_free(bkpinfo->include_paths);
    2044             mr_asprintf(bkpinfo->include_paths, "%s", "/");
     2101            strcpy(bkpinfo->include_paths, "/");
    20452102            if (strlen(not_mounted_on_dsf)) {
    20462103                log_msg (5, "Adding to bkpinfo->exclude_paths due to -I option: %s", not_mounted_on_dsf);
     
    20792136            mr_asprintf(tmp,"|%s|",bkpinfo->include_paths);
    20802137            if (strstr(tmp,tmp2) == NULL) {
    2081                 mr_strcat(bkpinfo->include_paths, "%s", tmp1);
     2138                strcat(bkpinfo->include_paths,tmp1);
    20822139            }
    20832140            mr_free(tmp1);
     
    21242181    char *q = NULL;
    21252182    char p[16*MAX_STR_LEN];
    2126     char *sz_size = NULL;
    2127     char *command = NULL;
     2183    char *sz_size;
     2184    char *command;
    21282185    char *compression_type = NULL;
    2129     char *comment = NULL;
     2186    char *comment;
     2187    char *prompt;
    21302188    int i;
    21312189    FILE *fin;
    21322190
     2191    malloc_string(sz_size);
     2192    malloc_string(command);
     2193    malloc_string(comment);
     2194    malloc_string(prompt);
    21332195    malloc_string(tmp1);
    21342196    assert(bkpinfo != NULL);
     2197    sz_size[0] = '\0';
    21352198    bkpinfo->nonbootable_backup = FALSE;
    21362199
     
    21692232        setup_scratchdir(tmp);
    21702233    }
    2171     log_msg(3, "media type = %s", bkptype_to_string(bkpinfo->backup_media_type));
     2234    log_msg(3, "media type = %s",
     2235            bkptype_to_string(bkpinfo->backup_media_type));
    21722236    bkpinfo->cdrw_speed = (bkpinfo->backup_media_type == cdstream) ? 2 : 4;
    2173     bkpinfo->compression_level = (bkpinfo->backup_media_type == cdstream) ? 1 : 5;
    2174     bkpinfo->use_lzo = (bkpinfo->backup_media_type == cdstream) ? TRUE : FALSE;
     2237    bkpinfo->compression_level =
     2238        (bkpinfo->backup_media_type == cdstream) ? 1 : 5;
     2239    bkpinfo->use_lzo =
     2240        (bkpinfo->backup_media_type == cdstream) ? TRUE : FALSE;
    21752241    mvaddstr_and_log_it(2, 0, " ");
    21762242
     
    21872253        if (archiving_to_media) {
    21882254            if ((bkpinfo->backup_media_type != dvd) && (bkpinfo->backup_media_type != usb)) {
    2189                 if (ask_me_yes_or_no("Is your computer a laptop, or does the CD writer incorporate BurnProof technology?")) {
     2255                if (ask_me_yes_or_no
     2256                    ("Is your computer a laptop, or does the CD writer incorporate BurnProof technology?"))
     2257                {
    21902258                    bkpinfo->manual_cd_tray = TRUE;
    21912259                }
     
    21952263                finish(1);
    21962264            }
    2197 
    2198             if ((bkpinfo->compression_level = which_compression_level()) == -1) {
     2265            if ((bkpinfo->compression_level =
     2266                which_compression_level()) == -1) {
    21992267                log_to_screen("User has chosen not to backup the PC");
    22002268                finish(1);
    22012269            }
    22022270            mds = media_descriptor_string(bkpinfo->backup_media_type);
    2203             mr_asprintf(comment, "What speed is your %s (re)writer?", mds);
     2271            sprintf(comment, "What speed is your %s (re)writer?", mds);
    22042272            if (bkpinfo->backup_media_type == dvd) {
    22052273                find_dvd_device(bkpinfo->media_device, FALSE);
    22062274                strcpy(tmp1, "1");
    2207                 mr_asprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE);  // 4.7 salesman's GB = 4.482 real GB = 4482 MB
     2275                sprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE);  // 4.7 salesman's GB = 4.482 real GB = 4482 MB
    22082276                log_msg(1, "Setting to DVD defaults");
    22092277            } else {
    22102278                strcpy(bkpinfo->media_device, VANILLA_SCSI_CDROM);
    22112279                strcpy(tmp1, "4");
    2212                 mr_asprintf(sz_size, "%d", 650);
     2280                strcpy(sz_size, "650");
    22132281                log_msg(1, "Setting to CD defaults");
    22142282            }
     
    22162284                if (!popup_and_get_string("Speed", comment, tmp1, 4)) {
    22172285                    log_to_screen("User has chosen not to backup the PC");
    2218                     mr_free(comment);
    22192286                    finish(1);
    22202287                }
    22212288            }
    2222             mr_free(comment);
    22232289            bkpinfo->cdrw_speed = atoi(tmp1);   // if DVD then this shouldn't ever be used anyway :)
    22242290
    2225             strcpy(tmp1, sz_size);
    2226             mr_asprintf(comment, "How much data (in Megabytes) will each %s store?", mds);
     2291            sprintf(comment,
     2292                    "How much data (in Megabytes) will each %s store?", mds);
    22272293            mr_free(mds);
    2228             if (!popup_and_get_string("Size", comment, tmp1, 5)) {
     2294            if (!popup_and_get_string("Size", comment, sz_size, 5)) {
    22292295                log_to_screen("User has chosen not to backup the PC");
    22302296                finish(1);
    22312297            }
    2232             mr_asprintf(sz_size, "%s", tmp1);
    22332298            bkpinfo->media_size = atoi(sz_size);
    2234 
    22352299            if (bkpinfo->media_size <= 0) {
    22362300                log_to_screen("User has chosen not to backup the PC");
     
    22442308        if ((bkpinfo->disaster_recovery) && (bkpinfo->backup_media_type != usb)) {
    22452309            strcpy(bkpinfo->media_device, "/dev/cdrom");
    2246             log_msg(2, "CD-ROM device assumed to be at %s", bkpinfo->media_device);
    2247         } else if ((bkpinfo->restore_data && (bkpinfo->backup_media_type != usb))  || bkpinfo->backup_media_type == dvd) {
     2310            log_msg(2, "CD-ROM device assumed to be at %s",
     2311                    bkpinfo->media_device);
     2312        } else if ((bkpinfo->restore_data && (bkpinfo->backup_media_type != usb))
     2313                   || bkpinfo->backup_media_type == dvd) {
    22482314            if (!bkpinfo->media_device[0]) {
    22492315                strcpy(bkpinfo->media_device, "/dev/cdrom");
    22502316            }                   // just for the heck of it :)
    2251             log_msg(1, "bkpinfo->media_device = %s", bkpinfo->media_device);
    2252             if (bkpinfo->backup_media_type == dvd || find_cdrom_device(bkpinfo->media_device, FALSE)) {
    2253                 log_msg(1, "bkpinfo->media_device = %s", bkpinfo->media_device);
    2254                 mr_asprintf(comment, "Please specify your %s drive's /dev entry", mds);
    2255                 if (!popup_and_get_string("Device?", comment, bkpinfo->media_device, MAX_STR_LEN / 4)) {
     2317            log_msg(1, "bkpinfo->media_device = %s",
     2318                    bkpinfo->media_device);
     2319            if (bkpinfo->backup_media_type == dvd
     2320                || find_cdrom_device(bkpinfo->media_device, FALSE)) {
     2321                log_msg(1, "bkpinfo->media_device = %s",
     2322                        bkpinfo->media_device);
     2323                sprintf(comment,
     2324                        "Please specify your %s drive's /dev entry", mds);
     2325                if (!popup_and_get_string
     2326                    ("Device?", comment, bkpinfo->media_device,
     2327                     MAX_STR_LEN / 4)) {
    22562328                    log_to_screen("User has chosen not to backup the PC");
    22572329                    finish(1);
     
    23272399            } else {
    23282400                if (does_file_exist("/tmp/mondo-restore.cfg")) {
    2329                     read_cfg_var("/tmp/mondo-restore.cfg", "media-dev", bkpinfo->media_device);
     2401                    read_cfg_var("/tmp/mondo-restore.cfg", "media-dev",
     2402                                 bkpinfo->media_device);
    23302403                }
    23312404            }
     
    23822455                finish(1);
    23832456            }
    2384             if ((bkpinfo->compression_level = which_compression_level()) == -1) {
     2457            if ((bkpinfo->compression_level =
     2458                 which_compression_level()) == -1) {
    23852459                log_to_screen("User has chosen not to backup the PC");
    23862460                finish(1);
     
    23942468        /* Never try to eject a NETFS device */
    23952469        bkpinfo->please_dont_eject = TRUE;
    2396         /*  Force NFS to be the protocol by default */
    2397         if (bkpinfo->netfs_proto == NULL) {
    2398             mr_asprintf(bkpinfo->netfs_proto, "nfs");
    2399         }
    24002470
    24012471        /* Initiate bkpinfo netfs_mount path from running environment if not already done */
    2402         if (!bkpinfo->netfs_mount == NULL) {
    2403             mr_asprintf(bkpinfo->netfs_mount, call_program_and_get_last_line_of_output("mount | grep \":\" | cut -d' ' -f1 | head -n1"));
     2472        if (!bkpinfo->netfs_mount[0]) {
     2473            strcpy(bkpinfo->netfs_mount,
     2474                   call_program_and_get_last_line_of_output
     2475                   ("mount | grep \":\" | cut -d' ' -f1 | head -n1"));
    24042476        }
    24052477#ifdef __FreeBSD__
     
    24122484                ("Network shared dir.",
    24132485                 "Please enter path and directory where archives are stored remotely. (Mondo has taken a guess at the correct value. If it is incorrect, delete it and type the correct one.)",
    2414                  p, MAX_STR_LEN / 4)) {
     2486                 bkpinfo->netfs_mount, MAX_STR_LEN / 4)) {
    24152487                log_to_screen("User has chosen not to backup the PC");
    24162488                finish(1);
    24172489            }
    2418             mr_free(bkpinfo->netfs_mount);
    2419             mr_asprintf(bkpinfo->netfs_mount, "%s", p;
    24202490            if (!bkpinfo->restore_data) {
    24212491                if ((compression_type = which_compression_type()) == NULL) {
     
    24232493                    finish(1);
    24242494                }
    2425 
    2426                 if ((bkpinfo->compression_level = which_compression_level()) == -1) {
     2495                if ((bkpinfo->compression_level =
     2496                    which_compression_level()) == -1) {
    24272497                    log_to_screen("User has chosen not to backup the PC");
    24282498                    finish(1);
     
    24312501            // check whether already mounted - we better remove
    24322502            // surrounding spaces and trailing '/' for this
    2433             mr_strip_spaces(bkpinfo->netfs_mount);
     2503            strip_spaces(bkpinfo->netfs_mount);
    24342504            if (bkpinfo->netfs_mount[strlen(bkpinfo->netfs_mount) - 1] == '/')
    24352505                bkpinfo->netfs_mount[strlen(bkpinfo->netfs_mount) - 1] = '\0';
     
    24432513                strcpy(tmp1,bkpinfo->netfs_mount);
    24442514            }
    2445             mr_asprintf(command, "mount | grep \"%s \" | cut -d' ' -f3", tmp1);
     2515            sprintf(command, "mount | grep \"%s \" | cut -d' ' -f3", tmp1);
    24462516            strcpy(bkpinfo->isodir, call_program_and_get_last_line_of_output(command));
    2447             mr_free(command);
    24482517
    24492518            if (!bkpinfo->restore_data) {
    2450                 mr_sprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE);   // 4.7 salesman's GB = 4.482 real GB = 4482 MB
    2451                 mr_asprintf(comment, "How much data (in Megabytes) will each media store?");
    2452                 strcpy(tmp1, sz_size);
    2453                 mr_free(sz_size);
    2454                 if (!popup_and_get_string("Size", comment, tmp1, 5)) {
     2519                sprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE);  // 4.7 salesman's GB = 4.482 real GB = 4482 MB
     2520                sprintf(comment,
     2521                    "How much data (in Megabytes) will each media store?");
     2522                if (!popup_and_get_string("Size", comment, sz_size, 5)) {
    24552523                    log_to_screen("User has chosen not to backup the PC");
    24562524                    finish(1);
    24572525                }
    2458                 mr_free(comment);
    2459                 mr_asprintf(sz_size, "%s", tmp1);
    24602526            } else {
    2461                 mr_asprintf(sz_size, "0");
     2527                strcpy(sz_size, "0");
    24622528            }
    24632529            bkpinfo->media_size = atoi(sz_size);
    2464             mr_free(sz_size);
    2465 
    24662530            if (bkpinfo->media_size < 0) {
    24672531                log_to_screen("User has chosen not to backup the PC");
     
    24692533            }
    24702534        }
     2535        /*  Force NFS to be the protocol by default */
     2536        if (bkpinfo->netfs_proto == NULL) {
     2537            mr_asprintf(bkpinfo->netfs_proto, "nfs");
     2538        }
    24712539        if (bkpinfo->disaster_recovery) {
    2472             mr_asprintf(command ,"umount %s/isodir 2> /dev/null", bkpinfo->tmpdir);
     2540            sprintf(command ,"umount %s/isodir 2> /dev/null", bkpinfo->tmpdir);
    24732541            paranoid_system(command);
    2474             mr_free(command);
    2475 
    24762542        }
    24772543        strcpy(tmp1, bkpinfo->netfs_proto);
    2478         if (!popup_and_get_string("Network protocol", "Which protocol should I use (nfs/sshfs/smbfs) ?",tmp1, MAX_STR_LEN)) {
     2544        if (!popup_and_get_string
     2545            ("Network protocol", "Which protocol should I use (nfs/sshfs/smbfs) ?",
     2546             tmp1, MAX_STR_LEN)) {
    24792547            log_to_screen("User has chosen not to backup the PC");
    24802548            finish(1);
     
    24822550        mr_free(bkpinfo->netfs_proto);
    24832551        mr_asprintf(bkpinfo->netfs_proto, "%s", tmp1);
    2484 
    2485         strcpy(tmp1, bkpinfo->netfs_mount);
    2486         if (!popup_and_get_string("Network share", "Which remote share should I mount?", tmp1, MAX_STR_LEN)) {
     2552        if (!popup_and_get_string
     2553            ("Network share", "Which remote share should I mount?",
     2554             bkpinfo->netfs_mount, MAX_STR_LEN)) {
    24872555            log_to_screen("User has chosen not to backup the PC");
    24882556            finish(1);
    24892557        }
    2490         mr_free(bkpinfo->netfs_mount);
    2491         mr_asprintf(bkpinfo->netfs_mount, "%s", tmp1);
    24922558
    24932559        if (bkpinfo->netfs_user) {
     
    24962562            strcpy(tmp1, "");
    24972563        }
    2498         if (!popup_and_get_string("Network user", "Which user should I use if any ?",tmp1)) {
     2564        if (!popup_and_get_string
     2565            ("Network user", "Which user should I use if any ?",
     2566             tmp1, MAX_STR_LEN)) {
    24992567            log_to_screen("User has chosen not to backup the PC");
    25002568            finish(1);
     
    25072575        /* Initiate bkpinfo isodir path from running environment if mount already done */
    25082576        if (is_this_device_mounted(bkpinfo->netfs_mount)) {
    2509             strcpy(bkpinfo->isodir, call_program_and_get_last_line_of_output("mount | grep \":\" | cut -d' ' -f3 | head -n1"));
     2577            strcpy(bkpinfo->isodir,
     2578                   call_program_and_get_last_line_of_output
     2579                   ("mount | grep \":\" | cut -d' ' -f3 | head -n1"));
    25102580        } else {
    25112581            sprintf(bkpinfo->isodir, "%s/netfsdir", bkpinfo->tmpdir);
    2512             mr_asprintf(command, "mkdir -p %s", bkpinfo->isodir);
     2582            sprintf(command, "mkdir -p %s", bkpinfo->isodir);
    25132583            run_program_and_log_output(command, 5);
    2514             mr_free(command);
    25152584
    25162585            if (bkpinfo->restore_data) {
     
    25462615        }
    25472616        if (!is_this_device_mounted(bkpinfo->netfs_mount)) {
    2548             popup_and_OK("Please mount that partition before you try to backup to or restore from it.");
     2617            popup_and_OK
     2618                ("Please mount that partition before you try to backup to or restore from it.");
    25492619            finish(1);
    25502620        }
     
    25702640        log_msg(3, "prefix set to %s", bkpinfo->prefix);
    25712641
    2572         log_msg(3, "Just set netfs_remote_dir to %s", bkpinfo->netfs_remote_dir);
     2642        log_msg(3, "Just set netfs_remote_dir to %s",
     2643                bkpinfo->netfs_remote_dir);
    25732644        log_msg(3, "isodir is still %s", bkpinfo->isodir);
    25742645        break;
     
    25882659                    finish(1);
    25892660                }
    2590                 if ((bkpinfo->compression_level = which_compression_level()) == -1) {
     2661                if ((bkpinfo->compression_level =
     2662                     which_compression_level()) == -1) {
    25912663                    log_to_screen("User has chosen not to backup the PC");
    25922664                    finish(1);
    25932665                }
    2594                 sprintf(tmp1, "%d", DEFAULT_DVD_DISK_SIZE); // 4.7 salesman's GB = 4.482 real GB = 4482 MB
     2666                sprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE);  // 4.7 salesman's GB = 4.482 real GB = 4482 MB
    25952667                if (!popup_and_get_string
    25962668                    ("ISO size.",
    25972669                     "Please enter how big you want each ISO image to be (in megabytes). This should be less than or equal to the size of the CD-R[W]'s (700) or DVD's (4480) you plan to backup to.",
    2598                      tmp1, 16)) {
     2670                     sz_size, 16)) {
    25992671                    log_to_screen("User has chosen not to backup the PC");
    26002672                    finish(1);
    26012673                }
    2602                 bkpinfo->media_size = atoi(tmp1);
     2674                bkpinfo->media_size = atoi(sz_size);
    26032675            } else {
    26042676                bkpinfo->media_size = 650;
     
    26512723                finish(1);
    26522724            }
    2653             if (does_string_exist_in_boot_block(bkpinfo->boot_device, "LILO")) {
     2725            if (does_string_exist_in_boot_block
     2726                (bkpinfo->boot_device, "LILO")) {
    26542727                i = 'L';
    26552728            } else
    2656                 if (does_string_exist_in_boot_block(bkpinfo->boot_device, "ELILO")) {
     2729                if (does_string_exist_in_boot_block
     2730                    (bkpinfo->boot_device, "ELILO")) {
    26572731                i = 'E';
    26582732            } else
    2659                 if (does_string_exist_in_boot_block(bkpinfo->boot_device, "GRUB")) {
     2733                if (does_string_exist_in_boot_block
     2734                    (bkpinfo->boot_device, "GRUB")) {
    26602735                i = 'G';
    26612736            } else {
     
    26642739#endif
    26652740            if (i == 'U') {
    2666                 if (ask_me_yes_or_no("Unidentified boot loader. Shall I restore it byte-for-byte at restore time and hope for the best?")) {
     2741                if (ask_me_yes_or_no
     2742                    ("Unidentified boot loader. Shall I restore it byte-for-byte at restore time and hope for the best?"))
     2743                {
    26672744                    i = 'R';    // raw
    26682745                } else {
    2669                     log_to_screen("I cannot find your boot loader. Please run mondoarchive with parameters.");
     2746                    log_to_screen
     2747                        ("I cannot find your boot loader. Please run mondoarchive with parameters.");
    26702748                    finish(1);
    26712749                }
     
    26732751        }
    26742752        bkpinfo->boot_loader = i;
    2675 
    2676         mr_free(bkpinfo->include_paths);
    2677         strcpy(tmp1, "/");
     2753        strcpy(bkpinfo->include_paths, "/");
    26782754        if (!popup_and_get_string
    26792755            ("Backup paths",
    26802756             "Please enter paths (separated by '|') which you want me to backup. The default is '/' (i.e. everything).",
    2681              tmp1, MAX_STR_LEN)) {
     2757             bkpinfo->include_paths, MAX_STR_LEN)) {
    26822758            log_to_screen("User has chosen not to backup the PC");
    26832759            finish(1);
    26842760        }
    2685         mr_asprintf(bkpinfo->include_paths, "%s", tmp1);
    2686 
    26872761        tmp = list_of_NETFS_mounts_only();
    26882762        if (strlen(tmp) > 2) {
     
    27412815        if (ask_me_yes_or_no("Do you want to backup extended attributes?")) {
    27422816            if (find_home_of_exe("getfattr")) {
    2743                 mr_free(g_getfattr);
    27442817                mr_asprintf(g_getfattr,"getfattr");
    27452818            }
    27462819            if (find_home_of_exe("getfacl")) {
    2747                 mr_free(g_getfacl);
    27482820                mr_asprintf(g_getfacl,"getfacl");
    27492821            }
     
    27632835            strcpy(bkpinfo->zip_exe, "gzip");
    27642836            strcpy(bkpinfo->zip_suffix, "gz");
    2765         } else if (strcmp(compression_type,"lzma") == 0) {
     2837        //} else if (strcmp(compression_type,"lzma") == 0) {
    27662838            //strcpy(bkpinfo->zip_exe, "xy");
    27672839            //strcpy(bkpinfo->zip_suffix, "xy");
     
    27772849            ("Will you want to verify your backups after Mondo has created them?");
    27782850
     2851#ifndef __FreeBSD__
     2852        if (!ask_me_yes_or_no
     2853            ("Are you confident that your kernel is a sane, sensible, standard Linux kernel? Say 'no' if you are using a Gentoo <1.4 or Debian <3.0, please."))
     2854#endif
     2855        {
     2856            strcpy(bkpinfo->kernel_path, "FAILSAFE");
     2857        }
     2858
    27792859        if (!ask_me_yes_or_no
    27802860            ("Are you sure you want to proceed? Hit 'no' to abort.")) {
     
    27952875#else
    27962876    if (bkpinfo->backup_media_type == netfs) {
    2797         log_msg(3, "I think the Remote mount is mounted at %s", bkpinfo->isodir);
     2877        log_msg(3, "I think the Remote mount is mounted at %s",
     2878                bkpinfo->isodir);
    27982879    }
    27992880    log_it("isodir = %s", bkpinfo->isodir);
    2800     if (bkpinfo->netfs_mount) {
    2801         log_it("netfs_mount = '%s'", bkpinfo->netfs_mount);
     2881    log_it("netfs_mount = '%s'", bkpinfo->netfs_mount);
     2882    if (bkpinfo->netfs_proto) {
     2883        log_it("netfs_proto = '%s'", bkpinfo->netfs_proto);
    28022884    }
    28032885    if (bkpinfo->netfs_user) {
    28042886        log_it("netfs_user = '%s'", bkpinfo->netfs_user);
    2805     }
    2806     if (bkpinfo->netfs_proto) {
    2807         log_it("netfs_proto = '%s'", bkpinfo->netfs_proto);
    28082887    }
    28092888#endif
     
    28122891    log_it("media size = %ld", bkpinfo->media_size);
    28132892    log_it("media type = %s", bkptype_to_string(bkpinfo->backup_media_type));
    2814     if (bkpinfo->prefix) {
    2815         log_it("prefix = %s", bkpinfo->prefix);
    2816     }
     2893    log_it("prefix = %s", bkpinfo->prefix);
    28172894    log_it("compression = %ld", bkpinfo->compression_level);
    28182895    log_it("exclude_path = %s", bkpinfo->exclude_paths);
     
    28202897
    28212898    /* Handle devices passed in bkpinfo and print result */
    2822     /*  the mr_make_devlist_from_pathlist function appends
    2823     /*  to the *_paths variables so copy before */
     2899    /*  the mr_make_devlist_from_pathlist function appends 
     2900     *  to the *_paths variables so copy before */
    28242901    mr_make_devlist_from_pathlist(bkpinfo->exclude_paths, 'E');
    28252902    mr_make_devlist_from_pathlist(bkpinfo->include_paths, 'I');
     
    28272904    log_it("scratchdir = '%s'", bkpinfo->scratchdir);
    28282905    log_it("tmpdir = '%s'", bkpinfo->tmpdir);
    2829     if (bkpinfo->image_devs) {
    2830         log_it("image_devs = '%s'", bkpinfo->image_devs);
    2831     }
    2832     log_it("boot_device = '%s' (loader=%c)", bkpinfo->boot_device, bkpinfo->boot_loader);
     2906    log_it("image_devs = '%s'", bkpinfo->image_devs);
     2907    log_it("boot_device = '%s' (loader=%c)", bkpinfo->boot_device,
     2908           bkpinfo->boot_loader);
    28332909    if (bkpinfo->media_size < 0) {
    28342910        if (archiving_to_media) {
     
    28412917    paranoid_free(sz_size);
    28422918    paranoid_free(tmp1);
     2919    paranoid_free(command);
     2920    paranoid_free(comment);
     2921    paranoid_free(prompt);
    28432922    return (0);
    28442923}
     
    30913170
    30923171    malloc_string(current_drive);
    3093 
    3094     /* UEFI is not supported here - but should be managed as a BIOS/UEFI option not a Boot Loader one per se */
    30953172
    30963173#ifdef __IA64__
  • branches/3.0/mondo/src/common/libmondo-fifo.c

    r3188 r3192  
    8585    wise_upper_limit = (am_I_in_disaster_recovery_mode()? 8 : 32);
    8686    wise_lower_limit = 1;       // wise_upper_limit/2 + 1;
    87     sync();
     87    paranoid_system("sync");
    8888    for (bufsize = wise_upper_limit, res = -1;
    8989         res != 0 && bufsize >= wise_lower_limit; bufsize--) {
    90         mr_asprintf(tmp,"dd if=/dev/zero bs=1024 count=16k 2> /dev/null | buffer -o /dev/null -s %ld -m %d%c", internal_tape_block_size, bufsize, 'm');
     90        mr_asprintf(tmp,
     91                "dd if=/dev/zero bs=1024 count=16k 2> /dev/null | buffer -o /dev/null -s %ld -m %d%c",
     92                internal_tape_block_size, bufsize, 'm');
    9193        res = run_program_and_log_output(tmp, 2);
    9294        mr_free(tmp);
     
    9496    if (!res) {
    9597        bufsize++;
    96         log_to_screen(tmp, "Negotiated max buffer of %d MB ", bufsize);
     98        mr_asprintf(tmp, "Negotiated max buffer of %d MB ", bufsize);
     99        log_to_screen(tmp);
     100        mr_free(tmp);
    97101    } else {
    98102        bufsize = 0;
     
    162166        return;
    163167    }
    164     sync();
     168    paranoid_system("sync");
    165169    mr_asprintf(command, "ps %s | grep -F \"%s\" | grep -Fv grep | awk '{print $2;}' | grep -v PID | head -1", ps_options, g_sz_call_to_buffer);
    166170    log_msg(2, "kill_buffer() --- command = %s", command);
  • branches/3.0/mondo/src/common/libmondo-filelist.c

    r3188 r3192  
    8686
    8787    /*@ pointers ********************** */
    88     char *ptr = NULL;
     88    char *ptr;
    8989    FILE *fout;
    9090
     
    116116    mr_free(tempfile);
    117117
    118     if (bkpinfo->image_devs) {
    119         log_it("image_devs : %s", bkpinfo->image_devs);
    120 
    121         ptr = bkpinfo->image_devs;
    122 
    123         while (ptr && *ptr) {
    124             mr_asprintf(dev, "%s", ptr);
    125             log_it("Examining imagedev %s", dev);
    126             for (i = 0; i < (int) strlen(dev) && dev[i] != ' '; i++);
    127             dev[i] = '\0';
    128             if (!strlen(dev)) {
    129                 mr_free(dev);
    130                 continue;
    131             }
    132             fprintf(fout, "%s\n", dev);
    133             log_it("Adding '%s' to biggielist", dev);
    134             if ((ptr = strchr(ptr, ' '))) {
    135                 ptr++;
    136             }
    137             mr_free(dev);
     118    log_it(bkpinfo->image_devs);
     119
     120    ptr = bkpinfo->image_devs;
     121
     122    malloc_string(dev);
     123    while (ptr && *ptr) {
     124        strcpy(dev, ptr);
     125        log_it("Examining imagedev %s", dev);
     126        for (i = 0; i < (int) strlen(dev) && dev[i] != ' '; i++);
     127        dev[i] = '\0';
     128        if (!strlen(dev)) {
     129            continue;
     130        }
     131        fprintf(fout, "%s\n", dev);
     132        log_it("Adding '%s' to biggielist", dev);
     133        if ((ptr = strchr(ptr, ' '))) {
     134            ptr++;
    138135        }
    139136    }
     
    141138    mvaddstr_and_log_it(g_currentY++, 74, "Done.");
    142139
     140    paranoid_free(dev);
    143141    return (retval);
    144142}
     
    160158
    161159    mr_asprintf(tmp_fname, "%s/sortfile", bkpinfo->tmpdir);
     160
    162161    mr_asprintf(command, "sort %s > %s 2>> %s", orig_fname, tmp_fname, MONDO_LOGFILE);
    163162    retval = system(command);
     
    332331
    333332    if (curr_set_no == 0) {
    334         log_msg(1, "Only one fileset. Fine.");
     333        mr_asprintf(tmp, "Only one fileset. Fine.");
    335334    } else {
    336         log_msg(1, "Filelist divided into %ld sets", curr_set_no + 1);
    337     }
     335        mr_asprintf(tmp, "Filelist divided into %ld sets", curr_set_no + 1);
     336    }
     337    log_msg(1, tmp);
     338    mr_free(tmp);
    338339    close_evalcall_form();
    339340    /* This is to work around an obscure bug in Newt; open a form, close it,
     
    341342       then update_progress_form() won't show the "time taken / time remaining"
    342343       line. The bug only crops up AFTER the call to chop_filelist(). Weird. */
     344#ifndef _XWIN
    343345    if (!g_text_mode) {
    344346        open_progress_form("", "", "", "", 100);
     
    347349        newtPopWindow();
    348350    }
     351#endif
    349352    return (err ? 0 : curr_set_no + 1);
    350353}
     
    407410int call_exe_and_pipe_output_to_fd(char *syscall, FILE * pout)
    408411{
    409     FILE *pattr = NULL;
    410     char *tmp = NULL;
     412    FILE *pattr;
     413    char *tmp;
     414    char *p;
    411415
    412416    pattr = popen(syscall, "r");
     
    420424        return (2);
    421425    }
    422     for (mr_getline(tmp, pattr); !feof(pattr); mr_getline(tmp, pattr)) {
     426    malloc_string(tmp);
     427    for (p = fgets(tmp, MAX_STR_LEN, pattr); !feof(pattr) && (p != NULL);
     428         p = fgets(tmp, MAX_STR_LEN, pattr)) {
    423429        fputs(tmp, pout);
    424         mr_free(tmp);
    425     }
    426     mr_free(tmp);
     430    }
    427431    paranoid_pclose(pattr);
     432    paranoid_free(tmp);
    428433    return (0);
    429434}
     
    434439                 char *auxlist_fname)
    435440{
    436     FILE *fin = NULL;
    437     FILE *pout = NULL;
     441    FILE *fin;
     442    FILE *pout;
    438443    char *pout_command = NULL;
    439     char *syscall = NULL;
    440     char *file_to_analyze = NULL;
     444    char *syscall;
     445    char *file_to_analyze;
    441446    char *strtmp = NULL;
    442447    char *tmp = NULL;
     448    char *p = NULL;
    443449    int i;
    444450
     
    456462    mr_free(pout_command);
    457463
    458     for (mr_getline(file_to_analyze, fin); !feof(fin); mr_getline(file_to_analyze, fin)) {
     464    malloc_string(file_to_analyze);
     465    for (p = fgets(file_to_analyze, MAX_STR_LEN, fin); !feof(fin) && (p != NULL);
     466         p = fgets(file_to_analyze, MAX_STR_LEN, fin)) {
    459467        i = strlen(file_to_analyze);
    460468        if (i > 0 && file_to_analyze[i - 1] < 32) {
     
    464472        tmp = mr_stresc(file_to_analyze, "'", '\\', '\'');
    465473        mr_asprintf(syscall, "%s '%s' 2>> /dev/null", syscall_sprintf, tmp);    // " MONDO_LOGFILE);
    466         mr_free(tmp);
     474        paranoid_free(tmp);
    467475        log_msg(20,"calling %s\n",syscall);
    468476        call_exe_and_pipe_output_to_fd(syscall, pout);
    469         mr_free(syscall);
    470         mr_free(file_to_analyze);
    471     }
    472     mr_free(file_to_analyze);
     477        paranoid_free(syscall);
     478    }
    473479    paranoid_fclose(fin);
    474480    paranoid_pclose(pout);
     481    paranoid_free(file_to_analyze);
    475482    return (0);
    476483}
     
    515522    char *syscall_pin = NULL;
    516523    char *syscall_pout = NULL;
    517     char *incoming = NULL;
    518     char *current_subset_file = NULL;
    519     char *current_master_file = NULL;
     524    char *incoming;
     525    char *current_subset_file, *current_master_file;
    520526    char *masklist = NULL;
    521527    int retval = 0;
    522528    int i;
    523     char *p, *q;
     529    char *p, *q, *r;
    524530    char *tmp = NULL;
    525531    FILE *pin, *pout, *faclin;
    526532
    527     log_msg(1, "set_EXAT_list(%s, %s, %s)", orig_msklist, original_exat_fname, executable);
     533    log_msg(1, "set_EXAT_list(%s, %s, %s)", orig_msklist,
     534            original_exat_fname, executable);
    528535    if (!orig_msklist || !orig_msklist[0]
    529536        || !does_file_exist(orig_msklist)) {
     
    545552    }
    546553    if (length_of_file(original_exat_fname) <= 0) {
    547         log_msg(1, "original_exat_fname %s is empty or missing, so no need to set EXAT list", original_exat_fname);
     554        log_msg(1,
     555                "original_exat_fname %s is empty or missing, so no need to set EXAT list",
     556                original_exat_fname);
    548557        return (0);
    549558    }
     559    malloc_string(incoming);
     560    malloc_string(current_subset_file);
     561    malloc_string(current_master_file);
    550562    mr_asprintf(masklist, "%s/masklist", bkpinfo->tmpdir);
    551563    mr_asprintf(command, "cp -f %s %s", orig_msklist, masklist);
     
    554566
    555567    sort_file(masklist);
     568    current_subset_file[0] = current_master_file[0] = '\0';
    556569
    557570    mr_asprintf(syscall_pout, "%s --restore - 2>> %s", executable, MONDO_LOGFILE);
     
    586599//  printf("Hi there. Starting the loop\n");
    587600
    588     mr_getline(current_subset_file, faclin);
    589     mr_getline(incoming, pin);
    590     while (!feof(pin) && !feof(faclin)) {
    591         mr_asprintf(current_master_file, "%s", incoming + 8);
     601    r = fgets(current_subset_file, MAX_STR_LEN, faclin);
     602    r = fgets(incoming, MAX_STR_LEN, pin);
     603    while (!feof(pin) && !feof(faclin) && (r != NULL)) {
     604//      printf("incoming = %s", incoming);
     605
     606        strcpy(current_master_file, incoming + 8);
    592607
    593608        p = current_subset_file;
     
    617632        if (i < 0) {            // read another subset file in.
    618633            log_msg(my_depth, "Reading next subset line in\n\n");
    619             mr_free(current_subset_file);
    620             mr_getline(current_subset_file, faclin);
     634            r = fgets(current_subset_file, MAX_STR_LEN, faclin);
    621635            continue;
    622636        }
     
    625639            fputs(incoming, pout);
    626640        }
    627         mr_free(incoming);
    628         mr_getline(incoming, pin);
     641        r = fgets(incoming, MAX_STR_LEN, pin);
    629642        if (!i) {
    630643            log_msg(my_depth, "Copying master %s", q);
    631644        }
     645//      if (!i) { printf("Match --- %s\n", q); }
    632646
    633647        while (!feof(pin) && strncmp(incoming, "# file: ", 8)) {
    634648            if (!i) {
     649
     650//    printf("%s", incoming);
     651
    635652                fputs(incoming, pout);
    636653            }
    637             mr_free(incoming);
    638             mr_getline(incoming, pin);
     654            r = fgets(incoming, MAX_STR_LEN, pin);
    639655        }
    640656        if (!i) {
    641             mr_free(current_subset_file);
    642             mr_getline(current_subset_file, faclin);
    643         }
    644         mr_free(current_master_file);
    645     }
    646     mr_free(current_subset_file);
    647     mr_free(incoming);
     657            r = fgets(current_subset_file, MAX_STR_LEN, faclin);
     658        }
     659    }
     660    while (!feof(pin)) {
     661        r = fgets(incoming, MAX_STR_LEN, pin);
     662    }
    648663    fclose(faclin);
    649664    pclose(pin);
    650665    pclose(pout);
    651666
     667//  printf("OK, loop is done\n");
     668
    652669    unlink(masklist);
    653670    mr_free(masklist);
    654671
     672    paranoid_free(current_subset_file);
     673    paranoid_free(current_master_file);
     674    paranoid_free(incoming);
    655675    return (retval);
    656676}
     
    750770    noof_chars = strlen(string_to_add) + 1; /* we include the '\0' */
    751771
    752     /* walk across tree if necessary */
     772/* walk across tree if necessary */
    753773    node = startnode;
    754774    char_to_add = string_to_add[0];
     
    759779    }
    760780
    761     /* walk down tree if appropriate */
     781/* walk down tree if appropriate */
    762782    if (node->down != NULL && node->ch == char_to_add) {
    763783        log_msg(7, "depth=%d char=%c --- going DOWN", depth, char_to_add);
     
    773793    }
    774794
    775     /* add here */
     795/* add here */
    776796    if (!(newnode = (struct s_node *) malloc(sizeof(struct s_node)))) {
    777797        log_to_screen("failed to malloc");
     
    844864    /*@ buffers **************************************************** */
    845865    char *command_to_open_fname = NULL;
    846     char *fname = NULL;
    847     char *tmp = NULL;
     866    char fname[MAX_STR_LEN];
     867    char tmp[MAX_STR_LEN];
    848868    char *tmp1 = NULL;
    849869    int pos_in_fname;
     
    891911
    892912    open_evalcall_form("Loading filelist from disk");
    893     for (mr_getline(fname, pin); !feof(pin); mr_getline(fname, pin)) {
    894         if ((strlen(fname) > 0) && (fname[strlen(fname) - 1] == 13 || fname[strlen(fname) - 1] == 10)) {
     913    for (tmp1 = fgets(fname, MAX_STR_LEN, pin); !feof(pin);
     914         tmp1 = fgets(fname, MAX_STR_LEN, pin)) {
     915        if (((fname[strlen(fname) - 1] == 13) || (fname[strlen(fname) - 1] == 10)) && (strlen(fname) > 0)) {
    895916            fname[strlen(fname) - 1] = '\0';
    896917        }
     918//      strip_spaces (fname);
    897919        if (!strlen(fname)) {
    898             mr_free(fname);
    899920            continue;
    900921        }
     
    903924                continue;
    904925            }
    905             mr_asprintf(tmp, "%s", fname);
     926            strcpy(tmp, fname);
    906927            tmp[pos_in_fname] = '\0';
    907928            if (strlen(tmp)) {
    908929                add_string_at_node(filelist, tmp);
    909930            }
    910             mr_free(tmp);
    911931        }
    912932        add_string_at_node(filelist, fname);
    913 
    914933        if (!(++lino % 1111)) {
    915934            percentage = (int) (lino * 100 / lines_in_filelist);
    916935            update_evalcall_form(percentage);
    917936        }
    918         mr_free(fname);
    919     }
    920     mr_free(fname);
    921 
     937    }
    922938    paranoid_pclose(pin);
    923939    close_evalcall_form();
     
    12811297
    12821298
     1299
     1300
    12831301/**
    12841302 * Number of entries in the skeleton filelist.
     
    12961314 * @bug Return value should be @c void.
    12971315 */
    1298 int open_and_list_dir(char *dir1, char *sth, FILE * fout, time_t time_of_last_full_backup) {
    1299 
     1316int open_and_list_dir(char *dir1, char *sth, FILE * fout,
     1317                      time_t time_of_last_full_backup)
     1318{
    13001319    const char delims[] = "|";
    13011320
     
    13041323    struct stat statbuf;
    13051324    char *new;
    1306     char *tmp = NULL;
     1325    char *tmp;
    13071326    char *dir = NULL;
    13081327    static int percentage = 0;
    1309     char *skip_these = NULL;
     1328    char *skip_these;
    13101329    char *new_with_pipe;
    13111330    char *strtmp = NULL;
    13121331    char *token = NULL;
    13131332    char *find_excludes = NULL;
    1314     char *name_of_evalcall_form = NULL;
    1315     char *find_skeleton_marker = NULL;
     1333    static char *name_of_evalcall_form;
    13161334    int i;
    13171335    int lastpos = 0;
     
    13201338    static int counter = 0;
    13211339    static int uberctr = 0;
    1322     static long skeleton_lino = 0L;
    1323     static time_t last_time = (time_t)0;
     1340    static char *find_skeleton_marker;
     1341    static long skeleton_lino = 0;
     1342    static time_t last_time = 0;
    13241343    time_t this_time;
    13251344
     
    13361355
    13371356    if (!depth) {
     1357        malloc_string(name_of_evalcall_form);
     1358        malloc_string(find_skeleton_marker);
    13381359        while((token = mr_strtok(sth, delims, &lastpos)) != NULL) {
    13391360          mr_strcat(find_excludes," -path %s -prune -o", token);
     
    13541375        mr_asprintf(strtmp, "find '%s' -maxdepth %d -fstype mvfs -prune -o -path /proc -prune -o %s -type d -print > %s 2> /dev/null", dir, MAX_SKEL_DEPTH, find_excludes, g_skeleton_filelist);
    13551376#endif
    1356         mr_free(find_excludes);
    1357 
     1377        paranoid_free(find_excludes);
    13581378        log_msg(5, "find command = %s", strtmp);
    13591379        paranoid_system(strtmp);
    1360         mr_free(strtmp);
    1361 
     1380        paranoid_free(strtmp);
    13621381        mr_asprintf(tmp, "wc -l %s | awk '{print $1;}'", g_skeleton_filelist);
    1363         g_skeleton_entries = 1 + atol(call_program_and_get_last_line_of_output(tmp));
    1364         mr_free(tmp);
    1365 
    1366         mr_asprintf(name_of_evalcall_form, "Making catalog of %s", dir1);
     1382        g_skeleton_entries =
     1383            1 + atol(call_program_and_get_last_line_of_output(tmp));
     1384        paranoid_free(tmp);
     1385        sprintf(name_of_evalcall_form, "Making catalog of %s", dir1);
    13671386        open_evalcall_form(name_of_evalcall_form);
    1368         mr_free(name_of_evalcall_form);
    1369 
     1387        find_skeleton_marker[0] = '\0';
    13701388        skeleton_lino = 1;
    13711389        log_msg(5, "entries = %ld", g_skeleton_entries);
     
    13731391    } else if (depth <= MAX_SKEL_DEPTH) // update evalcall form if appropriate
    13741392    {
    1375         mr_asprintf(find_skeleton_marker, "grep -Fv '%s' %s > %s.new 2> /dev/null", dir, g_skeleton_filelist, g_skeleton_filelist);
     1393        sprintf(find_skeleton_marker,
     1394                "grep -Fv '%s' %s > %s.new 2> /dev/null", dir,
     1395                g_skeleton_filelist, g_skeleton_filelist);
     1396//    log_msg(0, "fsm = %s", find_skeleton_marker);
    13761397        if (!system(find_skeleton_marker)) {
    13771398            percentage = (int) (skeleton_lino * 100 / g_skeleton_entries);
    13781399            skeleton_lino++;
    1379             mr_free(find_skeleton_marker);
    1380 
    1381             mr_asprintf(find_skeleton_marker, "mv -f %s.new %s", g_skeleton_filelist, g_skeleton_filelist);
     1400//        log_msg(5, "Found %s", dir);
     1401//        log_msg(2, "Incrementing skeleton_lino; now %ld/%ld (%d%%)", skeleton_lino, g_skeleton_entries, percentage);
     1402            sprintf(find_skeleton_marker, "mv -f %s.new %s",
     1403                    g_skeleton_filelist, g_skeleton_filelist);
     1404//        log_msg(6, "fsm = %s", find_skeleton_marker);
    13821405            paranoid_system(find_skeleton_marker);
    13831406            time(&this_time);
    13841407            if (this_time != last_time) {
    13851408                last_time = this_time;
     1409#ifndef _XWIN
    13861410                if (!g_text_mode) {
    13871411                    int cols, rows;
     
    13911415                    mr_free(tmp);
    13921416                }
     1417#endif
    13931418                update_evalcall_form(percentage);
    13941419            }
    13951420        }
    1396         mr_free(find_skeleton_marker);
    13971421    }
    13981422
     
    14061430        mr_asprintf(tmp,"opendir %s", dir1);
    14071431        log_OS_error(tmp);
    1408         mr_free(tmp);
     1432        paranoid_free(tmp);
    14091433    } else if (strstr(skip_these, new_with_pipe)) {
    14101434        log_msg(10, "Found dir ***%s**** excluded", dir1);
     
    14201444                mr_asprintf(new,"%s%s",dir1,dit->d_name);
    14211445            }
    1422             mr_free(new_with_pipe);
     1446            paranoid_free(new_with_pipe);
    14231447            mr_asprintf(new_with_pipe, "|%s|", new);
    14241448            if (strstr(skip_these, new_with_pipe)) {
    14251449                fprintf(fout, "%s\n", new);
    14261450                log_msg(10, "Found child dir ***%s**** excluded", new);
    1427                 mr_free(new_with_pipe);
     1451                paranoid_free(new_with_pipe);
    14281452            } else {
    1429                 mr_free(new_with_pipe);
     1453                paranoid_free(new_with_pipe);
    14301454                if (!lstat(new, &statbuf)) {
    14311455                    if (!S_ISLNK(statbuf.st_mode)
    14321456                        && S_ISDIR(statbuf.st_mode)) {
    14331457                        log_msg(10, "Found child dir ***%s**** parsed", new);
    1434                         open_and_list_dir(new, skip_these, fout, time_of_last_full_backup);
     1458                        open_and_list_dir(new, skip_these, fout,
     1459                                          time_of_last_full_backup);
    14351460                    } else {
    1436                         if (time_of_last_full_backup == 0 || time_of_last_full_backup < statbuf.st_ctime) {
     1461                        if (time_of_last_full_backup == 0
     1462                            || time_of_last_full_backup <
     1463                            statbuf.st_ctime) {
    14371464                            log_msg(10, "Found child file ***%s**** parsed", new);
    14381465                            fprintf(fout, "%s\n", new);
     
    14411468                                uberctr++;
    14421469                                mr_asprintf(tmp, " %c ", special_dot_char(uberctr));
     1470#ifndef _XWIN
    14431471                                if (!g_text_mode) {
    1444                                     newtDrawRootText(77, g_noof_rows - 3, tmp);
     1472                                    newtDrawRootText(77, g_noof_rows - 3,
     1473                                                     tmp);
    14451474                                    newtRefresh();
    14461475                                }
    1447                                 mr_free(tmp);
     1476#endif
     1477                                paranoid_free(tmp);
    14481478                            }
    14491479                        }
     
    14511481                }
    14521482            }
    1453             mr_free(new);
    1454         }
    1455     }
    1456     mr_free(new_with_pipe);
    1457     mr_free(skip_these);
     1483            paranoid_free(new);
     1484        }
     1485    }
     1486    paranoid_free(new_with_pipe);
     1487    paranoid_free(skip_these);
    14581488    mr_free(dir);
    14591489
     
    14661496    if (!depth) {
    14671497        close_evalcall_form();
     1498        paranoid_free(name_of_evalcall_form);
     1499        paranoid_free(find_skeleton_marker);
    14681500        unlink(g_skeleton_filelist);
    14691501        log_msg(5, "g_skeleton_entries = %ld", g_skeleton_entries);
     
    14931525    char *p, *q;
    14941526    char *sz_datefile;
    1495     char *sz_filelist;
     1527    char *sz_filelist, *tmp;
    14961528    char *exclude_paths = NULL;
    14971529    FILE *fout;
     
    15021534    char *tmp2 = NULL;
    15031535
     1536    malloc_string(tmp);
     1537    malloc_string(g_skeleton_filelist);
    15041538    mr_asprintf(sz_datefile,MONDO_CACHE"/difflevel.%d" , 0);
    15051539    if (!include_paths && !userdef_filelist) {
    1506         fatal_error("Please supply either include_paths or userdef_filelist");
    1507     }
    1508     // make hole for filelist
     1540        fatal_error
     1541            ("Please supply either include_paths or userdef_filelist");
     1542    }
     1543// make hole for filelist
    15091544    mr_asprintf(command, "mkdir -p %s/archives", scratchdir);
    15101545    paranoid_system(command);
     
    15221557        // backup last known good datefile just in case :)
    15231558        if (does_file_exist(sz_datefile)) {
    1524             mr_asprintf(command, "mv -f %s %s.aborted", sz_datefile, sz_datefile);
     1559            mr_asprintf(command, "mv -f %s %s.aborted", sz_datefile,
     1560                    sz_datefile);
    15251561            paranoid_system(command);
    15261562            mr_free(command);
     
    15311567                                  ("date +%s"));
    15321568    } else if (lstat(sz_datefile, &statbuf)) {
    1533         log_msg(2, "Warning - unable to find date of previous backup. Full backup instead.");
     1569        log_msg(2,
     1570                "Warning - unable to find date of previous backup. Full backup instead.");
    15341571        differential = 0;
    15351572        time_of_last_full_backup = 0;
     
    15421579// use user-specified filelist (if specified)
    15431580    if (userdef_filelist) {
    1544         log_msg(1, "Using the user-specified filelist - %s - instead of calculating one", userdef_filelist);
     1581        log_msg(1,
     1582                "Using the user-specified filelist - %s - instead of calculating one",
     1583                userdef_filelist);
    15451584        mr_asprintf(command, "cp -f %s %s", userdef_filelist, sz_filelist);
    15461585        if (run_program_and_log_output(command, 3)) {
     
    15501589        mr_free(command);
    15511590    } else {
    1552         if (include_paths) {
    1553             log_msg(2, "include_paths = '%s'", include_paths);
    1554         }
     1591        log_msg(2, "include_paths = '%s'", include_paths);
    15551592        log_msg(1, "Calculating filelist");
    15561593        mr_asprintf(tmp2, "%s", call_program_and_get_last_line_of_output("mount | grep -Ew 'ntfs|ntfs-3g|fat|vfat|dos' | awk '{print $3}'"));
     
    15601597            log_msg(2, "Found windows FS: %s",tmp2);
    15611598            mr_asprintf(tmp1, "find %s -name '/win386.swp' -o -name '/hiberfil.sys' -o -name '/pagefile.sys' 2> /dev/null\n",tmp2);
    1562             mr_free(tmp2);
     1599            paranoid_free(tmp2);
    15631600            mr_asprintf(tmp2, "%s", call_program_and_get_last_line_of_output(tmp1));
    15641601            log_msg(2, "Found windows files: %s",tmp2);
    15651602        }
    1566         mr_free(tmp1);
     1603        paranoid_free(tmp1);
    15671604
    15681605        mr_asprintf(exclude_paths, MONDO_CACHE"|%s|%s|%s|.|..|"MNT_CDROM"|"MNT_FLOPPY"|/media|/tmp|/proc|/sys|/run|/dev/shm|"MINDI_CACHE, tmp2, (tmpdir[0] == '/' && tmpdir[1] == '/') ? (tmpdir + 1) : tmpdir, (scratchdir[0] == '/' && scratchdir[1] == '/') ? (scratchdir + 1) : scratchdir);
     
    15701607            mr_strcat(exclude_paths,"|%s",excp);
    15711608        }
    1572         mr_free(tmp2);
     1609        paranoid_free(tmp2);
    15731610
    15741611        log_msg(2, "Excluding paths = '%s'", exclude_paths);
    1575         log_msg(2, "Generating skeleton filelist so that we can track our progress");
    1576         mr_asprintf(g_skeleton_filelist, "%s/tmpfs/skeleton.txt", tmpdir);
     1612        log_msg(2,
     1613                "Generating skeleton filelist so that we can track our progress");
     1614        sprintf(g_skeleton_filelist, "%s/tmpfs/skeleton.txt", tmpdir);
    15771615        make_hole_for_file(g_skeleton_filelist);
    1578 
    15791616        log_msg(4, "g_skeleton_entries = %ld", g_skeleton_entries);
    15801617        log_msg(2, "Opening out filelist to %s", sz_filelist);
     
    15821619            fatal_error("Cannot openout to sz_filelist");
    15831620        }
    1584         if ((include_paths != NULL) && (strlen(include_paths) == 0)) {
     1621        if (strlen(include_paths) == 0) {
    15851622            log_msg(1, "Including only '/' in %s", sz_filelist);
    15861623            open_and_list_dir("/", exclude_paths, fout,
     
    16001637            }
    16011638        }
    1602         mr_free(exclude_paths);
    16031639        paranoid_fclose(fout);
    16041640    }
     
    16181654    paranoid_free(sz_filelist);
    16191655    log_msg(2, "Freeing variables");
    1620     mr_free(g_skeleton_filelist);
     1656    paranoid_free(exclude_paths);
     1657    paranoid_free(tmp);
     1658    paranoid_free(g_skeleton_filelist);
    16211659    log_msg(2, "Exiting");
    16221660    return (0);
    16231661}
    1624 
    16251662
    16261663/**
     
    16431680
    16441681    assert(bkpinfo != NULL);
    1645     log_it("tmpdir=%s; scratchdir=%s", bkpinfo->tmpdir, bkpinfo->scratchdir);
     1682    log_it("tmpdir=%s; scratchdir=%s", bkpinfo->tmpdir,
     1683           bkpinfo->scratchdir);
    16461684    if (bkpinfo->make_filelist) {
    16471685        mvaddstr_and_log_it(g_currentY, 0,
     
    17541792    FILE *fin;
    17551793    FILE *fout;
    1756     char *fname = NULL;
    1757     char *tmp = NULL;
    1758 
     1794    char *fname;
     1795    char *tmp;
     1796    size_t len = 0;             // Scrub's patch doesn't work without that
     1797
     1798//  log_msg(1, "use_star = %s", (use_star)?"TRUE":"FALSE");
     1799    malloc_string(fname);
     1800    malloc_string(tmp);
    17591801    log_msg(5, "starting");
    17601802    log_msg(5, "needles_list_fname = %s", needles_list_fname);
     
    17671809    }
    17681810    while (!feof(fin)) {
    1769         mr_getline(fname, fin);
     1811//      fscanf(fin, "%s\n", fname);
     1812        len = MAX_STR_LEN - 1;
     1813        if (getline(&fname, &len, fin)) {
     1814            // FIXME
     1815        }
    17701816        if (!use_star) {
    17711817            if (fname[0] == '/') {
    1772                 mr_asprintf(tmp, "%s", fname);
     1818                strcpy(tmp, fname);
    17731819            } else {
    1774                 mr_asprintf(tmp, "/%s", fname);
     1820                tmp[0] = '/';
     1821                strcpy(tmp + 1, fname);
    17751822            }
    1776             mr_free(fname);
    1777             fname = tmp;
     1823            strcpy(fname, tmp);
    17781824        }
    17791825        while (strlen(fname) > 0 && fname[strlen(fname) - 1] < 32) {
     
    17861832            if (found_node->selected) {
    17871833                if (fname[0] == '/') {
    1788                     mr_asprintf(tmp, "%s", fname + 1);
    1789                     mr_free(fname);
    1790                     fname = tmp;
     1834                    strcpy(tmp, fname + 1);
     1835                    strcpy(fname, tmp);
    17911836                }
    17921837                log_msg(5, "Found '%s'", fname);
    1793                 tmp = mr_stresc(fname, "[]*?", '\\', "'");
    1794                 mr_free(fname);
    1795                 fname = tmp;
    1796                 fprintf(fout, "%s\n", fname);
     1838                turn_wildcard_chars_into_literal_chars(tmp, fname);
     1839                fprintf(fout, "%s\n", tmp);
    17971840                retval++;
    1798