Changeset 3060 in MondoRescue for branches/3.0/mondo/src/common


Ignore:
Timestamp:
Nov 10, 2012, 5:05:37 AM (11 years ago)
Author:
Bruno Cornec
Message:

r5035@localhost: bruno | 2012-11-09 03:17:01 +0100

  • Fix a compilation error and most compilation warnings
Location:
branches/3.0/mondo/src/common
Files:
12 edited

Legend:

Unmodified
Added
Removed

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

    r3056 r3060  
    10231023    char *curr_acl_list_fname;
    10241024
    1025     struct s_bkpinfo *bkpinfo_bis;
    10261025    char *tmp;
    10271026    int res = 0, retval = 0;
    … …  
    10411040    p_next_set_to_archive = (int *) (inbuf + 8);
    10421041    p_list_of_fileset_flags = (char *) (inbuf + 12);
    1043     bkpinfo_bis = (struct s_bkpinfo *) (inbuf + BKPINFO_LOC_OFFSET);
    10441042
    10451043    sprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ,
    … …  
    15971595
    15981596    log_msg(2, "make_usb_fs --- scratchdir=%s", bkpinfo->scratchdir);
    1599     (void) getcwd(old_pwd, MAX_STR_LEN - 1);
     1597    tmp1 = getcwd(old_pwd, MAX_STR_LEN - 1);
    16001598    mr_asprintf(&tmp, "chmod 700 %s", bkpinfo->scratchdir);
    16011599    run_program_and_log_output(tmp, FALSE);
    16021600    paranoid_free(tmp);
    1603     (void)chdir(bkpinfo->scratchdir);
     1601    if (chdir(bkpinfo->scratchdir)) {
     1602        // FIXME
     1603    }
    16041604
    16051605    mds = media_descriptor_string(bkpinfo->backup_media_type);
    … …  
    16601660    }
    16611661
    1662     (void)chdir(old_pwd);
     1662    if (chdir(old_pwd)) {
     1663        // FIXME
     1664    }
    16631665    if (retval) {
    16641666        log_msg(1, "WARNING - make_usb_fs returned an error");
    … …  
    17341736    log_msg(2, "make_iso_fs --- scratchdir=%s --- destfile=%s",
    17351737            bkpinfo->scratchdir, destfile);
    1736     (void) getcwd(old_pwd, MAX_STR_LEN - 1);
     1738    tmp2 = getcwd(old_pwd, MAX_STR_LEN - 1);
    17371739    sprintf(tmp, "chmod 700 %s", bkpinfo->scratchdir);
    17381740    run_program_and_log_output(tmp, FALSE);
    1739     chdir(bkpinfo->scratchdir);
     1741    if (chdir(bkpinfo->scratchdir)) {
     1742        // FIXME
     1743    }
    17401744
    17411745    if (bkpinfo->call_before_iso[0] != '\0') {
    … …  
    17961800                /* reset error counter before trying to blank DVD */
    17971801                retval -= res;
    1798                 (void)system("sync");
     1802                paranoid_system("sync");
    17991803                pause_for_N_seconds(5, "Letting DVD drive settle");
    18001804
    … …  
    19841988    }
    19851989
    1986     chdir(old_pwd);
     1990    if (chdir(old_pwd)) {
     1991        // FIXME
     1992    }
    19871993    if (retval) {
    19881994        log_msg(1, "WARNING - make_iso_fs returned an error");
    … …  
    20402046    FILE *fin;
    20412047    char *p;
     2048    char *q;
    20422049
    20432050    /*@ buffers ******************************************** */
    … …  
    20902097
    20912098    malloc_string(bigfile_fname);
    2092     for (fgets(bigfile_fname, MAX_STR_LEN, fin); !feof(fin);
    2093          fgets(bigfile_fname, MAX_STR_LEN, fin), biggie_file_number++) {
     2099    for (q = fgets(bigfile_fname, MAX_STR_LEN, fin); !feof(fin) && (q != NULL);
     2100         q = fgets(bigfile_fname, MAX_STR_LEN, fin), biggie_file_number++) {
    20942101        use_ntfsprog = FALSE;
    20952102        if (bigfile_fname[strlen(bigfile_fname) - 1] < 32) {
    … …  
    26212628    /*@ long long ****************************************************** */
    26222629    off_t length_of_incoming_file = (off_t)0;
    2623     t_archtype type;
    26242630    va_list ap;
    26252631
    … …  
    26432649        write_header_block_to_stream(length_of_incoming_file, curr_file,
    26442650                                     start_chr);
    2645         if (strstr(curr_file, ".afio.") || strstr(curr_file, ".star.")) {
    2646             type = fileset;
    2647         } else if (strstr(curr_file, "slice")) {
    2648             type = biggieslice;
    2649         } else {
    2650             type = other;
    2651         }
    26522651        res = write_file_to_stream_from_file(curr_file);
    26532652        retval += res;
    … …  
    29772976    off_t totalread = (off_t)0;
    29782977    off_t totallength = (off_t)0;
    2979     off_t length;
    29802978
    29812979    /*@ int ******************************************************** */
    … …  
    30363034        }
    30373035        mr_free(command);
    3038         (void) fgets(checksum_line, MAX_STR_LEN, fin);
     3036        tmp = fgets(checksum_line, MAX_STR_LEN, fin);
    30393037        pclose(fin);
    30403038        totallength = length_of_file (biggie_filename);
    … …  
    30613059    paranoid_free(tmp);
    30623060
    3063     (void) fwrite((void *) &biggiestruct, 1, sizeof(biggiestruct), fout);
     3061    res = fwrite((void *) &biggiestruct, 1, sizeof(biggiestruct), fout);
    30643062    if (fout != NULL) {
    30653063        paranoid_fclose(fout);
    30663064    }
    3067     length = totallength / optimal_set_size / 1024;
    30683065    log_msg(1, "Opening in %s; slicing it and writing to CD/tape",
    30693066            file_to_openin);
    … …  
    31103107                if (blksize > 0) {
    31113108                    totalread = totalread + blksize;
    3112                     (void) fwrite(tempblock, 1, blksize, fout);
     3109                    res = fwrite(tempblock, 1, blksize, fout);
    31133110                } else {
    31143111                    break;
    … …  
    34173414                ("Please reboot from the 1st %s in Compare Mode, as a precaution.", mds);
    34183415            mr_free(mds);
    3419             chdir("/");
     3416            if (chdir("/")) {
     3417                // FIXME
     3418            }
    34203419            log_it("Before calling verification of image()");
    34213420            if (bkpinfo->backup_media_type == usb) {
    … …  
    34973496    assert(bkpinfo != NULL);
    34983497    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
    3499         chdir("/");
     3498        if (chdir("/")) {
     3499            // FIXME
     3500        }
    35003501        mvaddstr_and_log_it(g_currentY, 0,
    35013502                            "Verifying archives against live filesystem");
    … …  
    35183519            find_cdrom_device(bkpinfo->media_device, FALSE);    // replace 0,0,0 with /dev/cdrom
    35193520        }
    3520         chdir("/");
     3521        if (chdir("/")) {
     3522            // FIXME
     3523        }
    35213524        for (cdno = 1; cdno < 99 && bkpinfo->verify_data; cdno++) {
    35223525            if (cdno != g_current_media_number) {
    … …  
    35413544        }
    35423545        mr_asprintf(&tmp, "grep 'afio: ' %s | sed 's/afio: //' | grep -vE '^/dev/.*$' >> %s/changed.files", MONDO_LOGFILE, MONDO_CACHE);
    3543         (void)system(tmp);
     3546        res = system(tmp);
    35443547        mr_free(tmp);
    35453548
    35463549        mr_asprintf(&tmp, "grep 'star: ' %s | sed 's/star: //' | grep -vE '^/dev/.*$' >> %s/changed.files", MONDO_LOGFILE, MONDO_CACHE);
    3547         (void)system(tmp);
     3550        res = system(tmp);
    35483551        mr_free(tmp);
    35493552        run_program_and_log_output("umount " MNT_CDROM, FALSE);

  • branches/3.0/mondo/src/common/libmondo-cli.c

    r2946 r3060  
    107107//    }
    108108    /*  Before erasing dirs go into a safe place */
    109     chdir("/tmp");
     109    if (chdir("/tmp")) {
     110        // FIXME
     111    }
    110112    sprintf(tmp, "rm -Rf %s/tmp.mondo.*", bkpinfo->tmpdir);
    111113    paranoid_system(tmp);
    … …  
    180182    int i = 0;
    181183    int retval = 0;
    182     int percent = 0;
    183     int lastpos = 0;
    184184
    185185    /*@ buffers ** */
    … …  
    389389                flag_val['d']);
    390390        log_to_screen(tmp);
    391         percent = 0;
    392391    }
    393392
    … …  
    660659        }
    661660        paranoid_free(tmp1);
    662         lastpos = 0;
    663661
    664662        mr_make_devlist_from_pathlist(flag_val['E'], 'E');
    … …  
    813811        /* Before changing remove old ones if any */
    814812        if (bkpinfo->scratchdir) {
    815             chdir("/tmp");
     813            if (chdir("/tmp")) {
     814                // FIXME
     815            }
    816816            mr_asprintf(&tmp1, "rm -Rf %s", bkpinfo->scratchdir);
    817817            paranoid_system(tmp1);

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

    r3052 r3060  
    348348    char *searchstr = NULL;
    349349    char *tmp;
     350    char *p;
    350351
    351352    /*@ ints ******************************************************* */
    … …  
    383384    (void) build_partition_name(searchstr, drive, partno);
    384385    strcat(searchstr, " ");
    385     for (res = 0; !res && fgets(incoming, MAX_STR_LEN - 1, fin);) {
     386    for (res = 0; !res && (p = fgets(incoming, MAX_STR_LEN - 1, fin));) {
    386387        if (strstr(incoming, searchstr)) {
    387388            res = 1;
    … …  
    677678        return (1);
    678679    }
    679     for ((void)fgets(tmp, MAX_STR_LEN, fin); !feof(fin);
    680          (void)fgets(tmp, MAX_STR_LEN, fin)) {
     680    for (tmp1 = fgets(tmp, MAX_STR_LEN, fin); !feof(fin) && (tmp1 != NULL);
     681         tmp1 = fgets(tmp, MAX_STR_LEN, fin)) {
    681682        p = strchr(tmp, '\'');
    682683        if (p) {
    … …  
    711712            log_msg(4, "Cannot run 2nd command - non-fatal, fortunately");
    712713        } else {
    713             for ((void)fgets(tmp, MAX_STR_LEN, fin); !feof(fin);
    714                  (void)fgets(tmp, MAX_STR_LEN, fin)) {
     714            for (tmp1 = fgets(tmp, MAX_STR_LEN, fin); !feof(fin) && (tmp1 != NULL);
     715                 tmp1 = fgets(tmp, MAX_STR_LEN, fin)) {
    715716                log_msg(5, "--> '%s'", tmp);
    716717                if (tmp[0] != ' ' && tmp[1] != ' ') {
    … …  
    915916    }
    916917
    917     sprintf(tmp, "%s", call_program_and_get_last_line_of_output
    918             ("dvdrecord -scanbus 2> /dev/null | grep \)\ \' | grep -n '' | grep -E '[D|C][V|D]' | cut -d':' -f1")
    919         );
     918    sprintf(tmp, "%s", call_program_and_get_last_line_of_output("dvdrecord -scanbus 2> /dev/null | grep -E '\)\ \'' | grep -n '' | grep -E '[D|C][V|D]' | cut -d':' -f1"));
    920919    log_msg(5, "tmp = '%s'", tmp);
    921920    if (!tmp[0])
    … …  
    959958#if linux
    960959    unsigned long long s = 0;
    961     int fileid, cylinders = 0, cylindersleft = 0;
     960    int fileid, cylinders = 0;
    962961    int cylindersize = 0;
    963962    int gotgeo = 0;
    … …  
    10081007            if (ioctl(fileid, HDIO_GETGEO, &hdgeo) != -1) {
    10091008                if (hdgeo.cylinders && hdgeo.heads && hdgeo.sectors) {
    1010                     cylindersleft = cylinders = hdgeo.cylinders;
    10111009                    cylindersize = hdgeo.heads * hdgeo.sectors / 2;
    10121010                    outvalA = cylindersize * cylinders / 1024;
    … …  
    10561054    char *command;
    10571055    char *format_sz;
     1056    char *p;
    10581057
    10591058    FILE *pin;
    … …  
    10811080    } else {
    10821081        strcpy(good_formats, " ");
    1083         (void) fgets(good_formats + 1, MAX_STR_LEN - 1, pin);
    1084         if (pclose(pin)) {
     1082        p = fgets(good_formats + 1, MAX_STR_LEN - 1, pin);
     1083        if (pclose(pin) && (p != NULL)) {
    10851084            log_OS_error("Cannot pclose good formats");
    10861085        }
    … …  
    11531152        return(FALSE);
    11541153    }
    1155     for ((void)fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin);
    1156          (void)fgets(incoming, MAX_STR_LEN - 1, fin)) {
     1154    for (tmp = fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin) && (tmp != NULL);
     1155         tmp = fgets(incoming, MAX_STR_LEN - 1, fin)) {
    11571156        if (strstr(incoming, device_with_space) //> incoming
    11581157            || strstr(incoming, device_with_tab))   // > incoming)
    … …  
    25252524        if (bkpinfo->disaster_recovery) {
    25262525            sprintf(command ,"umount %s/isodir 2> /dev/null", bkpinfo->tmpdir);
    2527             (void)system(command);
     2526            paranoid_system(command);
    25282527        }
    25292528        strcpy(tmp1, bkpinfo->netfs_proto);
    … …  
    29812980    /* Before changing remove old ones if any */
    29822981    if (bkpinfo->scratchdir) {
    2983         chdir("/tmp");
     2982        if (chdir("/tmp")) {
     2983            // FIXME
     2984        }
    29842985        mr_asprintf(&tmp1, "rm -Rf %s", bkpinfo->scratchdir);
    29852986        paranoid_system(tmp1);
    … …  
    31903191    char *list_drives_cmd = NULL;
    31913192    char *current_drive;
     3193    char *tmp;
    31923194
    31933195    /*@ pointers *************************************************** */
    … …  
    32193221    mr_free(list_drives_cmd);
    32203222
    3221     for ((void)fgets(current_drive, MAX_STR_LEN, pdrives); !feof(pdrives);
    3222          (void)fgets(current_drive, MAX_STR_LEN, pdrives)) {
     3223    for (tmp = fgets(current_drive, MAX_STR_LEN, pdrives); !feof(pdrives) && (tmp != NULL);
     3224         tmp = fgets(current_drive, MAX_STR_LEN, pdrives)) {
    32233225        strip_spaces(current_drive);
    32243226        log_it("looking at drive %s's MBR", current_drive);
    … …  
    32613263        mr_free(list_drives_cmd);
    32623264
    3263         for ((void)fgets(current_drive, MAX_STR_LEN, pdrives); !feof(pdrives);
    3264             (void)fgets(current_drive, MAX_STR_LEN, pdrives)) {
     3265        for (tmp = fgets(current_drive, MAX_STR_LEN, pdrives); !feof(pdrives) && (tmp != NULL);
     3266            tmp = fgets(current_drive, MAX_STR_LEN, pdrives)) {
    32653267            strip_spaces(current_drive);
    32663268            log_it("looking at partition %s's BR", current_drive);

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

    r2972 r3060  
    212212    char *incoming;
    213213    char *tmp = NULL;
     214    char *p = NULL;
    214215
    215216    /*@ pointers *********************************** */
    … …  
    259260    incoming = malloc(MAX_STR_LEN * 2);
    260261
    261     (void) fgets(incoming, MAX_STR_LEN * 2 - 1, fin);
    262     while (!feof(fin)) {
     262    p = fgets(incoming, MAX_STR_LEN * 2 - 1, fin);
     263    while (!feof(fin) && (p != NULL)) {
    263264        lino++;
    264265        i = strlen(incoming) - 1;
    … …  
    307308            }
    308309        }
    309         (void) fgets(incoming, MAX_STR_LEN * 2 - 1, fin);
     310        p = fgets(incoming, MAX_STR_LEN * 2 - 1, fin);
    310311    }
    311312    paranoid_free(incoming);
    … …  
    417418    FILE *pattr;
    418419    char *tmp;
     420    char *p;
     421
    419422    pattr = popen(syscall, "r");
    420423    if (!pattr) {
    … …  
    428431    }
    429432    malloc_string(tmp);
    430     for ((void)fgets(tmp, MAX_STR_LEN, pattr); !feof(pattr);
    431          (void)fgets(tmp, MAX_STR_LEN, pattr)) {
     433    for (p = fgets(tmp, MAX_STR_LEN, pattr); !feof(pattr) && (p != NULL);
     434         p = fgets(tmp, MAX_STR_LEN, pattr)) {
    432435        fputs(tmp, pout);
    433436    }
    … …  
    449452    char *strtmp = NULL;
    450453    char *tmp = NULL;
     454    char *p = NULL;
    451455    int i;
    452456
    … …  
    465469
    466470    malloc_string(file_to_analyze);
    467     for ((void)fgets(file_to_analyze, MAX_STR_LEN, fin); !feof(fin);
    468          (void)fgets(file_to_analyze, MAX_STR_LEN, fin)) {
     471    for (p = fgets(file_to_analyze, MAX_STR_LEN, fin); !feof(fin) && (p != NULL);
     472         p = fgets(file_to_analyze, MAX_STR_LEN, fin)) {
    469473        i = strlen(file_to_analyze);
    470474        if (i > 0 && file_to_analyze[i - 1] < 32) {
    … …  
    535539    int retval = 0;
    536540    int i;
    537     char *p, *q;
     541    char *p, *q, *r;
    538542    char *tmp = NULL;
    539543    FILE *pin, *pout, *faclin;
    … …  
    607611//  printf("Hi there. Starting the loop\n");
    608612
    609     (void)fgets(current_subset_file, MAX_STR_LEN, faclin);
    610     (void)fgets(incoming, MAX_STR_LEN, pin);
    611     while (!feof(pin) && !feof(faclin)) {
     613    r = fgets(current_subset_file, MAX_STR_LEN, faclin);
     614    r = fgets(incoming, MAX_STR_LEN, pin);
     615    while (!feof(pin) && !feof(faclin) && (r != NULL)) {
    612616//      printf("incoming = %s", incoming);
    613617
    … …  
    640644        if (i < 0) {            // read another subset file in.
    641645            log_msg(my_depth, "Reading next subset line in\n\n");
    642             (void)fgets(current_subset_file, MAX_STR_LEN, faclin);
     646            r = fgets(current_subset_file, MAX_STR_LEN, faclin);
    643647            continue;
    644648        }
    … …  
    647651            fputs(incoming, pout);
    648652        }
    649         (void)fgets(incoming, MAX_STR_LEN, pin);
     653        r = fgets(incoming, MAX_STR_LEN, pin);
    650654        if (!i) {
    651655            log_msg(my_depth, "Copying master %s", q);
    … …  
    660664                fputs(incoming, pout);
    661665            }
    662             (void)fgets(incoming, MAX_STR_LEN, pin);
     666            r = fgets(incoming, MAX_STR_LEN, pin);
    663667        }
    664668        if (!i) {
    665             (void)fgets(current_subset_file, MAX_STR_LEN, faclin);
     669            r = fgets(current_subset_file, MAX_STR_LEN, faclin);
    666670        }
    667671    }
    668672    while (!feof(pin)) {
    669         (void)fgets(incoming, MAX_STR_LEN, pin);
     673        r = fgets(incoming, MAX_STR_LEN, pin);
    670674    }
    671675    fclose(faclin);
    … …  
    919923
    920924    open_evalcall_form("Loading filelist from disk");
    921     for ((void)fgets(fname, MAX_STR_LEN, pin); !feof(pin);
    922          (void)fgets(fname, MAX_STR_LEN, pin)) {
     925    for (tmp1 = fgets(fname, MAX_STR_LEN, pin); !feof(pin);
     926         tmp1 = fgets(fname, MAX_STR_LEN, pin)) {
    923927        if ((fname[strlen(fname) - 1] == 13
    924928             || fname[strlen(fname) - 1] == 10) && strlen(fname) > 0) {
    … …  
    13861390        paranoid_free(find_excludes);
    13871391        log_msg(5, "find command = %s", strtmp);
    1388         (void)system(strtmp);
     1392        paranoid_system(strtmp);
    13891393        paranoid_free(strtmp);
    13901394        mr_asprintf(&tmp, "wc -l %s | awk '{print $1;}'", g_skeleton_filelist);
    … …  
    15361540    char *sz_filelist, *tmp;
    15371541    char *exclude_paths = NULL;
    1538     int i;
    15391542    FILE *fout;
    15401543    char *command = NULL;
    … …  
    16291632            fatal_error("Cannot openout to sz_filelist");
    16301633        }
    1631         i = 0;
    16321634        if (strlen(include_paths) == 0) {
    16331635            log_msg(1, "Including only '/' in %s", sz_filelist);
    … …  
    17371739{
    17381740    /*@ int ******************************************************** */
    1739     int noof_chars;
    17401741    static int depth = 0;
    17411742    static char original_string[MAX_STR_LEN];
    … …  
    17551756    assert(startnode != NULL);
    17561757    assert(string_to_find != NULL);
    1757 
    1758     noof_chars = strlen(string_to_find) + 1;    /* we include the '\0' */
    17591758
    17601759    log_msg(7, "starting --- str=%s", string_to_find);
    … …  
    18251824//      fscanf(fin, "%s\n", fname);
    18261825        len = MAX_STR_LEN - 1;
    1827         (void)getline(&fname, &len, fin);   // patch by Scrub
     1826        if (getline(&fname, &len, fin)) {
     1827            // FIXME
     1828        }
    18281829        if (!use_star) {
    18291830            if (fname[0] == '/') {
    … …  
    18791880    FILE *fin;
    18801881    char *tmp;
     1882    char *p;
    18811883    struct s_node *nod;
    18821884
    … …  
    18871889        return (1);
    18881890    }
    1889     for ((void)fgets(tmp, MAX_STR_LEN, fin); !feof(fin);
    1890          (void)fgets(tmp, MAX_STR_LEN, fin)) {
     1891    for (p = fgets(tmp, MAX_STR_LEN, fin); !feof(fin) && (p != NULL);
     1892         p = fgets(tmp, MAX_STR_LEN, fin)) {
    18911893        if (!tmp[0]) {
    18921894            continue;

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

    r2921 r3060  
    5252    /*@ pointers **************************************************** */
    5353    char *p;
     54    char *q;
    5455    FILE *fin;
    5556
    … …  
    6566        fin = popen(command, "r");
    6667        if (fin) {
    67             (void) fgets(output, MAX_STR_LEN, fin);
    68             p = strchr(output, ' ');
     68            q = fgets(output, MAX_STR_LEN, fin);
     69            if (!q) {
     70                // FIXME
     71            }
     72            q = strchr(output, ' ');
    6973            paranoid_pclose(fin);
    7074        }
    … …  
    129133    char incoming[MAX_STR_LEN];
    130134    char tmp[MAX_STR_LEN];
     135    char *q;
    131136
    132137    /*@ long ******************************************************** */
    … …  
    156161            noof_lines = 0;
    157162        } else {
    158             (void) fgets(incoming, MAX_STR_LEN - 1, fin);
    159             while (strlen(incoming) > 0
     163            q = fgets(incoming, MAX_STR_LEN - 1, fin);
     164            if (!q) {
     165                // FIXME
     166            }
     167            while (strlen(incoming) > 0 && (q != NULL)
    160168                   && incoming[strlen(incoming) - 1] < 32) {
    161169                incoming[strlen(incoming) - 1] = '\0';
    … …  
    211219    char tmp[MAX_STR_LEN];
    212220    char incoming[MAX_STR_LEN];
     221    char *q;
    213222
    214223    /*@ int ********************************************************* */
    … …  
    234243        return;
    235244    }
    236     for (fgets(incoming, MAX_STR_LEN, fin); !feof(fin);
    237          fgets(incoming, MAX_STR_LEN, fin)) {
     245    for (q = fgets(incoming, MAX_STR_LEN, fin); !feof(fin) && (q != NULL);
     246         q = fgets(incoming, MAX_STR_LEN, fin)) {
    238247        i = strlen(incoming) - 1;
    239248        if (i >= 0 && incoming[i] < 32) {
    … …  
    497506    static char command[MAX_STR_LEN * 2];
    498507    static char tmp[MAX_STR_LEN];
     508    char *p = NULL;
    499509
    500510    /*@ pointers **************************************************** */
    … …  
    512522    sprintf(command, "tail -n1 %s", filename);
    513523    fin = popen(command, "r");
    514     (void) fgets(output, MAX_STR_LEN, fin);
     524    p = fgets(output, MAX_STR_LEN, fin);
     525    if (p == NULL) {
     526        // FIXME
     527    }
    515528    paranoid_pclose(fin);
    516529    while (strlen(output) > 0 && output[strlen(output) - 1] < 32) {
    … …  
    568581    char curr_cksum[1000];
    569582    char tmp[1000];
     583    char *q;
    570584
    571585    /*@ long [long] ************************************************* */
    … …  
    596610        return (1);
    597611    }
    598     for (fgets(stub_fname, 999, fin); !feof(fin);
    599          fgets(stub_fname, 999, fin)) {
     612    for (q = fgets(stub_fname, 999, fin); !feof(fin) && (q != NULL);
     613         q = fgets(stub_fname, 999, fin)) {
    600614        if (stub_fname[(i = strlen(stub_fname) - 1)] < 32) {
    601615            stub_fname[i] = '\0';
    … …  
    700714    /*@ buffers **************************************************** */
    701715    char incoming[MAX_STR_LEN];
     716    char *p = NULL;
    702717
    703718    /*@ end vars *************************************************** */
    … …  
    710725        return (0);
    711726    }
    712     (void) fgets(incoming, MAX_STR_LEN - 1, fin);
    713     while (!feof(fin)) {
     727    p = fgets(incoming, MAX_STR_LEN - 1, fin);
     728    while (!feof(fin) && (p != NULL)) {
    714729        if (strstr(incoming, wildcard)) {
    715730            matches++;
    716731        }
    717         (void) fgets(incoming, MAX_STR_LEN - 1, fin);
     732        p = fgets(incoming, MAX_STR_LEN - 1, fin);
    718733    }
    719734    paranoid_fclose(fin);
    … …  
    759774    char *comment;
    760775    char *tmp;
     776    char *q;
    761777    char *command;
    762778
    … …  
    783799    } else {
    784800        log_msg(4, "Reading it...");
    785         for (fgets(fname, MAX_STR_LEN, fin); !feof(fin);
    786              fgets(fname, MAX_STR_LEN, fin)) {
     801        for (q = fgets(fname, MAX_STR_LEN, fin); !feof(fin) && (q != NULL);
     802             q = fgets(fname, MAX_STR_LEN, fin)) {
    787803            if (fname[strlen(fname) - 1] <= 32) {
    788804                fname[strlen(fname) - 1] = '\0';
    … …  
    854870      llres = 0;
    855871    } else {
    856       (void) fgets(tmp, MAX_STR_LEN, fin);
     872      p = fgets(tmp, MAX_STR_LEN, fin);
    857873      paranoid_pclose(fin);
    858874      p = strchr(tmp, '\t');
    … …  
    9911007        return (1);
    9921008    }
    993     fscanf(fin, "%s\n", contents);
     1009    res = fscanf(fin, "%s\n", contents);
    9941010    i = strlen(contents);
    9951011    if (i > 0 && contents[i - 1] < 32) {
    … …  
    9971013    }
    9981014    paranoid_fclose(fin);
     1015    res = 0;
    9991016    return (res);
    10001017}
    … …  
    10241041    char tmp[MAX_STR_LEN];
    10251042    char old_pwd[MAX_STR_LEN];
     1043    int res = 0;
    10261044
    10271045    mvaddstr_and_log_it(g_currentY, 0,
    … …  
    10441062        log_it("Untarring payload %s to scratchdir %s", tmp,
    10451063               bkpinfo->scratchdir);
    1046         (void) getcwd(old_pwd, MAX_STR_LEN - 1);
    1047         chdir(bkpinfo->scratchdir);
     1064        if (getcwd(old_pwd, MAX_STR_LEN - 1)) {
     1065            // FIXME
     1066        }
     1067        if (chdir(bkpinfo->scratchdir)) {
     1068            // FIXME
     1069        }
    10481070        sprintf(command, "tar -zxvf %s", tmp);
    10491071        if (run_program_and_log_output(command, FALSE)) {
    10501072            fatal_error("Failed to untar payload");
    10511073        }
    1052         chdir(old_pwd);
     1074        if (chdir(old_pwd)) {
     1075            // FIXME
     1076        }
    10531077    }
    10541078

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

    r3042 r3060  
    3939    static char result[MAX_STR_LEN];
    4040    char *tmp;
     41    char *p;
    4142
    4243    /*@ pointers **************************************************** */
    … …  
    5253    assert_string_is_neither_NULL_nor_zerolength(call);
    5354    if ((fin = popen(call, "r"))) {
    54         for (fgets(tmp, MAX_STR_LEN, fin); !feof(fin);
    55              fgets(tmp, MAX_STR_LEN, fin)) {
     55        for (p = fgets(tmp, MAX_STR_LEN, fin); !feof(fin) && (p != NULL);
     56             p = fgets(tmp, MAX_STR_LEN, fin)) {
    5657            if (strlen(tmp) > 1) {
    5758                strcpy(result, tmp);
    … …  
    267268    FILE *fin;
    268269    char *p;
     270    char *q;
    269271
    270272    /*@ end vars *************************************************** */
    … …  
    312314    fin = fopen(tmp1, "r");
    313315    if (fin) {
    314         for (fgets(incoming, MAX_STR_LEN, fin); !feof(fin); fgets(incoming, MAX_STR_LEN, fin)) {
     316        for (q = fgets(incoming, MAX_STR_LEN, fin); !feof(fin) && (q != NULL); q = fgets(incoming, MAX_STR_LEN, fin)) {
    315317            p = incoming;
    316318            while (p && *p) {
    … …  
    562564                log_msg(1, "bytes_read_in = %ld", bytes_read_in);
    563565//      if (bytes_read_in!=128+64) { fatal_error("Can't read the terminating block"); }
    564                 fwrite(tmp, 1, bytes_read_in, ftmp);
     566                if (fwrite(tmp, 1, bytes_read_in, ftmp)) {
     567                    fatal_error("Can't fwrite here");
     568                }
    565569                sprintf(tmp, "I am here - %lld", (long long)ftello(fin));
    566570//    log_msg(0, tmp);
    567                 fread(tmp, 1, tmpcap, fin);
     571                if (fread(tmp, 1, tmpcap, fin)) {
     572                    fatal_error("Can't fread here");
     573                }
    568574                log_msg(0, "tmp = '%s'", tmp);
    569                 fwrite(tmp, 1, tmpcap, ftmp);
     575                if (fwrite(tmp, 1, tmpcap, ftmp)) {
     576                    fatal_error("Can't fwrite there");
     577                }
    570578                fclose(ftmp);
    571579                fatal_error("Missing terminating block");

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

    r2944 r3060  
    5050    int pos = 0, npos = 0;
    5151    int res = 0;
    52     int mountpoint_copies = 0;
    5352    int device_copies = 0;
    5453    int i = 0;
    … …  
    111110            }
    112111            /* does partition /dev/adXsYZ exist more than once in the mountlist? */
    113             for (i = 0, mountpoint_copies = 0, device_copies = 0;
     112            for (i = 0, device_copies = 0;
    114113                 i < mountlist->entries; i++) {
    115114                if (!strcmp(device, mountlist->el[i].device)) {
    … …  
    208207            }
    209208            /* does partition /dev/adXsY exist more than once in the mountlist? */
    210             for (i = 0, mountpoint_copies = 0, device_copies = 0;
     209            for (i = 0, device_copies = 0;
    211210                 i < mountlist->entries; i++) {
    212211                if (!strcmp(device, mountlist->el[i].device)) {
    … …  
    271270                }
    272271                /* does partition /dev/adXsYZ exist more than once in the mountlist? */
    273                 for (i = 0, mountpoint_copies = 0, device_copies = 0;
     272                for (i = 0, device_copies = 0;
    274273                     i < mountlist->entries; i++) {
    275274                    if (!strcmp(device, mountlist->el[i].device)) {
    … …  
    372371    int pos = 0;
    373372    int res = 0;
    374     int mountpoint_copies = 0;
    375373    int device_copies = 0;
    376374    int i = 0;
    … …  
    454452        }
    455453        /* does partition /dev/hdNX exist more than once in the mountlist? */
    456         for (i = 0, mountpoint_copies = 0, device_copies = 0;
     454        for (i = 0, device_copies = 0;
    457455             i < mountlist->entries; i++) {
    458456            if (!strcmp(device, mountlist->el[i].device)) {
    … …  
    812810    char *tmp = NULL;
    813811    char *p = NULL;
     812    char *q = NULL;
    814813
    815814    int items = 0;
    … …  
    827826    malloc_string(incoming);
    828827    malloc_string(siz);
    829     (void) fgets(incoming, MAX_STR_LEN - 1, fin);
     828    q = fgets(incoming, MAX_STR_LEN - 1, fin);
    830829    log_it("Loading mountlist...");
    831     while (!feof(fin)) {
     830    while (!feof(fin) && (q != NULL)) {
    832831#if linux
    833832        res = sscanf(incoming,
    … …  
    863862                    "Ignoring %s in mountlist - not loading that line :) ",
    864863                    mountlist->el[items].device);
    865             (void) fgets(incoming, MAX_STR_LEN - 1, fin);
     864            q = fgets(incoming, MAX_STR_LEN - 1, fin);
    866865            continue;
    867866        }
    … …  
    906905            }
    907906        }
    908         (void) fgets(incoming, MAX_STR_LEN - 1, fin);
     907        q = fgets(incoming, MAX_STR_LEN - 1, fin);
    909908    }
    910909    paranoid_fclose(fin);

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

    r3043 r3060  
    429429    char *incoming;
    430430    char *p;
     431    char *q;
    431432
    432433    malloc_string(incoming);
    … …  
    440441        return (1);
    441442    }
    442     for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin);
    443          fgets(incoming, MAX_STR_LEN - 1, fin)) {
     443    for (q = fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin) && (q != NULL);
     444         q = fgets(incoming, MAX_STR_LEN - 1, fin)) {
    444445        strip_spaces(incoming);
    445446        p = strchr(incoming, ' ');
    … …  
    810811    static char *argv[64];
    811812    char **ap;
     813    char *q;
    812814    char *line = (char *) malloc(MAX_STR_LEN);
     815
    813816    if (!line)
    814817        errx(1,
    815818             "unable to allocate %i bytes of memory for `char *line' at %s:%i",
    816819             MAX_STR_LEN, __FILE__, __LINE__);
    817     (void) fgets(line, MAX_STR_LEN, f);
    818     if (feof(f)) {
     820    q = fgets(line, MAX_STR_LEN, f);
     821    if (feof(f) && (q != NULL)) {
    819822        log_it("[GNVCL] Uh... I reached the EOF.");
    820823        return 0;
    … …  
    10311034            mr_asprintf(&strtmp,"%s%s", device_prefix, token);
    10321035            strncpy(raidlist->el[raidlist->entries].raid_device, strtmp, 63);
    1033             raidlist->el[raidlist->entries].raid_device[64] = '\0';
     1036            raidlist->el[raidlist->entries].raid_device[63] = '\0';
    10341037            mr_free(strtmp);
    10351038            mr_free(token);

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

    r2900 r3060  
    116116    char *blk;
    117117    int i;
     118    int j;
    118119
    119120    blk = (char *) malloc(256 * 1024);
    … …  
    131132    }
    132133    for (i = 0; i < 8 && !feof(g_tape_stream); i++) {
    133         (void) fread(blk, 1, 256 * 1024, g_tape_stream);
     134        j = fread(blk, 1, 256 * 1024, g_tape_stream);
     135        if (j) {
     136            // FIXME
     137        }
    134138    }
    135139    sleep(1);
    … …  
    191195    }
    192196    for (i = 0; i < 4 * 8; i++) {
    193         (void) fwrite(blk, 1, 256 * 1024, g_tape_stream);
     197        if (fwrite(blk, 1, 256 * 1024, g_tape_stream)) {
     198            //FIXME
     199        }
    194200        if (should_we_write_to_next_tape
    195201            (bkpinfo->media_size[g_current_media_number], (off_t)256 * 1024)) {
    … …  
    528534{
    529535    long long final_alleged_writeK, final_projected_certain_writeK,
    530         final_actually_certain_writeK = 0, cposK, bufsize_K;
     536        cposK, bufsize_K;
    531537    int last, curr, i;
    532     t_archtype type = other;
    533538    char *command = NULL;
    534539    char *tmpdir = NULL;
    … …  
    542547    } else {
    543548        suffix[0] = '\0';
    544     }
    545     if (strstr(latest_fname, ".afio.") || strstr(latest_fname, ".star.")) {
    546         type = fileset;
    547     } else if (strstr(latest_fname, "slice")) {
    548         type = biggieslice;
    549     } else {
    550         log_it("fname = %s", latest_fname);
    551         fatal_error
    552             ("Unknown type. Internal error in maintain_collection_of_recent_archives()");
    553549    }
    554550    mr_asprintf(&tmpdir, "%s/tmpfs/backcatalog", td);
    … …  
    572568        cposK = g_tapecatalog->el[curr].tape_posK;
    573569        if (cposK < final_projected_certain_writeK) {
    574             final_actually_certain_writeK = cposK;
    575570            break;
    576571        }
    … …  
    845840                          g_tape_stream);
    846841            }
    847             (void) fwrite(datablock, 1, (size_t) length, fout);
     842            if (fwrite(datablock, 1, (size_t) length, fout)) {
     843                // FIXME
     844            }
    848845            g_tape_posK += length / 1024;
    849846        }
    … …  
    870867    close_evalcall_form();
    871868    log_it("Saved all.tar.gz to '%s'", outfname);
    872     (void) getcwd(old_cwd, MAX_STR_LEN);
    873     chdir(bkpinfo->tmpdir);
     869    if (getcwd(old_cwd, MAX_STR_LEN)) {
     870        // FIXME
     871    }
     872    if (chdir(bkpinfo->tmpdir)) {
     873        // FIXME
     874    }
    874875    mr_asprintf(&tmp, "tar -zxf %s ./tmp/mondo-restore.cfg 2> /dev/null",
    875876            outfname);
    … …  
    878879
    879880    paranoid_system("cp -f tmp/mondo-restore.cfg . 2> /dev/null");
    880     chdir(old_cwd);
     881    if (chdir(old_cwd)) {
     882        // FIXME
     883    }
    881884    unlink(outfname);
    882885    mr_free(outfname);
    … …  
    10591062    unsigned int crctt;
    10601063
    1061     bool had_to_resync = FALSE;
    1062 
    10631064    /*@ init  ******************************************************* */
    10641065    malloc_string(temp_fname);
    … …  
    10721073
    10731074    res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
     1075    if (res) {
     1076        // FIXME
     1077    }
    10741078    if (orig_size != temp_size && orig_size != -1) {
    10751079        mr_asprintf(&tmp, "output file's size should be %ld K but is apparently %ld K", (long) size >> 10, (long) temp_size >> 10);
    … …  
    11121116            for (size = orig_size; size > where_I_was_before_tape_change;
    11131117                 size -= bytes_to_write) {
    1114                 bytes_read =
    1115                     fread(datablock, 1, bytes_to_read, g_tape_stream);
     1118                bytes_read = fread(datablock, 1, bytes_to_read, g_tape_stream);
    11161119            }
    11171120            log_msg(4, "'size' is now %lld (should be %lld)", size,
    11181121                    where_I_was_before_tape_change);
    11191122            log_to_screen("Successfully re-sync'd tape");
    1120             had_to_resync = TRUE;
    11211123            bytes_read = fread(datablock, 1, bytes_to_read, g_tape_stream);
    11221124        }
    11231125
    1124         (void) fwrite(datablock, 1, (size_t) bytes_to_write, fout); // for blocking reasons, bytes_successfully_read_in isn't necessarily the same as bytes_to_write
     1126        if (fwrite(datablock, 1, (size_t) bytes_to_write, fout)) {  // for blocking reasons, bytes_successfully_read_in isn't necessarily the same as bytes_to_write
     1127            // FIXME
     1128        }
    11251129
    11261130#ifdef EXTRA_TAPE_CHECKSUMS
    … …  
    11971201    }
    11981202    while (!(*pcontrol_char = tempblock[7000])) {
    1199         g_tape_posK +=
    1200             fread(tempblock, 1, (size_t) TAPE_BLOCK_SIZE,
    1201                   g_tape_stream) / 1024;
     1203        g_tape_posK += fread(tempblock, 1, (size_t) TAPE_BLOCK_SIZE, g_tape_stream) / 1024;
    12021204    }
    12031205/*  memcpy((char*)plength_of_incoming_file,(char*)tempblock+7001,sizeof(long long)); */
    … …  
    13471349    ctrl_chr = -1;
    13481350    while (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
    1349         res =
    1350             read_header_block_from_stream(&temp_size, temp_fname,
    1351                                           &ctrl_chr);
     1351        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
     1352        if (res) {
     1353            // FIXME
     1354        }
    13521355        if (ctrl_chr == BLK_START_AN_AFIO_OR_SLICE) {
    13531356            break;
    … …  
    13581361    }
    13591362    while (ctrl_chr != BLK_START_FILE) {
    1360         res =
    1361             read_header_block_from_stream(&temp_size, temp_fname,
    1362                                           &ctrl_chr);
     1363        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
    13631364        if (ctrl_chr == BLK_START_FILE) {
    13641365            break;
    … …  
    13861387            bytes_to_write =
    13871388                (size < TAPE_BLOCK_SIZE) ? (long) size : TAPE_BLOCK_SIZE;
    1388             // FIXME - needs error-checking and -catching
    1389             fread(datablock, 1, (size_t) TAPE_BLOCK_SIZE, g_tape_stream);
    1390         }
    1391         res =
    1392             read_header_block_from_stream(&temp_size, temp_fname,
    1393                                           &ctrl_chr);
     1389            if (fread(datablock, 1, (size_t) TAPE_BLOCK_SIZE, g_tape_stream)) {
     1390                // FIXME - needs error-checking and -catching
     1391            }
     1392        }
     1393        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
    13941394        if (ctrl_chr != BLK_STOP_FILE) {
    13951395            wrong_marker(BLK_STOP_FILE, ctrl_chr);
    13961396        }
    1397         res =
    1398             read_header_block_from_stream(&temp_size, temp_fname,
    1399                                           &ctrl_chr);
     1397        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
    14001398        if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
    14011399            wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
    14021400        }
    1403         res =
    1404             read_header_block_from_stream(&temp_size, temp_fname,
    1405                                           &ctrl_chr);
     1401        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
    14061402        if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
    14071403            wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
    14081404        }
    1409         res =
    1410             read_header_block_from_stream(&temp_size, temp_fname,
    1411                                           &ctrl_chr);
     1405        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
    14121406        if (ctrl_chr != BLK_START_FILE) {
    14131407            wrong_marker(BLK_START_FILE, ctrl_chr);
    … …  
    14931487
    14941488    paranoid_pclose(g_tape_stream);
    1495     system("sync");
    1496     system("sync");
    1497     system("sync");
     1489    paranoid_system("sync");
     1490    paranoid_system("sync");
     1491    paranoid_system("sync");
    14981492    log_it("New tape requested.");
    14991493    insist_on_this_tape_number(g_current_media_number + 1); // will increment g_current_media, too
    … …  
    17301724            bytes_to_read = TAPE_BLOCK_SIZE;
    17311725        }
    1732         (void) fread(datablock, 1, (size_t) bytes_to_read, fin);
     1726        if (fread(datablock, 1, (size_t) bytes_to_read, fin)) {
     1727            // FIXME
     1728        }
    17331729        g_tape_posK +=
    17341730            fwrite(datablock, 1, /*bytes_to_read */

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

    r3054 r3060  
    325325{
    326326#ifdef __FreeBSD__
    327     system("kldstat | grep msdosfs || kldload msdosfs 2> /dev/null");
    328     system("kldstat | grep ext2fs  || kldload ext2fs 2> /dev/null");
     327    paranoid_system("kldstat | grep msdosfs || kldload msdosfs 2> /dev/null");
     328    paranoid_system("kldstat | grep ext2fs  || kldload ext2fs 2> /dev/null");
    329329#else
    330     system("modprobe -a msdos vfat loop &> /dev/null");
     330    paranoid_system("modprobe -a msdos vfat loop &> /dev/null");
    331331#endif
    332332}
    … …  
    747747        /* purging a potential old tmpdir */
    748748        log_it("Purging old tmpdir %s", bkpinfo->tmpdir);
    749         chdir("/tmp");
     749        if (chdir("/tmp")) {
     750            // FIXME
     751        }
    750752        mr_asprintf(&tmp,"rm -Rf %s",bkpinfo->tmpdir);
    751         (void)system(tmp);
     753        paranoid_system(tmp);
    752754        paranoid_free(tmp);
    753755    }

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

    r3056 r3060  
    337337                            biggiestruct.filename,
    338338                            bkpinfo->tmpdir);
    339                 system(tmp);
     339                paranoid_system(tmp);
    340340                paranoid_free(tmp);
    341341
    … …  
    445445    char *outlog;
    446446    char *tmp;
    447     //  char *p;
     447    char *p;
    448448
    449449    /*@ pointers ******************************************************* */
    … …  
    512512        pin = popen(command, "r");
    513513        if (pin) {
    514             for (fgets(tmp, MAX_STR_LEN, pin); !feof(pin);
    515                  fgets(tmp, MAX_STR_LEN, pin)) {
     514            for (p = fgets(tmp, MAX_STR_LEN, pin); !feof(pin) && (p != NULL);
     515                 p = fgets(tmp, MAX_STR_LEN, pin)) {
    516516                if (bkpinfo->use_star) {
    517517                    if (!strstr(tmp, "diffopts=")) {
    … …  
    724724            sprintf(tmp, "echo \"%s\" >> %s/biggies.changed",
    725725                    biggie_fname, bkpinfo->tmpdir);
    726             system(tmp);
     726            paranoid_system(tmp);
    727727        }
    728728    }

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

    r2982 r3060  
    123123        /*@ buffers ********************************************************** */
    124124        int i;
     125        char *p;
    125126
    126127         assert_string_is_neither_NULL_nor_zerolength(prompt);
    … …  
    132133
    133134            while (1) {
    134                 system("sync");
     135                paranoid_system("sync");
    135136                printf
    136137                    ("---promptdialogYN---1--- %s\n---promptdialogYN---Q--- [yes] [no] ---\n--> ",
    137138                     prompt);
    138                 (void) fgets(tmp, MAX_NEWT_COMMENT_LEN, stdin);
     139                p= fgets(tmp, MAX_NEWT_COMMENT_LEN, stdin);
     140                if (!p) {
     141                    //FIXME
     142                }
    139143                if (tmp[strlen(tmp) - 1] == '\n')
    140144                    tmp[strlen(tmp) - 1] = '\0';
    … …  
    151155                    return (FALSE);
    152156                } else {
    153                     system("sync");
     157                    paranoid_system("sync");
    154158                    printf
    155159                        ("Please enter either YES or NO (or yes or no, or y or n, or...)\n");
    … …  
    172176        /*@ buffer *********************************************************** */
    173177        char *tmp;
     178        char *p;
    174179        int i;
    175180
    … …  
    177182        assert_string_is_neither_NULL_nor_zerolength(prompt);
    178183        if (g_text_mode) {
    179             system("sync");
     184            paranoid_system("sync");
    180185            printf
    181186                ("---promptdialogOKC---1--- %s\n---promptdialogOKC---Q--- [OK] [Cancel] ---\n--> ",
    182187                 prompt);
    183             (void) fgets(tmp, MAX_NEWT_COMMENT_LEN, stdin);
     188            p = fgets(tmp, MAX_NEWT_COMMENT_LEN, stdin);
     189            if (!p) {
     190                // FIXME
     191            }
    184192            if (tmp[strlen(tmp) - 1] == '\n')
    185193                tmp[strlen(tmp) - 1] = '\0';
    … …  
    347355        */
    348356
    349         chdir("/");
     357        if (chdir("/")) {
     358            // FIXME
     359        }
    350360        if (g_selfmounted_isodir) {
    351361            sprintf(command, "umount -d %s", g_selfmounted_isodir);
    … …  
    406416
    407417        /*  Before removing dir, make sure we're out of them */
    408         chdir("/tmp");
     418        if (chdir("/tmp")) {
     419            // FIXME
     420        }
    409421        run_program_and_log_output("umount -d " MNT_CDROM, FALSE);
    410422        if (g_selfmounted_isodir) {
    … …  
    432444                log_msg(8,"erasing tempdir %s",bkpinfo->tmpdir);
    433445                mr_asprintf(&command, "rm -Rf %s", bkpinfo->tmpdir);
    434                 system(command);
     446                paranoid_system(command);
    435447                mr_free(command);
    436448            }
    … …  
    441453                log_msg(8,"erasing scratchdir %s",bkpinfo->scratchdir);
    442454                mr_asprintf(&command, "rm -Rf %s", bkpinfo->scratchdir);
    443                 system(command);
     455                paranoid_system(command);
    444456                mr_free(command);
    445457            }
    … …  
    475487        char *command = NULL;
    476488        char *tmp = NULL;
     489        char *p = NULL;
    477490
    478491        /*@ pointers ********************************************************* */
    … …  
    502515                for (err_log_lines[i][0] = '\0';
    503516                     strlen(err_log_lines[i]) < 2 && !feof(fin);) {
    504                     (void) fgets(err_log_lines[i], MAX_NEWT_COMMENT_LEN,
    505                                  fin);
     517                    p = fgets(err_log_lines[i], MAX_NEWT_COMMENT_LEN, fin);
     518                    if (!p) {
     519                        // FIXME
     520                    }
    506521                    /* Commented to make valgrind happy and avoid crash
    507522                    strip_spaces(err_log_lines[i]);
    … …  
    774789        /*@ buffers ********************************************************** */
    775790        char *blurb;
     791        char *p;
    776792        char *original_contents;
    777793
    … …  
    786802                ("---promptstring---1--- %s\n---promptstring---2--- %s\n---promptstring---Q---\n-->  ",
    787803                 title, b);
    788             (void) fgets(output, maxsize, stdin);
     804            p = fgets(output, maxsize, stdin);
     805            if (!p) {
     806                // FIXME
     807            }
    789808            if (output[strlen(output) - 1] == '\n')
    790809                output[strlen(output) - 1] = '\0';
    … …  
    843862        /*@ buffers *********************************************************** */
    844863        char *prompt;
     864        char *q;
    845865
    846866        /*@ newt ************************************************************** */
    … …  
    865885                                          || strcmp(prompt, button2));) {
    866886                printf("--> ");
    867                 (void) fgets(prompt, MAX_NEWT_COMMENT_LEN, stdin);
     887                q = fgets(prompt, MAX_NEWT_COMMENT_LEN, stdin);
     888                if (!q) {
     889                    // FIXME
     890                }
    868891            }
    869892            if (!strcmp(prompt, button1)) {
    … …  
    12761299"netfs", "iso", NULL };
    12771300        char *outstr;
     1301        char *p;
    12781302        t_bkptype backup_type;
    12791303        int i;
    … …  
    13011325                }
    13021326                printf(")\n--> ");
    1303                 (void) fgets(outstr, MAX_NEWT_COMMENT_LEN, stdin);
     1327                p = fgets(outstr, MAX_NEWT_COMMENT_LEN, stdin);
     1328                if (!p) {
     1329                    // FIXME
     1330                }
    13041331                strip_spaces(outstr);
    13051332                for (i = 0; possible_responses[i]; i++) {
    … …  
    14841511        bool done;
    14851512        char *tmp;
     1513        char *p;
    14861514        char *tmp1 = NULL;
    14871515        FILE *fin, *fout;
    … …  
    15131541                break;
    15141542            }
    1515             (void) fgets(tmp, MAX_NEWT_COMMENT_LEN, fin);
     1543            p = fgets(tmp, MAX_NEWT_COMMENT_LEN, fin);
     1544            if (!p) {
     1545                // FIXME
     1546            }
    15161547            i = (int) strlen(tmp);
    15171548            if (i < 2) {
Note: See TracChangeset for help on using the changeset viewer.