int main(int argc, char** argv)
{
if (argc < 2)
{
printf("at least 2 arg\n");
}
du_file(argv [1]);
return 1;
}
int
main
(int argc,char *argv[]) {
if (argc < 3) {
fprintf(stderr,"Usage : %s <filepath> <0/1> \n", argv[0]);
exit (EXIT_FAILURE);
}
if (*argv[2] == '0')
opt_apparent_size=0;
printf("Taille : %i\n", du_file(argv[1]));
return 0;
}
/*Main du programme*/
int main(int argc, char* argv[]) {
/*Les retours des fonctions 'du' et 'verify_options'*/
int retour_du, retour_options, test_to_verify;
/*Chaine de caractères constituant le pathname*/
char* pathname;
/*Chaine de caractères constituant la liste des options demandées par l'utilisateur*/
char* options = NULL;
test_to_verify = 0;
/*Si trop d'arguments -> erreur*/
if (argc>3) {
perror("Utilisation: ./du_file [-abL] or [-h] [pathname]\n");
return 1;
}
if (argv[1][0] == '-') {
test_to_verify = 1;
options = &argv[1][1];
};
/*Si 2 ou 3 arguments pris en compte alors...*/
if (argc == 3) {
/*On regarde s'il y a bien 3 arguments...*/
assert(argv[1][0] == '-');
pathname = argv[2];
}
/*...ou alors 2*/
else {
/*Si ce n'est pas une option (-h), alors le 1er argument est le chemin du fichier*/
if (test_to_verify != 1) pathname = argv[1];
};
/*Si des options ont été entrés, alors on va les vérifier une par une*/
if (test_to_verify == 1) {
retour_options = verify_options(options);
};
if (retour_options != 0) return 1;
retour_du = du_file(pathname);
printf("%d %s\n",retour_du,pathname);
return 0;
}
int
compute_dir
(char *p) {
DIR *d;
struct dirent *sd;
struct stat st;
int taille;
lstat(p,&st);
if (opt_apparent_size)
taille=st.st_size;
else
taille=st.st_blocks;
d=opendir(p);
while ((sd=readdir(d)) != 0) {
build_path(p,sd->d_name,p);
taille+=du_file(p);
}
return taille;
}
int du_file(const char * pathname)
{
struct stat st;
struct dirent* stdir;
char current [PATH_MAX+1];
int size;/*count dir size*/
DIR * dir;
/*Check if the st is init*/
assert(lstat(pathname, &st) == 0);
/*if it is a regular file, return the size (using the opt)*/
if(S_ISREG(st.st_mode) || S_ISLNK(st.st_mode) ){
return opt_apparent_size ? st.st_size : st.st_blocks;
}
/*If is a directory*/
if(S_ISDIR(st.st_mode)){
/*Open directory*/
dir = opendir(pathname);
/*add the directory size (unsing the opt)*/
size = opt_apparent_size ? st.st_size : st.st_blocks ;
while( (stdir = readdir(dir)) != NULL ){
/*if the directory is the same or the parent ignore*/
if(!validName(stdir->d_name)){
continue;
}
/*add the path of the current dir to the given path*/
snprintf(current,PATH_MAX,"%s/%s",pathname, stdir->d_name);
size+= du_file(current);
}
closedir(dir);
return size;
}
/*4 autres type possibles*/
printf("Warning the pathname were ignored because the type of file is not treated");
return 0;
}
/*Fonction du_file -> Permet de donner l'espace mémoire ROM utilisé par le chemin donné en paramètre de la fonction*/
int du_file(const char *pathname) {
/*Variable contenant le répertoire*/
DIR *dirp;
/*Variable path*/
char path[PATH_MAX + 1], link_path[PATH_MAX + 1];
/*Structure du répertoire*/
struct dirent *dp;
/*Variable contenant la taille du répertoire donné + d'un répertoire qui sera remis à 0 ensuite*/
int r = 0, dir_size = 0, status;
/*Structure stat*/
struct stat sb;
status = lstat(pathname, &sb);
/*Si le chemin donné mène vers un fichier, on retourne l'espace mémoire utilisé*/
if (S_ISREG(sb.st_mode)) {
return opt_apparent_size?sb.st_size:sb.st_blocks;
}
/*Sinon -> répertoire / lien symbolique*/
else {
/*Si c'est un répertoire...*/
if (S_ISDIR(sb.st_mode)) {
/*On s'assure que l'on peut ouvrir le dossier donné en paramètre*/
assert(dirp = opendir(pathname));
/*On lit les sous-dossiers*/
while((dp=readdir(dirp))) {
if(valid_name(dp -> d_name)) {
assert(strlen(pathname)+1+strlen(dp->d_name)+1 <= PATH_MAX);
/*On concatène le chemin donné en paramètre avec l'autre dossier ouvert*/
strcpy(path, pathname);
strcat(path,"/");
strcat(path,dp->d_name);
r+=du_file(path);
/*Vérification du list_all (option -a)*/
if (opt_list_all == 1) {
dir_size = du_file(path);
printf("%d %s\n",dir_size,path);
};
/*Fin de vérification du list_all*/
};
}
r+=opt_apparent_size?sb.st_size:sb.st_blocks;
closedir(dirp);
}
else {
/*On vérifie si ce n'est pas un lien symbolique, et si l'option demandé par l'utilisateur est bon*/
if (S_ISLNK(sb.st_mode) && (opt_follow_links == 1)) {
/*S'il est bon, on fait un readlink sur le pathname, que l'on stocke dans link_path*/
status = readlink(pathname, link_path, PATH_MAX);
/*Si tout va bien...*/
if (status > 0) {
/*On ferme la chaîne par \0*/
link_path[status] = '\0';
/*On ajoute en mémoire l'espace mémoire utilisé pour le fichier pointé par le lien symbolique*/
r+=opt_apparent_size?sb.st_size:sb.st_blocks;
r+=du_file(link_path);
}
}
}
return r;
}
return 0;
}
int main(int argc, char*argv[])
{
int size = du_file(argv[1]);
printf("Size : %d\n", size);
return 0;
}