[C] My_ls

[Darmo]

Plop!
Comme promis, voici mon my_ls (ne vous étonnez pas de la syntaxe, c'est celle d'Epitech):
my_ls.h :

Code :

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

struct        opt
{
  int        opt_l;
  int        opt_R;
  int        opt_d;
  int        opt_r;
  int        opt_t;
};

void        check_opt(struct opt *opts, int i, int j, char *argv[]);
int        count_dir(char *argv[]);
int        count_files(char path[]);
void        directory(char dir[], struct opt options);
int        *getargs(char *argv[], struct opt *opts, int ok);
char        *getpath(char dirname[], char path[]);
size_t        get_mtime(char filename[]);
size_t        get_size(char **path__of_files, int nb_files, char path[]); //stat.c
void            init_struct(struct opt *opt);
int        is_dir(char path[]);
int        my_ls(int *path, char *argv[],struct opt options, int i);
void        my_ls_end(char **file_index, char path[], int nb_files, struct opt options);
int        my_lsNoDir(char *argv[], struct opt options);
char            *my_strcat(char *dest, char *src);
int        my_strcmp(const char *s1, const char *s2);
char            *my_strcpy(char *dest, const char *src);
char        *my_strdup(const char *s);
void        print_file_right(struct stat *status);
void        print_stat(char filename[]);
void        recursive(char path[], struct opt options);
void        recursive_end(char **path_of_dir, int nb_file, struct opt options);
void        recursive_print(char path[], struct opt options, char **path_of_dir, char **files);
char        **rempl_index(char path[], int nb_files);
char        **rempl_index_path(char path[], int nb_files);
void        sort_tab(char **tab, int n, struct opt options);
#endif

main.c :

Code :

#include        "my_ls.h"

int             main (int argc, char **argv)
{
  int           nb_dir;
  int           n;
  int           i;
  int           *tab = NULL;
  struct opt    options;

  i = 0;
  nb_dir = count_dir(argv);
  init_struct(&options);
  tab = getargs(argv, &options, nb_dir);
  if (nb_dir == -1)
    my_lsNoDir(argv, options);
  else
    my_ls(tab, argv, options, i);
  return (0);
}

int             my_ls(int *path, char *argv[], struct opt options, int i)
{
  int           path_num;
  char          **file_index;
  int        nb_files;

  while (path[i] != '\0')
    {
      path_num = path[i];
      nb_files = count_files(argv[path_num]);
      if (check_dir_exist(argv[path_num]) != -1)
    {
      if (options.opt_d == 1)
        directory(argv[path_num], options);
      else
        {
          file_index = rempl_index(argv[path_num], nb_files);
          sort_tab(file_index, nb_files, options);
          if (options.opt_R == 1)
        recursive(argv[path_num], options);
          else
        my_ls_end(file_index, argv[path_num], nb_files, options);
        }
    }
      i++;
    }
  return (0);
}
    
int             my_lsNoDir(char *argv[], struct opt options)
{
  char          **file_index;
  int           nb_files;

  nb_files = count_files(".");
  if (options.opt_d == 1)
    directory(".", options);
  else
    {
      file_index = rempl_index(".", nb_files);
      sort_tab(file_index, nb_files, options);
      if (options.opt_R == 1)
    recursive(".", options);
      else
    my_ls_end(file_index, ".",  nb_files, options);
    }
  return (0);
}

void        my_ls_end(char **file_index, char path[], int nb_files, struct opt options)
{
  int        i;
  char        **path_of_files;

  i = 0;
  path_of_files = rempl_index_path(path, nb_files);
  sort_tab(path_of_files, nb_files, options);
  if (options.opt_t == 1)
    {
      sort_tab_mtime(path_of_files, nb_files);
      sort_tab_mtime(file_index, nb_files);
    }
  if (options.opt_l == 1)
    my_printf("Total: %d", get_size(path_of_files, nb_files, path));
  while (i < nb_files)
    {
      if (options.opt_l == 1)
    print_stat(path_of_files[i]);
      my_printf("%s\n", file_index[i]);
      i++;
    }
}

args.c :

Code :

#include    "my_ls.h"

int        *getargs(char *argv[], struct opt *opts, int ok)
{
  int        i;
  int        j;
  int        n;
  int        *path;

  n = 0;
  i = 1;
  j = 0;
  path = NULL;
  if (ok != -1) {
    if ((path = calloc(ok, sizeof (int))) == NULL)
      exit(0);
  }
  while (argv[i] != '\0') {
    if (argv[i][j] == '-') {
      while (argv[i][j] != '\0') {
    j++;
    if (argv[i][j] == 'l')
      opts->opt_l = 1;
    if (argv[i][j] == 'R')
      opts->opt_R = 1;
    if (argv[i][j] == 'd')
      opts->opt_d = 1;
    if (argv[i][j] == 'r')
      opts->opt_r = 1;
    if (argv[i][j] == 't')
      opts->opt_t = 1;
      }
    }
    else if (ok != -1 || ok != 0) {
      path[n] = i;
      n++;
      ok--;
    }
    j = 0;
    i++;
  }
  return (path);
}

count.c :

Code :

#include    "my_ls.h"

int        count_dir(char *argv[])
{
  int        n;
  int        i;
  
  i = 1;
  n = 0;
  while (argv[i] != '\0')
    {
      if (argv[i][0] != '-')
    n++;
      i++;
    }
  if (n == 0)
    return (-1);
  else
    return (n);
}

int        count_files(char path[])
{
  DIR        *dir;
  struct dirent *entry;
  int        i;

  i = 0;
  dir = opendir(path);
  while ((entry = readdir(dir)) != NULL)
    if (entry->d_name[0] != '.')
      i++;
  return (i);
}

directory.c :

Code :

#include    "my_ls.h"

void        directory(char dir[], struct opt options)
{
  if (options.opt_l == 1)
    print_stat(dir);
  my_printf("%s\n", dir);
}

int        check_dir_exist(char directory[])
{
  DIR        *dir;
  
  if ((dir = opendir(directory)) == NULL)
    {
      my_printf("my_ls: impossible d'acceder a %s: Aucun fichier ou dossier de ce type", directory);
      return (-1);
    }
  else
    return (0);
}

index.c :

Code :

#include    "my_ls.h"

char        **rempl_index(char path[], int nb_files)
{
  DIR        *dir;
  struct dirent *entry;
  int        i;
  char        **tab;

  tab = NULL;
  i = 0;
  tab = calloc(nb_files, sizeof(char *));
  dir = opendir(path);
  while ((entry = readdir(dir)) != NULL)
    {
      if (entry->d_name[0] != '.') {
    tab[i] = strdup(entry->d_name);
    i++;
      }
    }
  closedir(dir);
  return (tab);
}

char            **rempl_index_path(char path[], int nb_files)
{
  DIR           *dir;
  struct dirent *entry;
  int           i;
  char          **tab;

  tab = NULL;
  i = 0;
  tab = calloc(nb_files, sizeof(char *));
  if ((dir = opendir(path)) == NULL)
    perror("my_ls");
  while ((entry = readdir(dir)) != NULL)
    {
      if (entry->d_name[0] != '.') {
    tab[i] = getpath(entry->d_name, path);
        i++;
      }
    }
  closedir(dir);
  return (tab);
}

init.c :

Code :

#include    "my_ls.h"

void        init_struct(struct opt *opt)
{
  opt->opt_l = 0;
  opt->opt_R = 0;
  opt->opt_r = 0;
  opt->opt_d = 0;
  opt->opt_t = 0;
}

recursive.c :

Code :

#include    "my_ls.h"

void        recursive(char path[], struct opt options)
{
  int        i;
  char        **files;
  int        nb_files;
  char        **path_of_dir;
  
  i = 0;
  nb_files = count_files(path);
  files = rempl_index(path, nb_files);
  path_of_dir = rempl_index_path(path, nb_files);
  sort_tab_mtime(path_of_dir, nb_files, options);
  if (options.opt_t == 1)
    sort_tab_mtime(files, nb_files, options);
  else
    sort_tab(files, nb_files, options);
  recursive_print(path, options, path_of_dir, files);
  nb_files = count_files(path);
  recursive_end(path_of_dir, nb_files, options);
}

void        recursive_end(char **path_of_dir, int nb_files, struct opt options)
{
  int        i;

  i = 0;
  while (i < nb_files)
    {
      if (is_dir(path_of_dir[i]) == 1)
    recursive(path_of_dir[i], options);
      i++;
    }
}
int        is_dir(char path[])
{
  struct stat    status;

  stat(path, &status);
  if (S_ISDIR(status.st_mode))
    return (1);
  else
    return (0);
}

char        *getpath(char dirname[], char path[])
{
  char        *dirpath;
  int        size;
  int        i;
  
  i = 0;
  dirpath = NULL;
  i = my_strlen(path);
  size = i;
  size = size + my_strlen(dirname);
  dirpath = calloc(size, sizeof(char*));
  my_strcat(dirpath, path);
  if (dirpath[i-1] != '/')
    dirpath[i] = '/';
  i++;
  my_strcat(dirpath, dirname);
  return (dirpath);
}

void        recursive_print(char path[], struct opt options, char **path_of_dir, char **files)
{
  int        i;
  
  i = 0;
  my_printf("\n%s:\n", path);
  while (i < (count_files(path)))
    {
      if(options.opt_l == 1)
    {
      print_stat(path_of_dir[i]);
      my_printf("%s\n", files[i]);
    }
      else
    my_printf("%s\n", files[i]);
      i++;
    }
}

sort.c :

Code :

#include    "my_ls.h"

void        sort_tab(char **tab, int n, struct opt options)
{
  int        i;
  int        j;
  char        *temp;

  i = 0;
  while (i < n)
    {
      j = 0;
      while (j < n)
    {
      if ((options.opt_r) ? (my_strcmp(tab[i], tab[j]) > 0) : (my_strcmp(tab[i], tab[j]) < 0))
        {
          temp = tab[i];
          tab[i] = tab[j];
          tab[j] = temp;
          }
      j++;
    }
      i++;
    }
}

void        sort_tab_mtime(char **tab, int n, struct opt options)
{
  int           i;
  int           j;
  char          *temp;
  int        r;

  r = options.opt_l;
  i = 0;
  while (i < n)
    {
      j = 0;
      while (j < n)
        {
          if ((r) ? (get_mtime(tab[i]) > get_mtime(tab[j])) : (get_mtime(tab[i]) < get_mtime(tab[j])))
            {
              temp = tab[i];
              tab[i] = tab[j];
              tab[j] = temp;
        }
          j++;
    }
      i++;
    }
}

size_t        get_mtime(char filename[])
{
  struct stat    status;
  stat(filename, &status);
  return (status.st_mtime);
}

stat.c :

Code :

#include    "my_ls.h"

void        print_stat(char filename[])
{
  struct stat    status;
  struct passwd    *pwuid;
  struct group    *grp;
  char        *tab;
  int        i;

  i = 0;
  if (stat(filename, &status) == -1)
    perror("stat");
  else
    {
      print_file_right(&status);
      if ((pwuid = getpwuid(status.st_uid)) == NULL)
    perror("getpwuid");
      else
    {
      my_printf(" %s", pwuid->pw_name);
      grp = getgrgid(status.st_gid);
      my_printf(" %s", grp->gr_name);
      my_printf(" %d", status.st_size);
      tab = ctime(&(status.st_mtime));
      while (tab[i] != '\0')
        i++;
      tab[i-1] = '\0';          //Enlever ce foutu '\n' que ctime met à la fin de la chaine
      my_printf(" %s ", tab);
    }
    }
}

void        print_file_right(struct stat *status)
{
  my_printf(S_ISDIR(status->st_mode) ? "d" : "-");
  my_printf(status->st_mode & S_IRUSR ? "r" : "-");
  my_printf(status->st_mode & S_IWUSR ? "w" : "-");
  my_printf(status->st_mode & S_IXUSR ? "x" : "-");
  my_printf(status->st_mode & S_IRGRP ? "r" : "-");
  my_printf(status->st_mode & S_IWGRP ? "w" : "-");
  my_printf(status->st_mode & S_IXGRP ? "x" : "-");
  my_printf(status->st_mode & S_IROTH ? "r" : "-");
  my_printf(status->st_mode & S_IWOTH ? "w" : "-");
  my_printf(status->st_mode & S_IXOTH ? "x" : "-");
}

size_t        get_size(char **path_of_files, int nb_files, char path[])
{
  struct stat    status;
  int        i;
  size_t    total;
  size_t    tot;
  
  
  total = 0;
  i = 0;
  while (i < nb_files)
    {
      stat(path_of_files[i], &status);
      total += status.st_size;
      i++;
    }
  stat(path, &status);
  total += status.st_size;
  tot = total / 966;
  return (tot);
}

Voilà
Les critiques et les conseils sont les bienvenus :p

[fr0g]

Cool de le partager, (plus complet que le mien :') )

[Darmo]

Peut-être, mais il reste des trucs à améliorer comme le tris alphabétique (problême avec les noms contenant des majuscules) :p

[Dobry]

Pas eu le temps de regarder, mais j'aurais jamais pensé qu'un LS soit aussi complexe !
Merci du partage !

[Darmo]

Le code est pas tellement complexe (enfin j'arrive à lire mon code, je ne sais pas si il est clair pour les autres), mais long, enfin c'est que mon deuxième projet qui fait + de 200 lignes quoi

[Trivial]

Merci du partage bro

(Même si je l'ai déjà chopé sur ton vps o_Q)

[Darmo]

LEECHER! :')

[Kiwazaru]

"Pas eu le temps de regarder, mais j'aurais jamais pensé qu'un LS soit aussi complexe !
Merci du partage ! "

Faut pas se fier aux apparences

Si tu regardes le code, tu vas voir la doc des fonctions dont tu ne connais pas l'utilité, tu comprends le principe de LS et puis ça coule de source :p

[Darmo]

Sinon des avis sur le code? Les trucs à améliorer, à rendre plus clair?

[Kiwazaru]

Personnellement je lirais le code demain, j'ai eu ma dose d'info today (installation de Linux à maintes et maintes reprises sans succès :'( ).

[ark]

Moi j'ai remarquer des fautes de normes! :p

[Sh4dows]

Moi j'ai remarquer des fautes de normes! Tongue

Tu n'es pas le seul

[Darmo]

Erf, la norme :p quoi comme fautes?

[Sh4dows]

Alors les define déjà c'est pas comme ça :

Code C :


#define        MY_LS_H
 

Mais comme ça :

Code C :


# define       _MY_LS_H_
 

Ensuite les includes dans les headers, tu c'est pas interdit mais a chaque fois on te dis que c'est dégeulasse !
Dans la fonction main tu initialises en même temps que tu déclares (peut être ailleurs aussi..) :

Code C :

  int           *tab = NULL;

Pas d'espace en fin de ligne, les noms des variables (déclaration) doivent être alignés avec
celui des fonctions.

Code :

char        **rempl_index(char path[], int nb_files)
{
  DIR        *dir;
  struct dirent *entry;
  int        i;
  char        **tab;
// ...

Maximum 25 lignes par fonction et 4 (ou 5 ; j'ai un doute là) fonctions par fichier !
J'ai du en oublié, si j'passe une moulinette tu prends chère

De toute manière ça vaut 1 ça car il manque les headers dans tes fichiers

Sinon tu veux aller à Epitech ?

EDIT : Faut pas de majuscule dans les noms de fonction ^^

[Darmo]

Oula! :p Heureusement que je suis pas à Epitech, je me serais fais tapé dessus! ^^
Le coup de l'initialisation de **tab = NULL; c'est une erreur bête, j'y fais gaffe d'habitude :/
J'aimerais bien y aller, mais c'est une école très cher, je préfère avoir des retours sur l'école 42 qui va ouvrir cette année, et qui elle, est gratuite :p
En tout cas merci d'avoir pris le temps de lire mon code