Get the size of a directory recursively - C - c

Question

I'm trying to get the size of a directory recursively but I only get segfaults. I really can't see where I'm wrong, could someone help me?
P.S. I don't need to verify if the file exist or not, this is only a try for another function I have to write.
Here's the code:
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
#include <stdlib.h>
#include <limits.h>
int main(int argc, char * argv[])
{
printf("%d\n", size(argv[1]));
return 0;
}
int is_folder(char * path)
{
struct stat path_stat;
stat(path, &path_stat);
return !(S_ISREG(path_stat.st_mode));
}
int size(char * name)
{
int dir_size = 0;
struct dirent * pDirent;
DIR * pDir = opendir(name);
while ((pDirent = readdir(pDir)) != NULL)
{
char buf[PATH_MAX + 1];
realpath(pDirent->d_name, buf);
if (is_folder(buf))
{
size(buf);
}
else
{
struct stat st;
stat(buf, &st);
int sz = st.st_size;
dir_size += sz;
}
}
return dir_size;
}

Answer 1

Building on your code, below is the closest I was able to reproduce what du -sk returns:
#include <stdio.h>
#include <sys/stat.h>
#include <dirent.h>
#include <limits.h>
#include <string.h>
off_t directorySize(char *directory_name)
{
off_t directory_size = 0;
DIR *pDir;
if ((pDir = opendir(directory_name)) != NULL)
{
struct dirent *pDirent;
while ((pDirent = readdir(pDir)) != NULL)
{
char buffer[PATH_MAX + 1];
strcat(strcat(strcpy(buffer, directory_name), "/"), pDirent->d_name);
struct stat file_stat;
if (stat(buffer, &file_stat) == 0)
{
directory_size += file_stat.st_blocks * S_BLKSIZE;
}
if (pDirent->d_type == DT_DIR)
{
if (strcmp(pDirent->d_name, ".") != 0 && strcmp(pDirent->d_name, "..") != 0)
{
directory_size += directorySize(buffer);
}
}
}
(void) closedir(pDir);
}
return directory_size;
}
int main(int argc, char *argv[])
{
printf("%lldKiB\n", directorySize(argv[1]) / 1024);
return 0;
}
I'm guessing the difference you're seeing is due to directories consuming a small amount of space which you need to include in your total and that file space usage is chunked so you need to count blocks, not bytes.

Answer 2

After one night spent on trying how to find a size that is quiet the same of the one reported by du -sh: I wrote this and it seems to work also on large directories (like the linux source that is 750MB or more).
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <dirent.h>
#include <stdlib.h>
#include <limits.h>
long folder_size(char *);
int main(int argc, char * argv[])
{
if (argc < 2)
{
exit(1);
}
printf("%ld\n", mysize(argv[1]));
return 0;
}
int not_folder(char * path)
{
struct stat path_stat;
stat(path, &path_stat);
return (S_ISREG(path_stat.st_mode));
}
long folder_size(char * name)
{
long dir_size = 0L;
struct dirent * pDirent;
DIR * pDir = opendir(name);
while ((pDirent = readdir(pDir)))
{
if (strcmp (pDirent->d_name, "..") != 0 && strcmp (pDirent->d_name, ".") != 0)
{
char buf[PATH_MAX];
strcpy(buf, name);
strcat(buf, "/");
strcat(buf, pDirent->d_name);
if (not_folder(buf))
{
struct stat st;
stat(buf, &st);
dir_size += st.st_blocks * S_BLKSIZE;
printf("%s %ld\n", buf, (long)st.st_size);
}
else
{
dir_size += folder_size(buf);
}
}
}
(void) closedir(pDir);
return dir_size;
}