List

#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pwd.h>
#include <grp.h>
#include <time.h>

#define SIZE 1000

void print(char dir[]);
void print_detail(char *text, char dir[]);
void print_normal(char *text);
void print_recurrence(char dir[]);

int compare_name(const void *a, const void *b);
int compare_time(const void *a, const void *b);

void print_time(time_t t);
void print_type(mode_t m);
void print_perm(mode_t m);

void print_num(int num);
void print_str(const char *c);

int is_dir(struct dirent *d, char * dir);
void createPath(char *dest, char *name);
void shortenPath(char *path);

int lflag = 0;
int tflag = 0;
int Rflag = 0;

char *separator = "\n";

int main(int argc, char **argv){

    char *dir = ".";
    int c;
    while((c = getopt(argc, argv, "lRt")) != -1){
        switch(c){
            case 'l':
                lflag = 1;
                break;
            case 'R':
                Rflag = 1;
                lflag = 1;
                break;
            case 't':
                tflag = 1;
                break;
            default:
                abort();
        }
    }

    if(optind < argc) {
        dir = argv[optind];
    }

    if(Rflag) {
        char * next_dir = malloc(SIZE*sizeof(char));
        strcpy(next_dir, dir);
        print_recurrence(next_dir);
    } else {
        print(dir);
    }

    return 0;
}


void print(char dir[]){
     // liczba wskazująca ilość rekordów możliwych do zapisania w liście
    int i = 0;
    int c_list = 10;
    struct dirent **list = calloc(c_list,sizeof(struct dirent*));

    DIR * katalog = opendir(dir);
        struct dirent * zawartosc = readdir(katalog);

        while(zawartosc != NULL) {
        if(i >= c_list) {
            c_list += 10;
            list = realloc(list, c_list*sizeof(struct dirent *));
        }
        list[i] = zawartosc;
        i++;
                zawartosc = readdir(katalog);
        }

    if(tflag) {
        qsort(list, i, sizeof(struct dirent*), compare_time);
    } else {
        qsort(list, i, sizeof(struct dirent*), compare_name);
    }

    struct dirent **tmp = list;

    for(i; i>0; i--){
        if(lflag) {
            print_detail((*tmp)->d_name, dir);
        } else {
            print_normal((*tmp)->d_name);
        }
        tmp++;
    }


    free(list);
}



void print_recurrence(char dir[]){

    DIR * katalog = opendir(dir);
    struct dirent * zawartosc = readdir(katalog);

    print_str(dir);
    print_str("\n");
    print(dir);
    print_str("\n");

        while(zawartosc != NULL) {
        if( strcmp(zawartosc->d_name, ".") != 0 &&
            strcmp(zawartosc->d_name,"..") != 0 && is_dir(zawartosc, dir)) {

            createPath(dir, zawartosc->d_name);
            print_recurrence(dir);
            shortenPath(dir);
        }
                zawartosc = readdir(katalog);
        }
}

void print_detail(char *text, char dir[]){
    struct stat buff;

    char * temp = (char*) calloc(SIZE,sizeof(char));
    strcat(temp, dir);
    strcat(temp, "/");
    strcat(temp, text);

    stat(temp, &buff);

    struct passwd* pass = getpwuid(buff.st_uid);
    struct group* g = getgrgid(buff.st_gid);

    if(g != NULL) {
        print_type(buff.st_mode);
        print_perm(buff.st_mode);
        print_str(" ");
        print_num(buff.st_nlink);
        print_str(" ");
        print_str(pass->pw_name);
        print_str(" ");
        print_str(g->gr_name);
        print_str(" ");
        print_num(buff.st_size);
        print_str(" ");
        print_time(buff.st_mtime);
        print_str(" ");
        print_str(text);
        print_str(separator);
    }

    free(temp);
}

void print_normal(char * text){
    print_str(text);
    print_str(separator);
}


void print_type(mode_t m){
    switch (m & S_IFMT) {
           case S_IFBLK:  print_str("b");   break;
           case S_IFCHR:  print_str("c");   break;
           case S_IFDIR:  print_str("d");   break;
           case S_IFIFO:  print_str("p");   break;
           case S_IFLNK:  print_str("l");   break;
           case S_IFREG:  print_str("-");   break;
           case S_IFSOCK: print_str("s");   break;
           default:       print_str("u");   break;
           }
}

void print_perm(mode_t m){

    if((m & S_IRUSR) == S_IRUSR) print_str("r");
    else print_str("-");
    if((m & S_IWUSR) == S_IWUSR) print_str("w");
    else print_str("-");
    if((m & S_IXUSR) == S_IXUSR) print_str("x");
    else print_str("-");


    if((m & S_IRGRP) == S_IRGRP) print_str("r");
    else print_str("-");
    if((m & S_IWGRP) == S_IWGRP) print_str("w");
    else print_str("-");
    if((m & S_IXGRP) == S_IXGRP) print_str("x");
    else print_str("-");


    if((m & S_IROTH) == S_IROTH) print_str("r");
    else print_str("-");
    if((m & S_IWOTH) == S_IWOTH) print_str("w");
    else print_str("-");
    if((m & S_IXOTH) == S_IXOTH) print_str("x");
    else print_str("-");
}

void print_time(time_t t){
    struct tm * timeinfo;
    timeinfo = localtime(&t);
    print_num(timeinfo->tm_mon);
    print_str("-");
    print_num(timeinfo->tm_mday);
    print_str(" ");
    print_num(timeinfo->tm_hour);
    print_str(":");
    print_num(timeinfo->tm_min);
}


void print_str(const char *c){
    write(1, c, strlen(c));
}

void print_num(int n){
    char cyfra[1];
    if(n > 0) {
        print_num(n/10);
        cyfra[0] = (n%10)+48;
        write(1,cyfra, 1);
    }
}

int compare_time(const void *a, const void *b){
    struct dirent * ad = (*(struct dirent **)a);
    struct dirent * bd = (*(struct dirent **)b);

    struct stat stat_a;
    stat(ad->d_name, &stat_a);

    struct stat stat_b;
    stat(bd->d_name, &stat_b);

    return stat_b.st_mtime - stat_a.st_mtime;
}

int compare_name(const void *a, const void*b){
    struct dirent * ad = (*(struct dirent **)a);
    struct dirent * bd = (*(struct dirent **)b);

    return strcmp(ad->d_name,bd->d_name);
}



void createPath(char *dest, char *name){
        strcat(dest, "/");
        strcat(dest, name);
}

void shortenPath(char *path) {
    char * tmp = path;
    while(*tmp != '\0'){
        tmp++;
    }
    while(*tmp != '/'){
        tmp--;
    }

    *tmp = '\0';
}

int is_dir(struct dirent *d, char *dir) {
    struct stat m_stat;
    char *name = (char*) calloc(SIZE,sizeof(char));

    strcat(name, dir);
    strcat(name, "/");
    strcat(name, d->d_name);

    stat(name, &m_stat);

    if(S_ISDIR(m_stat.st_mode))  {
        // print_str("Check true");
        // print_str(name);
        // print_str("\n");
        free(name);
        return 1;
    } else {
        // print_str("Check false");
        // print_str(name);
        // print_str("\n");
        free(name);
        return 0;
    }
}