Ignore:
Timestamp:
Jun 3, 2009, 7:10:28 PM (15 years ago)
Author:
Bruno Cornec
Message:

r3094@localhost: bruno | 2009-06-03 17:25:25 +0200

Replaces strcpy in 5 source where no other impact by mr_asprintf. Improves quality report

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r2211 r2214  
    508508{
    509509    /*@ buffer ************************************************************ */
    510     char *tmp;
     510    char *tmp = NULL;
    511511    char *tmp1 = NULL;
    512512    char *tmp2 = NULL;
    513     char *scratchdir;
    514513    char *command = NULL;
    515     char *use_lzo_sz;
    516     char *use_gzip_sz;
    517     char *use_comp_sz;
    518     char *use_star_sz;
    519     char *bootldr_str;
    520     char *tape_device;
    521     char *last_filelist_number;
    522     char *broken_bios_sz;
    523     char *cd_recovery_sz;
    524     char *tape_size_sz;
    525     char *devs_to_exclude;
    526     char *use_lilo_sz;
    527     char *value;
    528     char *bootdev;
     514    char *use_lzo_sz = NULL;
     515    char *use_gzip_sz = NULL;
     516    char *use_comp_sz = NULL;
     517    char *use_star_sz = NULL;
     518    char *bootldr_str = NULL;
     519    char *tape_device = NULL;
     520    char *last_filelist_number = NULL;
     521    char *broken_bios_sz = NULL;
     522    char *cd_recovery_sz = NULL;
     523    char *tape_size_sz = NULL;
     524    char *devs_to_exclude = NULL;
     525    char *use_lilo_sz = NULL;   /* BCO: shared between LILO/ELILO */
     526    char *value = NULL;
     527    char *bootdev = NULL;
    529528    char *ntapedev = NULL;
    530529
    … …  
    542541
    543542    assert(bkpinfo != NULL);
    544     tmp = malloc(9*MAX_STR_LEN);
    545     malloc_string(scratchdir);
    546     malloc_string(use_lzo_sz);
    547     malloc_string(use_gzip_sz);
    548     malloc_string(use_star_sz);
    549     malloc_string(use_comp_sz);
    550     malloc_string(bootldr_str);
    551     malloc_string(tape_device);
    552543    malloc_string(last_filelist_number);
    553     malloc_string(broken_bios_sz);
    554     malloc_string(cd_recovery_sz);
    555     malloc_string(tape_size_sz);
    556     malloc_string(devs_to_exclude);
    557     malloc_string(use_lilo_sz); /* BCO: shared between LILO/ELILO */
    558     malloc_string(value);
    559     malloc_string(bootdev);
    560 
    561     strcpy(scratchdir, bkpinfo->scratchdir);
    562     sprintf(tmp,
     544
     545    mr_asprintf(&tmp,
    563546            "echo '%s' | tr -s ' ' '\n' | grep -E '^/dev/.*$' | tr -s '\n' ' ' | awk '{print $0\"\\n\";}'",
    564547            bkpinfo->exclude_paths);
    565     strcpy(devs_to_exclude, call_program_and_get_last_line_of_output(tmp));
    566     sprintf(tmp, "devs_to_exclude = '%s'", devs_to_exclude);
     548    mr_asprintf(&devs_to_exclude, "%s", call_program_and_get_last_line_of_output(tmp));
     549    mr_free(tmp);
     550
     551    mr_asprintf(&tmp, "devs_to_exclude = '%s'", devs_to_exclude);
    567552    log_msg(2, tmp);
     553    mr_free(tmp);
     554
    568555    mvaddstr_and_log_it(g_currentY, 0,
    569556                        "Calling MINDI to create boot+data disks");
    570     sprintf(tmp, "%s/filelist.full", bkpinfo->tmpdir);
     557    mr_asprintf(&tmp, "%s/filelist.full", bkpinfo->tmpdir);
    571558    if (!does_file_exist(tmp)) {
    572         sprintf(tmp, "%s/tmpfs/filelist.full", bkpinfo->tmpdir);
     559        mr_free(tmp);
     560        mr_asprintf(&tmp, "%s/tmpfs/filelist.full", bkpinfo->tmpdir);
    573561        if (!does_file_exist(tmp)) {
    574562            fatal_error
    … …  
    577565    }
    578566    lines_in_filelist = count_lines_in_file(tmp);
    579     sprintf(tmp, "%s/LAST-FILELIST-NUMBER", bkpinfo->tmpdir);
    580     strcpy(last_filelist_number, last_line_of_file(tmp));
     567    mr_free(tmp);
     568
     569    mr_asprintf(&tmp, "%s/LAST-FILELIST-NUMBER", bkpinfo->tmpdir);
     570    mr_asprintf(&last_filelist_number, "%s", last_line_of_file(tmp));
     571    mr_free(tmp);
     572
    581573    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
    582         sprintf(tape_size_sz, "%ld", bkpinfo->media_size[1]);
     574        mr_asprintf(&tape_size_sz, "%ld", bkpinfo->media_size[1]);
    583575        ntapedev = get_non_rewind_dev(bkpinfo->media_device);
    584576        if ((bkpinfo->use_obdr) && (ntapedev != NULL)) {
    … …  
    590582        }
    591583        paranoid_free(ntapedev);
    592         strcpy(tape_device, bkpinfo->media_device);
     584        mr_asprintf(&tape_device, "%s", bkpinfo->media_device);
    593585    } else {
    594         tape_size_sz[0] = '\0';
    595         tape_device[0] = '\0';
     586        mr_asprintf(&tape_size_sz, "%ld", 0L);;
     587        mr_asprintf(&tape_device, "");
    596588    }
    597589    if (bkpinfo->use_lzo) {
    598         strcpy(use_lzo_sz, "yes");
     590        mr_asprintf(&use_lzo_sz, "yes");
    599591    } else {
    600         strcpy(use_lzo_sz, "no");
     592        mr_asprintf(&use_lzo_sz, "no");
    601593    }
    602594    if (bkpinfo->use_gzip) {
    603         strcpy(use_gzip_sz, "yes");
     595        mr_asprintf(&use_gzip_sz, "yes");
    604596    } else {
    605         strcpy(use_gzip_sz, "no");
     597        mr_asprintf(&use_gzip_sz, "no");
    606598    }
    607599    if (bkpinfo->use_star) {
    608         strcpy(use_star_sz, "yes");
     600        mr_asprintf(&use_star_sz, "yes");
    609601    } else {
    610         strcpy(use_star_sz, "no");
     602        mr_asprintf(&use_star_sz, "no");
    611603    }
    612604
    613605    if (bkpinfo->compression_level > 0) {
    614         strcpy(use_comp_sz, "yes");
     606        mr_asprintf(&use_comp_sz, "yes");
    615607    } else {
    616         strcpy(use_comp_sz, "no");
    617     }
    618 
    619     strcpy(broken_bios_sz, "yes");  /* assume so */
     608        mr_asprintf(&use_comp_sz, "no");
     609    }
     610
     611    mr_asprintf(&broken_bios_sz, "yes");    /* assume so */
    620612    if (g_cd_recovery) {
    621         strcpy(cd_recovery_sz, "yes");
     613        mr_asprintf(&cd_recovery_sz, "yes");
    622614    } else {
    623         strcpy(cd_recovery_sz, "no");
     615        mr_asprintf(&cd_recovery_sz, "no");
    624616    }
    625617    if (bkpinfo->make_cd_use_lilo) {
    626         strcpy(use_lilo_sz, "yes");
     618        mr_asprintf(&use_lilo_sz, "yes");
    627619    } else {
    628         strcpy(use_lilo_sz, "no");
     620        mr_asprintf(&use_lilo_sz, "no");
    629621    }
    630622
    … …  
    634626
    635627#ifdef __FreeBSD__
    636         strcpy(bootdev, call_program_and_get_last_line_of_output
     628        mr_asprintf(&bootdev, call_program_and_get_last_line_of_output
    637629               ("mount | grep ' /boot ' | head -1 | cut -d' ' -f1 | sed 's/\\([0-9]\\).*/\\1/'"));
    638630        if (!bootdev[0]) {
    639             strcpy(bootdev, call_program_and_get_last_line_of_output
     631            mr_free(bootdev);
     632            mr_asprintf(&bootdev, call_program_and_get_last_line_of_output
    640633                   ("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/\\([0-9]\\).*/\\1/'"));
    641634        }
    … …  
    643636        /* Linux */
    644637#ifdef __IA64__
    645         strcpy(bootdev, call_program_and_get_last_line_of_output
     638        mr_asprintf(&bootdev, call_program_and_get_last_line_of_output
    646639               ("mount | grep ' /boot/efi ' | head -1 | cut -d' ' -f1 | sed 's/[0-9].*//'"));
    647640#else
    648         strcpy(bootdev, call_program_and_get_last_line_of_output
     641        mr_asprintf(&bootdev, call_program_and_get_last_line_of_output
    649642               ("mount | grep ' /boot ' | head -1 | cut -d' ' -f1 | sed 's/[0-9].*//'"));
    650643#endif
    651644        if (strstr(bootdev, "/dev/cciss/")) {
     645            mr_free(bootdev);
    652646#ifdef __IA64__
    653             strcpy(bootdev, call_program_and_get_last_line_of_output
     647            mr_asprintf(&bootdev, call_program_and_get_last_line_of_output
    654648                   ("mount | grep ' /boot/efi ' | head -1 | cut -d' ' -f1 | cut -dp -f1"));
    655649#else
    656             strcpy(bootdev, call_program_and_get_last_line_of_output
     650            mr_asprintf(&bootdev, call_program_and_get_last_line_of_output
    657651                   ("mount | grep ' /boot ' | head -1 | cut -d' ' -f1 | cut -dp -f1"));
    658652#endif
    659653        }
    660654        if (!bootdev[0]) {
    661             strcpy(bootdev, call_program_and_get_last_line_of_output
     655            mr_free(bootdev);
     656            mr_asprintf(&bootdev, call_program_and_get_last_line_of_output
    662657                   ("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/[0-9].*//'"));
    663658            if (strstr(bootdev, "/dev/cciss/")) {
    664                 strcpy(bootdev, call_program_and_get_last_line_of_output
     659                mr_free(bootdev);
     660                mr_asprintf(&bootdev, call_program_and_get_last_line_of_output
    665661                       ("mount | grep ' / ' | head -1 | cut -d' ' -f1 | cut -dp -f1"));
    666662            }
    … …  
    673669            ch = 'U';
    674670        if (bkpinfo->boot_loader != '\0') {
    675             sprintf(tmp, "User specified boot loader. It is '%c'.",
     671            mr_asprintf(&tmp, "User specified boot loader. It is '%c'.",
    676672                    bkpinfo->boot_loader);
    677673            log_msg(2, tmp);
     674            mr_free(tmp);
    678675        } else {
    679676            bkpinfo->boot_loader = ch;
    680677        }
    681678        if (bkpinfo->boot_device[0] != '\0') {
    682             sprintf(tmp, "User specified boot device. It is '%s'.",
     679            mr_asprintf(&tmp, "User specified boot device. It is '%s'.",
    683680                    bkpinfo->boot_device);
    684681            log_msg(2, tmp);
     682            mr_free(tmp);
    685683        } else {
    686684            strcpy(bkpinfo->boot_device, bootdev);
    687685        }
    688686    }
     687    mr_free(bootdev);
    689688
    690689    if (
    … …  
    702701    }
    703702    if (bkpinfo->boot_loader == 'L') {
    704         strcpy(bootldr_str, "LILO");
     703        mr_asprintf(&bootldr_str, "LILO");
    705704        if (!does_file_exist("/etc/lilo.conf")) {
    706705            fatal_error
    … …  
    708707        }
    709708    } else if (bkpinfo->boot_loader == 'G') {
    710         strcpy(bootldr_str, "GRUB");
     709        mr_asprintf(&bootldr_str, "GRUB");
    711710        if (!does_file_exist("/boot/grub/menu.lst")
    712711            && does_file_exist("/boot/grub/grub.conf")) {
    … …  
    719718        }
    720719    } else if (bkpinfo->boot_loader == 'E') {
    721         strcpy(bootldr_str, "ELILO");
     720        mr_asprintf(&bootldr_str, "ELILO");
    722721        /* BCO: fix it for Debian, Mandrake, ... */
    723722        if (!does_file_exist("/etc/elilo.conf")
    … …  
    750749        }
    751750    } else if (bkpinfo->boot_loader == 'R') {
    752         strcpy(bootldr_str, "RAW");
     751        mr_asprintf(&bootldr_str, "RAW");
    753752    }
    754753#ifdef __FreeBSD__
    755754    else if (bkpinfo->boot_loader == 'D') {
    756         strcpy(bootldr_str, "DD");
     755        mr_asprintf(&bootldr_str, "DD");
    757756    }
    758757
    759758    else if (bkpinfo->boot_loader == 'B') {
    760         strcpy(bootldr_str, "BOOT0");
     759        mr_asprintf(&bootldr_str, "BOOT0");
    761760    }
    762761#endif
    763762    else {
    764         strcpy(bootldr_str, "unknown");
    765     }
    766     sprintf(tmp, "Your boot loader is %s and it boots from %s",
     763        mr_asprintf(&bootldr_str, "unknown");
     764    }
     765    mr_asprintf(&tmp, "Your boot loader is %s and it boots from %s",
    767766            bootldr_str, bkpinfo->boot_device);
    768767    log_to_screen(tmp);
    769     sprintf(tmp, "%s/BOOTLOADER.DEVICE", bkpinfo->tmpdir);
     768    mr_free(tmp);
     769
     770    mr_asprintf(&tmp, "%s/BOOTLOADER.DEVICE", bkpinfo->tmpdir);
    770771    if (write_one_liner_data_file(tmp, bkpinfo->boot_device)) {
    771772        log_msg(1, "%ld: Unable to write one-liner boot device", __LINE__);
    772773    }
     774    mr_free(tmp);
     775
    773776    switch (bkpinfo->backup_media_type) {
    774777    case cdr:
    775         strcpy(value, "cdr");
     778        mr_asprintf(&value, "cdr");
    776779        break;
    777780    case cdrw:
    778         strcpy(value, "cdrw");
     781        mr_asprintf(&value, "cdrw");
    779782        break;
    780783    case cdstream:
    781         strcpy(value, "cdstream");
     784        mr_asprintf(&value, "cdstream");
    782785        break;
    783786    case tape:
    784         strcpy(value, "tape");
     787        mr_asprintf(&value, "tape");
    785788        break;
    786789    case udev:
    787         strcpy(value, "udev");
     790        mr_asprintf(&value, "udev");
    788791        break;
    789792    case iso:
    790         strcpy(value, "iso");
     793        mr_asprintf(&value, "iso");
    791794        break;
    792795    case nfs:
    793         strcpy(value, "nfs");
     796        mr_asprintf(&value, "nfs");
    794797        break;
    795798    case dvd:
    796         strcpy(value, "dvd");
     799        mr_asprintf(&value, "dvd");
    797800        break;
    798801    case usb:
    799         strcpy(value, "usb");
     802        mr_asprintf(&value, "usb");
    800803        break;
    801804    default:
    … …  
    808811    }
    809812
    810     sprintf(tmp, "%s/BACKUP-MEDIA-TYPE", bkpinfo->tmpdir);
     813    mr_asprintf(&tmp, "%s/BACKUP-MEDIA-TYPE", bkpinfo->tmpdir);
    811814    if (write_one_liner_data_file(tmp, value)) {
    812815        res++;
    … …  
    814817                __LINE__);
    815818    }
    816     sprintf(tmp, "%s/BOOTLOADER.NAME", bkpinfo->tmpdir);
     819    mr_free(value);
     820    mr_free(tmp);
     821
     822    mr_asprintf(&tmp, "%s/BOOTLOADER.NAME", bkpinfo->tmpdir);
    817823    if (write_one_liner_data_file(tmp, bootldr_str)) {
    818824        res++;
    … …  
    820826                __LINE__);
    821827    }
    822     sprintf(tmp, "%s/DIFFERENTIAL", bkpinfo->tmpdir);
     828    mr_free(bootldr_str);
     829    mr_free(tmp);
     830
     831    mr_asprintf(&tmp, "%s/DIFFERENTIAL", bkpinfo->tmpdir);
    823832    if (bkpinfo->differential) {
    824833        res += write_one_liner_data_file(tmp, "1");
    … …  
    826835        res += write_one_liner_data_file(tmp, "0");
    827836    }
     837    mr_free(tmp);
    828838
    829839    if (g_getfattr) {
    … …  
    861871    }
    862872    paranoid_free(command);
    863     sprintf(tmp, "BTW, I'm telling Mindi your kernel is '%s'",
    864             bkpinfo->kernel_path);
    865 
    866873    log_msg(1, "lines_in_filelist = %ld", lines_in_filelist);
    867874
    … …  
    892899            use_gzip_sz);       // parameter #20 (STRING)
    893900
     901    mr_free(devs_to_exclude);
     902    mr_free(last_filelist_number);
     903    mr_free(tape_device);
     904    mr_free(use_lzo_sz);
     905    mr_free(use_gzip_sz);
     906    mr_free(use_star_sz);
     907    mr_free(use_comp_sz);
     908    mr_free(broken_bios_sz);
     909    mr_free(cd_recovery_sz);
     910    mr_free(use_lilo_sz);
     911    mr_free(tape_size_sz);
     912
    894913    if (bkpinfo->nonbootable_backup) {
    895914        mr_strcat(command, " NONBOOTABLE");
    … …  
    928947            paranoid_free(command);
    929948        } else {
    930             sprintf(tmp, "cp -f %s/images/all.tar.gz %s", bkpinfo->scratchdir,
     949            mr_asprintf(&tmp, "cp -f %s/images/all.tar.gz %s", bkpinfo->scratchdir,
    931950                bkpinfo->tmpdir);
    932951            if (system(tmp)) {
    933952                fatal_error("Cannot find all.tar.gz in tmpdir");
    934953            }
     954            mr_free(tmp);
    935955        }
    936956        if (res) {
    … …  
    942962        log_to_screen("Mindi failed to create your boot+data disks.");
    943963        mr_asprintf(&command, "grep 'Fatal error' /var/log/mindi.log");
    944         strcpy(tmp, call_program_and_get_last_line_of_output(command));
     964        mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
    945965        paranoid_free(command);
    946966
    … …  
    948968            popup_and_OK(tmp);
    949969        }
    950     }
    951     paranoid_free(tmp);
    952     paranoid_free(use_lzo_sz);
    953     paranoid_free(use_gzip_sz);
    954     paranoid_free(scratchdir);
    955     paranoid_free(use_comp_sz);
    956     paranoid_free(bootldr_str);
    957     paranoid_free(tape_device);
    958     paranoid_free(last_filelist_number);
    959     paranoid_free(broken_bios_sz);
    960     paranoid_free(cd_recovery_sz);
    961     paranoid_free(tape_size_sz);
    962     paranoid_free(devs_to_exclude);
    963     paranoid_free(use_lilo_sz);
    964     paranoid_free(value);
    965     paranoid_free(bootdev);
    966     paranoid_free(use_star_sz);
     970        mr_free(tmp);
     971    }
    967972    return (res);
    968973}
    … …  
    13521357    char *storing_afioball_fname;
    13531358    char *tmp = NULL;
    1354     char *media_usage_comment;
     1359    char *media_usage_comment = NULL;
    13551360    pthread_t archival_thread[ARCH_THREADS];
    13561361    char *p_list_of_fileset_flags;
    … …  
    13701375    malloc_string(curr_acl_list_fname);
    13711376    malloc_string(storing_filelist_fname);
    1372     malloc_string(media_usage_comment);
    13731377    malloc_string(storing_afioball_fname);
    13741378    transfer_block =
    … …  
    14341438            misc_counter_that_is_not_important =
    14351439                (misc_counter_that_is_not_important + 1) % 5;
     1440            /* BCO the media_usage_comment is not really initialized there !
    14361441            if (!misc_counter_that_is_not_important) {
    14371442                update_progress_form(media_usage_comment);
     1443                */
    14381444            }
    14391445            sleep(1);
    … …  
    14621468                sleep(5);
    14631469            }
    1464             strcpy(media_usage_comment, percent_media_full_comment());
     1470            mr_asprintf(&media_usage_comment, "%s", percent_media_full_comment());
    14651471            /* copy to CD (scratchdir) ... and an actual CD-R if necessary */
    14661472            if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
    … …  
    15031509            g_current_progress++;
    15041510            update_progress_form(media_usage_comment);
     1511            mr_free(media_usage_comment);
    15051512            if (res) {
    15061513                mr_asprintf(&tmp,
    … …  
    15371544    paranoid_free(result_str);
    15381545    paranoid_free(storing_filelist_fname);
    1539     paranoid_free(media_usage_comment);
    15401546    paranoid_free(storing_afioball_fname);
    15411547    paranoid_free(curr_xattr_list_fname);
    … …  
    19801986bool is_dev_an_NTFS_dev(char *bigfile_fname)
    19811987{
    1982     char *tmp;
    1983     char *command;
    1984     malloc_string(tmp);
    1985     malloc_string(command);
    1986     sprintf(command,
     1988    char *tmp = NULL;
     1989    char *command = NULL;
     1990    bool ret = TRUE;
     1991
     1992    mr_asprintf(&command,
    19871993            "dd if=%s bs=512 count=1 2> /dev/null | strings | head -n1",
    19881994            bigfile_fname);
    19891995    log_msg(1, "command = '%s'", command);
    1990     strcpy(tmp, call_program_and_get_last_line_of_output(command));
     1996    mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
     1997    mr_free(command);
     1998
    19911999    log_msg(1, "--> tmp = '%s'", tmp);
    19922000    if (strstr(tmp, "NTFS")) {
    19932001        iamhere("TRUE");
    1994         return (TRUE);
     2002        ret = TRUE;
    19952003    } else {
    19962004        iamhere("FALSE");
    1997         return (FALSE);
    1998     }
     2005        ret = FALSE;
     2006    }
     2007    mr_free(tmp);
     2008    return(ret);
    19992009}
    20002010
    … …  
    22032213    char *curr_acl_list_fname;
    22042214    char *tmp = NULL;
    2205     char *media_usage_comment;
     2215    char *media_usage_comment = NULL;
    22062216
    22072217    malloc_string(curr_afioball_fname);
    2208     malloc_string(media_usage_comment);
    22092218    malloc_string(curr_filelist_fname);
    22102219    malloc_string(curr_xattr_list_fname);
    … …  
    22562265        }
    22572266
    2258         strcpy(media_usage_comment, percent_media_full_comment());
     2267        mr_asprintf(&media_usage_comment, "%s", percent_media_full_comment());
    22592268
    22602269        /* copy to CD (scratchdir) ... and an actual CD-R if necessary */
    … …  
    22942303        g_current_progress++;
    22952304        update_progress_form(media_usage_comment);
     2305        mr_free(media_usage_comment);
    22962306
    22972307        if (res) {
    … …  
    23152325    paranoid_free(curr_filelist_fname);
    23162326    paranoid_free(curr_afioball_fname);
    2317     paranoid_free(media_usage_comment);
    23182327    paranoid_free(curr_xattr_list_fname);
    23192328    paranoid_free(curr_acl_list_fname);
    … …  
    25002509
    25012510    /*@ buffers ******************************************************** */
    2502     char *tmp, *curr_file, *cf;
     2511    char *tmp = NULL;
     2512    char *curr_file = NULL
     2513    char *cf;
    25032514
    25042515    /*@ long ************************************************************ */
    … …  
    25072518
    25082519    assert(bkpinfo != NULL);
    2509     malloc_string(curr_file);
    2510     tmp = malloc(1200);
    25112520    would_occupy = space_occupied_by_cd(bkpinfo->scratchdir);
    25122521    va_start(ap, files_to_add); // initialize the variable arguments
    … …  
    25152524            continue;
    25162525        }
    2517         strcpy(curr_file, cf);
     2526        mr_asprintf(&curr_file, cf);
    25182527        if (!does_file_exist(curr_file)) {
    25192528            log_msg(1,
    … …  
    25242533            would_occupy += length_of_file(curr_file) / 1024;
    25252534        }
     2535        mr_free(curr_file);
    25262536    }
    25272537    va_end(ap);
    … …  
    25432553            continue;
    25442554        }
    2545         strcpy(curr_file, cf);
    2546 
    2547         sprintf(tmp, "mv -f %s %s/archives/", curr_file,
    2548                 bkpinfo->scratchdir);
     2555        mr_asprintf(&curr_file, cf);
     2556
     2557        mr_asprintf(&tmp, "mv -f %s %s/archives/", curr_file, bkpinfo->scratchdir);
     2558        mr_free(curr_file);
    25492559        res = run_program_and_log_output(tmp, 5);
    25502560        retval += res;
    … …  
    25542564            log_msg(8, "Moved %s to CD OK", tmp);
    25552565        }
    2556         //      unlink (curr_file);
     2566        mr_free(tmp);
    25572567    }
    25582568    va_end(ap);
    … …  
    25622572                "Warning - errors occurred while I was adding files to CD dir");
    25632573    }
    2564     paranoid_free(tmp);
    2565     paranoid_free(curr_file);
    25662574    return (retval);
    25672575}
    … …  
    26092617    char start_chr;
    26102618    char stop_chr;
    2611     char *curr_file, *cf;
     2619    char *curr_file = NULL
     2620    char *cf;
    26122621    /*@ long long ****************************************************** */
    26132622    off_t length_of_incoming_file = (off_t)0;
    … …  
    26162625
    26172626    assert(bkpinfo != NULL);
    2618     malloc_string(curr_file);
    26192627    va_start(ap, files_to_add);
    26202628    for (cf = files_to_add; cf != NULL; cf = va_arg(ap, char *)) {
    … …  
    26222630            continue;
    26232631        }
    2624         strcpy(curr_file, cf);
     2632        mr_asprintf(&curr_file, cf);
    26252633        if (!does_file_exist(curr_file)) {
    26262634            log_msg(1,
    … …  
    26282636                    curr_file);
    26292637        }
    2630 /* create header chars */
     2638        /* create header chars */
    26312639        start_chr = BLK_START_AN_AFIO_OR_SLICE;
    26322640        stop_chr = BLK_STOP_AN_AFIO_OR_SLICE;
    2633 /* ask for new tape if necessary */
     2641        /* ask for new tape if necessary */
    26342642        length_of_incoming_file = length_of_file(curr_file);
    26352643        write_header_block_to_stream(length_of_incoming_file, curr_file,
    … …  
    26452653        retval += res;
    26462654        unlink(curr_file);
    2647 /* write closing header */
     2655        mr_free(curr_file);
     2656        /* write closing header */
    26482657        write_header_block_to_stream((off_t)0, "finished-writing-file", stop_chr);
    26492658    }
    … …  
    26542663                "Warning - errors occurred while I was adding file to tape");
    26552664    }
    2656     paranoid_free(curr_file);
    26572665    return (retval);
    26582666}
    … …  
    26782686    char *tmp;
    26792687    int res = 0;
    2680     char *bkp;
     2688    char *bkp = NULL;
    26812689    char *cdrecord;
    26822690
    26832691    malloc_string(tmp);
    2684     malloc_string(bkp);
    26852692    malloc_string(cdrecord);
    2686     strcpy(bkp, cdrw_dev);
     2693    mr_asprintf(&bkp, cdrw_dev);
    26872694    if (find_cdrw_device(cdrw_dev)) {
    26882695        strcpy(cdrw_dev, bkp);
    … …  
    27132720        }
    27142721    }
     2722    mr_free(bkp);
     2723
    27152724//  retract_CD_tray_and_defeat_autorun();
    27162725    paranoid_free(tmp);
    27172726    paranoid_free(cdrecord);
    2718     paranoid_free(bkp);
    27192727    return (res);
    27202728}
    … …  
    27422750    char *cdrom_dev;
    27432751    char *cdrw_dev;
    2744     char *our_serial_str;
     2752    char *our_serial_str = NULL;
    27452753    bool ok_go_ahead_burn_it;
    27462754    int cd_number = -1;
    … …  
    27582766    malloc_string(szcdno);
    27592767    malloc_string(szserfname);
    2760     malloc_string(our_serial_str);
    27612768    malloc_string(szunmount);
    27622769
    … …  
    27852792        sprintf(szunmount, "umount %s", mtpt);
    27862793        cd_number = -1;
    2787         our_serial_str[0] = '\0';
    27882794        sprintf(tmp, "mount %s %s", cdrom_dev, mtpt);
     2795        mr_asprintf(&our_serial_str, "%s", "");
    27892796        if ((attempt_to_mount_returned_this =
    27902797             run_program_and_log_output(tmp, 1))) {
    … …  
    28122819            cd_number = atoi(last_line_of_file(szcdno));
    28132820            sprintf(tmp, "cat %s 2> /dev/null", szserfname);
    2814             strcpy(our_serial_str,
     2821            mr_free(our_serial_str);
     2822            mr_asprintf(&our_serial_str, "%s",
    28152823                   call_program_and_get_last_line_of_output(tmp));
    28162824            // FIXME - should be able to use last_line_of_file(), surely?
    … …  
    28362844            log_to_screen("...but not part of _our_ backup set.");
    28372845        }
     2846        mr_free(our_serial_str);
    28382847    } else {
    28392848        log_msg(2,
    … …  
    28832892    paranoid_free(szcdno);
    28842893    paranoid_free(szserfname);
    2885     paranoid_free(our_serial_str);
    28862894    paranoid_free(szunmount);
    28872895    if (pmountable) {
    … …  
    29662974    char *checksum_line, *command;
    29672975    char *tempblock;
    2968     char *curr_slice_fname_uncompressed;
    2969     char *curr_slice_fname_compressed;
    2970     char *file_to_archive;
     2976    char *curr_slice_fname_uncompressed = NULL;
     2977    char *curr_slice_fname_compressed = NULL;
     2978    char *file_to_archive = NULL;
    29712979    char *file_to_openin;
    29722980    /*@ pointers ************************************************** */
    … …  
    29832991    long optimal_set_size;
    29842992    bool should_I_compress_slices;
    2985     char *suffix;               // for compressed slices
     2993    char *suffix = NULL;                // for compressed slices
    29862994
    29872995    /*@ long long ************************************************** */
    … …  
    30013009    assert_string_is_neither_NULL_nor_zerolength(biggie_filename);
    30023010    malloc_string(checksum_line);
    3003     malloc_string(curr_slice_fname_uncompressed);
    3004     malloc_string(curr_slice_fname_compressed);
    3005     malloc_string(file_to_archive);
    3006     malloc_string(suffix);
    30073011    command = malloc(MAX_STR_LEN * 8);
    30083012
    … …  
    30153019    if (is_this_file_compressed(biggie_filename)
    30163020        || bkpinfo->compression_level == 0) {
    3017         suffix[0] = '\0';
     3021        mr_asprintf(&suffix, "%s", "");
    30183022        //      log_it("%s is indeed compressed :-)", filename);
    30193023        should_I_compress_slices = FALSE;
    30203024    } else {
    3021         strcpy(suffix, bkpinfo->zip_suffix);
     3025        mr_asprintf(&suffix, "%s", bkpinfo->zip_suffix);
    30223026        should_I_compress_slices = TRUE;
    30233027    }
    … …  
    30503054        if (!(fin = popen(command, "r"))) {
    30513055            log_OS_error("Unable to popen-in command");
     3056            mr_free(suffix);
    30523057            return (1);
    30533058        }
    … …  
    30723077        log_msg(1, "Unable to open and write to %s\n", tmp);
    30733078        paranoid_free(tmp);
    3074         paranoid_free(suffix);
     3079        mr_free(suffix);
    30753080        return (1);
    30763081    }
    … …  
    30933098        paranoid_free(checksum_line);
    30943099        paranoid_free(command);
     3100        mr_free(suffix);
    30953101        return (1);
    30963102    }
    … …  
    31063112    i = bkpinfo->optimal_set_size / 256;
    31073113    for (slice_num = 1; !finished; slice_num++) {
    3108         strcpy(curr_slice_fname_uncompressed,
     3114        mr_asprintf(&curr_slice_fname_uncompressed, "%s",
    31093115               slice_fname(biggie_file_number, slice_num, bkpinfo->tmpdir,
    31103116                           ""));
    3111         strcpy(curr_slice_fname_compressed,
     3117        mr_asprintf(&curr_slice_fname_compressed, "%s",
    31123118               slice_fname(biggie_file_number, slice_num, bkpinfo->tmpdir,
    31133119                           suffix));
    … …  
    31193125        if (!(fout = fopen(curr_slice_fname_uncompressed, "w"))) {
    31203126            log_OS_error(curr_slice_fname_uncompressed);
     3127            mr_free(suffix);
    31213128            return (1);
    31223129        }
    … …  
    31883195            paranoid_free(tmp);
    31893196
    3190             strcpy(file_to_archive, curr_slice_fname_compressed);
     3197            mr_asprintf(&file_to_archive, curr_slice_fname_compressed);
    31913198            g_current_progress++;
    31923199        } else {                /* if i==0 then ... */
    31933200
    31943201            finished = TRUE;
    3195             strcpy(file_to_archive, curr_slice_fname_uncompressed);
     3202            mr_asprintf(&file_to_archive, curr_slice_fname_uncompressed);
    31963203            if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
    31973204                break;
    31983205            }
    31993206        }
     3207        mr_free(curr_slice_fname_uncompressed);
     3208        mr_free(curr_slice_fname_compressed);
    32003209
    32013210        if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
    … …  
    32083217            res = move_files_to_cd(file_to_archive, NULL);
    32093218        }
     3219        mr_free(file_to_archive);
     3220
    32103221        retval += res;
    32113222        if (res) {
    … …  
    32193230        }
    32203231    }
     3232    mr_free(suffix);
    32213233    paranoid_fclose(fin);
    32223234    mr_asprintf(&tmp, "Sliced bigfile #%ld", biggie_file_number + 1);
    … …  
    32323244    paranoid_free(checksum_line);
    32333245    paranoid_free(command);
    3234     paranoid_free(curr_slice_fname_uncompressed);
    3235     paranoid_free(curr_slice_fname_compressed);
    3236     paranoid_free(file_to_archive);
    3237     paranoid_free(suffix);
    32383246    return (retval);
    32393247}
Note: See TracChangeset for help on using the changeset viewer.