Programma Tansfer File via UDP (TFTP)

[LeleFT]

Premetto che non ho mai lavorato con le DatagramSocket, ma il problema è di fondo. Il server non ha alcun accesso al file originario (che risiede sulla macchina client: è il client che glielo deve inviare, quindi il server non lo conosce, non conosce nulla di questo file e, chiaramente, non vi può "accedere" perchè, di fatto, sul server quel file non esiste).

Questa problematica (che c'è anche con le classiche Socket TCP), si risolve pensando ad un "protocollo" di comunicazione. Un esempio banale: ciascun pacchetto sarà composto da una stringa che indica il tipo di pacchetto, da un intero che indica il "contatore progressivo" di pacchetti di quel tipo e un'array di byte.

1) Il client, per prima cosa, invia al server una richiesta di "inizio trasferimento". Sarà un pacchetto contenente, ad esempio, "START_FILE" nella prima stringa, 0 nel valore intero (tanto non ce ne saranno altre), e, magari, il nome del file come array di byte.

2) Poi, il client inizia ad inviare una serie di pacchetti, ciascuno contenente "DATA_FILE" nella stringa (che indica che si tratta di un pacchetto dei dati del file), un valore progressivo come nel valore intero e il blocco di N byte letti dal file (ad esempio, un blocco di 1024 byte). Il client, in questa fase, sta leggendo il file a blocchi di 1024 byte e continuerà ad inviare pacchetti di questo tipo finchè non avrà letto tutto il file. Dopo ciascuna lettura, dovrà incrementare il valore intero da passare. Quindi, al server verrà inviata una sequenza di pacchetti come questa:

"DATA_FILE", 0, { ... }   // Primo pacchetto dati inviato
"DATA_FILE", 1, { ... }   // Secondo pacchetto dati inviato
"DATA_FILE", 2, { ... }   // Terzo pacchetto dati inviato
...

(tra le graffe ci saranno i byte di dati)


3) Raggiunta la fine del file ed inviato l'ultimo pacchetto dati, il client invierà al server un pacchetto con, ad esempio, "END_FILE" nella prima stringa, il numero di pacchetti inviati nel valore intero e un array di byte vuoto. In questo modo il server può sapere esattamente quanti pacchetti deve aspettarsi e può, eventualmente, controllare di averli ricevuti tutti.


Supponiamo, quindi, di voler trasferire il file "pippo.txt", di 5 KB. Il client invierà questa sequenza di pacchetti:

"START_FILE", 0, {'p','i','p','p','o','.','t','x','t'}
"DATA_FILE", 0, { ... }   // 1° pacchetto dati inviato
"DATA_FILE", 1, { ... }   // 2° pacchetto dati inviato
"DATA_FILE", 2, { ... }   // 3° pacchetto dati inviato
"DATA_FILE", 3, { ... }   // 4° pacchetto dati inviato
"DATA_FILE", 4, { ... }   // 5° pacchetto dati inviato
"END_FILE", 5, {}

Il server, di conseguenza, dovrà "regolarsi": il protocollo UDP non garantisce né che un pacchetto arrivi a destinazione, né che i pacchetti inviati siano ricevuti nell'ordine... quindi è il server che deve sobbarcarsi tutto il lavoro: deve ricevere i pacchetti, capire di che tipo di pacchetto si tratta (potrebbe ricevere, per primo, il pacchetto numero 3 dei dati, ad esempio), e trattarlo di conseguenza.

Ora, io non so perchè tu debba per forza usare UDP al posto del più pratico TCP... ma se usi UDP devi sottostare alle sue regole... quindi, sei tu che devi farti carico di ricevere i pacchetti, riordinarli e, alla fine, scrivere il file.

Se usassi TCP sarebbe tutta un'altra musica... rimane il fatto che il server, anche in questo caso, non ha a disposizione un FileInputStream, ma è agevolato dal fatto che i pacchetti sono sicuramente ricevuti in ordine e "garantiti"... quindi è tutto più semplice.


Ciao.

[sanchez88]

Eh lo so che con il TCP era più facile. Talmente facile che lo avevo anche già fatto.
Solamente che il programma che sto facendo è per un progetto universitario di reti e il prof mi ha specificato
di usare il protocollo UDP.

Comunque LeleFT grazie di tutto per il tempo e l'aiuto che mi hai dato

[schumy2000]

Sembra strano che il prof. ti abbia specificato di usare UDP nell'invio di un file.
Solitamente l'UDP sia usa nello streaming audio o video, anche se arriva un frame prima o dopo non costitutisce un problema grave, ma in un file invece l'ordine dei pacchetti è fondamentale.

[sanchez88]

Si lui mi ha commissionato la base di un TFTP per l'invio di piccoli dati tra host all'interno della rete. Poi ovviamente vado per gradi e questa è la base. Spero di aver compreso bene il progetto altrimenti non sono messo tanto bene. comunque le pretese non sono alte ma qui mi sta dando questo tipo di problemi descritti sopra. Sperei che seppur banale il programma possa soddisfare le richieste. =(

[sanchez88]

Ciao. Allora per il problema delle gestione del While nel ricevitore sto provando a passare come dati la dimensione del file selezionato in modo di mettere un limite di dati inviati nel momento in cui diventano maggiori della deimensione del file stesso. il problema è che sto provando in tutti i modi ma non riesco a passargli quel valore. Ho anche provato a convertire il numero di bytes in una stringa per poi ricodificarlo in interno subito dopo ricevuta ma niente, per qualche motivo la stringa viene sempre dimensione+estensione (ES. 11098pdf) e non capisco il perchè. Prima dell'invio quando faccio la stampa della dimensione mi da una stringa normale di soli numeri. BOH!!!!

private void invia_Dimensione (String  dimensione_stringa) throws IOException {
        
        byte [] dimension = {0};
        dataSocket = new DatagramSocket();
        dataPacket = new DatagramPacket (dimension, dimension.length, indirizzoServer, porta);
        String dimensione_file = dimensione_stringa;
        System.out.println("La dimensione del file è: " +dimensione_file);        
        dimension  = dimensione_file.getBytes();
        dataPacket.setData(dimension);
        dataPacket.setLength(dimension.length);
        
        // INVIO DEL PACCEHTTO SUL SOCKET
        dataSocket.send(dataPacket);
    }// FINE INVIA DIMENSIONE

private int acquisisci_dimensione(int dimensione) throws IOException {
        
            dataSocket.receive(dataPacket);
            
            //Acquisisco le informazioni del client che si collega
            InetAddress address = dataPacket.getAddress();           
            String client = address.getHostName();          
            int port = dataPacket.getPort();

            
             
            String dimension_string = (new String(dataPacket.getData()).trim());
            int dimension = Integer.valueOf(dimension_string);
            System.out.println("La dimensione è " +dimension+ " bytes");
            return dimension;
    }

[sanchez88]

Risolto il passaggio della dimensione in questo modo.

private void invia_Dimensione (String  dimensione_stringa) throws IOException {
        
        byte [] dimension = {0};
        String dimensione_file = dimensione_stringa;
        dataSocket = new DatagramSocket();
        dataPacket = new DatagramPacket (dimensione_file.getBytes(), dimensione_file.length(), indirizzoServer, porta);
       
        System.out.println("La dimensione del file è: " +dimensione_file);        
        
        // INVIO DEL PACCEHTTO SUL SOCKET
        dataSocket.send(dataPacket);
        dataSocket.close();
    }// FINE INVIA DIMENSIONE

private int acquisisci_dimensione(int dimensione) throws IOException {
             
            byte[] buf = new byte[1024];  
            DatagramPacket dataPacket = new DatagramPacket(buf, 1024);  
            dataSocket.receive(dataPacket);
            
            String str = new String(dataPacket.getData(), 0, dataPacket.getLength());  
            System.out.println("Dimensione stringa" +str);  
            int dim = Integer.parseInt(str);
            System.out.println("Dimensione intero " +dim);
            return dim;
    }

Raga io scrivo tutto cosi magari se un giorno uno ha il mio stesso problema può trovare qualcosa qui.