fopen? fails w/ mounted dvd

So the fseek/ftell method seems more reliable than stat.st_size (for acquiring file size) albeit much slower.

...except i get irregular results calling on mounted dvd's (burnt by me on redhat7). Sometimes this is a null pointer from fopen, but usually the program completes without reporting an error, but also without collecting any file sizes. I haven't had any other problems with the dvd's.

Here's the code -- it works almost exactly like du -h DIR (the code for which I haven't looked at). du b/t/w does work where this doesn't:

Code:

#include <stdio.h>
#include <dirent.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>

int sw1=0;
float totalsize; // kb count

int dodir (char *doname) {
        long int bytes, testbytes;      // "testbytes" is needed 
        float dividit;                  // for the return value error check 
        char nextfile[256];             // since "bytes" is +=
        struct dirent *dcon;
        FILE *fh;
    
        if (sw1 != 0) printf ("\t%s ", doname);
    
        DIR *dir = opendir (doname); 
        if (dir == NULL ) { 
                printf ("For Directory %s ERROR: %s\n", doname, strerror(errno)); 
                exit(1);
        }
    
        bytes = 0;
        while (dcon = readdir(dir)) {
                if (dcon->d_type == DT_REG) {   
                        strcpy(nextfile, doname);
                        strcat(nextfile, "/");
                        strcat(nextfile, dcon->d_name);
                        fh = fopen (nextfile, "r");
                        if (fh == NULL) 
                                printf ("\t\tFor regular file %s ERROR: %s\n", nextfile, strerror(errno));
                        if ((fseek(fh,0,SEEK_END)) != 0)  
                                printf ("\t\tfseek ERROR (%s)\n", nextfile);
                        if ((testbytes = ftell(fh)) == -1) 
                                printf ("ftell ERROR (%s)\n", nextfile);
                        else bytes += testbytes; 
                        fclose(fh);
                }
        }
        dividit = bytes; 
        dividit /= 1024; // gives kb 
        totalsize += dividit;
        if (sw1 == 0) printf (" (%.2f kb):\n", dividit);
        else if (sw1 >= 1) printf ("\t%.2f kb\n", dividit);

        sw1++;
        rewinddir(dir);

        while (dcon = readdir(dir)) {
                if ((strcmp (dcon->d_name, "..")) == 0 || (strcmp(dcon->d_name, ".")) == 0)     
                     continue;
                strcpy(nextfile, doname);
                strcat(nextfile, "/");
                strcat(nextfile, dcon->d_name);
                if (dcon->d_type == DT_DIR) dodir(nextfile);
        }
        closedir(dir);
}

int main (int argc, char *argv[]) {
        char unit[6];

        if (argc < 2) 
                puts ("Directory pathname required on command-line.");
                
        strcpy(unit, "kb");
        printf ("In %s", argv[1]);

        dodir(argv[1]);

        if (totalsize >= 1024) { totalsize /= 1024; strcpy(unit, "Mb"); }
        if (totalsize >= 1024) { totalsize /= 1024; strcpy(unit, "GB"); }
        printf ("Total size of regular files: %.2f %s\n", totalsize,unit);
}

Do you have large file support enabled ?

"Do you have large file support enabled ?"

No, but none of the files are bigger than a gigabyte.

But what about the sum of all the sizes?

The sum of all sizes!!!

Depends on the size of the tree. The code will add up over 4 GB fine (as long as no individual file is more than 4). I can sit and watch it do a whole harddrive, so one dvd shouldn't present a problem.

Of course, all the sizes are floats...

Since you are printing sterror(errno) when the fopen() fails... Why not tell us which error code is reported?

The fixed-size buffer for filenames is suspicious as well. 256 seems big but may not be big enough. You can avoid the whole issue by chdir()'ing into the directory and opening by relative path, then chdir()'ing back out again.

Large file support may not be the problem... But in any case, you should probably turn it on. Why artificially restrict your utility when it is easy to do otherwise? Compile with this:

-D_FILE_OFFSET_BITS=64

And use the fseeko() and ftello() functions with off_t instead of fseek() and ftell() with long.

Also, why not just stat() the file to get its size?