Newsgroup: it.comp.java
Titolo: Confronto tra percorsi di file.

Salve a tutti,
Ho un piccolo problema con un programma java: dovrei cercare di capire
se un file o una cartella specificata è DISCENDENTE di una particolare
cartella. 
Nella mia applicazione voglio infatti consentire la lettura/scrittura
di file solo all'interno di una cartella specifica (x questioni di
sicurezza). 
Nella classe File ho trovato il metodo compareTo... da quanto ho letto
nella documentazione tale metodo effettua un confronto lessicografico
tra due percorsi di file/cartelle. 
Ma da quanto ho visto sembra semplicemente confrontare le due stringhe
corrispondenti ai percorsi.... quindi secondo voi tale metodo è
sufficiente a raggiungere il mio scopo? Se no qualcuno conosce metodi
migliori ?
Ciao e grazie dell'attenzione

 migliori ?
Potresti avere problemi soltanto se il software dovesse girare sotto i 
sistemi unix/linux dove al contrario di windows puoi creare link 
simbolici (e quindi accedere alla stessa cartella da un percorso 
completamente differente).
ciao
antonio


wrote:

Ti ringrazio, in effetti quello potrebbe essere un problema... almeno
inizialmente volevo permettere quello che hai detto tu.... pero a
quest punto preferisco accettare riferimenti a file esterni alla
cartella di lavoro del programma solo se corrispondono a particolari
file ammessi dall'applicazione... ma con i link simbolici mi creerebbe
un bel po di problemi. Esiste una soluzione? visto che creo un oggetto
File a partire dal percorso dato e da questo ottengo il percorso
assoluto non verrebbe convertito in automatico il percorso reale
completo ? (o almeno sotto macchine unix) 
Questo è il codice che si occupa di controllare il percorso: 
   private boolean controlloPercorso(String path) {
      // determina il file corrente
      File curfile = new File(path);
      // determina il percorso assoluto
      File comfile = new File(curFile.getAbsoluteFile());
      // confronta il percorso trovato con quello principale
      return (comfile).compareTo(hdlMainDirectory)>0;
   }
NB: questo è solo un esperimento.... l'idea originale era quella di
creare un SecurityManager... ma devo sapere se come metodo è
completamente affidabile o è facilmente aggirabile. 

 completo ? (o almeno sotto macchine unix) 
questo non te lo so dire, non ho mai provato queste cose...
Se lavori sotto sistemi *nix non è meglio affidarti a qualcos'altro? 
Magari attribuire la proprietà delle cartelle che ti interessano ad un 
particolare gruppo.. piuttosto che verificare la corrispondenza tra due 
semplici stringhe..
antonio

DamageInc wrote:

uso java appunto per essere indipendete dalla piattaforma.... nn mi
sembra il caso di sfruttare proprieta del sistema operativo
sottostante .... il problema cmq nn è solo nel confronto delle
stringhe.... ma a quanto pare la protezione è facilmente aggriabile
semplicementre usando un percorso come: 
"..\file_esterno" 
Pensavo che getAbsolutePath fosse convertisse il path dato in percorso
ASSOLUTO... mi sembra un po strano che nn tenga conto dei .. :-\
Cmq ti ringrazio... gia troppo che mi hai risposto :-)

 ASSOLUTO... mi sembra un po strano che nn tenga conto dei .. :-\
Bastava guardare un pelo sotto per trovare getCanonicalPath() che dovrebbe
fare al coso tuo.
Io (che non sono nessuno :) farei:
getCanonicalFile() per la directory che deve contenere i file che si possono
accedere, e lo stesso per il file da controllare. E poi risali il ramo del
file con getParentFile() e lo confronti con la dir. Cioé usi equals() di
File, evitando i confronti lessicografici che creano sempre casini (ad
esempio i sistemi Windows non conosiderano maiuscole e minuscole nei nomi
di file e dir).
Ciao
Matteo
-- 
chi sono e soprattutto chi non sono:
http://www.ilnomedeldominio.it
un piccolo programma per studenti universitari:
http://inutility.ilnomedeldominio.it/imsv/



Era la mia soluzione originaria... prima che provassi con il confronto
lessicografico. Eccetto per il CanonicalPath che sinceremente nn
capivo a cosa servisse..... finche nn l'ho provato :-)
Pensavo che il confronto lessicografico tra percorsi intendeva non il
confronto tra le STRINGHE ma il confronto tra i PERCORSI reali... cioè
considerava come alfabeto le directory stesse... ma da quanto ho visto
fa solo un confronto tra stringhe (cosa che si poteva fare senza
aggiungere un altro metodo alla classe...) 
questo è il metodo che ho scritto di conseguenza: 
   private static boolean controlloPercorso(String path) {
      File curfile;
      try {
         // elabora il percorso specificato
         curfile = new File(path);
         curfile = new File(curfile.getCanonicalPath());
         curfile = new File(curfile.getAbsolutePath());
         // controlla se il percorso è valido
         while (curfile.getParent()!=null) {
            if (curfile.getParent().equals(strHomeDirectory))
               return true;
            curfile = new File(curfile.getParent());
         }
      }
      catch (IOException e) {
      }
      return false;
   }
Ti ringrazio immensamente.... perche sinceramente pensavo che
esistessero metodi piu immediati e eleganti di questo... ma a quanto
pare è la soluzione piu immediata... se non l'unica per quanto
riguarda il case sensitive... su quello nn ci sono problemi visto che
un altra sezione di codice si preoccupa di rendere i percorsi e i nomi
dei file case insesitive, indipendentemente dal sistema operativo
utilizzato.
Di nuovo grazie :-)
Simone

 File f = new File(path).getCanonicalPath();
                                      ^^^^^
Questo era getCanonicalFile()
:)


Giusto per rimangiarmi tutto prova questo:
private static boolean controlloPercorso(String path) {
File f = new File(path).getCanonicalPath();
String path = f.getAbsolutePath().toLowerCase();
String dir = strHomeDirectory.getAbsolutePath().toLowerCase();
 //se strHomeDirectory e' gia canonical
return dir.startsWith(path);
}
ma non so quanto sia indipendente dalla piattaforma e a prova di bomba, per
questo vedo meglio quello che hai fatto tu.
