Changeset 1080 in MondoRescue for branches/stable/mondo/src/common


Ignore:
Timestamp:
Jan 28, 2007, 7:04:41 PM (17 years ago)
Author:
Bruno Cornec
Message:
  • Fix mindi install messages (reported by Andree Leidenfrost)
  • remove paranoid_free/free for mr_free
  • mr_asprintf used everywhere
  • mr_malloc used everywhere
Location:
branches/stable/mondo/src/common
Files:
13 edited

Legend:

Unmodified
Added
Removed

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

    r1075 r1080  
    267267    }
    268268
    269     paranoid_free(command);
    270     paranoid_free(zipparams);
    271     paranoid_free(tmp);
     269    mr_free(command);
     270    mr_free(zipparams);
     271    mr_free(tmp);
    272272    return (retval);
    273273}
    … …  
    403403        }
    404404    }
    405     paranoid_free(command);
    406     paranoid_free(zipparams);
    407     paranoid_free(tmp);
     405    mr_free(command);
     406    mr_free(zipparams);
     407    mr_free(tmp);
    408408    return (retval);
    409409}
    … …  
    496496        sleep(2);
    497497    }
    498     paranoid_free(tmp);
     498    mr_free(tmp);
    499499    return (retval);
    500500}
    … …  
    565565
    566566    assert(bkpinfo != NULL);
    567     command = malloc(1200);
     567    command = mr_malloc(1200);
    568568    malloc_string(tmp);
    569569    malloc_string(scratchdir);
    … …  
    814814
    815815    if (g_getfattr) {
    816         asprintf(&tmp1, "%s/XATTR", bkpinfo->tmpdir);
     816        mr_asprintf(&tmp1, "%s/XATTR", bkpinfo->tmpdir);
    817817        if (write_one_liner_data_file(tmp1, "TRUE")) {
    818818            log_msg(1, "%ld: Unable to write one-liner XATTR",
    819819                __LINE__);
    820820        }
    821         paranoid_free(tmp1);
     821        mr_free(tmp1);
    822822    }
    823823    if (g_getfacl) {
    824         asprintf(&tmp1, "%s/ACL", bkpinfo->tmpdir);
     824        mr_asprintf(&tmp1, "%s/ACL", bkpinfo->tmpdir);
    825825        if (write_one_liner_data_file(tmp1, "TRUE")) {
    826826            log_msg(1, "%ld: Unable to write one-liner ACL",
    827827                __LINE__);
    828828        }
    829         paranoid_free(tmp1);
     829        mr_free(tmp1);
    830830    }
    831831
    … …  
    849849
    850850    if (bkpinfo->backup_media_type == usb) {
    851         asprintf(&tmp2, "--usb %s", bkpinfo->media_device);
     851        mr_asprintf(&tmp2, "--usb %s", bkpinfo->media_device);
    852852    } else {
    853         asprintf(&tmp2,"");
     853        mr_asprintf(&tmp2,"");
    854854    }
    855855
    … …  
    935935        }
    936936    }
    937     paranoid_free(tmp);
    938     paranoid_free(use_lzo_sz);
    939     paranoid_free(use_gzip_sz);
    940     paranoid_free(scratchdir);
    941     paranoid_free(use_comp_sz);
    942     paranoid_free(bootldr_str);
    943     paranoid_free(tape_device);
    944     paranoid_free(last_filelist_number);
    945     paranoid_free(broken_bios_sz);
    946     paranoid_free(cd_recovery_sz);
    947     paranoid_free(tape_size_sz);
    948     paranoid_free(devs_to_exclude);
    949     paranoid_free(use_lilo_sz);
    950     paranoid_free(value);
    951     paranoid_free(bootdev);
    952     paranoid_free(command);
    953     paranoid_free(use_star_sz);
     937    mr_free(tmp);
     938    mr_free(use_lzo_sz);
     939    mr_free(use_gzip_sz);
     940    mr_free(scratchdir);
     941    mr_free(use_comp_sz);
     942    mr_free(bootldr_str);
     943    mr_free(tape_device);
     944    mr_free(last_filelist_number);
     945    mr_free(broken_bios_sz);
     946    mr_free(cd_recovery_sz);
     947    mr_free(tape_size_sz);
     948    mr_free(devs_to_exclude);
     949    mr_free(use_lilo_sz);
     950    mr_free(value);
     951    mr_free(bootdev);
     952    mr_free(command);
     953    mr_free(use_star_sz);
    954954    return (res);
    955955}
    … …  
    11221122    log_msg(3, "%s[%d:%d] - exiting", FORTY_SPACES, getpid(),
    11231123            this_thread_no);
    1124     paranoid_free(archiving_filelist_fname);
    1125     paranoid_free(archiving_afioball_fname);
    1126     paranoid_free(curr_xattr_list_fname);
    1127     paranoid_free(curr_acl_list_fname);
    1128     paranoid_free(tmp);
     1124    mr_free(archiving_filelist_fname);
     1125    mr_free(archiving_afioball_fname);
     1126    mr_free(curr_xattr_list_fname);
     1127    mr_free(curr_acl_list_fname);
     1128    mr_free(tmp);
    11291129    pthread_exit(NULL);
    11301130}
    … …  
    12591259                                     BLK_START_OF_BACKUP);
    12601260    }
    1261     paranoid_free(command);
    1262     paranoid_free(tmpfile);
    1263     paranoid_free(data_disks_file);
     1261    mr_free(command);
     1262    mr_free(tmpfile);
     1263    mr_free(data_disks_file);
    12641264    return (retval);
    12651265}
    … …  
    13501350    }
    13511351    unlink(tempfile);
    1352     paranoid_free(command);
    1353     paranoid_free(tempfile);
     1352    mr_free(command);
     1353    mr_free(tempfile);
    13541354    return (res);
    13551355}
    … …  
    13791379    assert_string_is_neither_NULL_nor_zerolength(device);
    13801380    malloc_string(title);
    1381     command = malloc(1000);
     1381    command = mr_malloc(1000);
    13821382    if (!system("which superformat > /dev/null 2> /dev/null")) {
    13831383        sprintf(command, "superformat %s", device);
    … …  
    13951395        }
    13961396    }
    1397     paranoid_free(title);
    1398     paranoid_free(command);
     1397    mr_free(title);
     1398    mr_free(command);
    13991399    return (res);
    14001400}
    … …  
    14851485    log_msg(8, "here");
    14861486    assert(bkpinfo != NULL);
    1487     tmp = malloc(MAX_STR_LEN * 2);
     1487    tmp = mr_malloc(MAX_STR_LEN * 2);
    14881488    malloc_string(result_str);
    14891489    malloc_string(curr_xattr_list_fname);
    … …  
    14931493    malloc_string(storing_afioball_fname);
    14941494    transfer_block =
    1495         malloc(sizeof(struct s_bkpinfo) + BKPINFO_LOC_OFFSET + 64);
     1495        mr_malloc(sizeof(struct s_bkpinfo) + BKPINFO_LOC_OFFSET + 64);
    14961496    memset((void *) transfer_block, 0,
    14971497           sizeof(struct s_bkpinfo) + BKPINFO_LOC_OFFSET + 64);
    … …  
    16541654    }
    16551655    log_to_screen(tmp);
    1656     paranoid_free(transfer_block);
    1657     paranoid_free(result_str);
    1658     paranoid_free(storing_filelist_fname);
    1659     paranoid_free(media_usage_comment);
    1660     paranoid_free(storing_afioball_fname);
    1661     paranoid_free(curr_xattr_list_fname);
    1662     paranoid_free(curr_acl_list_fname);
     1656    mr_free(transfer_block);
     1657    mr_free(result_str);
     1658    mr_free(storing_filelist_fname);
     1659    mr_free(media_usage_comment);
     1660    mr_free(storing_afioball_fname);
     1661    mr_free(curr_xattr_list_fname);
     1662    mr_free(curr_acl_list_fname);
    16631663    return (retval);
    16641664}
    … …  
    17181718    malloc_string(sz_blank_disk);
    17191719    malloc_string(fnam);
    1720     tmp = malloc(1200);
    1721     tmp2 = malloc(1200);
    1722     tmp3 = malloc(1200);
     1720    tmp = mr_malloc(1200);
     1721    tmp2 = mr_malloc(1200);
     1722    tmp3 = mr_malloc(1200);
    17231723    assert(bkpinfo != NULL);
    17241724    assert_string_is_neither_NULL_nor_zerolength(destfile);
    … …  
    17541754       }
    17551755     */
    1756     free(tmp2);
    1757     free(tmp3);
    1758     tmp2 = NULL;
    1759     tmp3 = NULL;
     1756    mr_free(tmp2);
     1757    mr_free(tmp3);
    17601758    if (bkpinfo->backup_media_type == iso && bkpinfo->manual_cd_tray) {
    17611759        popup_and_OK("Please insert new media and press Enter.");
    … …  
    20072005        log_msg(1, "WARNING - make_iso_fs returned an error");
    20082006    }
    2009     paranoid_free(old_pwd);
    2010     paranoid_free(result_sz);
    2011     paranoid_free(message_to_screen);
    2012     paranoid_free(sz_blank_disk);
    2013     paranoid_free(fnam);
    2014     paranoid_free(tmp);
     2007    mr_free(old_pwd);
     2008    mr_free(result_sz);
     2009    mr_free(message_to_screen);
     2010    mr_free(sz_blank_disk);
     2011    mr_free(fnam);
     2012    mr_free(tmp);
    20152013    return (retval);
    20162014}
    … …  
    22202218    close_progress_form();
    22212219    paranoid_fclose(fin);
    2222     paranoid_free(tmp);
    2223     paranoid_free(bigfile_fname);
    2224     paranoid_free(sz_devfile);
     2220    mr_free(tmp);
     2221    mr_free(bigfile_fname);
     2222    mr_free(sz_devfile);
    22252223    return (retval);
    22262224}
    … …  
    22552253    malloc_string(curr_acl_list_fname);
    22562254
    2257     tmp = malloc(MAX_STR_LEN * 2);
     2255    tmp = mr_malloc(MAX_STR_LEN * 2);
    22582256
    22592257    sprintf(tmp, "%s/archives/filelist.full", bkpinfo->scratchdir);
    … …  
    23602358    }
    23612359    log_to_screen(tmp);
    2362     paranoid_free(tmp);
    2363     paranoid_free(curr_filelist_fname);
    2364     paranoid_free(curr_afioball_fname);
    2365     paranoid_free(media_usage_comment);
    2366     paranoid_free(curr_xattr_list_fname);
    2367     paranoid_free(curr_acl_list_fname);
     2360    mr_free(tmp);
     2361    mr_free(curr_filelist_fname);
     2362    mr_free(curr_afioball_fname);
     2363    mr_free(media_usage_comment);
     2364    mr_free(curr_xattr_list_fname);
     2365    mr_free(curr_acl_list_fname);
    23682366    return (retval);
    23692367}
    … …  
    24462444    malloc_string(xattr_fname);
    24472445    malloc_string(acl_fname);
    2448     command = malloc(1200);
     2446    command = mr_malloc(1200);
    24492447    mvaddstr_and_log_it(g_currentY, 0,
    24502448                        "Archiving large files to media           ");
    … …  
    24962494        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
    24972495    }
    2498     paranoid_free(blah);
    2499     paranoid_free(biggielist);
    2500     paranoid_free(command);
    2501     paranoid_free(xattr_fname);
    2502     paranoid_free(acl_fname);
     2496    mr_free(blah);
     2497    mr_free(biggielist);
     2498    mr_free(command);
     2499    mr_free(xattr_fname);
     2500    mr_free(acl_fname);
    25032501    return (retval);
    25042502}
    … …  
    25522550    assert(bkpinfo != NULL);
    25532551    malloc_string(curr_file);
    2554     tmp = malloc(1200);
     2552    tmp = mr_malloc(1200);
    25552553    would_occupy = space_occupied_by_cd(bkpinfo->scratchdir);
    25562554    va_start(ap, files_to_add); // initialize the variable arguments
    … …  
    26062604                "Warning - errors occurred while I was adding files to CD dir");
    26072605    }
    2608     paranoid_free(tmp);
    2609     paranoid_free(curr_file);
     2606    mr_free(tmp);
     2607    mr_free(curr_file);
    26102608    return (retval);
    26112609}
    … …  
    27682766        }
    27692767    }
    2770     paranoid_free(tmp);
    2771     paranoid_free(comment);
    2772     paranoid_free(bootdisk_dev);
    2773     paranoid_free(datadisk_dev);
     2768    mr_free(tmp);
     2769    mr_free(comment);
     2770    mr_free(bootdisk_dev);
     2771    mr_free(datadisk_dev);
    27742772    return (res);
    27752773}
    … …  
    29132911                "Warning - errors occurred while I was adding file to tape");
    29142912    }
    2915     paranoid_free(curr_file);
     2913    mr_free(curr_file);
    29162914    return (retval);
    29172915}
    … …  
    29732971    }
    29742972//  retract_CD_tray_and_defeat_autorun();
    2975     paranoid_free(tmp);
    2976     paranoid_free(cdrecord);
    2977     paranoid_free(bkp);
     2973    mr_free(tmp);
     2974    mr_free(cdrecord);
     2975    mr_free(bkp);
    29782976    return (res);
    29792977}
    … …  
    31363134    log_to_screen("Proceeding w/ %s in drive.",
    31373135                  media_descriptor_string(g_backup_media_type));
    3138     paranoid_free(tmp);
    3139     paranoid_free(szmsg);
    3140     paranoid_free(cdrom_dev);
    3141     paranoid_free(cdrw_dev);
    3142     paranoid_free(mtpt);
    3143     paranoid_free(szcdno);
    3144     paranoid_free(szserfname);
    3145     paranoid_free(our_serial_str);
    3146     paranoid_free(szunmount);
     3136    mr_free(tmp);
     3137    mr_free(szmsg);
     3138    mr_free(cdrom_dev);
     3139    mr_free(cdrw_dev);
     3140    mr_free(mtpt);
     3141    mr_free(szcdno);
     3142    mr_free(szserfname);
     3143    mr_free(our_serial_str);
     3144    mr_free(szunmount);
    31473145    if (pmountable) {
    31483146        if (attempt_to_mount_returned_this) {
    … …  
    32653263    malloc_string(file_to_archive);
    32663264    malloc_string(suffix);
    3267     command = malloc(MAX_STR_LEN * 8);
     3265    command = mr_malloc(MAX_STR_LEN * 8);
    32683266
    32693267    biggiestruct.for_backward_compatibility = '\n';
    32703268    biggiestruct.use_ntfsprog = use_ntfsprog;
    3271     if (!(tempblock = (char *) malloc(256 * 1024))) {
    3272         fatal_error("malloc error 256*1024");
    3273     }
     3269    tempblock = (char *) mr_malloc(256 * 1024);
    32743270    optimal_set_size = bkpinfo->optimal_set_size;
    32753271    if (is_this_file_compressed(biggie_filename)
    … …  
    33383334                biggie_filename);
    33393335        log_to_screen(tmp);
    3340         paranoid_free(tempblock);
    3341         paranoid_free(tmp);
    3342         paranoid_free(checksum_line);
    3343         paranoid_free(command);
     3336        mr_free(tempblock);
     3337        mr_free(tmp);
     3338        mr_free(checksum_line);
     3339        mr_free(command);
    33443340        return (1);
    33453341    }
    … …  
    34733469    }
    34743470    log_msg(1, tmp);
    3475     paranoid_free(tempblock);
    3476     paranoid_free(tmp);
    3477     paranoid_free(checksum_line);
    3478     paranoid_free(command);
    3479     paranoid_free(curr_slice_fname_uncompressed);
    3480     paranoid_free(curr_slice_fname_compressed);
    3481     paranoid_free(file_to_archive);
    3482     paranoid_free(suffix);
     3471    mr_free(tempblock);
     3472    mr_free(tmp);
     3473    mr_free(checksum_line);
     3474    mr_free(command);
     3475    mr_free(curr_slice_fname_uncompressed);
     3476    mr_free(curr_slice_fname_compressed);
     3477    mr_free(file_to_archive);
     3478    mr_free(suffix);
    34833479    return (retval);
    34843480}
    … …  
    35253521    sprintf(tmp, "ls -l %s", dir);
    35263522    run_program_and_log_output(tmp, FALSE);
    3527     paranoid_free(tmp);
    3528     paranoid_free(dir);
     3523    mr_free(tmp);
     3524    mr_free(dir);
    35293525}
    35303526
    … …  
    35733569#endif
    35743570    log_msg(2, "Returning from writing final ISO (res=%d)", res);
    3575     paranoid_free(tmp);
     3571    mr_free(tmp);
    35763572    return (res);
    35773573}
    … …  
    37403736
    37413737    bkpinfo->verify_data = orig_vfy_flag_val;
    3742     paranoid_free(tmp);
    3743     paranoid_free(cdno_fname);
    3744     paranoid_free(lastcd_fname);
    3745     paranoid_free(isofile);
     3738    mr_free(tmp);
     3739    mr_free(cdno_fname);
     3740    mr_free(lastcd_fname);
     3741    mr_free(isofile);
    37463742    return (0);
    37473743}
    … …  
    38433839        }
    38443840    }
    3845     paranoid_free(tmp);
     3841    mr_free(tmp);
    38463842    return (retval);
    38473843}
    … …  
    39313927    paranoid_fclose(fin);
    39323928    paranoid_fclose(fout);
    3933     paranoid_free(tmp);
    3934     paranoid_free(title);
     3929    mr_free(tmp);
     3930    mr_free(title);
    39353931    close_evalcall_form();
    39363932    return (res);

  • branches/stable/mondo/src/common/libmondo-devices.c

    r1075 r1080  
    139139        is_this_a_ramdisk = TRUE;
    140140    }
    141     paranoid_free(tmp);
    142     paranoid_free(comment);
     141    mr_free(tmp);
     142    mr_free(comment);
    143143    log_msg(1, "Is this a ramdisk? result = %d", is_this_a_ramdisk);
    144144    return (is_this_a_ramdisk);
    … …  
    228228    log_msg(3, "Ejecting %s", dev);
    229229    res2 = run_program_and_log_output(command, 1);
    230     paranoid_free(command);
     230    mr_free(command);
    231231    if (res1 && res2) {
    232232        return (1);
    … …  
    260260#endif
    261261    i = run_program_and_log_output(command, FALSE);
    262     paranoid_free(command);
     262    mr_free(command);
    263263    return (i);
    264264}
    … …  
    287287        ret = TRUE;
    288288    }
    289     paranoid_free(tmp);
     289    mr_free(tmp);
    290290    return (ret);
    291291}
    … …  
    365365        log_OS_error("Cannot pclose fin");
    366366    }
    367     paranoid_free(program);
    368     paranoid_free(incoming);
    369     paranoid_free(searchstr);
    370     paranoid_free(tmp);
     367    mr_free(program);
     368    mr_free(incoming);
     369    mr_free(searchstr);
     370    mr_free(tmp);
    371371    return (res);
    372372}
    … …  
    398398            dev, str);
    399399    i = system(command);
    400     paranoid_free(command);
     400    mr_free(command);
    401401    if (i) {
    402402        return (FALSE);
    … …  
    425425            dev, n, str);
    426426    i = system(command);
    427     paranoid_free(command);
     427    mr_free(command);
    428428    if (i) {
    429429        return (FALSE);
    … …  
    487487        log_msg(1, "mount succeeded with %s", dev);
    488488    }
    489     paranoid_free(dev);
     489    mr_free(dev);
    490490    return (res);
    491491}
    … …  
    522522        strcpy(cdrw_device, g_cdrw_drive_is_here);
    523523        log_msg(3, "Been there, done that. Returning %s", cdrw_device);
    524         paranoid_free(comment);
    525         paranoid_free(tmp);
    526         paranoid_free(cdr_exe);
    527         paranoid_free(command);
     524        mr_free(comment);
     525        mr_free(tmp);
     526        mr_free(cdr_exe);
     527        mr_free(command);
    528528        return (0);
    529529    }
    … …  
    531531        log_msg(1,
    532532                "This is dumb. You're calling find_cdrw_device() but you're backing up to DVD. WTF?");
    533         paranoid_free(comment);
    534         paranoid_free(tmp);
    535         paranoid_free(cdr_exe);
    536         paranoid_free(command);
     533        mr_free(comment);
     534        mr_free(tmp);
     535        mr_free(cdr_exe);
     536        mr_free(command);
    537537        return (1);
    538538    }
    … …  
    551551    }
    552552    if (strlen(tmp) < 2) {
    553         paranoid_free(comment);
    554         paranoid_free(tmp);
    555         paranoid_free(cdr_exe);
    556         paranoid_free(command);
     553        mr_free(comment);
     554        mr_free(tmp);
     555        mr_free(cdr_exe);
     556        mr_free(command);
    557557        return 1;
    558558    } else {
    … …  
    561561        log_it(comment);
    562562        strcpy(g_cdrw_drive_is_here, cdrw_device);
    563         paranoid_free(comment);
    564         paranoid_free(tmp);
    565         paranoid_free(cdr_exe);
    566         paranoid_free(command);
     563        mr_free(comment);
     564        mr_free(tmp);
     565        mr_free(cdr_exe);
     566        mr_free(command);
    567567        return (0);
    568568    }
    … …  
    872872    }
    873873  end_of_find_cdrom_device:
    874     paranoid_free(tmp);
    875     paranoid_free(cdr_exe);
    876     paranoid_free(phrase_one);
    877     paranoid_free(phrase_two);
    878     paranoid_free(command);
    879     paranoid_free(dvd_last_resort);
    880     paranoid_free(mountpoint);
     874    mr_free(tmp);
     875    mr_free(cdr_exe);
     876    mr_free(phrase_one);
     877    mr_free(phrase_two);
     878    mr_free(command);
     879    mr_free(dvd_last_resort);
     880    mr_free(mountpoint);
    881881    return (retval);
    882882}
    … …  
    11201120                outL = tempLa * tempLb / 1024 * tempLc / 1024;
    11211121                if (outL > 100) {
    1122                     paranoid_free(tmp);
    1123                     paranoid_free(command);
     1122                    mr_free(tmp);
     1123                    mr_free(command);
    11241124                    return (outL);
    11251125                }
    … …  
    11341134    strcpy(tmp, call_program_and_get_last_line_of_output(command));
    11351135    if (atol(tmp) > 0) {
    1136         paranoid_free(tmp);
    1137         paranoid_free(command);
     1136        mr_free(tmp);
     1137        mr_free(command);
    11381138        return (atol(tmp));
    11391139    }
    … …  
    11441144        strcpy(tmp, p + 1);
    11451145    } else {
    1146         paranoid_free(tmp);
    1147         paranoid_free(command);
     1146        mr_free(tmp);
     1147        mr_free(command);
    11481148        return (-1);
    11491149    }
    … …  
    11631163        log_msg(3, "Cannot find %s's size: dmesg isn't helping either.",
    11641164                drive);
    1165         paranoid_free(tmp);
    1166         paranoid_free(command);
     1165        mr_free(tmp);
     1166        mr_free(command);
    11671167        return (-1);
    11681168    }
    … …  
    11721172    outL = atol(p);
    11731173    if (outL <= 0) {
    1174         paranoid_free(tmp);
    1175         paranoid_free(command);
     1174        mr_free(tmp);
     1175        mr_free(command);
    11761176        return (-1);
    11771177    }
    … …  
    11791179        outL = outL * 1024;
    11801180    }
    1181     paranoid_free(tmp);
    1182     paranoid_free(command);
     1181    mr_free(tmp);
     1182    mr_free(command);
    11831183    return (outL * 19 / 20);
    11841184#endif
    … …  
    12381238        }
    12391239    }
    1240     paranoid_free(good_formats);
    1241     paranoid_free(command);
    1242     paranoid_free(format_sz);
     1240    mr_free(good_formats);
     1241    mr_free(command);
     1242    mr_free(format_sz);
    12431243    return (retval);
    12441244}
    … …  
    13181318    }
    13191319  end_of_func:
    1320     paranoid_free(incoming);
    1321     paranoid_free(device_with_tab);
    1322     paranoid_free(device_with_space);
    1323     paranoid_free(tmp);
     1320    mr_free(incoming);
     1321    mr_free(device_with_tab);
     1322    mr_free(device_with_space);
     1323    mr_free(tmp);
    13241324    return (retval);
    13251325}
    … …  
    14541454    log_msg(1, "system(%s) returned %d", command, retval);
    14551455
    1456     paranoid_free(command);
    1457     paranoid_free(dev);
    1458     paranoid_free(options);
     1456    mr_free(command);
     1457    mr_free(dev);
     1458    mr_free(options);
    14591459    return (retval);
    14601460}
    … …  
    15711571        g_current_media_number = cd_number_i_want;
    15721572    }
    1573     paranoid_free(tmp);
    1574     paranoid_free(request);
     1573    mr_free(tmp);
     1574    mr_free(request);
    15751575}
    15761576
    … …  
    21732173        }
    21742174    }
    2175     paranoid_free(tmp);
    2176     paranoid_free(sz_size);
    2177     paranoid_free(command);
    2178     paranoid_free(comment);
    2179     paranoid_free(prompt);
     2175    mr_free(tmp);
     2176    mr_free(sz_size);
     2177    mr_free(command);
     2178    mr_free(comment);
     2179    mr_free(prompt);
    21802180    return (0);
    21812181}
    … …  
    22092209    sprintf(result_sz, "%s %s", exclude_these_directories,
    22102210            exclude_these_devices);
    2211     paranoid_free(exclude_these_devices);
    2212     paranoid_free(exclude_these_directories);
     2211    mr_free(exclude_these_devices);
     2212    mr_free(exclude_these_directories);
    22132213    return (result_sz);
    22142214}
    … …  
    22382238           ("tr -s '\t' ' ' < /etc/fstab | grep -E '( (coda|ncpfs|nfs|smbfs|cifs|mvfs) )' | cut -d' ' -f1 | tr -s '\n' ' ' | awk '{print $0;}'"));
    22392239    sprintf(result_sz, "%s", exclude_these_directories);
    2240     paranoid_free(exclude_these_devices);
    2241     paranoid_free(exclude_these_directories);
     2240    mr_free(exclude_these_devices);
     2241    mr_free(exclude_these_directories);
    22422242    return (result_sz);
    22432243}
    … …  
    22692269    sprintf(tmp, "chmod 770 %s", store_name_here);
    22702270    paranoid_system(tmp);
    2271     paranoid_free(tmp);
     2271    mr_free(tmp);
    22722272}
    22732273
    … …  
    23232323    sprintf(command, "rm -Rf %s/tmp.mondo.* %s/mondo.scratch.*", tmp, tmp);
    23242324    paranoid_system(command);
    2325     paranoid_free(tmp);
    2326     paranoid_free(command);
    2327     paranoid_free(sz);
     2325    mr_free(tmp);
     2326    mr_free(command);
     2327    mr_free(sz);
    23282328}
    23292329
    … …  
    24042404        cd_number = atoi(last_line_of_file(mountdev));
    24052405//      log_it("cd_number = %d", cd_number);
    2406         paranoid_free(mountdev);
    2407         paranoid_free(tmp);
     2406        mr_free(mountdev);
     2407        mr_free(tmp);
    24082408        return (cd_number);
    24092409    }
    … …  
    24212421        atoi(last_line_of_file(MNT_CDROM "/archives/THIS-CD-NUMBER"));
    24222422//  log_it("cd_number..later.. = %d", cd_number);
    2423     paranoid_free(mountdev);
    2424     paranoid_free(tmp);
     2423    mr_free(mountdev);
     2424    mr_free(tmp);
    24252425    return (cd_number);
    24262426}
    … …  
    25502550    if (!(pdrives = popen(list_drives_cmd, "r"))) {
    25512551        log_OS_error("Unable to open list of drives");
    2552         paranoid_free(list_drives_cmd);
    2553         paranoid_free(current_drive);
     2552        mr_free(list_drives_cmd);
     2553        mr_free(current_drive);
    25542554        return ('\0');
    25552555    }
    … …  
    25732573    }
    25742574    log_it("%d grubs and %d lilos\n", count_grubs, count_lilos);
    2575     paranoid_free(list_drives_cmd);
    2576     paranoid_free(current_drive);
     2575    mr_free(list_drives_cmd);
     2576    mr_free(current_drive);
    25772577    if (count_grubs && !count_lilos) {
    25782578        return ('G');
    … …  
    26742674        log_it("resolved %s to %s", incoming, output);
    26752675    }
    2676     paranoid_free(command);
    2677     paranoid_free(curr_fname);
    2678     paranoid_free(tmp);
     2676    mr_free(command);
     2677    mr_free(curr_fname);
     2678    mr_free(tmp);
    26792679    return (output);
    26802680}
    … …  
    27092709    }
    27102710    log_msg(0, "Found %s partition table format type", output);
    2711     paranoid_free(command);
    2712     paranoid_free(tmp);
    2713     paranoid_free(fdisk);
     2711    mr_free(command);
     2712    mr_free(tmp);
     2713    mr_free(fdisk);
    27142714    return (output);
    27152715}

  • branches/stable/mondo/src/common/libmondo-fifo.c

    r1075 r1080  
    146146    }
    147147
    148     paranoid_free(command);
    149     paranoid_free(tmp);
     148    mr_free(command);
     149    mr_free(tmp);
    150150    return (fres);
    151151}
    … …  
    179179        run_program_and_log_output(command, TRUE);
    180180    }
    181     paranoid_free(tmp);
    182     paranoid_free(command);
     181    mr_free(tmp);
     182    mr_free(command);
    183183}
    184184

  • branches/stable/mondo/src/common/libmondo-filelist.c

    r1075 r1080  
    1818#include "libmondo-tools-EXT.h"
    1919#include "mr_str.h"
     20#include "mr_mem.h"
    2021
    2122#include <time.h>
    … …  
    148149
    149150  end_of_func:
    150     paranoid_free(filelist);
    151     paranoid_free(tempfile);
    152     paranoid_free(cksumlist);
    153     paranoid_free(dev);
    154     paranoid_free(tmp);
     151    mr_free(filelist);
     152    mr_free(tempfile);
     153    mr_free(cksumlist);
     154    mr_free(dev);
     155    mr_free(tmp);
    155156    return (retval);
    156157}
    … …  
    191192        }
    192193    }
    193     paranoid_free(tmp_fname);
    194     paranoid_free(command);
     194    mr_free(tmp_fname);
     195    mr_free(command);
    195196    log_msg(1, "Finished sorting file %s", orig_fname);
    196197    return (retval);
    … …  
    243244    malloc_string(outfname);
    244245    malloc_string(biggie_fname);
    245     incoming = malloc(MAX_STR_LEN * 2);
     246    incoming = mr_malloc(MAX_STR_LEN * 2);
    246247    malloc_string(tmp);
    247248    malloc_string(acl_fname);
    … …  
    364365#endif
    365366  end_of_func:
    366     paranoid_free(outfname);
    367     paranoid_free(biggie_fname);
    368     paranoid_free(incoming);
    369     paranoid_free(tmp);
    370     paranoid_free(acl_fname);
    371     paranoid_free(xattr_fname);
     367    mr_free(outfname);
     368    mr_free(biggie_fname);
     369    mr_free(incoming);
     370    mr_free(tmp);
     371    mr_free(acl_fname);
     372    mr_free(xattr_fname);
    372373    return (err ? 0 : curr_set_no + 1);
    373374}
    … …  
    419420    }
    420421    filelist->ch = '\0';
    421     paranoid_free(filelist);
     422    mr_free(filelist);
    422423    depth--;
    423424    if (depth == 0) {
    … …  
    448449    }
    449450    paranoid_pclose(pattr);
    450     paranoid_free(tmp);
     451    mr_free(tmp);
    451452    return (0);
    452453}
    … …  
    474475        log_msg(1, "Cannot openout auxlist_fname %s", auxlist_fname);
    475476        fclose(fin);
    476         paranoid_free(pout_command);
     477        mr_free(pout_command);
    477478        return (4);
    478479    }
    … …  
    487488        asprintf(&strtmp, syscall_sprintf, mr_stresc(file_to_analyze, "`$\\\"", '\\'));
    488489        asprintf(&syscall, "%s 2>> /dev/null", strtmp); // " MONDO_LOGFILE);
    489         paranoid_free(strtmp);
     490        mr_free(strtmp);
    490491        call_exe_and_pipe_output_to_fd(syscall, pout);
    491         paranoid_free(syscall);
     492        mr_free(syscall);
    492493    }
    493494    paranoid_fclose(fin);
    494495    paranoid_pclose(pout);
    495     paranoid_free(file_to_analyze);
    496     paranoid_free(pout_command);
     496    mr_free(file_to_analyze);
     497    mr_free(pout_command);
    497498    return (0);
    498499}
    … …  
    514515        iamhere(command);
    515516        retval = system(command);
    516         paranoid_free(command);
     517        mr_free(command);
    517518    }
    518519    return (retval);
    … …  
    529530        sprintf(command, "touch %s", fattr_fname);
    530531        run_program_and_log_output(command, 8);
    531         paranoid_free(command);
     532        mr_free(command);
    532533//      sort_file(filelist); // FIXME - filelist chopper sorts, so this isn't necessary
    533534        retval =
    … …  
    561562        log_msg(1, "command = %s", command);
    562563        retval = system(command);
    563         paranoid_free(command);
     564        mr_free(command);
    564565        log_msg(1, "Returning w/ retval=%d", retval);
    565566        return (retval);
    … …  
    569570                "original_exat_fname %s is empty or missing, so no need to set EXAT list",
    570571                original_exat_fname);
    571         paranoid_free(command);
     572        mr_free(command);
    572573        return (0);
    573574    }
    … …  
    679680
    680681    unlink(masklist);
    681     paranoid_free(current_subset_file);
    682     paranoid_free(current_master_file);
    683     paranoid_free(syscall_pout);
    684     paranoid_free(syscall_pin);
    685     paranoid_free(masklist);
    686     paranoid_free(incoming);
    687     paranoid_free(command);
     682    mr_free(current_subset_file);
     683    mr_free(current_master_file);
     684    mr_free(syscall_pout);
     685    mr_free(syscall_pin);
     686    mr_free(masklist);
     687    mr_free(incoming);
     688    mr_free(command);
    688689    return (retval);
    689690}
    … …  
    805806
    806807/* add here */
    807     if (!(newnode = (struct s_node *) malloc(sizeof(struct s_node)))) {
    808         log_to_screen("failed to malloc");
    809         depth--;
    810         return (1);
    811     }
     808    newnode = (struct s_node *) mr_malloc(sizeof(struct s_node));
    812809    if (char_to_add < node->ch) // add to the left of node
    813810    {
    … …  
    835832    log_msg(6, "Adding remaining chars ('%s')", string_to_add + 1);
    836833    for (i = 1; i < noof_chars; i++) {
    837         if (!
    838             (node->down =
    839              (struct s_node *) malloc(sizeof(struct s_node)))) {
    840             log_to_screen("%s - failed to malloc", string_to_add);
    841             return (1);
     834            node->down = (struct s_node *) mr_malloc(sizeof(struct s_node));
    842835        }
    843836        node = node->down;
    … …  
    901894    }
    902895    g_original_noof_lines_in_filelist = lines_in_filelist;
    903     if (!(filelist = (struct s_node *) malloc(sizeof(struct s_node)))) {
    904         return (NULL);
    905     }
     896    filelist = (struct s_node *) mr_malloc(sizeof(struct s_node));
    906897    filelist->ch = '/';
    907898    filelist->right = NULL;
    908     filelist->down = malloc(sizeof(struct s_node));
     899    filelist->down = mr_malloc(sizeof(struct s_node));
    909900    filelist->expanded = filelist->selected = FALSE;
    910901    (filelist->down)->ch = '\0';
    … …  
    13961387        while((token = mr_strtok (sth, delims, &lastpos))) {
    13971388          asprintf(&strtmp,"%s", find_excludes);
    1398           paranoid_free(find_excludes);
     1389          mr_free(find_excludes);
    13991390          asprintf(&find_excludes,"%s -path %s -prune -o", strtmp, token);
    1400           paranoid_free(strtmp);
    1401           paranoid_free(token);
     1391          mr_free(strtmp);
     1392          mr_free(token);
    14021393        }
    14031394#if linux
    … …  
    14121403                dir, MAX_SKEL_DEPTH, find_excludes, g_skeleton_filelist);
    14131404#endif
    1414         paranoid_free(find_excludes);
     1405        mr_free(find_excludes);
    14151406        log_msg(5, "find command = %s", strtmp);
    14161407        system(strtmp);
    1417         paranoid_free(strtmp);
     1408        mr_free(strtmp);
    14181409        sprintf(tmp, "wc -l %s | awk '{print $1;}'", g_skeleton_filelist);
    14191410        g_skeleton_entries =
    … …  
    15201511    if (!depth) {
    15211512        close_evalcall_form();
    1522         paranoid_free(name_of_evalcall_form);
    1523         paranoid_free(find_skeleton_marker);
     1513        mr_free(name_of_evalcall_form);
     1514        mr_free(find_skeleton_marker);
    15241515        unlink(g_skeleton_filelist);
    15251516        log_msg(5, "g_skeleton_entries = %ld", g_skeleton_entries);
    15261517    }
    1527     paranoid_free(tmp);
    1528     paranoid_free(sth_B);
    1529     paranoid_free(ith_B);
    1530     paranoid_free(new_with_spaces);
     1518    mr_free(tmp);
     1519    mr_free(sth_B);
     1520    mr_free(ith_B);
     1521    mr_free(new_with_spaces);
    15311522    return (0);
    15321523}
    … …  
    15931584    malloc_string(sz_filelist);
    15941585    malloc_string(g_skeleton_filelist);
    1595     if (!(exclude_paths = malloc(1000))) {
    1596         fatal_error("Cannot malloc exclude_paths");
    1597     }
     1586    exclude_paths = mr_malloc(1000);
    15981587    log_msg(3, "Trying to write test string to exclude_paths");
    15991588    strcpy(exclude_paths, "/blah /froo");
    … …  
    16881677    paranoid_system(command);
    16891678    log_msg(2, "Freeing variables");
    1690     paranoid_free(sz_filelist);
    1691     paranoid_free(command);
    1692     paranoid_free(exclude_paths);
    1693     paranoid_free(tmp);
    1694     paranoid_free(g_skeleton_filelist);
     1679    mr_free(sz_filelist);
     1680    mr_free(command);
     1681    mr_free(exclude_paths);
     1682    mr_free(tmp);
     1683    mr_free(g_skeleton_filelist);
    16951684    log_msg(2, "Exiting");
    16961685    return (0);
    … …  
    18381827    paranoid_fclose(fout);
    18391828    paranoid_fclose(fin);
    1840     paranoid_free(fname);
    1841     paranoid_free(tmp);
     1829    mr_free(fname);
     1830    mr_free(tmp);
    18421831    return (retval);
    18431832}
    … …  
    18951884    }
    18961885    paranoid_fclose(fin);
    1897     paranoid_free(tmp);
     1886    mr_free(tmp);
    18981887    return (0);
    18991888}

  • branches/stable/mondo/src/common/libmondo-files.c

    r1075 r1080  
    282282            fatal_error("Mindi gave a fatal error. Please check '/var/log/mindi.log'.");
    283283        }
    284         paranoid_free(command);
     284        mr_free(command);
    285285    }
    286286    log_it("Calling Mindi with kernel path of '%s'", kernel);
    … …  
    334334    if (incoming[0] == '\0') {
    335335        if (system("which file > /dev/null 2> /dev/null")) {
    336             paranoid_free(incoming);
    337             paranoid_free(command);
     336            mr_free(incoming);
     337            mr_free(command);
    338338            output[0] = '\0';
    339339            return (NULL);      // forget it :)
    … …  
    359359        log_msg(4, "find_home_of_exe() --- Could not find %s", fname);
    360360    }
    361     paranoid_free(incoming);
    362     paranoid_free(command);
     361    mr_free(incoming);
     362    mr_free(command);
    363363    if (!output[0]) {
    364364        return (NULL);
    … …  
    865865    paranoid_fclose(fin);
    866866    log_it("Finished calculating total size of all biggiefiles");
    867     paranoid_free(fname);
    868     paranoid_free(biggielist);
    869     paranoid_free(comment);
    870     paranoid_free(tmp);
    871     paranoid_free(command);
     867    mr_free(fname);
     868    mr_free(biggielist);
     869    mr_free(comment);
     870    mr_free(tmp);
     871    mr_free(command);
    872872    return (scratchL);
    873873}
    … …  
    14031403        retval = 1;
    14041404    }
    1405     paranoid_free(tmp);
     1405    mr_free(tmp);
    14061406    return (retval);
    14071407}

  • branches/stable/mondo/src/common/libmondo-fork.c

    r1075 r1080  
    55
    66#include "my-stuff.h"
     7#include "mr_mem.h"
    78#include "mondostructures.h"
    89#include "libmondo-fork.h"
    … …  
    106107    assert_string_is_neither_NULL_nor_zerolength(isofile);
    107108    assert_string_is_neither_NULL_nor_zerolength(logstub);
    108     if (!(midway_call = malloc(1200))) {
    109         fatal_error("Cannot malloc midway_call");
    110     }
    111     if (!(ultimate_call = malloc(1200))) {
    112         fatal_error("Cannot malloc ultimate_call");
    113     }
    114     if (!(tmp = malloc(1200))) {
    115         fatal_error("Cannot malloc tmp");
    116     }
    117     if (!(command = malloc(1200))) {
    118         fatal_error("Cannot malloc command");
    119     }
     109    midway_call = mr_malloc(1200);
     110    ultimate_call = mr_malloc(1200);
     111    tmp = mr_malloc(1200);
     112    command = mr_malloc(1200);
    120113    malloc_string(incoming);
    121114    malloc_string(old_stderr);
    … …  
    178171    }
    179172
    180     paranoid_free(midway_call);
    181     paranoid_free(ultimate_call);
    182     paranoid_free(tmp);
    183     paranoid_free(command);
    184     paranoid_free(incoming);
    185     paranoid_free(old_stderr);
    186     paranoid_free(cd_number_str);
     173    mr_free(midway_call);
     174    mr_free(ultimate_call);
     175    mr_free(tmp);
     176    mr_free(command);
     177    mr_free(incoming);
     178    mr_free(old_stderr);
     179    mr_free(cd_number_str);
    187180/*
    188181  if (bkpinfo->backup_media_type == dvd && !bkpinfo->please_dont_eject_when_restoring)
    … …  
    424417    tmp[0] = '\0';
    425418    bufcap = 256L * 1024L;
    426     if (!(buf = malloc(bufcap))) {
    427         fatal_error("Failed to malloc() buf");
    428     }
     419    buf = mr_malloc(bufcap);
    429420
    430421    if (direction == 'w') {
    … …  
    529520    }
    530521
    531     paranoid_free(buf);
    532     paranoid_free(tmp);
     522    mr_free(buf);
     523    mr_free(tmp);
    533524    log_msg(3, "Successfully copied %ld bytes", bytes_written_out);
    534525    return (retval);
    … …  
    559550    sprintf(command, "ntfsclone --force --save-image --overwrite %s %s", output_fname, input_device);
    560551    res = run_program_and_log_output(command, 5);
    561     paranoid_free(command);
     552    mr_free(command);
    562553    unlink(output_fname);
    563554    return (res);
    … …  
    627618    }
    628619    unlink(tempfile);
    629     paranoid_free(command);
    630     paranoid_free(tempfile);
    631     paranoid_free(title);
     620    mr_free(command);
     621    mr_free(tempfile);
     622    mr_free(title);
    632623    return (res);
    633624}
    … …  
    721712    }
    722713    log_msg(3, "Parent res = %d", res);
    723     paranoid_free(command);
    724     paranoid_free(title);
     714    mr_free(command);
     715    mr_free(title);
    725716    return (res);
    726717}
    … …  
    747738    sprintf(command, "ntfsclone --force --restore-image --overwrite %s %s", output_device, input_fifo);
    748739    res = run_program_and_log_output(command, 5);
    749     paranoid_free(command);
     740    mr_free(command);
    750741    return (res);
    751742}

  • branches/stable/mondo/src/common/libmondo-mountlist.c

    r1075 r1080  
    1 /* libmondo-mountlist.c                            subroutines for handling mountlist
     1/* subroutines for handling mountlist
    22   $Id$
    33*/
    … …  
    1818#include "libmondo-string-EXT.h"
    1919#include "libmondo-gui-EXT.h"
     20#include "mr_mem.h"
    2021
    2122/*@unused@*/
    … …  
    488489
    489490  endoffunc:
    490     paranoid_free(tmp);
    491     paranoid_free(device);
    492     paranoid_free(mountpoint);
     491    mr_free(tmp);
     492    mr_free(device);
     493    mr_free(mountpoint);
    493494
    494495    if (res) {
    … …  
    528529    /*@ initialize ******************************************************* */
    529530
    530     drivelist = malloc(sizeof(struct list_of_disks));
     531    drivelist = mr_malloc(sizeof(struct list_of_disks));
    531532    malloc_string(tmp);
    532533    malloc_string(flaws_str);
    … …  
    591592         && strcmp(mountlist->el[i].device, device) != 0; i++);
    592593
    593     paranoid_free(tmp);
    594     paranoid_free(flaws_str);
     594    mr_free(tmp);
     595    mr_free(flaws_str);
    595596
    596597    if (i == mountlist->entries) {
    … …  
    651652        }
    652653    }
    653     paranoid_free(curr_mountpoint);
    654     paranoid_free(tmp);
     654    mr_free(curr_mountpoint);
     655    mr_free(tmp);
    655656    return (res);
    656657}
    … …  
    702703        }
    703704    }
    704     paranoid_free(tmp);
    705     paranoid_free(format_sz);
     705    mr_free(tmp);
     706    mr_free(format_sz);
    706707    return (res);
    707708}
    … …  
    783784    drivelist->entries = noof_drives;
    784785    log_msg(8, "Made list of drives");
    785     paranoid_free(drive);
    786     paranoid_free(tmp);
     786    mr_free(drive);
     787    mr_free(tmp);
    787788
    788789    return (noof_drives);
    … …  
    844845    output_list->entries = items;
    845846    log_it("MLUORP -- ending");
    846     paranoid_free(tmp);
     847    mr_free(tmp);
    847848}
    848849
    … …  
    911912        log_it("Unable to open mountlist - '%s'", fname);
    912913        log_to_screen("Cannot open mountlist");
    913         paranoid_free(incoming);
    914         paranoid_free(siz);
    915         paranoid_free(tmp);
     914        mr_free(incoming);
     915        mr_free(siz);
     916        mr_free(tmp);
    916917        return (1);
    917918    }
    … …  
    9991000    sprintf(tmp, "%d entries in mountlist", items);
    10001001    log_it(tmp);
    1001     paranoid_free(incoming);
    1002     paranoid_free(siz);
    1003     paranoid_free(tmp);
     1002    mr_free(incoming);
     1003    mr_free(siz);
     1004    mr_free(tmp);
    10041005    return (0);
    10051006}

  • branches/stable/mondo/src/common/libmondo-raid.c

    r1075 r1080  
    1818#include "libmondo-raid.h"
    1919#include "mr_str.h"
     20#include "mr_mem.h"
    2021
    2122#ifdef __FreeBSD__
    … …  
    4950    int res;
    5051
    51     command = malloc(MAX_STR_LEN * 2);
     52    command = mr_malloc(MAX_STR_LEN * 2);
    5253    strcpy(command, "grep \" /proc/mdstat");
    5354    if (raidno == -1) {
    … …  
    5960    log_it("Is raid %d registered? Command = '%s'", raidno, command);
    6061    res = system(command);
    61     paranoid_free(command);
     62    mr_free(command);
    6263    if (res) {
    6364        return (FALSE);
    … …  
    200201    strcpy(raidrec->additional_vars.el[lino].label, label);
    201202    strcpy(raidrec->additional_vars.el[lino].value, sz_value);
    202     paranoid_free(sz_value);
     203    mr_free(sz_value);
    203204}
    204205#endif
    … …  
    436437    label[0] = value[0] = '\0';
    437438    if (feof(fin)) {
    438         paranoid_free(incoming);
     439        mr_free(incoming);
    439440        return (1);
    440441    }
    … …  
    452453        strcpy(label, incoming);
    453454        strcpy(value, p);
    454         paranoid_free(incoming);
     455        mr_free(incoming);
    455456        return (0);
    456457    }
    … …  
    480481        log_it("Raidtab is very small or non-existent. Ignoring it.");
    481482        raidlist->entries = 0;
    482         paranoid_free(tmp);
     483        mr_free(tmp);
    483484        return (0);
    484485    }
    485486    if (!(fin = fopen(fname, "r"))) {
    486487        log_it("Cannot open raidtab");
    487         paranoid_free(tmp);
     488        mr_free(tmp);
    488489        return (1);
    489490    }
    … …  
    590591    sprintf(tmp, "%d RAID devices in raidtab", raidlist->entries);
    591592    log_it(tmp);
    592     paranoid_free(tmp);
     593    mr_free(tmp);
    593594    return (0);
    594595}
    … …  
    616617        log_it("Raidtab is very small or non-existent. Ignoring it.");
    617618        raidlist->entries = 0;
    618         paranoid_free(tmp);
    619         paranoid_free(label);
    620         paranoid_free(value);
     619        mr_free(tmp);
     620        mr_free(label);
     621        mr_free(value);
    621622        return (0);
    622623    }
    623624    if (!(fin = fopen(fname, "r"))) {
    624625        log_it("Cannot open raidtab");
    625         paranoid_free(tmp);
    626         paranoid_free(label);
    627         paranoid_free(value);
     626        mr_free(tmp);
     627        mr_free(label);
     628        mr_free(value);
    628629        return (1);
    629630    }
    … …  
    661662    log_msg(1, "Raidtab loaded successfully.");
    662663    log_msg(1, "%d RAID devices in raidtab", items);
    663     paranoid_free(tmp);
    664     paranoid_free(label);
    665     paranoid_free(value);
     664    mr_free(tmp);
     665    mr_free(label);
     666    mr_free(value);
    666667    return (0);
    667668}
    … …  
    762763        raidrec->additional_vars.entries = ++v;
    763764    }
    764     paranoid_free(tmp);
    765     paranoid_free(labelB);
    766     paranoid_free(valueB);
     765    mr_free(tmp);
     766    mr_free(labelB);
     767    mr_free(valueB);
    767768}
    768769#endif
    … …  
    820821    static char *argv[64];
    821822    char **ap;
    822     char *line = (char *) malloc(MAX_STR_LEN);
    823     if (!line)
    824         errx(1,
    825              "unable to allocate %i bytes of memory for `char *line' at %s:%i",
    826              MAX_STR_LEN, __FILE__, __LINE__);
     823    char *line = (char *) mr_malloc(MAX_STR_LEN);
    827824    (void) fgets(line, MAX_STR_LEN, f);
    828825    if (feof(f)) {
    … …  
    868865    int i, j;
    869866    static char **ret;
    870     ret = (char **) malloc(nval * sizeof(char *));
     867    ret = (char **) mr_malloc(nval * sizeof(char *));
    871868    for (i = 0; i < (argc - nval); ++i) {
    872869        if (!strcmp(argv[i], option)) {
    873870            for (j = 0; j < nval; ++j) {
    874                 ret[j] = (char *) malloc(strlen(argv[i + j + 1]) + 1);
     871                ret[j] = (char *) mr_malloc(strlen(argv[i + j + 1]) + 1);
    875872                strcpy(ret[j], argv[i + j + 1]);
    876873            }
    … …  
    10141011    asprintf(&strtmp, pos);
    10151012    strcpy(string, strtmp);
    1016     paranoid_free(strtmp);
     1013    mr_free(strtmp);
    10171014    // if we have newline after only spaces, this is a blank line, update
    10181015    // counters, otherwise do normal parsing
    … …  
    10351032    asprintf(&strtmp,"%s%s", device_prefix, token);
    10361033    strcpy(raidlist->el[raidlist->entries].raid_device, strtmp);
    1037     paranoid_free(strtmp);
    1038     paranoid_free(token);
     1034    mr_free(strtmp);
     1035    mr_free(token);
    10391036    // skip ':' and status
    10401037    token = mr_strtok (string, delims, &lastpos);
    1041     paranoid_free(token);
     1038    mr_free(token);
    10421039    token = mr_strtok (string, delims, &lastpos);
    10431040    if (!strcmp(token, "inactive")) {
    10441041      log_msg(1, "RAID device '%s' inactive.\n",
    10451042         raidlist->el[raidlist->entries].raid_device);
    1046       paranoid_free(string);
    1047       paranoid_free(token);
     1043      mr_free(string);
     1044      mr_free(token);
    10481045      return 1;
    10491046    }
    1050     paranoid_free(token);
     1047    mr_free(token);
    10511048
    10521049    // get RAID level
    … …  
    10701067    } else {
    10711068      log_msg(1, "Unknown RAID level '%s'.\n", token);
    1072       paranoid_free(string);
    1073       paranoid_free(token);
     1069      mr_free(string);
     1070      mr_free(token);
    10741071      return 1;
    10751072    }
    1076     paranoid_free(token);
     1073    mr_free(token);
    10771074
    10781075    // get RAID devices (type, index, device)
    … …  
    10941091        asprintf(&strtmp,"%s%s", device_prefix, token);
    10951092        strcpy(raidlist->el[raidlist->entries].data_disks.el[raidlist->el[raidlist->entries].data_disks.entries].device, strtmp);
    1096         paranoid_free(strtmp);
     1093        mr_free(strtmp);
    10971094        raidlist->el[raidlist->entries].data_disks.entries++;
    10981095        break;
    … …  
    11011098        asprintf(&strtmp,"%s%s", device_prefix, token);
    11021099        strcpy(raidlist->el[raidlist->entries].spare_disks.el[raidlist->el[raidlist->entries].spare_disks.entries].device, strtmp);
    1103         paranoid_free(strtmp);
     1100        mr_free(strtmp);
    11041101        raidlist->el[raidlist->entries].spare_disks.entries++;
    11051102        break;
    … …  
    11081105        asprintf(&strtmp,"%s%s", device_prefix, token);
    11091106        strcpy(raidlist->el[raidlist->entries].failed_disks.el[raidlist->el[raidlist->entries].failed_disks.entries].device, strtmp);
    1110         paranoid_free(strtmp);
     1107        mr_free(strtmp);
    11111108        raidlist->el[raidlist->entries].failed_disks.entries++;
    11121109        log_it("At least one failed disk found in RAID array.\n");
    … …  
    11141111      default: // error
    11151112        log_msg(1, "Unknown device type '%c'\n", type);
    1116         paranoid_free(string);
    1117         paranoid_free(token);
     1113        mr_free(string);
     1114        mr_free(token);
    11181115        return 1;
    11191116        break;
    11201117      }
    1121       paranoid_free(token);
     1118      mr_free(token);
    11221119    }
    11231120
    … …  
    11721169        if (pos < string) {
    11731170          log_it("String underflow!\n");
    1174           paranoid_free(string);
     1171          mr_free(string);
    11751172          return 1;
    11761173        }
    … …  
    11971194        if (pos < string) {
    11981195          printf("ERROR: String underflow!\n");
    1199           paranoid_free(string);
     1196          mr_free(string);
    12001197          return 1;
    12011198        }
    … …  
    12141211  fclose(fin);
    12151212  // free string
    1216   paranoid_free(string);
     1213  mr_free(string);
    12171214  // return success
    12181215  return 0;
    … …  
    12281225    int retval = 0;
    12291226
    1230     raidlist = malloc(sizeof(struct raidlist_itself));
     1227    raidlist = mr_malloc(sizeof(struct raidlist_itself));
    12311228
    12321229    // FIXME: Prefix '/dev/' should really be dynamic!

  • branches/stable/mondo/src/common/libmondo-stream.c

    r1075 r1080  
    1313
    1414#include "my-stuff.h"
     15#include "mr_mem.h"
    1516#include "mondostructures.h"
    1617#include "libmondo-devices.h"
    … …  
    111112    int i;
    112113
    113     blk = (char *) malloc(256 * 1024);
     114    blk = (char *) mr_malloc(256 * 1024);
    114115
    115116    log_it("closein_tape() -- entering");
    … …  
    141142        eject_device(bkpinfo->media_device);
    142143    }
    143     paranoid_free(blk);
    144     paranoid_free(g_tapecatalog);
     144    mr_free(blk);
     145    mr_free(g_tapecatalog);
    145146    return (retval);
    146147}
    … …  
    170171    char *blk;
    171172
    172     blk = (char *) malloc(256 * 1024);
     173    blk = (char *) mr_malloc(256 * 1024);
    173174
    174175    sleep(1);
    … …  
    218219    //  if (!bkpinfo->please_dont_eject)
    219220    //    { eject_device(bkpinfo->media_device); }
    220     paranoid_free(blk);
    221     paranoid_free(g_tapecatalog);
     221    mr_free(blk);
     222    mr_free(g_tapecatalog);
    222223    return (retval);
    223224}
    … …  
    233234    sprintf(command, "mt -f %s status", dev);
    234235    res = run_program_and_log_output(command, 1);
    235     paranoid_free(command);
     236    mr_free(command);
    236237    if (res) {
    237238        return (FALSE);
    … …  
    596597    sprintf(tmp, "mt -f %s setblk %ld", tapedev, internal_tape_block_size);
    597598    res = run_program_and_log_output(tmp, 3);
    598     paranoid_free(tmp);
     599    mr_free(tmp);
    599600    return (res);
    600601}
    … …  
    636637
    637638    assert_string_is_neither_NULL_nor_zerolength(bkpinfo->media_device);
    638     if (!(g_tapecatalog = malloc(sizeof(struct s_tapecatalog)))) {
    639         fatal_error("Cannot alloc mem for tape catalog");
    640     }
     639    g_tapecatalog = mr_malloc(sizeof(struct s_tapecatalog));
    641640    g_tapecatalog->entries = 0;
    642641    g_tape_posK = 0;
    … …  
    672671        return (-1);
    673672    }
    674     if (!(datablock = (char *) malloc(256 * 1024))) {
    675         log_to_screen("Unable to malloc 256*1024");
    676         exit(1);
    677     }
     673    datablock = (char *) mr_malloc(256 * 1024);
    678674    for (i = 0; i < 32; i++) {
    679675        for (j = 0; j < 4; j++) {
    … …  
    692688    }
    693689    paranoid_fclose(fout);
    694     paranoid_free(datablock);
     690    mr_free(datablock);
    695691/* find initial blocks */
    696692    res = read_header_block_from_stream(&size, fname, &ctrl_chr);
    … …  
    738734/*  initialise the catalog */
    739735    g_current_media_number = 1;
    740     if (!(g_tapecatalog = malloc(sizeof(struct s_tapecatalog)))) {
    741         fatal_error("Cannot alloc mem for tape catalog");
    742     }
     736    g_tapecatalog = mr_malloc(sizeof(struct s_tapecatalog));
    743737    g_tapecatalog->entries = 0;
    744738/* log stuff */
    … …  
    771765        return (0);
    772766    }
    773     if (!(g_tapecatalog = malloc(sizeof(struct s_tapecatalog)))) {
    774         fatal_error("Cannot alloc mem for tape catalog");
    775     }
     767    g_tapecatalog = mr_malloc(sizeof(struct s_tapecatalog));
    776768    g_tapecatalog->entries = 0;
    777769    g_tape_posK = 0;
    … …  
    898890    malloc_string(temp_cksum);
    899891    malloc_string(actual_cksum);
    900     datablock = malloc(TAPE_BLOCK_SIZE);
     892    datablock = mr_malloc(TAPE_BLOCK_SIZE);
    901893    crc16 = 0;
    902894    crctt = 0;
    … …  
    995987        /*      log_it(tmp); */
    996988    }
    997     paranoid_free(datablock);
    998     paranoid_free(tmp);
    999     paranoid_free(temp_fname);
    1000     paranoid_free(temp_cksum);
    1001     paranoid_free(actual_cksum);
     989    mr_free(datablock);
     990    mr_free(tmp);
     991    mr_free(temp_fname);
     992    mr_free(temp_cksum);
     993    mr_free(actual_cksum);
    1002994    return (retval);
    1003995}
    … …  
    10281020    /*@ end vars *************************************************** */
    10291021
    1030     tempblock = (char *) malloc((size_t) TAPE_BLOCK_SIZE);
     1022    tempblock = (char *) mr_malloc((size_t) TAPE_BLOCK_SIZE);
    10311023
    10321024    for (i = 0; i < (int) TAPE_BLOCK_SIZE; i++) {
    … …  
    10651057            marker_to_string(*pcontrol_char), tempblock + 1000,
    10661058            (long) (*plen) >> 10);
    1067     paranoid_free(tempblock);
     1059    mr_free(tempblock);
    10681060    return (retval);
    10691061}
    … …  
    11721164    long bytes_to_write;
    11731165
    1174     datablock = malloc(TAPE_BLOCK_SIZE);
     1166    datablock = mr_malloc(TAPE_BLOCK_SIZE);
    11751167    malloc_string(temp_fname);
    11761168    pB = strrchr(the_file_I_was_reading, '/');
    … …  
    12651257    log_msg(2, "Reading %s (it matches %s)", temp_fname,
    12661258            the_file_I_was_reading);
    1267     paranoid_free(temp_fname);
    1268     paranoid_free(datablock);
     1259    mr_free(temp_fname);
     1260    mr_free(datablock);
    12691261    return (0);
    12701262}
    … …  
    13131305        log_msg(3, "Next tape opened OK. Whoopee!");
    13141306    }
    1315     paranoid_free(sz_msg);
     1307    mr_free(sz_msg);
    13161308    return (res);
    13171309}
    … …  
    14131405        }
    14141406    }
    1415     paranoid_free(fname);
     1407    mr_free(fname);
    14161408    log_msg(2, "Finished writing back catalog to tape");
    14171409    return (res);

  • branches/stable/mondo/src/common/libmondo-string.c

    r1063 r1080  
    88
    99#include "my-stuff.h"
     10#include "mr_mem.h"
    1011#include "mondostructures.h"
    1112#include "libmondo-string.h"
    … …  
    220221    malloc_string(tmp);
    221222    if (!incoming[0]) {
    222         free(tmp);
     223        mr_free(tmp);
    223224        return (0);
    224225    }
    … …  
    254255        fatal_error(tmp);
    255256    }
    256     paranoid_free(tmp);
     257    mr_free(tmp);
    257258    return (outval);
    258259}
    … …  
    512513    char *p;
    513514
    514     input = malloc(2000);
     515    input = mr_malloc(2000);
    515516    assert_string_is_neither_NULL_nor_zerolength(ip);
    516517    assert_string_is_neither_NULL_nor_zerolength(token);
    … …  
    526527        strcat(output, p);
    527528    }
    528     paranoid_free(input);
     529    mr_free(input);
    529530}
    530531
    … …  
    796797    }
    797798    in_out[i] = '\0';
    798     paranoid_free(tmp);
     799    mr_free(tmp);
    799800/*  for(i=strlen(in_out); i>0 && in_out[i-1]<=32; i--) {in_out[i-1]='\0';} */
    800801}
    … …  
    10181019        strcpy(out_reason, reason);
    10191020    }
    1020     paranoid_free(filename);
    1021     paranoid_free(reason);
     1021    mr_free(filename);
     1022    mr_free(reason);
    10221023    return (sev);
    10231024}
    … …  
    11121113    j = (int) strlen(outstr);
    11131114    sprintf(outstr + j, "] %d%% used", percentage);
    1114     paranoid_free(pos_w_commas);
    1115     paranoid_free(tmp);
     1115    mr_free(pos_w_commas);
     1116    mr_free(tmp);
    11161117    return (outstr);
    11171118}

  • branches/stable/mondo/src/common/libmondo-tools.c

    r1075 r1080  
    1010
    1111#include "my-stuff.h"
     12#include "mr_mem.h"
    1213#include "mondostructures.h"
    1314#include "lib-common-externs.h"
    … …  
    175176else { print $0;};}' $file.old  > $file ; fi ; done");
    176177    run_program_and_log_output(tmp, 5);
    177     paranoid_free(tmp);
     178    mr_free(tmp);
    178179}
    179180
    … …  
    724725    chmod(bkpinfo->tmpdir, 0700);
    725726    g_backup_media_type = bkpinfo->backup_media_type;
    726     paranoid_free(mtpt);
    727     paranoid_free(extra_cdrom_params);
    728     paranoid_free(mondo_mkisofs_sz);
    729     paranoid_free(command);
    730     paranoid_free(hostname);
    731     paranoid_free(ip_address);
    732     paranoid_free(cdr_exe);
    733     paranoid_free(tmp);
    734     paranoid_free(iso_dev);
    735     paranoid_free(iso_mnt);
    736     paranoid_free(iso_tmp);
    737     paranoid_free(iso_path);
     727    mr_free(mtpt);
     728    mr_free(extra_cdrom_params);
     729    mr_free(mondo_mkisofs_sz);
     730    mr_free(command);
     731    mr_free(hostname);
     732    mr_free(ip_address);
     733    mr_free(cdr_exe);
     734    mr_free(tmp);
     735    mr_free(iso_dev);
     736    mr_free(iso_mnt);
     737    mr_free(iso_tmp);
     738    mr_free(iso_path);
    738739    return (retval);
    739740}
    … …  
    13901391    }
    13911392    depth--;
    1392     paranoid_free(tmp);
     1393    mr_free(tmp);
    13931394}
    13941395
    … …  
    14041405 * @bug This function seems orphaned. Please remove.
    14051406 */
    1406 #define do_alloc_or_free_depending(x,y) { if(y) {x=malloc(MAX_STR_LEN);} else {paranoid_free(x);} }
     1407#define do_alloc_or_free_depending(x,y) { if(y) {x=mr_malloc(MAX_STR_LEN);} else {mr_free(x);} }
    14071408
    14081409/**
    … …  
    14221423    } else {
    14231424        iamhere("Freeing globals");
    1424         paranoid_free(g_boot_mountpt);
    1425         paranoid_free(g_mondo_home);
    1426         paranoid_free(g_tmpfs_mountpt);
    1427         paranoid_free(g_erase_tmpdir_and_scratchdir);
    1428         paranoid_free(g_serial_string);
    1429         paranoid_free(g_magicdev_command);
     1425        mr_free(g_boot_mountpt);
     1426        mr_free(g_mondo_home);
     1427        mr_free(g_tmpfs_mountpt);
     1428        mr_free(g_erase_tmpdir_and_scratchdir);
     1429        mr_free(g_serial_string);
     1430        mr_free(g_magicdev_command);
    14301431    }
    14311432
    … …  
    15091510        paranoid_system(tmp);
    15101511    }
    1511     paranoid_free(tmp);
     1512    mr_free(tmp);
    15121513}
    15131514

  • branches/stable/mondo/src/common/libmondo-verify.c

    r1075 r1080  
    99
    1010#include "my-stuff.h"
     11#include "mr_mem.h"
    1112#include "mondostructures.h"
    1213#include "libmondo-verify.h"
    … …  
    5960    long afio_diffs = 0;
    6061
    61     command = malloc(2000);
    62     afio_found_changes = malloc(500);
     62    command = mr_malloc(2000);
     63    afio_found_changes = mr_malloc(500);
    6364    assert_string_is_neither_NULL_nor_zerolength(changedfiles_fname);
    6465    assert_string_is_neither_NULL_nor_zerolength(ignorefiles_fname);
    … …  
    100101    log_msg(2, command);
    101102    paranoid_system(command);
    102     paranoid_free(command);
    103     paranoid_free(afio_found_changes);
     103    mr_free(command);
     104    mr_free(afio_found_changes);
    104105    return (afio_diffs);
    105106}
    … …  
    179180    g_last_afioball_number = set_number - 1;
    180181    close_evalcall_form();
    181     paranoid_free(tmp);
     182    mr_free(tmp);
    182183    return (retval);
    183184}
    … …  
    229230    malloc_string(sz_exe);
    230231    if (!bufblkA) {
    231         if (!(bufblkA = malloc(maxbufsize))) {
    232             fatal_error("Cannot malloc bufblkA");
    233         }
     232        bufblkA = mr_malloc(maxbufsize);
    234233    }
    235234    if (!bufblkB) {
    236         if (!(bufblkB = malloc(maxbufsize))) {
    237             fatal_error("Cannot malloc bufblkB");
    238         }
     235        bufblkB = mr_malloc(maxbufsize);
    239236    }
    240237
    … …  
    369366    close_evalcall_form();
    370367    if (bufblkA) {
    371         paranoid_free(bufblkA);
     368        mr_free(bufblkA);
    372369    }
    373370    if (bufblkB) {
    374         paranoid_free(bufblkB);
    375     }
    376     paranoid_free(tmp);
    377     paranoid_free(command);
    378     paranoid_free(sz_exe);
    379     paranoid_free(mountpoint);
     371        mr_free(bufblkB);
     372    }
     373    mr_free(tmp);
     374    mr_free(command);
     375    mr_free(sz_exe);
     376    mr_free(mountpoint);
    380377    return (0);
    381378}
    … …  
    413410
    414411
    415     command = malloc(2000);
     412    command = mr_malloc(2000);
    416413    malloc_string(outlog);
    417414    malloc_string(tmp);
    … …  
    506503    //  paranoid_system (tmp);
    507504    //  unlink ("/tmp/mondo-verify.err");
    508     paranoid_free(command);
    509     paranoid_free(outlog);
    510     paranoid_free(tmp);
     505    mr_free(command);
     506    mr_free(outlog);
     507    mr_free(tmp);
    511508    return (0);
    512509}
    … …  
    596593    }
    597594    unlink(tarball_fname);
    598     paranoid_free(tmp);
    599     paranoid_free(tarball_fname);
     595    mr_free(tmp);
     596    mr_free(tarball_fname);
    600597    return (retval);
    601598}
    … …  
    688685        }
    689686    }
    690     paranoid_free(test_file);
    691     paranoid_free(biggie_cksum);
    692     paranoid_free(orig_cksum);
    693     paranoid_free(tmp);
    694     paranoid_free(slice_fnam);
     687    mr_free(test_file);
     688    mr_free(biggie_cksum);
     689    mr_free(orig_cksum);
     690    mr_free(tmp);
     691    mr_free(slice_fnam);
    695692    return (retval);
    696693}
    … …  
    798795    log_msg(1, "All done with afioballs");
    799796    close_progress_form();
    800     paranoid_free(tmp);
    801     paranoid_free(fname);
    802     paranoid_free(curr_xattr_list_fname);
    803     paranoid_free(curr_acl_list_fname);
     797    mr_free(tmp);
     798    mr_free(fname);
     799    mr_free(curr_xattr_list_fname);
     800    mr_free(curr_acl_list_fname);
    804801    return (retval);
    805802}
    … …  
    900897    }
    901898    close_progress_form();
    902     paranoid_free(orig_fname);
    903     paranoid_free(logical_fname);
    904     paranoid_free(curr_xattr_list_fname);
    905     paranoid_free(curr_acl_list_fname);
    906     paranoid_free(comment);
    907     paranoid_free(tmp);
     899    mr_free(orig_fname);
     900    mr_free(logical_fname);
     901    mr_free(curr_xattr_list_fname);
     902    mr_free(curr_acl_list_fname);
     903    mr_free(comment);
     904    mr_free(tmp);
    908905    return (retval);
    909906}
    … …  
    946943#endif
    947944
    948     command = malloc(2000);
     945    command = mr_malloc(2000);
    949946    malloc_string(mountpoint);
    950947    malloc_string(tmp);
    … …  
    10371034        }
    10381035    }
    1039     paranoid_free(command);
    1040     paranoid_free(mountpoint);
    1041     paranoid_free(tmp);
    1042     paranoid_free(fname);
     1036    mr_free(command);
     1037    mr_free(mountpoint);
     1038    mr_free(tmp);
     1039    mr_free(fname);
    10431040    return (retval);
    10441041}

  • branches/stable/mondo/src/common/newt-specific.c

    r1075 r1080  
    1919
    2020#include "my-stuff.h"
     21#include "mr_mem.h"
    2122#include "mondostructures.h"
    2223#include "newt-specific.h"
    … …  
    120121        int i;
    121122
    122          tmp = malloc(MAX_NEWT_COMMENT_LEN);
     123         tmp = mr_malloc(MAX_NEWT_COMMENT_LEN);
    123124         assert_string_is_neither_NULL_nor_zerolength(prompt);
    124125
    … …  
    138139                }
    139140                if (strstr("yesYES", tmp)) {
    140                     paranoid_free(tmp);
     141                    mr_free(tmp);
    141142                    return (TRUE);
    142143                } else if (strstr("NOno", tmp)) {
    143                     paranoid_free(tmp);
     144                    mr_free(tmp);
    144145                    return (FALSE);
    145146                } else {
    … …  
    150151            }
    151152        } else {
    152             paranoid_free(tmp);
     153            mr_free(tmp);
    153154            return (popup_with_buttons(prompt, "Yes", "No"));
    154155        }
    … …  
    168169        int i;
    169170
    170         tmp = malloc(MAX_NEWT_COMMENT_LEN);
     171        tmp = mr_malloc(MAX_NEWT_COMMENT_LEN);
    171172        assert_string_is_neither_NULL_nor_zerolength(prompt);
    172173        if (g_text_mode) {
    … …  
    184185            }
    185186            if (strstr("okOKOkYESyes", tmp)) {
    186                 paranoid_free(tmp);
     187                mr_free(tmp);
    187188                return (TRUE);
    188189            } else {
    189                 paranoid_free(tmp);
     190                mr_free(tmp);
    190191                return (FALSE);
    191192            }
    192193        } else {
    193             paranoid_free(tmp);
     194            mr_free(tmp);
    194195            return (popup_with_buttons(prompt, " Okay ", "Cancel"));
    195196        }
    … …  
    259260asprintf(&tmp,"kill `ps %s | grep \" %s \" | awk '{print %s;}' | grep -vx \"\\?\"`", ps_options, str , ps_proc_id);
    260261run_program_and_log_output(tmp, TRUE);
    261 paranoid_free(tmp);
     262mr_free(tmp);
    262263}
    263264
    … …  
    281282
    282283        malloc_string(command);
    283         tmp = malloc(MAX_NEWT_COMMENT_LEN);
     284        tmp = mr_malloc(MAX_NEWT_COMMENT_LEN);
    284285        set_signals(FALSE);     // link to external func
    285286        g_exiting = TRUE;
    … …  
    289290            log_msg(2, "mastermind %d is exiting", (int) getpid());
    290291            kill(g_main_pid, SIGTERM);
    291             paranoid_free(tmp);
     292            mr_free(tmp);
    292293            finish(1);
    293294        }
    … …  
    297298                log_msg(2, "non-m/m %d is exiting", (int) getpid());
    298299                kill(g_main_pid, SIGTERM);
    299                 paranoid_free(tmp);
     300                mr_free(tmp);
    300301                finish(1);
    301302            }
    … …  
    305306        if (already_exiting) {
    306307            log_msg(3, "...I'm already exiting. Give me time, Julian!");
    307             paranoid_free(tmp);
     308            mr_free(tmp);
    308309            finish(1);
    309310        }
    … …  
    360361            log_msg(3, "FYI - g_main_pid is blank");
    361362        }
    362         paranoid_free(tmp);
    363         paranoid_free(command);
     363        mr_free(tmp);
     364        mr_free(command);
    364365        finish(254);
    365366    }
    … …  
    445446
    446447        if (!does_file_exist(filename)) {
    447             paranoid_free(command);
    448             paranoid_free(tmp);
     448            mr_free(command);
     449            mr_free(tmp);
    449450            return;
    450451        }
    … …  
    478479        }
    479480        refresh_log_screen();
    480         paranoid_free(command);
    481         paranoid_free(tmp);
     481        mr_free(command);
     482        mr_free(tmp);
    482483    }
    483484
    … …  
    533534            refresh_log_screen();
    534535        }
    535         paranoid_free(output);
     536        mr_free(output);
    536537    }
    537538
    … …  
    606607        }
    607608        update_evalcall_form(0);
    608         paranoid_free(tmp);
    609         paranoid_free(title);
     609        mr_free(tmp);
     610        mr_free(title);
    610611    }
    611612
    … …  
    680681        }
    681682        update_progress_form_full(blurb1, blurb2, blurb3);
    682         paranoid_free(b1c);
    683         paranoid_free(blurb1);
    684         paranoid_free(blurb2);
    685         paranoid_free(blurb3);
     683        mr_free(b1c);
     684        mr_free(blurb1);
     685        mr_free(blurb2);
     686        mr_free(blurb3);
    686687    }
    687688
    … …  
    733734        char *original_contents;
    734735
    735         blurb = malloc(MAX_NEWT_COMMENT_LEN);
    736         original_contents = malloc(MAX_NEWT_COMMENT_LEN);
     736        blurb = mr_malloc(MAX_NEWT_COMMENT_LEN);
     737        original_contents = mr_malloc(MAX_NEWT_COMMENT_LEN);
    737738        assert_string_is_neither_NULL_nor_zerolength(title);
    738739        assert(b != NULL);
    … …  
    746747            if (output[strlen(output) - 1] == '\n')
    747748                output[strlen(output) - 1] = '\0';
    748             paranoid_free(blurb);
    749             paranoid_free(original_contents);
     749            mr_free(blurb);
     750            mr_free(original_contents);
    750751            return (TRUE);
    751752        }
    … …  
    778779        if (b_res == b_2) {
    779780            strcpy(output, original_contents);
    780             paranoid_free(blurb);
    781             paranoid_free(original_contents);
     781            mr_free(blurb);
     782            mr_free(original_contents);
    782783            return (FALSE);
    783784        } else {
    784             paranoid_free(blurb);
    785             paranoid_free(original_contents);
     785            mr_free(blurb);
     786            mr_free(original_contents);
    786787            return (TRUE);
    787788        }
    … …  
    808809        newtComponent text;
    809810
    810         prompt = malloc(MAX_NEWT_COMMENT_LEN);
    811         tmp = malloc(MAX_NEWT_COMMENT_LEN);
     811        prompt = mr_malloc(MAX_NEWT_COMMENT_LEN);
     812        tmp = mr_malloc(MAX_NEWT_COMMENT_LEN);
    812813        assert_string_is_neither_NULL_nor_zerolength(p);
    813814        assert(button1 != NULL);
    … …  
    826827            }
    827828            if (!strcmp(tmp, button1)) {
    828                 paranoid_free(tmp);
    829                 paranoid_free(prompt);
     829                mr_free(tmp);
     830                mr_free(prompt);
    830831                return (TRUE);
    831832            } else {
    832                 paranoid_free(tmp);
    833                 paranoid_free(prompt);
     833                mr_free(tmp);
     834                mr_free(prompt);
    834835                return (FALSE);
    835836            }
    … …  
    862863        newtPopWindow();
    863864        if (b_res == b_1) {
    864             paranoid_free(tmp);
    865             paranoid_free(prompt);
     865            mr_free(tmp);
     866            mr_free(prompt);
    866867            return (TRUE);
    867868        } else {
    868             paranoid_free(tmp);
    869             paranoid_free(prompt);
     869            mr_free(tmp);
     870            mr_free(prompt);
    870871            return (FALSE);
    871872        }
    … …  
    927928
    928929        err_log_lines =
    929             (char **) malloc(sizeof(char *) * g_noof_log_lines);
     930            (char **) mr_malloc(sizeof(char *) * g_noof_log_lines);
    930931        if (!err_log_lines) {
    931932            fatal_error("Out of memory");
    … …  
    933934
    934935        for (i = 0; i < g_noof_log_lines; i++) {
    935             err_log_lines[i] = (char *) malloc(MAX_NEWT_COMMENT_LEN);
     936            err_log_lines[i] = (char *) mr_malloc(MAX_NEWT_COMMENT_LEN);
    936937            if (!err_log_lines[i]) {
    937938                fatal_error("Out of memory");
    … …  
    10431044            newtRefresh();
    10441045        }
    1045         paranoid_free(timeline_str);
    1046         paranoid_free(pcline_str);
    1047         paranoid_free(taskprogress);
     1046        mr_free(timeline_str);
     1047        mr_free(pcline_str);
     1048        mr_free(taskprogress);
    10481049    }
    10491050
    … …  
    11041105
    11051106//  log_msg(1, "'%s' '%s' '%s'", blurb1, blurb2, blurb3);
    1106         percentline_str = malloc(MAX_NEWT_COMMENT_LEN);
    1107         timeline_str = malloc(MAX_NEWT_COMMENT_LEN);
    1108         taskprogress = malloc(MAX_NEWT_COMMENT_LEN);
     1107        percentline_str = mr_malloc(MAX_NEWT_COMMENT_LEN);
     1108        timeline_str = mr_malloc(MAX_NEWT_COMMENT_LEN);
     1109        taskprogress = mr_malloc(MAX_NEWT_COMMENT_LEN);
    11091110        malloc_string(tmp);
    11101111        if (!g_text_mode) {
    … …  
    11901191            newtRefresh();
    11911192        }
    1192         paranoid_free(percentline_str);
    1193         paranoid_free(timeline_str);
    1194         paranoid_free(taskprogress);
    1195         paranoid_free(tmp);
     1193        mr_free(percentline_str);
     1194        mr_free(timeline_str);
     1195        mr_free(taskprogress);
     1196        mr_free(tmp);
    11961197    }
    11971198
    … …  
    12461247        newtComponent myForm;
    12471248
    1248         title_sz = malloc(MAX_NEWT_COMMENT_LEN);
    1249         minimsg_sz = malloc(MAX_NEWT_COMMENT_LEN);
    1250         outstr = malloc(MAX_NEWT_COMMENT_LEN);
     1249        title_sz = mr_malloc(MAX_NEWT_COMMENT_LEN);
     1250        minimsg_sz = mr_malloc(MAX_NEWT_COMMENT_LEN);
     1251        outstr = mr_malloc(MAX_NEWT_COMMENT_LEN);
    12511252        if (g_text_mode) {
    12521253            for (backup_type = none; backup_type == none;) {
    … …  
    12651266                }
    12661267            }
    1267             paranoid_free(title_sz);
    1268             paranoid_free(minimsg_sz);
    1269             paranoid_free(outstr);
     1268            mr_free(title_sz);
     1269            mr_free(minimsg_sz);
     1270            mr_free(outstr);
    12701271            return (backup_type);
    12711272        }
    … …  
    13151316        }
    13161317        newtPopHelpLine();
    1317         paranoid_free(title_sz);
    1318         paranoid_free(minimsg_sz);
    1319         paranoid_free(outstr);
     1318        mr_free(title_sz);
     1319        mr_free(minimsg_sz);
     1320        mr_free(outstr);
    13201321        return (output);
    13211322    }
    … …  
    14031404            log_msg(2, "Can't open %s; therefore, cannot popup list",
    14041405                    source_file);
    1405             paranoid_free(tmp);
     1406            mr_free(tmp);
    14061407            return (1);
    14071408        }
    … …  
    14371438        if (filelist->entries >= ARBITRARY_MAXIMUM) {
    14381439            log_to_screen("Arbitrary limits suck, man!");
    1439             paranoid_free(tmp);
     1440            mr_free(tmp);
    14401441            return (1);
    14411442        }
    … …  
    14651466            }
    14661467        }
    1467         paranoid_free(tmp);
     1468        mr_free(tmp);
    14681469        iamhere("leaving");
    14691470        return (0);
    … …  
    14981499        tmp[98] = '\0';
    14991500        strcpy(comment, tmp);
    1500         paranoid_free(tmp);
     1501        mr_free(tmp);
    15011502        iamhere("leaving");
    15021503        return (comment);
    … …  
    15391540        struct s_filelist *filelist;
    15401541        malloc_string(reason);
    1541         tmp = malloc(5000);
     1542        tmp = mr_malloc(5000);
    15421543        malloc_string(differ_sz);
    15431544        assert_string_is_neither_NULL_nor_zerolength(source_file);
    … …  
    15511552        if (lng < 1) {
    15521553            log_msg(2, "No lines in file. Therefore, no popup list.");
    1553             paranoid_free(reason);
     1554            mr_free(reason);
    15541555            goto free_to_go;
    15551556        } else if (lng >= ARBITRARY_MAXIMUM) {
    … …  
    15581559        }
    15591560
    1560         filelist = (struct s_filelist *) malloc(sizeof(struct s_filelist));
     1561        filelist = (struct s_filelist *) mr_malloc(sizeof(struct s_filelist));
    15611562        fileListbox =
    15621563            newtListbox(2, 2, 12, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
    … …  
    15661567            log_msg(2, "Can't open %s; therefore, cannot popup list",
    15671568                    source_file);
    1568             paranoid_free(reason);
     1569            mr_free(reason);
    15691570            return;
    15701571        }
    … …  
    16181619        newtPopHelpLine();
    16191620      free_to_go:
    1620         paranoid_free(reason);
    1621         paranoid_free(tmp);
    1622         paranoid_free(differ_sz);
     1621        mr_free(reason);
     1622        mr_free(tmp);
     1623        mr_free(differ_sz);
    16231624        return;
    16241625    }
Note: See TracChangeset for help on using the changeset viewer.