Paste2 Logo
  1. /*
  2. Autore: Red Skull 92
  3. Programma : Dir Maker
  4. Web : Www.RedSkull92.Wordpress.Com
  5. Mail : RedSkull92 AT gmail DOT com
  6. */
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <dirent.h>
  10. #include <string.h>
  11. #include <unistd.h>
  12. //Dichiaro i prototipi
  13. void _pwd();
  14. void _cd();
  15. void _catdir();
  16. void _crea();
  17. void _canc();
  18. void _about();
  19. void leggodir(char *dire);
  20. void canc_dir();
  21.  
  22. //Inizio Main
  23. int main()
  24. {
  25.         //Dichiaro come intero risp
  26.         int risp;
  27.         //Inizio il ciclo Do-While
  28.         do
  29.         {
  30.                 printf("\n$$$$$$$$$$$$$$$$$$$$$$$$$$\n"
  31.                 "$   Autore:Red Skull 92  $\n"
  32.                 "$   Titolo:Dir Maker     $\n"
  33.                 "$          Menu          $\n"
  34.                 "$     Cosa vuoi Fare ?   $\n"
  35.                 "$  0)Directory Corrente  $\n"
  36.                 "$  1)Cambia Directory    $\n"
  37.                 "$  2)Controlla Directory $\n"
  38.                 "$  3)Crea Directory      $\n"
  39.                 "$  4)Cancella Directory  $\n"
  40.                 "$  5)About               $\n"
  41.                 "$  6)Esci                $\n"
  42.                 "$$$$$$$$$$$$$$$$$$$$$$$$$$\n"
  43.                 "Risposta: ");
  44.                 //Se Risp non è un intero esco
  45.                 if(!(scanf("%d",&risp))){
  46.                         printf("Scelta non Valida!\n");
  47.                         break;}
  48.                 putchar('\n');
  49.                 switch (risp)
  50.                 {
  51.                 case 0:
  52.                         _pwd();
  53.                         break;
  54.                 case 1:
  55.                         _cd();
  56.                         break;
  57.                 case 2:
  58.                         _catdir();
  59.                         break;
  60.                 case 3:
  61.                         _crea();
  62.                         break;
  63.                 case 4:
  64.                         _canc();
  65.                         break;
  66.                 case 5:
  67.                         _about();
  68.                         break;
  69.                 default:
  70.                         printf("Opzione non valida ! ! !\n");
  71.                         break;
  72.                 }
  73.         }
  74.         //Se si digita 6 esco
  75.         while (risp != 6);    
  76. }
  77. //Funzione _pwd (Stampa la directory di lavoro)          
  78. void _pwd()
  79. {
  80.         getchar();
  81.         char perche[FILENAME_MAX];
  82.         //Con getcwd prendo la directory corrente e la salvo in perche
  83.         getcwd(perche,sizeof(perche));  
  84.         //Stampo il contenuto di perche      
  85.         printf("\n%s\n\n",perche);
  86.         printf("Premi Invio per tornare al menu.");
  87.         getchar();
  88.         getchar();
  89. }
  90. //Fine _pwd()
  91. //Funzione _cd (Per cambiare directory)
  92. void _cd()
  93. {
  94.         char nome[1024];
  95.         printf("Inserisci il path della Directory di destinazione.\n");
  96.         getchar();
  97.         gets(nome);
  98.         //Con chdir mi sposto da una directory all'altra
  99.         if(!(chdir(nome)))
  100.         {
  101.                 _pwd();
  102.         }
  103.         else
  104.         {
  105.                 printf("Impossibile trovare il percorso specificato.\n\n");
  106.                 printf("Premi Invio per tornare al menu.");
  107.                 getchar();
  108.         }  
  109. }
  110. //Fine _cd()          
  111. //Funzione _catdir() (Per leggere il contenuto di una directory)
  112. void _catdir()
  113. {
  114.         DIR *dir;
  115.         struct dirent *leggo;
  116.         //Apro la directory di lavoro
  117.         dir=opendir(".");
  118.         if (!dir)
  119.         {
  120.                 printf("Impossibile aprire la directory\n");
  121.                 printf("Premi Invio per tornare al menu.");
  122.                 getchar();
  123.                 getchar();
  124.         }
  125.         printf("File e cartelle presenti:\n");
  126.         //Faccio un ciclo fino a quando non vengono printati tutti i file
  127.         while((leggo=readdir(dir)))
  128.         {
  129.                 //I file . e .. non vengono printati
  130.                 if(!strcmp(leggo->d_name, ".") || !strcmp(leggo->d_name, "..")) continue;
  131.                 //Se riesco a leggere il file è un file altrimenti una cartella
  132.                 if(fopen(leggo->d_name,"r")==NULL)
  133.                 {
  134.                         printf("%s\n",strcat(leggo->d_name," ---DIR--- "));
  135.                 }
  136.                 else
  137.                 {
  138.                         printf("%s\n", leggo->d_name);
  139.                 }
  140.         }
  141.         printf("FINE\n");
  142.         closedir(dir);
  143.         printf("Premi Invio per tornare al menu.");
  144.         getchar();
  145.         getchar();
  146. }
  147. //Fine _catdir()
  148. //Funzione _crea() (Permette di creare una cartella)    
  149. void _crea()
  150. {
  151.         char nome[562];
  152.         printf("Inserisci il nome della cartella da creare: ");
  153.         getchar();
  154.         gets(nome);
  155.         //La funzione mkdir crea una cartella
  156.         if(!(mkdir(nome)))
  157.         {
  158.                 printf("Directory Creata con successo !\n");
  159.                 printf("Premi Invio per tornare al menu.");
  160.                 getchar();
  161.                 main();
  162.         }
  163.         else
  164.         {
  165.                 printf("Impossibile creare la Directory!\n");
  166.                 printf("Premi Invio per tornare al menu.");
  167.                 getchar();
  168.         }
  169. }
  170. //Fine _crea()
  171. //Funzione _canc() (Permette di  decidere se cancellare o meno la directory corrente)
  172. void _canc()
  173. {  
  174.         char y;
  175.         printf("Sei sicuro di voler cancellare la cartella e tutti i suoi file? (Y/N) (y/n)\n");
  176.         y=getchar();
  177.         getchar();
  178.         if (y == 'y' || y == 'Y')
  179.         {
  180.                 canc_dir();
  181.                 printf("Premi Invio per tornare al menu.\n");
  182.                 getchar();
  183.         }
  184.         if (y == 'n' || y == 'N')
  185.         {
  186.                 printf("Ritorno al menu...\n");
  187.                 getchar();
  188.         }
  189. }          
  190. //Fine _canc()
  191. //Funzione _about() (Stampa alcune info dell'autore)
  192. void _about()
  193. {
  194.         printf("##################################\n"
  195.         "##    Autore: Red Skull 92      ##\n"  
  196.         "##    Titolo: Dir Maker         ##\n"
  197.         "## Www.RedSkull92.Wordpress.Com ##\n"
  198.         "##################################\n"
  199.         "Premi Invio per tornare al menu.  \n");
  200.         getchar();
  201.         getchar();
  202. }
  203. // Fine _about()
  204. //Funzione leggodir (Funzione ricorsiva per cancellare le sotto directory e i relativi file)
  205. void leggodir( char *dire)
  206. {
  207.         chdir(dire);
  208.         DIR *apro2;
  209.         struct dirent *leggo1;
  210.         apro2=opendir(".");
  211.         while((leggo1=readdir(apro2)))
  212.         {
  213.                 if(!strcmp(leggo1->d_name, ".") || !strcmp(leggo1->d_name, "..")) continue;
  214.                 if(remove(leggo1->d_name))
  215.                 {
  216.                         leggodir(leggo1->d_name);
  217.                 }
  218.                 else
  219.                 {
  220.                         printf("Il file %s presente nella directory %s e' stato cancellato\n",leggo1->d_name,dire);
  221.                 }
  222.         }
  223.         // Mi sposto una directory indietro
  224.         chdir("../");
  225.         //Chiudo la directory precedentemente aperta
  226.         closedir(apro2);
  227.         //Cancella la directory (Solo se vuota)
  228.         rmdir(dire);          
  229. }
  230. //Fine leggodir()
  231. //Funzione canc_dir() (permette di verificare se ci sono cartelle o file  di richiamare la funzione ricorsiva)    
  232. void canc_dir()
  233. {
  234.         DIR *apro;
  235.         struct dirent *leggo0;
  236.         int dir=0;
  237.         char dove[FILENAME_MAX];
  238.         getcwd(dove,sizeof(dove));
  239.         printf("Cancellazione in corso...\n");
  240.  
  241.         chdir("../");
  242.         if(rmdir(dove)==-1)
  243.         {
  244.                 chdir(dove);
  245.                 apro=opendir(dove);
  246.                 while((leggo0=readdir(apro)))
  247.                 {
  248.                         if(!strcmp(leggo0->d_name, ".") || !strcmp(leggo0->d_name, "..")) continue;
  249.                         if(remove(leggo0->d_name))
  250.                         {
  251.                                 leggodir(leggo0->d_name);
  252.                         }  
  253.                         else
  254.                         {    
  255.                                 printf("Il file %s presente nella directory %s e' stato cancellato\n",leggo0->d_name,dove);
  256.                         }
  257.                 }
  258.         }      
  259.         else{
  260.                 printf("Cancellazione completata\n");
  261.         }
  262.         chdir("../");
  263.         if(!rmdir(dove))
  264.         {
  265.                 printf("La Cartella %s e' stata cancellata!\n",dove);
  266.         }
  267.         else
  268.         {
  269.                 printf("Impossibile cancellare %s !!\n",dove);
  270.         }
  271.         closedir(apro);
  272. }
  273. //Fine canc_dir()
  274.  
  275. //By Red Skull 92
  276.  

Dir Maker By Red Skull 92