예제 #1
0
int main(int argc, char** argv)
{
	if (argc < 2)
	{
		printf("at least 2 arg\n");
	}
	
	du_file(argv [1]);
		
	return 1;
}
예제 #2
0
파일: mdu.c 프로젝트: MaximeMenotti/L3S5-TP
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;
}
예제 #3
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;

}
예제 #4
0
파일: mdu.c 프로젝트: MaximeMenotti/L3S5-TP
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;
}
예제 #5
0
파일: du_file.c 프로젝트: jhoukem/tpS5
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;
    
}
예제 #6
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;
}
예제 #7
0
파일: du_file.c 프로젝트: jhoukem/tpS5
int main(int argc, char*argv[])
{
  int size = du_file(argv[1]);
  printf("Size : %d\n", size);
  return 0;
}