Visualizzazione dei risultati da 1 a 3 su 3
  1. #1

    ERRORE - DatagramSocket transfer file in pacchetti via UDP

    Salve a tutti.
    Da un po' oramai sto cercando di sviluppare un programma per il trasferimento di un file via protocollo UDP utilizzando i datagrampacket e le datagramsocket.
    Il programma deve funzionare con due classi Server e Client in cui la prima si mette in attesa e la seconda ti fa selezionare il file da inviare al server per poi iniziare l'invio.
    Il server salverà il file ricevuto nella specifica cartella selezionata.
    Il Client invia correttamente i pacchetti del file ma nel momento della ricezione il server si blocca sempre dopo aver ricevuto i primi 4/5 pacchetti (eattamente a 8192 byte)
    Mi sapete dire dov'è il problema? =(
    E' un po oramai che ci sbatto la testa.
    Di seguito vi metto l'output delle due classi e il codice. Ringrazio chiunque abbia un po' di tempo da perderci per potermi dare una dritta.

    OUTPUT CLIENT:

    PROGRAMMA DI TRASFERIMENTO IN PACCHETTI
    il nome da inviare è: Doc1.pdf
    La sua dimensione : 11408 byte
    Percorso: C:\Users\ste\Documents\Doc1.pdf
    Il nome del file è: Doc1.pdf
    La dimensione del file è: 11408
    *** Inizio invio file
    - 1024 byte
    - 2048 byte
    - 3072 byte
    - 4096 byte
    - 5120 byte
    - 6144 byte
    - 7168 byte
    - 8192 byte
    - 9216 byte
    - 10240 byte
    - 11264 byte
    - 11408 byte
    *** FILE INVIATO CON SUCCESSO ***
    BUILD SUCCESSFUL (total time: 3 seconds)

    OUTPUT SERVER:
    PROGRAMMA DI TRASFERIMENTO IN PACCHETTIAVVIO NUOVA CONNESSIONE
    La cartella di destinazione è C:\prova\
    Server in attesa sulla porta: 9876
    Attendo un Client ...
    Il nome del file é: Doc1.pdf

    La dimensione del file é: 11408
    Il suo percorso sarà : C:\prova\Doc1.pdf
    Inizio processo di ricezione

    1 - creato file in:C:\prova\Doc1.pdf QUI FUNZIONA

    2 - fino creazione datapacket funzia:C:\prova\Doc1.pdf

    Parte il ciclo While e la ricezione della socket
    Acquisisco il valore
    3 - DataSocket receive: FUNIONA :C:\prova\Doc1.pdf
    - 1024 byte
    4 - Qui funziona.
    Acuisisco Outputstream

    Parte il ciclo While e la ricezione della socket

    Acquisisco il valore

    3 - DataSocket receive: FUNIONA :C:\prova\Doc1.pdf
    - 2048 byte
    4 - Qui funziona.
    Acuisisco Outputstream

    Parte il ciclo While e la ricezione della socket
    Acquisisco il valore
    3 - DataSocket receive: FUNIONA :C:\prova\Doc1.pdf - 3072 byte
    4 - Qui funziona.
    Acuisisco Outputstream
    Parte il ciclo While e la ricezione della socket
    Acquisisco il valore

    3 - DataSocket receive: FUNIONA :C:\prova\Doc1.pdf
    - 4096 byte
    4 - Qui funziona.
    Acuisisco Outputstream

    Parte il ciclo While e la ricezione della socket

    Acquisisco il valore
    3 - DataSocket receive: FUNIONA :C:\prova\Doc1.pdf - 5120 byte
    4 - Qui funziona.
    Acuisisco Outputstream
    Parte il ciclo While e la ricezione della socketAcquisisco il valore
    3 - DataSocket receive: FUNIONA :C:\prova\Doc1.pdf
    - 6144 byte
    4 - Qui funziona.
    Acuisisco Outputstream
    Parte il ciclo While e la ricezione della socket
    Acquisisco il valore
    3 - DataSocket receive: FUNIONA :C:\prova\Doc1.pdf
    - 7168 byte
    4 - Qui funziona.
    Acuisisco Outputstream
    Parte il ciclo While e la ricezione della socketAcquisisco il valore
    3 - DataSocket receive: FUNIONA :C:\prova\Doc1.pdf
    - 8192 byte
    4 - Qui funziona.
    Acuisisco Outputstream

    Parte il ciclo While e la ricezione della socket
    Acquisisco il valore

    QUI VA IN STALLO E NON SUCCEDE PIU' NIENTE.
    Ultima modifica di sanchez88; 04-08-2014 a 17:40

  2. #2
    CLASSE SERVER

    codice:
    package udp_pacchetti;
    
    import java.io.ByteArrayInputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    
    
    
    
    public class UDP_Server_pacchetti {
        
        DatagramSocket dataSocket;
        DatagramPacket dataPacket;
        
        private int porta;
        private String destinazione;
        
        /****   METODO PRINCIPALE  *****/
        public void connessioneRicezione() throws IOException {
            
            int read = 0;
            int tot = 0;
            String nome = null;
            
            int dimensione = 0;
            porta = 9876;
            
                destinazione = "C:\\prova\\";
                System.out.println("PROGRAMMA DI TRASFERIMENTO IN PACCHETTI");
                System.out.println("AVVIO NUOVA CONNESSIONE");
                System.out.println("La cartella di destinazione è " +destinazione);
                
                // Creo la connessione 
                try {
                    dataSocket = new DatagramSocket(porta);
                    System.out.println("Server in attesa sulla porta: " +porta);
                
                } catch (IOException e) {
                    e.printStackTrace();
                } 
            
                byte[] buf = new byte[1024];
                System.out.println("Attendo un Client ... ");
                dataPacket = new DatagramPacket(buf, buf.length);
            
                
                String nome_file = acquisisci_nome(nome);
                System.out.println("Il nome del file é: " +nome_file);
                int dimensione_file = acquisisci_dimensione(dimensione);
                System.out.println("La dimensione del file é: " +dimensione_file);
                
                File file = new File(destinazione+nome_file);
                
                //FileOutputStream fos = new FileOutputStream(file, true);
                
                String percorso_finale = file.getAbsolutePath();
                System.out.println("Il suo percorso sarà : " +percorso_finale);
                // QUI AVVIAMO IL METODO PER LA RICEZIONE DEL FILE
                ricevi_File(file, nome_file, dimensione_file);
                
        } // FINE CONNESSIONE
        
        
        private void ricevi_File(File file, String name, int dimension) throws IOException 
        {
            System.out.println("Inizio processo di ricezione");
            
            String nome = name;
            int dimensione = dimension;
            int read = 0;
            int tot = 0;
            
            String percorso = file.getAbsolutePath();
            byte[] buffer = new byte[dimensione];
            
            FileOutputStream outputStream = new FileOutputStream(file);
            System.out.println("1 - creato file in:" +percorso+ " QUI FUNZIONA");
            
            try{
                
                System.out.println("2 - fino creazione datapacket funzia:" +percorso);
    
                while (tot <= dimensione) { 
                    System.out.println("Parte il ciclo While e la ricezione della socket");
                    DatagramPacket datapacchetto = new DatagramPacket(buffer, buffer.length);
                    System.out.println("Acquisisco il valore");
                    try{
                        dataSocket.receive(datapacchetto);
                    } catch (java.net.SocketException e){
                        System.out.println("non fa");
                    }
                    
                    System.out.println("3 - DataSocket receive: FUNIONA :" +percorso);
                    tot += 1024;
                    System.out.println("  - "+tot+ " byte");
                    outputStream.write(datapacchetto.getData(), 0, datapacchetto.getLength());
                    System.out.println("4 - Qui funziona. Acuisisco Outputstream");
                    outputStream.flush();
                }  
            }catch (java.net.SocketException e)
            {
                    System.out.println("*** FILE RICEVUTO CON SUCCESSO ***");
                
            }
                
              
        }
        
        private String acquisisci_nome(String nome) 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 name = (new String(dataPacket.getData()).trim()); 
                return name;
        }
    
        private int acquisisci_dimensione(int dimensione) throws IOException {
                 
                byte[] buf = new byte[1024];  
                dataSocket.receive(dataPacket);
                
                String str = new String(dataPacket.getData(), 0, dataPacket.getLength());    
                int dim = Integer.parseInt(str);
                return dim;
        }
        
        
        public static void main(String[] args) throws IOException
            {
                UDP_Server_pacchetti udpServerPac = new UDP_Server_pacchetti();
                udpServerPac.connessioneRicezione();
            }
        
    }

  3. #3
    CLASSE CLIENT

    codice:
    package udp_pacchetti;
    
    
    import java.io.DataOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    import javax.swing.JFileChooser;
    
    /*
     * To change this template, choose Tools | Templates
     * and open the template in the editor.
     */
    
        
    /**
     *
     * @author ste
     */
    public class UDP_Client_pacchetti {
        
        DatagramSocket dataSocket;
        DatagramPacket dataPacket;
        
        String nome;
        int dimensione;
        String dimension;
        private InetAddress indirizzoServer;
        private int porta;
        
        public void Start() throws IOException {
                
                porta = 9876;
                indirizzoServer = InetAddress.getByName("127.0.0.1");  
                
                // QUI SELEZIONO IL FILE
                JFileChooser fileChooser = new JFileChooser();
                int n = fileChooser.showOpenDialog(null);
                File file = fileChooser.getSelectedFile(); 
                String path_file = file.getAbsolutePath();
                
                // E NE ACQUISISCO I DATI
                nome = file.getName();
                String nome_stringa = nome;
                System.out.println("PROGRAMMA DI TRASFERIMENTO IN PACCHETTI");
                System.out.println("il nome da inviare è: " +nome_stringa);
                dimensione = (int) file.length();
                dimension = String.valueOf(dimensione);
                String dimensione_stringa = dimension;
                
                //System.out.println("Il nome del fileselezionato è: " +nome);
                System.out.println("La sua dimensione :  " +dimensione_stringa+ " byte");
                System.out.println("Percorso: " +path_file);
                
                invia_Nome(nome_stringa);
                invia_Dimensione(dimensione_stringa);
                invia_File(file, nome, path_file, dimensione );
        }
        
        private void invia_File(File file, String nome, String path_file, int dimensione) throws IOException {
            System.out.println("*** Inizio invio file");
            dataSocket = new DatagramSocket();
            try {
                
                byte[] buf = new byte[1024];
                int read,tot=0;
                FileInputStream inputStream = new FileInputStream(file);
                
                   
                // INVIO I PACCHETTI 
                while ((read = inputStream.read(buf)) != -1 ){
                    tot += read;
                    System.out.println("  - "+tot+ " byte");
                    dataPacket = new DatagramPacket(buf, buf.length, indirizzoServer, 9876);
                    dataSocket.send(dataPacket);
                }
                System.out.println("*** FILE INVIATO CON SUCCESSO ***");    
            } catch (FileNotFoundException e) {
                e.printStackTrace();    
            }
            
            
        }   // FINE INVIA_FILE   
    
        private void invia_Nome(String nome) throws IOException {
            
            byte [] name = {0};
            dataSocket = new DatagramSocket();
            dataPacket = new DatagramPacket (name, name.length, indirizzoServer, porta);
            String nome_file = nome;
            System.out.println("Il nome del file è: " +nome_file);        
            name  = nome_file.getBytes();
            dataPacket.setData(name);
            dataPacket.setLength(name.length);
            
            // INVIO DEL PACCEHTTO SUL SOCKET
            dataSocket.send(dataPacket);
        }// FINE INVIA NOME
        
        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
    
        
       
        
        
    
        public static void main(String[] args) throws IOException
            {
                UDP_Client_pacchetti udpClientPac = new UDP_Client_pacchetti();
                udpClientPac.Start();
            }
    
        
    
        
    
        
    }

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2026 vBulletin Solutions, Inc. All rights reserved.