Changeset 2521


Ignore:
Timestamp:
Jan 4, 2010, 7:42:31 PM (10 years ago)
Author:
bruno
Message:

r3231@localhost (orig r2265): bruno | 2009-07-12 02:04:40 +0200

r3206@localhost: bruno | 2009-07-06 23:29:05 +0200

  • Replace sprintf by mr_asprintf in libmondo-filelist.c


File:
1 edited

Legend:

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

    r2469 r2521  
    7878{
    7979    /*@ buffers *********************** */
    80     char *dev;
    81     char *filelist;
    82     char *tempfile;
    83     char *cksumlist;
    84     char *tmp;
     80    char *dev = NULL;
     81    char *filelist = NULL;
     82    char *tempfile = NULL;
    8583    long noof_sets;
    8684
     
    9290    int i, retval = 0;
    9391
    94     malloc_string(dev);
    95     malloc_string(filelist);
    96     malloc_string(tempfile);
    97     malloc_string(cksumlist);
    98     malloc_string(tmp);
    9992    mvaddstr_and_log_it(g_currentY, 0, "Dividing filelist into sets");
    10093
    10194    log_to_screen("Dividing filelist into sets. Please wait.");
    10295    i = 0;
    103     sprintf(filelist, "%s/archives/filelist.full", bkpinfo->scratchdir);
    104     sprintf(cksumlist, "%s/cklist.full", bkpinfo->tmpdir);
     96    mr_asprintf(&filelist, "%s/archives/filelist.full", bkpinfo->scratchdir);
    10597    if (!does_file_exist(filelist)) {
    10698        log_it("filelist %s not found", filelist);
     99        mr_free(filelist);
    107100        fatal_error("call_filelist_chopper() -- filelist not found!");
    108101    }
    109102
    110     noof_sets =
    111         chop_filelist(filelist, bkpinfo->tmpdir,
    112                       bkpinfo->optimal_set_size);
     103    noof_sets = chop_filelist(filelist, bkpinfo->tmpdir, bkpinfo->optimal_set_size);
     104    mr_free(filelist);
    113105    estimate_noof_media_required(noof_sets);    // for cosmetic purposes
    114106
    115     sprintf(tempfile, "%s/biggielist.txt", bkpinfo->tmpdir);
     107    mr_asprintf(&tempfile, "%s/biggielist.txt", bkpinfo->tmpdir);
    116108    if (!(fout = fopen(tempfile, "a"))) {
    117109        log_OS_error("Cannot append to biggielist");
    118110        retval++;
    119         goto end_of_func;
    120     }
     111        mr_free(tempfile);
     112        return (retval);
     113    }
     114    mr_free(tempfile);
     115
    121116    log_it(bkpinfo->image_devs);
    122117
    123118    ptr = bkpinfo->image_devs;
    124119
     120    malloc_string(dev);
    125121    while (ptr && *ptr) {
    126122        strcpy(dev, ptr);
     
    140136    mvaddstr_and_log_it(g_currentY++, 74, "Done.");
    141137
    142   end_of_func:
    143     paranoid_free(filelist);
    144     paranoid_free(tempfile);
    145     paranoid_free(cksumlist);
    146138    paranoid_free(dev);
    147     paranoid_free(tmp);
    148139    return (retval);
    149140}
     
    153144int sort_file(char *orig_fname)
    154145{
    155     char *tmp_fname;
    156     char *command;
     146    char *tmp_fname = NULL;
     147    char *command = NULL;
    157148    int retval = 0;
    158149
    159150    log_msg(5, "Sorting file %s", orig_fname);
    160     malloc_string(tmp_fname);
    161     malloc_string(command);
    162     sprintf(tmp_fname, "%s/sortfile", bkpinfo->tmpdir);
    163151
    164152    if (!does_file_exist(orig_fname)) {
     
    167155    }                           // no sense in trying to sort an empty file
    168156
    169     sprintf(command, "sort %s > %s 2>> %s", orig_fname, tmp_fname,
    170             MONDO_LOGFILE);
     157    mr_asprintf(&tmp_fname, "%s/sortfile", bkpinfo->tmpdir);
     158
     159    mr_asprintf(&command, "sort %s > %s 2>> %s", orig_fname, tmp_fname, MONDO_LOGFILE);
    171160    retval = system(command);
     161    mr_free(command);
     162
    172163    if (retval) {
    173164        log_msg(2, "Failed to sort %s - oh dear", orig_fname);
    174165    } else {
    175         log_msg(5, "Sorted %s --> %s OK. Copying it back to %s now",
    176                 orig_fname, tmp_fname, orig_fname);
    177         sprintf(command, "mv -f %s %s", tmp_fname, orig_fname);
     166        log_msg(5, "Sorted %s --> %s OK. Copying it back to %s now", orig_fname, tmp_fname, orig_fname);
     167        mr_asprintf(&command, "mv -f %s %s", tmp_fname, orig_fname);
    178168        retval += run_program_and_log_output(command, 5);
     169        mr_free(command);
     170
    179171        if (retval) {
    180             log_msg(2, "Failed to copy %s back to %s - oh dear", tmp_fname,
    181                     orig_fname);
     172            log_msg(2, "Failed to copy %s back to %s - oh dear", tmp_fname, orig_fname);
    182173        } else {
    183174            log_msg(5, "%s was sorted OK.", orig_fname);
    184175        }
    185176    }
    186     paranoid_free(tmp_fname);
    187     paranoid_free(command);
     177    mr_free(tmp_fname);
    188178    log_msg(5, "Finished sorting file %s", orig_fname);
    189179    return (retval);
     
    218208
    219209    /*@ buffers ************************************* */
    220     char *outfname;
    221     char *biggie_fname;
     210    char *outfname = NULL;
     211    char *biggie_fname = NULL;
    222212    char *incoming;
    223     char *tmp;
    224     char *acl_fname;
    225     char *xattr_fname;
     213    char *tmp = NULL;
    226214
    227215    /*@ pointers *********************************** */
     
    233221    struct stat buf;
    234222    int err = 0;
    235 
    236     malloc_string(outfname);
    237     malloc_string(biggie_fname);
    238     incoming = malloc(MAX_STR_LEN * 2);
    239     malloc_string(tmp);
    240     malloc_string(acl_fname);
    241     malloc_string(xattr_fname);
    242223
    243224    assert_string_is_neither_NULL_nor_zerolength(filelist);
     
    259240    curr_set_no = 0;
    260241    curr_set_size = 0;
    261     sprintf(outfname, "%s/filelist.%ld", outdir, curr_set_no);
    262     sprintf(biggie_fname, "%s/biggielist.txt", outdir);
     242    mr_asprintf(&outfname, "%s/filelist.%ld", outdir, curr_set_no);
     243    mr_asprintf(&biggie_fname, "%s/biggielist.txt", outdir);
    263244    log_it("outfname=%s; biggie_fname=%s", outfname, biggie_fname);
    264245    if (!(fbig = fopen(biggie_fname, "w"))) {
    265246        log_OS_error("Cannot openout biggie_fname");
    266247        err++;
    267         goto end_of_func;
     248        mr_free(outfname);
     249        mr_free(biggie_fname);
     250        return (curr_set_no + 1);
    268251    }
    269252    if (!(fout = fopen(outfname, "w"))) {
    270253        log_OS_error("Cannot openout outfname");
    271254        err++;
    272         goto end_of_func;
    273     }
     255        mr_free(outfname);
     256        mr_free(biggie_fname);
     257        return (curr_set_no + 1);
     258    }
     259    incoming = malloc(MAX_STR_LEN * 2);
     260
    274261    (void) fgets(incoming, MAX_STR_LEN * 2 - 1, fin);
    275262    while (!feof(fin)) {
     
    294281            siz = (long) (buf.st_size >> 10);
    295282        }
    296         if (siz > max_sane_size_for_a_file)
    297 // && strcmp(incoming+strlen(incoming)-4, ".bz2") && strcmp(incoming+strlen(incoming)-4, ".tbz"))
    298         {
     283        if (siz > max_sane_size_for_a_file) {
    299284            fprintf(fbig, "%s\n", incoming);
    300285        } else {
     
    304289                paranoid_fclose(fout);
    305290                sort_file(outfname);
     291                mr_free(outfname);
    306292                curr_set_no++;
    307293                curr_set_size = 0;
    308                 sprintf(outfname, "%s/filelist.%ld", outdir, curr_set_no);
     294
     295                mr_asprintf(&outfname, "%s/filelist.%ld", outdir, curr_set_no);
    309296                if (!(fout = fopen(outfname, "w"))) {
    310297                    log_OS_error("Unable to openout outfname");
    311298                    err++;
    312                     goto end_of_func;
     299                    mr_free(outfname);
     300                    mr_free(biggie_fname);
     301                    paranoid_free(incoming);
     302                    return (curr_set_no + 1);
    313303                }
    314                 sprintf(tmp, "Fileset #%ld chopped ", curr_set_no - 1);
    315304                update_evalcall_form((int) (lino * 100 / noof_lines));
    316                 /*              if (!g_text_mode) {newtDrawRootText(0,22,tmp);newtRefresh();} else {log_it(tmp);} */
    317305            }
    318306        }
    319307        (void) fgets(incoming, MAX_STR_LEN * 2 - 1, fin);
    320308    }
     309    paranoid_free(incoming);
    321310    paranoid_fclose(fin);
    322311    paranoid_fclose(fout);
     
    329318    g_noof_sets = curr_set_no;
    330319    sort_file(outfname);
     320    mr_free(outfname);
     321
    331322    sort_file(biggie_fname);
    332     sprintf(outfname, "%s/LAST-FILELIST-NUMBER", outdir);
    333     sprintf(tmp, "%ld", curr_set_no);
     323    mr_free(biggie_fname);
     324
     325    mr_asprintf(&outfname, "%s/LAST-FILELIST-NUMBER", outdir);
     326    mr_asprintf(&tmp, "%ld", curr_set_no);
    334327    if (write_one_liner_data_file(outfname, tmp)) {
    335328        log_OS_error
     
    337330        err = 1;
    338331    }
     332    mr_free(tmp);
     333    mr_free(outfname);
     334
    339335    if (curr_set_no == 0) {
    340         sprintf(tmp, "Only one fileset. Fine.");
     336        mr_asprintf(&tmp, "Only one fileset. Fine.");
    341337    } else {
    342         sprintf(tmp, "Filelist divided into %ld sets", curr_set_no + 1);
     338        mr_asprintf(&tmp, "Filelist divided into %ld sets", curr_set_no + 1);
    343339    }
    344340    log_msg(1, tmp);
     341    mr_free(tmp);
    345342    close_evalcall_form();
    346343    /* This is to work around an obscure bug in Newt; open a form, close it,
     
    356353    }
    357354#endif
    358   end_of_func:
    359     paranoid_free(outfname);
    360     paranoid_free(biggie_fname);
    361     paranoid_free(incoming);
    362     paranoid_free(tmp);
    363     paranoid_free(acl_fname);
    364     paranoid_free(xattr_fname);
    365355    return (err ? 0 : curr_set_no + 1);
    366356}
     
    452442    FILE *fin;
    453443    FILE *pout;
    454     char *pout_command;
     444    char *pout_command = NULL;
    455445    char *syscall;
    456446    char *file_to_analyze;
     
    463453        return (1);
    464454    }
    465     malloc_string(pout_command);
    466     sprintf(pout_command, "gzip -c1 > %s", auxlist_fname);
     455    mr_asprintf(&pout_command, "gzip -c1 > %s", auxlist_fname);
    467456    if (!(pout = popen(pout_command, "w"))) {
    468457        log_msg(1, "Cannot openout auxlist_fname %s", auxlist_fname);
    469458        fclose(fin);
    470         paranoid_free(pout_command);
     459        mr_free(pout_command);
    471460        return (4);
    472461    }
     462    mr_free(pout_command);
     463
    473464    malloc_string(file_to_analyze);
    474465    for ((void)fgets(file_to_analyze, MAX_STR_LEN, fin); !feof(fin);
     
    490481    paranoid_pclose(pout);
    491482    paranoid_free(file_to_analyze);
    492     paranoid_free(pout_command);
    493483    return (0);
    494484}
     
    497487int get_acl_list(char *filelist, char *facl_fname)
    498488{
    499     char *command;
     489    char *command = NULL;
    500490    int retval = 0;
    501491
    502492    if (g_getfacl != NULL) {
    503         malloc_string(command);
    504         sprintf(command, "touch %s", facl_fname);
     493        mr_asprintf(&command, "touch %s", facl_fname);
    505494        run_program_and_log_output(command, 8);
    506 //      sort_file(filelist); // FIXME - filelist chopper sorts, so this isn't necessary
    507         sprintf(command,
     495        mr_free(command);
     496
     497        mr_asprintf(&command,
    508498                "getfacl --all-effective -P %s 2>> %s | gzip -c1 > %s 2>> %s",
    509499                filelist, MONDO_LOGFILE, facl_fname, MONDO_LOGFILE);
    510500        log_it("%s",command);
    511501        retval = system(command);
    512         paranoid_free(command);
     502        mr_free(command);
    513503    }
    514504    return (retval);
     
    522512
    523513    if (g_getfattr != NULL) {
    524         malloc_string(command);
    525         sprintf(command, "touch %s", fattr_fname);
     514        mr_asprintf(&command, "touch %s", fattr_fname);
    526515        run_program_and_log_output(command, 8);
    527         paranoid_free(command);
    528 //      sort_file(filelist); // FIXME - filelist chopper sorts, so this isn't necessary
     516        mr_free(command);
    529517        retval =
    530518            gen_aux_list(filelist, "getfattr --en=hex -P -m - -d \"%s\"",
     
    539527{
    540528    const int my_depth = 8;
    541     char *command, *syscall_pin, *syscall_pout, *incoming;
    542     char *current_subset_file, *current_master_file, *masklist;
     529    char *command = NULL;
     530    char *syscall_pin = NULL;
     531    char *syscall_pout = NULL;
     532    char *incoming;
     533    char *current_subset_file, *current_master_file;
     534    char *masklist = NULL;
    543535    int retval = 0;
    544536    int i;
     
    546538    FILE *pin, *pout, *faclin;
    547539
    548     malloc_string(command);
    549540    log_msg(1, "set_EXAT_list(%s, %s, %s)", orig_msklist,
    550541            original_exat_fname, executable);
    551542    if (!orig_msklist || !orig_msklist[0]
    552543        || !does_file_exist(orig_msklist)) {
    553         log_msg(1,
    554                 "No masklist provided. I shall therefore set ALL attributes.");
    555         sprintf(command, "gzip -dc %s | %s --restore - 2>> %s",
    556                 original_exat_fname, executable, MONDO_LOGFILE);
     544        log_msg(1, "No masklist provided. I shall therefore set ALL attributes.");
     545        mr_asprintf(&command, "gzip -dc %s | %s --restore - 2>> %s", original_exat_fname, executable, MONDO_LOGFILE);
    557546        log_msg(1, "command = %s", command);
    558547        retval = system(command);
    559         paranoid_free(command);
     548        mr_free(command);
    560549        log_msg(1, "Returning w/ retval=%d", retval);
    561550        return (retval);
     
    565554                "original_exat_fname %s is empty or missing, so no need to set EXAT list",
    566555                original_exat_fname);
    567         paranoid_free(command);
    568556        return (0);
    569557    }
    570558    malloc_string(incoming);
    571     malloc_string(masklist);
    572559    malloc_string(current_subset_file);
    573560    malloc_string(current_master_file);
    574     malloc_string(syscall_pin);
    575     malloc_string(syscall_pout);
    576     sprintf(masklist, "%s/masklist", bkpinfo->tmpdir);
    577     sprintf(command, "cp -f %s %s", orig_msklist, masklist);
     561    mr_asprintf(&masklist, "%s/masklist", bkpinfo->tmpdir);
     562    mr_asprintf(&command, "cp -f %s %s", orig_msklist, masklist);
    578563    run_program_and_log_output(command, 1);
     564    mr_free(command);
     565
    579566    sort_file(masklist);
    580567    current_subset_file[0] = current_master_file[0] = '\0';
    581     sprintf(syscall_pin, "gzip -dc %s", original_exat_fname);
    582     sprintf(syscall_pout, "%s --restore - 2>> %s", executable,
    583             MONDO_LOGFILE);
    584 
    585     log_msg(1, "syscall_pin = %s", syscall_pin);
     568
     569    mr_asprintf(&syscall_pout, "%s --restore - 2>> %s", executable, MONDO_LOGFILE);
    586570    log_msg(1, "syscall_pout = %s", syscall_pout);
    587571    pout = popen(syscall_pout, "w");
     572    mr_free(syscall_pout);
     573
    588574    if (!pout) {
    589575        log_it("Unable to openout to syscall_pout");
     576        mr_free(masklist);
    590577        return (1);
    591578    }
     579
     580    mr_asprintf(&syscall_pin, "gzip -dc %s", original_exat_fname);
     581    log_msg(1, "syscall_pin = %s", syscall_pin);
    592582    pin = popen(syscall_pin, "r");
     583    mr_free(syscall_pin);
     584
    593585    if (!pin) {
    594586        pclose(pout);
     
    601593        pclose(pout);
    602594        log_it("Unable to openin masklist");
     595        mr_free(masklist);
    603596        return (1);
    604597    }
     
    674667
    675668    unlink(masklist);
     669    mr_free(masklist);
     670
    676671    paranoid_free(current_subset_file);
    677672    paranoid_free(current_master_file);
    678     paranoid_free(syscall_pout);
    679     paranoid_free(syscall_pin);
    680     paranoid_free(masklist);
    681673    paranoid_free(incoming);
    682     paranoid_free(command);
    683674    return (retval);
    684675}
     
    718709    /*@ buffers ***************************************************** */
    719710    char val_sz[MAX_STR_LEN];
    720     char cfg_fname[MAX_STR_LEN];
    721 /*  char tmp[MAX_STR_LEN]; remove stan benoit apr 2002 */
     711    char *cfg_fname = NULL;
    722712
    723713    /*@ long ******************************************************** */
     
    729719
    730720    strcpy(val_sz,"");
    731     sprintf(cfg_fname, "%s/mondo-restore.cfg", bkpinfo->tmpdir);
     721    mr_asprintf(&cfg_fname, "%s/mondo-restore.cfg", bkpinfo->tmpdir);
    732722    read_cfg_var(cfg_fname, "last-filelist-number", val_sz);
     723    mr_free(cfg_fname);
     724
    733725    val_i = atoi(val_sz);
    734726    if (val_i <= 0) {
     
    870862
    871863    /*@ buffers **************************************************** */
    872     char command_to_open_fname[MAX_STR_LEN];
     864    char *command_to_open_fname = NULL;
    873865    char fname[MAX_STR_LEN];
    874866    char tmp[MAX_STR_LEN];
     867    char *tmp1 = NULL;
    875868    int pos_in_fname;
    876869    /*@ int ******************************************************** */
     
    888881    }
    889882    log_to_screen("Loading filelist");
    890     sprintf(command_to_open_fname, "gzip -dc %s", filelist_fname);
    891     sprintf(tmp, "zcat %s | wc -l", filelist_fname);
    892     log_msg(6, "tmp = %s", tmp);
    893     lines_in_filelist =
    894         atol(call_program_and_get_last_line_of_output(tmp));
     883    mr_asprintf(&tmp1, "zcat %s | wc -l", filelist_fname);
     884    log_msg(6, "tmp1 = %s", tmp1);
     885    lines_in_filelist = atol(call_program_and_get_last_line_of_output(tmp1));
     886    mr_free(tmp1);
     887
    895888    if (lines_in_filelist < 3) {
    896889        log_to_screen("Warning - surprisingly short filelist.");
     
    907900    (filelist->down)->right = (filelist->down)->down = FALSE;
    908901    (filelist->down)->expanded = (filelist->down)->selected = FALSE;
     902
     903    mr_asprintf(&command_to_open_fname, "gzip -dc %s", filelist_fname);
    909904    if (!(pin = popen(command_to_open_fname, "r"))) {
    910905        log_OS_error("Unable to openin filelist_fname");
     906        mr_free(command_to_open_fname);
    911907        return (NULL);
    912908    }
     909    mr_free(command_to_open_fname);
     910
    913911    open_evalcall_form("Loading filelist from disk");
    914912    for ((void)fgets(fname, MAX_STR_LEN, pin); !feof(pin);
     
    12051203    /*@ buffers ***************************************************** */
    12061204    static char current_filename[MAX_STR_LEN];
    1207     char tmp[MAX_STR_LEN + 2];
    12081205
    12091206    /*@ end vars *************************************************** */
     
    12251222                     pathname[j] != '\0'
    12261223                     && pathname[j] == current_filename[j]; j++);
    1227                 if (current_filename[j] == '/'
    1228                     || current_filename[j] == '\0') {
    1229                     node->selected = on_or_off;
    1230                     sprintf(tmp, "%s is now %s\n", current_filename,
    1231                             (on_or_off ? "ON" : "OFF"));
     1224                    if (current_filename[j] == '/'
     1225                        || current_filename[j] == '\0') {
     1226                        node->selected = on_or_off;
    12321227                }
    12331228            }
     
    15301525    int i;
    15311526    FILE *fout;
    1532     char *command;
     1527    char *command = NULL;
    15331528    time_t time_of_last_full_backup = 0;
    15341529    struct stat statbuf;
     
    15361531    char *tmp2 = NULL;
    15371532
    1538     malloc_string(command);
    15391533    malloc_string(tmp);
    15401534    malloc_string(g_skeleton_filelist);
     
    15481542    }
    15491543// make hole for filelist
    1550     sprintf(command, "mkdir -p %s/archives", scratchdir);
     1544    mr_asprintf(&command, "mkdir -p %s/archives", scratchdir);
    15511545    paranoid_system(command);
     1546    mr_free(command);
     1547
    15521548    mr_asprintf(&sz_filelist, "%s/tmpfs/filelist.full", tmpdir);
    15531549    make_hole_for_file(sz_filelist);
     
    15551551    if (differential == 0) {
    15561552        // restore last good datefile if it exists
    1557         sprintf(command, "cp -f %s.aborted %s", sz_datefile, sz_datefile);
     1553        mr_asprintf(&command, "cp -f %s.aborted %s", sz_datefile, sz_datefile);
    15581554        run_program_and_log_output(command, 3);
     1555        mr_free(command);
     1556
    15591557        // backup last known good datefile just in case :)
    15601558        if (does_file_exist(sz_datefile)) {
    1561             sprintf(command, "mv -f %s %s.aborted", sz_datefile,
     1559            mr_asprintf(&command, "mv -f %s %s.aborted", sz_datefile,
    15621560                    sz_datefile);
    15631561            paranoid_system(command);
     1562            mr_free(command);
    15641563        }
    15651564        make_hole_for_file(sz_datefile);
     
    15831582                "Using the user-specified filelist - %s - instead of calculating one",
    15841583                userdef_filelist);
    1585         sprintf(command, "cp -f %s %s", userdef_filelist, sz_filelist);
     1584        mr_asprintf(&command, "cp -f %s %s", userdef_filelist, sz_filelist);
    15861585        if (run_program_and_log_output(command, 3)) {
     1586            mr_free(command);
    15871587            fatal_error("Failed to copy user-specified filelist");
    15881588        }
     1589        mr_free(command);
    15891590    } else {
    15901591        log_msg(2, "include_paths = '%s'", include_paths);
     
    16391640    }
    16401641    log_msg(2, "Copying new filelist to scratchdir");
    1641     sprintf(command, "mkdir -p %s/archives", scratchdir);
     1642    mr_asprintf(&command, "mkdir -p %s/archives", scratchdir);
    16421643    paranoid_system(command);
    1643     sprintf(command, "cp -f %s %s/archives/", sz_filelist, scratchdir);
     1644    mr_free(command);
     1645
     1646    mr_asprintf(&command, "cp -f %s %s/archives/", sz_filelist, scratchdir);
    16441647    paranoid_system(command);
    1645     sprintf(command, "mv -f %s %s", sz_filelist, tmpdir);
     1648    mr_free(command);
     1649
     1650    mr_asprintf(&command, "mv -f %s %s", sz_filelist, tmpdir);
    16461651    paranoid_system(command);
     1652    mr_free(command);
     1653
    16471654    paranoid_free(sz_filelist);
    16481655    log_msg(2, "Freeing variables");
    1649     paranoid_free(command);
    16501656    paranoid_free(exclude_paths);
    16511657    paranoid_free(tmp);
     
    18221828        }
    18231829
    1824 /*
    1825       if (strlen(fname)>3 && fname[strlen(fname)-1]=='/') { fname[strlen(fname)-1] = '\0'; }
    1826       if (strlen(fname)==0) { continue; }
    1827       sprintf(temporary_string, "echo \"Looking for '%s'\" >> /tmp/looking.txt", fname);
    1828       system(temporary_string);
    1829 */
    1830 
    18311830        log_msg(5, "Looking for '%s'", fname);
    18321831        found_node = find_string_at_node(filelist, fname);
    18331832        if (found_node) {
    18341833            if (found_node->selected) {
    1835 //              if (use_star)
    18361834                if (fname[0] == '/') {
    18371835                    strcpy(tmp, fname + 1);
Note: See TracChangeset for help on using the changeset viewer.