tree.c

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/stat.h>

int compare_names(const void *a, const void *b){
    const char **a_ptr = (const char **)a;
    const char **b_ptr = (const char **)b;
    return strcmp(*a_ptr, *b_ptr);
}
int path_concatenate(char *dest, size_t dest_size, const char *src, const char *add){
    size_t src_len = strlen(src);
    size_t add_len = strlen(add);

    if (src_len + 1 + add_len>=dest_size){ 
        return -1; //path doesn't fit in buffer
    }
    strcpy(dest, src);
    if (src[src_len - 1] != '/'){
        strcat(dest, "/");
    }
    strcat(dest, add);
    return 0; 
}

void tree_output(const char *path, int spacing, int print_size, int print_hidden){
    DIR *d;
    struct dirent *dirent;
    char **names = NULL;
    int num_ent = 0;
    int i;

    //open directory and count number of directory entries 
    d = opendir(path);
    if (!d) {//if directory doesn't exist show error msg 
        perror(path);
        return;
    }
    while ((dirent = readdir(d)) != NULL) {//iterate over directory entries
        if (strcmp(dirent->d_name, ".") == 0 || strcmp(dirent->d_name, "..") == 0) continue;//skip over "." and ".."
        if (!print_hidden && dirent->d_name[0] == '.') continue;//skip over hidden files if -a flag not passed
        num_ent++;//increment number of entries for allocating 
    }
    closedir(d);//close directory, freeing fd's 
    names = malloc(num_ent * sizeof(char *)); 
    if (!names) {//make sure space was allocated successfully
        perror("malloc");
        return;
    }
    //open directory again to put names on heap array names 
    d = opendir(path);
    if (!d) {//ensure path exists 
        perror(path);
        free(names);
        return;
    }//iterate over names
    i = 0;
    while ((dirent = readdir(d)) != NULL){
        if (strcmp(dirent->d_name, ".") == 0 || strcmp(dirent->d_name, "..") == 0) continue;
        if (!print_hidden && dirent->d_name[0] == '.') continue;
        names[i] = strdup(dirent->d_name);
        if (!names[i]) {
            perror("strdup");//ensure strings were copied
            for (int j=0; j<i; j++) {
                free(names[j]);
            }
            free(names);
            closedir(d);
            return;
        }
        i++;
    }
    closedir(d); 
    //sort entries 
    qsort(names, num_ent, sizeof(char *), compare_names);
    //print entries
    d = opendir(path); 
    if (!d){
        perror(path);
        free(names);
        return;
    }
    for (i=0; i<num_ent; i++){
        struct stat sb;
        char full_path[10000];
      
        if (path_concatenate(full_path, sizeof(full_path), path, names[i]) == 0){
            if (lstat(full_path, &sb) == 0){
                for (int j=0; j<spacing; j++) printf("|   ");
                printf("|-- %s", names[i]);
                if (print_size) printf(" [size: %ld]", (long)sb.st_size);
                printf("\n");
                if (S_ISDIR(sb.st_mode)) {
                    tree_output(full_path, spacing+1, print_size, print_hidden);
                }
            } 
        }else{
            fprintf(stderr, "Path too long");
        }
        free(names[i]);
    }

    free(names);
    closedir(d);
}

int main(int argc, char *argv[]){
    int print_hidden = 0;
    int print_size = 0;
    int arg_number = 1;

    while (arg_number < argc && argv[arg_number][0] == '-'){
        if (strcmp(argv[arg_number], "-a") == 0) print_hidden = 1;
        else if (strcmp(argv[arg_number], "-s") == 0) print_size = 1;
        else{
            fprintf(stderr, "Invalid switch: %s\n", argv[arg_number]);
            return 1;
        }
        arg_number++;
    }

    if (arg_number == argc){// print current directory if no arguments are given
        tree_output(".", 0, print_size, print_hidden);
    } else{
        while (arg_number < argc){
            struct stat sb;
            if (lstat(argv[arg_number], &sb) == 0){
                if (S_ISDIR(sb.st_mode)){
                    printf("%s\n", argv[arg_number]);
                    tree_output(argv[arg_number], 0, print_size, print_hidden);
                } else{
                    printf("%s", argv[arg_number]);
                    if (print_size) printf(" [size: %ld]", (long)sb.st_size);
                    printf("\n");
                }
            } else{
                perror(argv[arg_number]);
            }
            arg_number++;
        }
    }

    return 0;
}