Changeset 2266


Ignore:
Timestamp:
Jul 12, 2009, 2:04:45 AM (10 years ago)
Author:
bruno
Message:

r3207@localhost: bruno | 2009-07-07 00:32:00 +0200

  • Replace sprintf by mr_asprintf in libmondo-devices.c
Location:
branches/2.2.10/mondo/src/common
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/2.2.10/mondo/src/common/libmondo-devices.c

    r2257 r2266  
    108108{
    109109    char *tmp = NULL;
    110     char *comment;
     110    char *comment = NULL;
    111111    bool is_this_a_ramdisk = FALSE;
    112112
    113113    malloc_string(comment);
    114114    mr_asprintf(&tmp, "%s", where_is_root_mounted());
    115     sprintf(comment, "root is mounted at %s\n", tmp);
     115    mr_asprintf(&comment, "root is mounted at %s\n", tmp);
    116116    log_msg(0, comment);
     117    mr_free(comment);
    117118    log_msg(0,
    118119            "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().",
     
    145146        is_this_a_ramdisk = TRUE;
    146147    }
    147     paranoid_free(comment);
    148148    log_msg(1, "Is this a ramdisk? result = %d", is_this_a_ramdisk);
    149149    return (is_this_a_ramdisk);
     
    210210int eject_device(char *dev)
    211211{
    212     char *command;
     212    char *command = NULL;
    213213    int res1 = 0, res2 = 0;
    214 
    215     malloc_string(command);
    216214
    217215    if (IS_THIS_A_STREAMING_BACKUP(g_backup_media_type)
    218216        && g_backup_media_type != udev) {
    219         sprintf(command, "mt -f %s offline", dev);
     217        mr_asprintf(&command, "mt -f %s offline", dev);
    220218        res1 = run_program_and_log_output(command, 1);
     219        mr_free(command);
    221220    } else {
    222221        res1 = 0;
     
    225224#ifdef __FreeBSD__
    226225    if (strstr(dev, "acd")) {
    227         sprintf(command, "cdcontrol -f %s eject", dev);
     226        mr_asprintf(&command, "cdcontrol -f %s eject", dev);
    228227    } else {
    229         sprintf(command, "camcontrol eject `echo %s | sed 's|/dev/||'`",
     228        mr_asprintf(&command, "camcontrol eject `echo %s | sed 's|/dev/||'`",
    230229                dev);
    231230    }
    232231#else
    233     sprintf(command, "eject %s", dev);
     232    mr_asprintf(&command, "eject %s", dev);
    234233#endif
    235234
    236235    log_msg(3, "Ejecting %s", dev);
    237236    res2 = run_program_and_log_output(command, 1);
    238     paranoid_free(command);
     237    mr_free(command);
    239238    if (res1 && res2) {
    240239        return (1);
     
    251250int inject_device(char *dev)
    252251{
    253     char *command;
     252    char *command = NULL;
    254253    int i;
    255 
    256     malloc_string(command);
    257 
    258254
    259255#ifdef __FreeBSD__
    260256    if (strstr(dev, "acd")) {
    261         sprintf(command, "cdcontrol -f %s close", dev);
     257        mr_asprintf(&command, "cdcontrol -f %s close", dev);
    262258    } else {
    263         sprintf(command, "camcontrol load `echo %s | sed 's|/dev/||'`",
     259        mr_asprintf(&command, "camcontrol load `echo %s | sed 's|/dev/||'`",
    264260                dev);
    265261    }
    266262#else
    267     sprintf(command, "eject -t %s", dev);
     263    mr_asprintf(&command, "eject -t %s", dev);
    268264#endif
    269265    i = run_program_and_log_output(command, FALSE);
    270     paranoid_free(command);
     266    mr_free(command);
    271267    return (i);
    272268}
     
    282278
    283279    /*@ buffers *********************************************************** */
    284     char *tmp;
     280    char *tmp = NULL;
    285281    bool ret;
    286282
    287     malloc_string(tmp);
    288283    assert_string_is_neither_NULL_nor_zerolength(device);
    289284
    290     sprintf(tmp, "ls %s > /dev/null 2> /dev/null", device);
     285    mr_asprintf(&tmp, "ls %s > /dev/null 2> /dev/null", device);
    291286
    292287    if (system(tmp)) {
     
    295290        ret = TRUE;
    296291    }
    297     paranoid_free(tmp);
     292    mr_free(tmp);
    298293    return (ret);
    299294}
     
    326321{
    327322    /*@ buffers **************************************************** */
    328     char *program;
     323    char *program = NULL;
    329324    char *incoming;
    330325    char *searchstr = NULL;
     
    342337    assert(partno >= 0 && partno < 999);
    343338
    344     malloc_string(program);
    345339    malloc_string(incoming);
    346340    malloc_string(searchstr);
     
    349343#ifdef __FreeBSD__
    350344    // We assume here that this is running from mondorestore. (It is.)
    351     sprintf(program, "ls %s %s >/dev/null 2>&1", drive,
     345    mr_asprintf(&program, "ls %s %s >/dev/null 2>&1", drive,
    352346            build_partition_name(tmp, drive, partno));
    353     return system(program);
     347    res = system(program);
     348    mr_free(program);
     349    return (res);
    354350#else
    355351    tmp[0] = '\0';
    356352#endif
    357353
    358     sprintf(program, "parted2fdisk -l %s 2> /dev/null", drive);
     354    mr_asprintf(&program, "parted2fdisk -l %s 2> /dev/null", drive);
    359355    fin = popen(program, "r");
    360356    if (!fin) {
    361357        log_it("program=%s", program);
    362358        log_OS_error("Cannot popen-in program");
     359        mr_free(program);
    363360        return (0);
    364361    }
     362    mr_free(program);
     363
    365364    (void) build_partition_name(searchstr, drive, partno);
    366365    strcat(searchstr, " ");
     
    373372        log_OS_error("Cannot pclose fin");
    374373    }
    375     paranoid_free(program);
    376374    paranoid_free(incoming);
    377375    paranoid_free(searchstr);
     
    393391{
    394392    /*@ buffers **************************************************** */
    395     char *command;
     393    char *command = NULL;
    396394
    397395    /*@ end vars *************************************************** */
     
    401399    assert_string_is_neither_NULL_nor_zerolength(str);
    402400
    403     malloc_string(command);
    404     sprintf(command,
     401    mr_asprintf(&command,
    405402            "dd if=%s bs=446 count=1 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null",
    406403            dev, str);
    407404    i = system(command);
    408     paranoid_free(command);
     405    mr_free(command);
    409406    if (i) {
    410407        return (FALSE);
     
    424421{
    425422    /*@ buffers **************************************************** */
    426     char *command;
     423    char *command = NULL;
    427424    /*@ end vars *************************************************** */
    428425    int i;
    429426
    430     malloc_string(command);
    431     sprintf(command,
     427    mr_asprintf(&command,
    432428            "dd if=%s bs=512 count=%i 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null",
    433429            dev, n, str);
    434430    i = system(command);
    435     paranoid_free(command);
     431    mr_free(command);
    436432    if (i) {
    437433        return (FALSE);
     
    512508{
    513509    /*@ buffers ************************ */
    514     char *comment;
     510    char *comment = NULL;
    515511    char *tmp = NULL;
    516512    char *cdr_exe = NULL;
    517     char *command;
    518 
    519     malloc_string(comment);
    520     malloc_string(command);
     513    char *command = NULL;
     514
    521515    if (g_cdrw_drive_is_here[0]) {
    522516        strcpy(cdrw_device, g_cdrw_drive_is_here);
    523517        log_msg(3, "Been there, done that. Returning %s", cdrw_device);
    524         paranoid_free(comment);
    525         paranoid_free(command);
    526518        return (0);
    527519    }
     
    529521        log_msg(1,
    530522                "This is dumb. You're calling find_cdrw_device() but you're backing up to DVD. WTF?");
    531         paranoid_free(comment);
    532         paranoid_free(command);
    533523        return (1);
    534524    }
     
    540530    }
    541531    if (find_home_of_exe(cdr_exe)) {
    542         sprintf(command,
     532        mr_asprintf(&command,
    543533                "%s -scanbus 2> /dev/null | tr -s '\t' ' ' | grep \"[0-9]*,[0-9]*,[0-9]*\" | grep -v \"[0-9]*) \\*\" | grep CD | cut -d' ' -f2 | head -n1",
    544534                cdr_exe);
    545535        mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output(command));
     536        mr_free(command);
    546537    }
    547538    if ((tmp == NULL) || (strlen(tmp) < 2)) {
    548         paranoid_free(comment);
    549539        mr_free(tmp);
    550540        mr_free(cdr_exe);
    551         paranoid_free(command);
    552541        return 1;
    553542    } else {
    554543        strcpy(cdrw_device, tmp);
    555         sprintf(comment, "Found CDRW device - %s", cdrw_device);
     544        mr_asprintf(&comment, "Found CDRW device - %s", cdrw_device);
    556545        log_it(comment);
    557546        strcpy(g_cdrw_drive_is_here, cdrw_device);
    558         paranoid_free(comment);
     547        mr_free(comment);
    559548        mr_free(tmp);
    560549        mr_free(cdr_exe);
    561         paranoid_free(command);
    562550        return (0);
    563551    }
    564552}
    565 
    566 
    567553
    568554
     
    594580    char *phrase_one;
    595581    char *phrase_two;
    596     char *command;
    597     char *dvd_last_resort;
    598     char *mountpoint;
     582    char *command = NULL;
     583#ifndef __FreeBSD__
     584    char *dvd_last_resort = NULL;
     585#endif
     586    char *mountpoint = NULL;
    599587    static char the_last_place_i_found_it[MAX_STR_LEN] = "";
    600588
     
    603591    malloc_string(phrase_one);
    604592    malloc_string(phrase_two);
    605     malloc_string(command);
    606     malloc_string(dvd_last_resort);
    607     malloc_string(mountpoint);
    608593
    609594    output[0] = '\0';
    610595    phrase_one[0] = '\0';
    611596    phrase_two[0] = '\0';
    612     dvd_last_resort[0] = '\0';
     597#ifndef __FreeBSD__
     598    mr_asprintf(&dvd_last_resort, "%s", "");;
     599#endif
    613600
    614601    /*@ end vars **************************************************** */
     
    629616    }
    630617
    631     sprintf(mountpoint, "%s/cd.mnt", bkpinfo->tmpdir);
     618    mr_asprintf(&mountpoint, "%s/cd.mnt", bkpinfo->tmpdir);
    632619    make_hole_for_dir(mountpoint);
    633620
     
    651638    }
    652639
    653     sprintf(command, "%s -scanbus 2> /dev/null", cdr_exe);
     640    mr_asprintf(&command, "%s -scanbus 2> /dev/null", cdr_exe);
    654641    fin = popen(command, "r");
     642    log_msg(4, "command=%s", command);
     643    mr_free(command);
     644
    655645    if (!fin) {
    656         log_msg(4, "command=%s", command);
    657646        log_OS_error("Cannot popen command");
    658647        mr_free(cdr_exe);
    659648        return (1);
    660649    }
     650
    661651    for ((void)fgets(tmp, MAX_STR_LEN, fin); !feof(fin);
    662652         (void)fgets(tmp, MAX_STR_LEN, fin)) {
     
    688678        log_msg(4, "Not running phase two. String is empty.");
    689679    } else {
    690         sprintf(command, "dmesg | grep \"%s\" 2> /dev/null", phrase_two);
     680        mr_asprintf(&command, "dmesg | grep \"%s\" 2> /dev/null", phrase_two);
    691681        fin = popen(command, "r");
     682        mr_free(command);
     683
    692684        if (!fin) {
    693685            log_msg(4, "Cannot run 2nd command - non-fatal, fortunately");
     
    701693                        *p = '\0';
    702694                        if (strstr(tmp, "DVD")) {
    703                             sprintf(dvd_last_resort, "/dev/%s", tmp);
     695                            mr_free(dvd_last_resort);
     696                            mr_asprintf(&dvd_last_resort, "/dev/%s", tmp);
    704697                            log_msg(4,
    705698                                    "Ignoring '%s' because it's a DVD drive",
     
    755748#else
    756749    if (!found_it && strlen(dvd_last_resort) > 0) {
    757         log_msg(4, "Well, I'll use the DVD - %s - as a last resort",
    758                 dvd_last_resort);
     750        log_msg(4, "Well, I'll use the DVD - %s - as a last resort", dvd_last_resort);
    759751        strcpy(output, dvd_last_resort);
    760752        found_it = TRUE;
    761753    }
     754    mr_free(dvd_last_resort);
    762755    if (found_it) {
    763756        sprintf(tmp, "grep \"%s=ide-scsi\" /proc/cmdline &> /dev/null",
     
    832825                found_it = FALSE;
    833826            } else {
    834                 sprintf(command, "umount %s", output);
     827                mr_asprintf(&command, "umount %s", output);
    835828                paranoid_system(command);
     829                mr_free(command);
     830
    836831                log_msg(4, "I'm confident the Mondo CD is in %s", output);
    837832            }
     
    839834    }
    840835    unlink(mountpoint);
     836    mr_free(mountpoint);
    841837
    842838    if (found_it) {
     
    852848    }
    853849
    854     sprintf(command,
     850    mr_asprintf(&command,
    855851            "%s -scanbus | grep \"[0-9],[0-9],[0-9]\" | grep \"[D|C][V|D]\" | grep -n \"\" | grep \"%s\" | cut -d':' -f2",
    856852            cdr_exe, g_cdrw_drive_is_here);
    857853    log_msg(1, "command=%s", command);
    858854    mr_asprintf(&tmp1, "%s", call_program_and_get_last_line_of_output(command));
     855    mr_free(command);
     856
    859857    if (strlen(tmp1) > 0) {
    860858        strcpy(output, tmp1);
     
    872870    paranoid_free(phrase_one);
    873871    paranoid_free(phrase_two);
    874     paranoid_free(command);
    875     paranoid_free(dvd_last_resort);
    876     paranoid_free(mountpoint);
    877872    return (retval);
    878873}
     
    884879int find_dvd_device(char *output, bool try_to_mount)
    885880{
    886     char *command;
    887     char *tmp;
     881    char *tmp = NULL;
    888882    int retval = 0, devno = -1;
    889 
    890     malloc_string(command);
    891     malloc_string(tmp);
    892883
    893884    if (g_dvd_drive_is_here[0]) {
     
    897888    }
    898889
    899     sprintf(tmp, "%s", call_program_and_get_last_line_of_output
     890    mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output
    900891            ("dvdrecord -scanbus 2> /dev/null | grep \") '\" | grep -n \"\" | grep DVD | cut -d':' -f1")
    901892        );
    902893    log_msg(5, "tmp = '%s'", tmp);
    903894    if (!tmp[0])
    904         sprintf(tmp, "%s", call_program_and_get_last_line_of_output
     895        mr_free(tmp);
     896        mr_asprintf(&tmp, "%s", call_program_and_get_last_line_of_output
    905897                ("cdrecord -scanbus 2> /dev/null | grep \") '\" | grep -n \"\" | grep DVD | cut -d':' -f1")
    906898            );
     
    908900        devno = atoi(tmp) - 1;
    909901    }
     902    mr_free(tmp);
     903
    910904    if (devno >= 0) {
    911905        retval = 0;
     
    10361030{
    10371031    char *good_formats = NULL;
    1038     char *command;
    1039     char *format_sz;
     1032    char *command = NULL;
     1033    char *format_sz = NULL;
    10401034
    10411035    FILE *pin;
    10421036    int retval;
    10431037    malloc_string(good_formats);
    1044     malloc_string(command);
    1045     malloc_string(format_sz);
    10461038
    10471039    assert_string_is_neither_NULL_nor_zerolength(format);
    10481040
    1049     sprintf(format_sz, "%s ", format);
     1041    mr_asprintf(&format_sz, "%s ", format);
    10501042
    10511043#ifdef __FreeBSD__
    1052     sprintf(command,
     1044    mr_asprintf(&command,
    10531045            "lsvfs | tr -s '\t' ' ' | grep -v Filesys | grep -v -- -- | cut -d' ' -f1 | tr -s '\n' ' '");
    10541046#else
    1055     sprintf(command,
     1047    mr_asprintf(&command,
    10561048            "grep -v nodev /proc/filesystems | tr -s '\t' ' ' | cut -d' ' -f2 | tr -s '\n' ' '");
    10571049#endif
    10581050
    10591051    pin = popen(command, "r");
     1052    mr_free(command);
     1053
    10601054    if (!pin) {
    10611055        log_OS_error("Unable to read good formats");
     
    10751069        }
    10761070    }
     1071    mr_free(format_sz);
     1072
    10771073    paranoid_free(good_formats);
    1078     paranoid_free(command);
    1079     paranoid_free(format_sz);
    10801074    return (retval);
    10811075}
     
    12061200int kick_vn(char *dname)
    12071201{
    1208     char command[MAX_STR_LEN];
     1202    char *command = NULL;
     1203    int res = 0;
    12091204
    12101205    if (strncmp(dname, "/dev/", 5) == 0) {
     
    12151210        (call_program_and_get_last_line_of_output
    12161211         ("/sbin/sysctl -n kern.osreldate")) < 500000) {
    1217         sprintf(command, "vnconfig -d %s", dname);
    1218         return system(command);
     1212        mr_asprintf(&command, "vnconfig -d %s", dname);
    12191213    } else {
    1220         sprintf(command, "mdconfig -d -u %s", dname);
    1221         return system(command);
    1222     }
    1223      /*NOTREACHED*/ return 255;
     1214        mr_asprintf(&command, "mdconfig -d -u %s", dname);
     1215    }
     1216    res = system(command);
     1217    mr_free(command);
     1218    return(res);
    12241219}
    12251220#endif
     
    12351230{
    12361231    /*@ buffer ****************************************************** */
    1237     char *command;
     1232    char *command = NULL;
    12381233    int retval;
    12391234
    1240     malloc_string(command);
    12411235    assert_string_is_neither_NULL_nor_zerolength(device);
    12421236    assert_string_is_neither_NULL_nor_zerolength(mountpoint);
     
    12501244
    12511245#ifdef __FreeBSD__
    1252     sprintf(command, "mount_vfat %s %s 2>> %s",
     1246    mr_asprintf(&command, "mount_vfat %s %s 2>> %s",
    12531247            device, mountpoint, MONDO_LOGFILE);
    12541248
    12551249#else
    1256     sprintf(command, "mount %s -t vfat %s 2>> %s",
     1250    mr_asprintf(&command, "mount %s -t vfat %s 2>> %s",
    12571251            device, mountpoint, MONDO_LOGFILE);
    12581252#endif
     
    12611255    retval = system(command);
    12621256    log_msg(1, "system(%s) returned %d", command, retval);
    1263 
    1264     paranoid_free(command);
     1257    mr_free(command);
     1258
    12651259    return (retval);
    12661260}
     
    13601354
    13611355    /*@ buffers ********************************************************* */
    1362     char *tmp;
     1356    char *tmp = NULL;
    13631357    char *mds = NULL;
    1364     char *request;
     1358    char *request = NULL;
    13651359
    13661360    assert(bkpinfo != NULL);
     
    13741368        return;
    13751369    }
    1376     malloc_string(tmp);
    1377     malloc_string(request);
    1378     sprintf(tmp, "mkdir -p " MNT_CDROM);
     1370    mr_asprintf(&tmp, "mkdir -p " MNT_CDROM);
    13791371    run_program_and_log_output(tmp, 5);
     1372    mr_free(tmp);
     1373
    13801374    if (g_ISO_restore_mode || bkpinfo->backup_media_type == iso
    13811375        || bkpinfo->backup_media_type == nfs) {
    13821376        log_msg(3, "Remounting CD");
    13831377        g_ISO_restore_mode = TRUE;
    1384 // FIXME --- I'm tempted to do something about this...
    1385 // Why unmount and remount again and again?
     1378        // FIXME --- I'm tempted to do something about this...
     1379        // Why unmount and remount again and again?
    13861380        if (is_this_device_mounted(MNT_CDROM)) {
    13871381            run_program_and_log_output("umount " MNT_CDROM, 5);
    13881382        }
    1389         sprintf(tmp, "mkdir -p %s/isodir &> /dev/null", bkpinfo->tmpdir);
     1383        mr_asprintf(&tmp, "mkdir -p %s/isodir &> /dev/null", bkpinfo->tmpdir);
    13901384        (void)system(tmp);
    1391         sprintf(tmp, "%s/%s/%s-%d.iso", bkpinfo->isodir,
     1385        mr_free(tmp);
     1386
     1387        mr_asprintf(&tmp, "%s/%s/%s-%d.iso", bkpinfo->isodir,
    13921388                bkpinfo->nfs_remote_dir, bkpinfo->prefix,
    13931389                cd_number_i_want);
    13941390        if (!does_file_exist(tmp)) {
    1395             sprintf(tmp, "%s/isodir/%s/%s-%d.iso", bkpinfo->tmpdir,
     1391            mr_free(tmp);
     1392            mr_asprintf(&tmp, "%s/isodir/%s/%s-%d.iso", bkpinfo->tmpdir,
    13961393                    bkpinfo->nfs_remote_dir, bkpinfo->prefix,
    13971394                    cd_number_i_want);
     
    14051402        log_msg(3, "Mounting %s at %s", tmp, MNT_CDROM);
    14061403        if (mount_CDROM_here(tmp, MNT_CDROM)) {
     1404            mr_free(tmp);
    14071405            fatal_error("Mommy!");
    14081406        }
    1409 //    g_current_media_number = cd_number_i_want;
    1410 //    return;
     1407        mr_free(tmp);
    14111408    }
    14121409    if ((res = what_number_cd_is_this()) != cd_number_i_want) {
     
    14141411                cd_number_i_want);
    14151412        mds = media_descriptor_string(bkpinfo->backup_media_type);
    1416         sprintf(tmp, "Insisting on %s #%d", mds, cd_number_i_want);
    1417         sprintf(request, "Please insert %s #%d and press Enter.", mds, cd_number_i_want);
     1413        mr_asprintf(&tmp, "Insisting on %s #%d", mds, cd_number_i_want);
     1414        mr_asprintf(&request, "Please insert %s #%d and press Enter.", mds, cd_number_i_want);
    14181415        mr_free(mds);
    14191416        log_msg(3, tmp);
     1417        mr_free(tmp);
     1418
    14201419        while (what_number_cd_is_this() != cd_number_i_want) {
    14211420            paranoid_system("sync");
     
    14431442            paranoid_system("sync");
    14441443        }
     1444        mr_free(request);
     1445
    14451446        log_msg(1, "Thankyou. Proceeding...");
    14461447        g_current_media_number = cd_number_i_want;
    14471448    }
    1448     paranoid_free(tmp);
    1449     paranoid_free(request);
    14501449}
    14511450
    14521451/* @} - end of deviceGroup */
    1453 
    1454 
    1455 
    1456 
    14571452
    14581453
     
    14721467    char *tmp = NULL;
    14731468    char *mds = NULL;
    1474     char *sz_size;
    1475     char *command;
    1476     char *comment;
     1469    char *sz_size = NULL;
     1470    char *command = NULL;
     1471    char *comment = NULL;
    14771472    char *prompt;
    14781473    int i;
    14791474    FILE *fin;
    14801475
     1476    malloc_string(prompt);
    14811477    malloc_string(sz_size);
    1482     malloc_string(command);
    1483     malloc_string(comment);
    1484     malloc_string(prompt);
    14851478    assert(bkpinfo != NULL);
    1486     sz_size[0] = '\0';
    14871479    bkpinfo->nonbootable_backup = FALSE;
    14881480
     
    15371529            }
    15381530            mds = media_descriptor_string(bkpinfo->backup_media_type);
    1539             sprintf(comment, "What speed is your %s (re)writer?", mds);
     1531            mr_asprintf(&comment, "What speed is your %s (re)writer?", mds);
    15401532            if (bkpinfo->backup_media_type == dvd) {
    15411533                find_dvd_device(bkpinfo->media_device, FALSE);
     
    15461538                strcpy(bkpinfo->media_device, VANILLA_SCSI_CDROM);
    15471539                mr_asprintf(&tmp, "4");
    1548                 strcpy(sz_size, "650");
     1540                sprintf(sz_size, "%d", 650);
    15491541                log_msg(1, "Setting to CD defaults");
    15501542            }
     
    15521544                if (!popup_and_get_string("Speed", comment, tmp, 4)) {
    15531545                    log_to_screen("User has chosen not to backup the PC");
     1546                    mr_free(comment);
    15541547                    finish(1);
    15551548                }
    15561549            }
     1550            mr_free(comment);
     1551
    15571552            bkpinfo->cdrw_speed = atoi(tmp);    // if DVD then this shouldn't ever be used anyway :)
    15581553            mr_free(tmp);
    15591554
    1560             sprintf(comment,
     1555            mr_asprintf(&comment,
    15611556                    "How much data (in Megabytes) will each %s store?", mds);
    15621557            mr_free(mds);
    15631558            if (!popup_and_get_string("Size", comment, sz_size, 5)) {
     1559                mr_free(comment);
    15641560                log_to_screen("User has chosen not to backup the PC");
    15651561                finish(1);
    15661562            }
     1563            mr_free(comment);
     1564
    15671565            for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
    15681566                bkpinfo->media_size[i] = atoi(sz_size);
    15691567            }
     1568
    15701569            if (bkpinfo->media_size[0] <= 0) {
    15711570                log_to_screen("User has chosen not to backup the PC");
     
    15921591                log_msg(1, "bkpinfo->media_device = %s",
    15931592                        bkpinfo->media_device);
    1594                 sprintf(comment,
     1593                mr_asprintf(&comment,
    15951594                        "Please specify your %s drive's /dev entry", mds);
    15961595                if (!popup_and_get_string
    15971596                    ("Device?", comment, bkpinfo->media_device,
    15981597                     MAX_STR_LEN / 4)) {
     1598                    mr_free(comment);
    15991599                    log_to_screen("User has chosen not to backup the PC");
    16001600                    finish(1);
    16011601                }
     1602                mr_free(comment);
    16021603            }
    16031604            log_msg(2, "%s device found at %s", mds, bkpinfo->media_device);
     
    17051706        }
    17061707        mr_free(tmp);
    1707         log_msg(4, "sz_size = %s", sz_size);
    1708         sz_size[0] = '\0';
    17091708
    17101709        bkpinfo->use_obdr = ask_me_yes_or_no
    17111710            ("Do you want to activate OBDR support for your tapes ?");
    1712         if (sz_size[0] == '\0') {
    1713             bkpinfo->media_size[0] = 0;
    1714         } else {
    1715             bkpinfo->media_size[0] =
    1716                 friendly_sizestr_to_sizelong(sz_size) / 2 - 50;
    1717         }
     1711        bkpinfo->media_size[0] = 0;
    17181712        log_msg(4, "media_size[0] = %ld", bkpinfo->media_size[0]);
    17191713        if (bkpinfo->media_size[0] <= 0) {
     
    17691763            if (bkpinfo->nfs_mount[strlen(bkpinfo->nfs_mount) - 1] == '/')
    17701764                bkpinfo->nfs_mount[strlen(bkpinfo->nfs_mount) - 1] = '\0';
    1771             sprintf(command, "mount | grep \"%s \" | cut -d' ' -f3",
     1765            mr_asprintf(&command, "mount | grep \"%s \" | cut -d' ' -f3",
    17721766                    bkpinfo->nfs_mount);
    17731767            strcpy(bkpinfo->isodir,
    17741768                   call_program_and_get_last_line_of_output(command));
     1769            mr_free(command);
    17751770
    17761771            if (!bkpinfo->restore_data) {
    1777                 sprintf(comment,
     1772                mr_asprintf(&comment,
    17781773                    "How much data (in Megabytes) will each media store?");
    17791774                if (!popup_and_get_string("Size", comment, sz_size, 5)) {
     1775                    mr_free(comment);
    17801776                    log_to_screen("User has chosen not to backup the PC");
    17811777                    finish(1);
    17821778                }
     1779                mr_free(comment);
    17831780            } else {
    17841781                strcpy(sz_size, "0");
     
    17931790        }
    17941791        if (bkpinfo->disaster_recovery) {
    1795             sprintf(command ,"umount %s/isodir 2> /dev/null", bkpinfo->tmpdir);
     1792            mr_asprintf(&command ,"umount %s/isodir 2> /dev/null", bkpinfo->tmpdir);
    17961793            (void)system(command);
     1794            mr_free(command);
     1795
    17971796            if (!popup_and_get_string
    17981797                ("NFS share", "Which remote NFS share should I mount?",
     
    18091808        } else {
    18101809            sprintf(bkpinfo->isodir, "%s/nfsdir", bkpinfo->tmpdir);
    1811             sprintf(command, "mkdir -p %s", bkpinfo->isodir);
     1810            mr_asprintf(&command, "mkdir -p %s", bkpinfo->isodir);
    18121811            run_program_and_log_output(command, 5);
     1812            mr_free(command);
     1813
    18131814            mr_asprintf(&tmp, "mount -t nfs -o nolock %s %s", bkpinfo->nfs_mount,
    18141815                    bkpinfo->isodir);
     
    20812082    }
    20822083    paranoid_free(sz_size);
    2083     paranoid_free(command);
    2084     paranoid_free(comment);
    20852084    paranoid_free(prompt);
    20862085    return (0);
     
    21522151void make_fifo(char *store_name_here, char *stub)
    21532152{
    2154     char *tmp;
    2155 
    2156     malloc_string(tmp);
     2153    char *tmp = NULL;
     2154
    21572155    assert_string_is_neither_NULL_nor_zerolength(stub);
    21582156
     
    21612159    make_hole_for_file(store_name_here);
    21622160    mkfifo(store_name_here, S_IRWXU | S_IRWXG);
    2163     sprintf(tmp, "chmod 770 %s", store_name_here);
     2161    mr_asprintf(&tmp, "chmod 770 %s", store_name_here);
    21642162    paranoid_system(tmp);
    2165     paranoid_free(tmp);
     2163    mr_free(tmp);
    21662164}
    21672165
     
    22362234bool set_dev_to_this_if_rx_OK(char *output, char *dev)
    22372235{
    2238     char *command;
    2239 
    2240     malloc_string(command);
     2236    char *command = NULL;
     2237    bool res;
     2238
    22412239    if (!dev || dev[0] == '\0') {
    22422240        output[0] = '\0';
    22432241        return (FALSE);
    22442242    }
    2245 //  assert_string_is_neither_NULL_nor_zerolength(dev);
    22462243    log_msg(10, "Injecting %s", dev);
    22472244    inject_device(dev);
     
    22502247        return (FALSE);
    22512248    }
    2252     sprintf(command, "dd bs=%ld count=1 if=%s of=/dev/null &> /dev/null",
    2253             512L, dev);
     2249    mr_asprintf(&command, "dd bs=%ld count=1 if=%s of=/dev/null &> /dev/null", 512L, dev);
    22542250    if (!run_program_and_log_output(command, FALSE)
    22552251        && !run_program_and_log_output(command, FALSE)) {
    22562252        strcpy(output, dev);
    22572253        log_msg(4, "Found it - %s", dev);
    2258         return (TRUE);
     2254        res = TRUE;
    22592255    } else {
    22602256        output[0] = '\0';
    22612257        log_msg(4, "It's not %s", dev);
    2262         return (FALSE);
    2263     }
     2258        res = FALSE;
     2259    }
     2260    mr_free(command);
     2261    return(res);
    22642262}
    22652263
     
    25562554{
    25572555    static char output[MAX_STR_LEN];
    2558     char *command;
     2556    char *command = NULL;
    25592557    char *curr_fname;
    25602558    char *scratch = NULL;
     
    25632561
    25642562    struct stat statbuf;
    2565     command = malloc(1000);
    25662563    malloc_string(curr_fname);
    25672564    if (!does_file_exist(incoming)) {
     
    25742571        while (S_ISLNK(statbuf.st_mode)) {
    25752572            log_msg(1, "curr_fname = %s", curr_fname);
    2576             sprintf(command, "file %s", curr_fname);
     2573            mr_asprintf(&command, "file %s", curr_fname);
    25772574            mr_asprintf(&tmp, call_program_and_get_last_line_of_output(command));
     2575            mr_free(command);
    25782576            for (p = tmp + strlen(tmp); p != tmp && *p != '`' && *p != ' ';
    25792577                 p--);
     
    26032601        log_it("resolved %s to %s", incoming, output);
    26042602    }
    2605     paranoid_free(command);
    26062603    paranoid_free(curr_fname);
    26072604    return (output);
     
    26182615    static char output[4];
    26192616    char *tmp = NULL;
    2620     char *command;
    2621     char *fdisk;
     2617    char *command = NULL;
     2618    char *fdisk = NULL;
    26222619#ifdef __IA64__
    26232620    struct stat buf;
    26242621#endif
    2625     malloc_string(command);
    2626     malloc_string(fdisk);
    26272622    log_msg(0, "Looking for partition table format type");
    2628     sprintf(fdisk, "/sbin/parted2fdisk");
     2623    mr_asprintf(&fdisk, "/sbin/parted2fdisk");
    26292624    log_msg(1, "Using %s", fdisk);
    2630     sprintf(command, "%s -l %s | grep 'EFI GPT'", fdisk, drive);
     2625    mr_asprintf(&command, "%s -l %s | grep 'EFI GPT'", fdisk, drive);
     2626    mr_free(fdisk);
     2627
    26312628    mr_asprintf(&tmp, call_program_and_get_last_line_of_output(command));
     2629    mr_free(command);
     2630
    26322631    if (strstr(tmp, "GPT") == NULL) {
    26332632        strcpy(output, "MBR");
     
    26382637
    26392638    log_msg(0, "Found %s partition table format type", output);
    2640     paranoid_free(command);
    2641     paranoid_free(fdisk);
    26422639    return (output);
    26432640}
  • branches/2.2.10/mondo/src/common/libmondo-stream.c

    r2264 r2266  
    264264
    265265    log_to_screen("I am looking for your tape streamer. Please wait.");
    266     dev[0] = siz[0] = '\0';
     266    dev[0] = '\0';
     267    if (siz != NULL) {
     268        siz[0] = '\0';
     269    }
    267270    if (find_home_of_exe("cdrecord")) {
    268271        strcpy(cdr_exe, "cdrecord");
     
    339342    }
    340343
    341     siz[0] = '\0';
    342344    log_it("res=%d; dev=%s", res, dev);
    343345
     
    347349
    348350    if (strlen(tmp) < 2) {
    349         siz[0] = '\0';
    350351        log_it("Warning - size of tape unknown");
    351352        return (0);
    352353    } else {
    353         strcpy(siz, tmp);
     354        if (siz != NULL) {
     355            strcpy(siz, tmp);
     356        }
    354357        return (0);
    355358    }
Note: See TracChangeset for help on using the changeset viewer.