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

Legend:

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

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