Programming

    char const * COMMON_FIFO = "FIFO_TEST";
    
    int walk_dir_and_calculate_sizes(char * path) {
    	opendir() ..
    	int totalRegularSizes = 0;
    	while ((entry = readdir) != NULL) {
    		char const *name = entry->d_name;
    		COMBINE path and name for example path is a/, name is b.txt(a/b.txt) or another DIRECTORY c(a/c)
    		IF (entry->d_type is DIRECTORY) {
    			if (name is "." or name is "..")
    			continue;
    
    			childPid = fork();
    			if (childPid == 0) {		//child
    				walk_dir_and_calculate_sizes(COMBINED_PATH);
    				_exit(0);
    			}
    
    			if (childPid > 0) {			// parent
    				continue;
    				// continue traversing if remaining dirs or files exist
    			}
    		}
    		ELSE {	// regular file like .txt, .pdf etc.
    			totalRegularSizes += another_func_giving_size_of_file(COMBINED_PATH);
    		}
    	}
    
    	closedir(..);
    	while (wait(&status) > 0);
    
    	RESTORE COMBINED_PATH to directory path, it is ok
    
    	int fd = OPEN(COMMON_FIFO, O_WRONLY);
    	char folderSizeInformation[100] = Current PID, directory size(= totalRegularSizes), directory name combinations
    	WRITE(fd, folderSizeInformation, strlen(folderSizeInformation)
    	CLOSE(fd)
    
    	return 123456 not important I think;
    
    }
    
    int main(char ** argv) {
    	mkfifo(COMMON_FIFO, 0644);
        OPEN(COMMON_FIFO, O_RDONLY|O_NONBLOCK);
    
        walk_dir_and_calculate_sizes(argv[1]);
    
        PRINT FIFO ON SCREEN
    
        exit(0);
        
    }

    char const * COMMON_FIFO = "FIFO_TEST";
    
    int walk_dir_and_calculate_sizes(char * path) {
    
    	/* PIPE */
    	int pfd[2];
    
    	opendir() ..
    	int totalRegularSizes = 0;
    	while ((entry = readdir) != NULL) {
    		char const *name = entry->d_name;
    		COMBINE path and name for example path is a/, name is b.txt(a/b.txt) or another DIRECTORY c(a/c)
    		IF (entry->d_type is DIRECTORY) {
    			if (name is "." or name is "..")
    			continue;
    
    			/* PIPE */
    			pipe(pfd);
    
    
    			childPid = fork();
    			if (childPid == 0) {		//child
    				walk_dir_and_calculate_sizes(COMBINED_PATH);
    				_exit(0);
    			}
    
    			if (childPid > 0) {			// parent
    				continue;
    				// continue traversing if remaining dirs or files exist
    			}
    		}
    		ELSE {	// regular file like .txt, .pdf etc.
    			totalRegularSizes += another_func_giving_size_of_file(COMBINED_PATH);
    		}
    	}
    
    	closedir(..);
    
    	/* PIPE COMMUNICATE READ */
    	while (wait(&status) > 0) {
    		close(pfd[1]);
    		int readVal = -1;
    		READ(pfd[0], &readVal, sizeof(readVal));
    		totalRegularSizes += readVal
    	}
    
    	RESTORE COMBINED_PATH to directory path, it is ok
    
    	int fd = OPEN(COMMON_FIFO, O_WRONLY);
    	char folderSizeInformation[100] = Current PID, directory size(= totalRegularSizes), directory name combinations
    	WRITE(fd, folderSizeInformation, strlen(folderSizeInformation)
    	close(fd)
    
    
    	/* PIPE COMMUNICATE WRITE */
    	// Since it is recursive function the deepest directory doesn't have any child(subdirectory)
    	// it omits wait() function and comes here
    
    	close(pfd[0]);
    	WRITE(pfd[1], &totalRegularSizes, sizeof(totalRegularSizes));
    
    
    	return 123456 not important I think;
    
    }

#include <ftw.h>
#include <sys/stat.h>
#include <stdio.h>
#include <string.h>

struct FTW {
        int base;
        int level;
};

struct result_t {
        char name[256];
        long int size;
} result[64];

int last_result=0;

int ftw_callback(const char *fpath, const struct stat *sb,
        int typeflag, struct FTW *ftwbuf);

int main(void) {
        int n;
        const char *ROOT="./";
        strcpy(result[0].name, ROOT);
        ftw(ROOT, ftw_callback, 8);

        for(n=0; n<=last_result; n++)
                printf("%s\t%ld bytes\n", result[n].name, result[n].size);
}

int ftw_callback(const char *fpath, const struct stat *sb,
        int typeflag, struct FTW *ftwbuf) {

        // Found a new second-level folder
        if((typeflag == FTW_D) && (ftwbuf->level == 1)) {
                last_result++;
                strcpy(result[last_result].name, fpath);
        }

        if(typeflag == FTW_F)
        {
                int res=last_result;
                // Special case for level-1 files, those are in ROOT
                if(ftwbuf->level == 1) res=0;
                result[res].size += sb->st_size;
        }

        return(0);
}