[java] errore di comunicazione client-server

[antovent]

Salve ragazzi,
ho un piccolo problema di comunicazione client-server.
Mi sapreste dire dove è il problema??

Server

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketTimeoutException;

public class PutFileServerSeq {
    // porta al di fuori del range 1-1024!
    // dichiarata come statica perche' caratterizza il server

    public static final int PORT = 54321;

    /**
     * Main invocabile con 0 o 1 argomenti. Argomento possibile -> porta su cui
     * il server ascolta.
     *
     */
    public static void main(String[] args) throws IOException {
        // Porta sulla quale ascolta il server
        int port = -1;
        Gui.Inizialize();
        /*
         * controllo argomenti
         */
        try {
            if (args.length == 1) {
                port = Integer.parseInt(args[0]);
                // controllo che la porta sia nel range consentito 1024-65535
                if (port < 1024 || port > 65535) {
                    System.out.println("Usage: java LineServer [serverPort>1024]");
                    System.exit(1);
                }
            } else if (args.length == 0) {
                port = PORT;
            } else {
                System.out.println("Usage: java PutFileServerSeq or java PutFileServerSeq port");
                System.exit(1);
            }
        } //try
        catch (Exception e) {
            System.out.println("Problemi, i seguenti: ");
            System.out.println("Usage: java PutFileServerSeq or java PutFileServerSeq port");
            System.exit(1);
        }

        /*
         * preparazione socket e in/out stream
         */
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(port, 2);
            serverSocket.setReuseAddress(true);
            System.out.println("PutFileServerSeq: avviato ");
            System.out.println("Creata la server socket: " + serverSocket);
        } catch (Exception e) {
            System.err.println("Problemi nella creazione della server socket: "
                    + e.getMessage());
            System.exit(2);
        }
        try {
            while (true) {
                Socket clientSocket = null;
                DataInputStream inSock = null;
                DataOutputStream outSock = null;

                System.out.println("\nIn attesa di richieste...");
                try {
                    // bloccante finche' non avviene una connessione
                    clientSocket = serverSocket.accept();
                    // visto che il server e' sequenziale se si bloccasse indefinitamente
                    // sull'unica socket da cui fornisce il servizio, il servizio sarebbe
                    // ospeso, quindi e' meglio mettere un timeout scaduto il quale
                    // tornare
                    // in attesa di richieste
                    clientSocket.setSoTimeout(30000);
                    System.out.println("Connessione accettata: " + clientSocket + "\n");
                } catch (SocketTimeoutException te) {
                    System.err.println("Non ho ricevuto nulla dal client per 30 sec., interrompo "
                            + "la comunicazione e accetto nuove richieste.");
                    // il server continua a fornire il servizio ricominciando dall'inizio
                    continue;
                } catch (Exception e) {
                    System.err.println("Problemi nella accettazione della connessione: "
                            + e.getMessage());
                    // il server continua a fornire il servizio ricominciando dall'inizio
                    // del ciclo, se ci sono stati problemi
                    continue;
                }
                try {
                    // creazione stream di input e out da socket
                    inSock = new DataInputStream(clientSocket.getInputStream());
                    outSock = new DataOutputStream(clientSocket.getOutputStream());
                } catch (IOException e) {
                    System.out.println("Problemi nella creazione degli stream di input/output "
                            + "su socket: ");
                    // il server continua l'esecuzione riprendendo dall'inizio del ciclo
                    continue;
                }
                /*
                 * ricezione file
                 */
                String nomeFile;
                // ricezione del nome
                try {
                    nomeFile = inSock.readUTF();
                } catch (SocketTimeoutException ste) {
                    System.out.println("Timeout scattato: ");
                    clientSocket.close();
                    System.out.print("\n^D(Unix)/^Z(Win)+invio per uscire, solo invio per continuare: ");
                    // il client continua l'esecuzione riprendendo dall'inizio del ciclo
                    continue;
                } catch (Exception e) {
                    System.out.println("Problemi nella ricezione del nome del file: ");
                    // servo nuove richieste
                    continue;
                }
                FileOutputStream outFile = null;
                String esito;
                if (nomeFile == null) {
                    System.out.println("Problemi nella ricezione del nome del file: ");
                    continue;
                } else {
                    // controllo se il file esiste, se non esiste lo creo, altrimenti
                    // torno errore
                    File curFile = new File("C:\\pippo.txt");
                    if (curFile.exists()) {
                        try {
                            esito = "Sovrascritto file esistente";
                            // distruggo il file da sovrascrivere
                            curFile.delete();
                        } catch (Exception e) {
                            System.out.println("Problemi nella notifica di file esistente: ");
                            // servo nuove richieste
                            continue;
                        }
                    } else {
                        esito = "Creato nuovo file";
                    }
                    outFile = new FileOutputStream("C:\\pippo.txt");
                }
                //ciclo di ricezione dal client, salvataggio file e stamapa a video
                try {
                    System.out.println("Ricevo il file " + nomeFile + ": \n");
                    FileUtility.trasferisci_a_byte_file_binario(inSock,
                            new DataOutputStream(outFile));
                    System.out.println("\nRicezione del file " + nomeFile
                            + " terminata\n");
                    // chiusura file
                    outFile.close();
                    // chiusura socket in downstream
                    clientSocket.shutdownInput();
                    // ritorno esito positivo al client
                    outSock.writeUTF(esito + ", file salvato lato server");
                    // System.out.println("\nTerminata connessione con "+clientSocket);
                    // chiudo la socket anche in upstream
                    clientSocket.shutdownOutput();
                    System.out.println("\nTerminata connessione con " + clientSocket);
                } catch (SocketTimeoutException ste) {
                    System.out.println("Timeout scattato: ");
                    clientSocket.close();
                    System.out.print("\n^D(Unix)/^Z(Win)+invio per uscire, solo invio per continuare: ");
                    // il client continua l'esecuzione riprendendo dall'inizio del ciclo
                    continue;
                } catch (Exception e) {
                    System.err.println("\nProblemi durante la ricezione e scrittura del file: "
                            + e.getMessage());
                    clientSocket.close();
                    System.out.println("Terminata connessione con " + clientSocket);
                    continue;
                    // il server continua a fornire il servizio ricominciando
                    // dall'inizio del ciclo esterno
                }
            }
        } // qui catturo le eccezioni non catturate all'interno del while
        // in seguito alle quali il server termina l'esecuzione
        catch (Exception e) {
            // chiusura di stream e socket
            System.out.println("Errore irreversibile, PutFileServerSeq: termino...");
            System.exit(3);
        }
    }
}

[antovent]

Client

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.SocketTimeoutException;

public class PutFileClient {

    public static void main(String[] args) throws IOException {
        /*
         * Come argomenti si devono passare un nome di host valido e una porta
         *
         */
        InetAddress addr = null;
        int port = -1;

        /*
         * controllo argomenti
         */
        try {
            if (args.length == 2) {
                addr = InetAddress.getByName(args[0]);
                port = Integer.parseInt(args[1]);
            } else {
                System.out.println("Usage: java PutFileClient serverAddr serverPort");
                System.exit(1);
            }
        } //try
        catch (Exception e) {
            System.out.println("Problemi, i seguenti: ");
            System.out.println("Usage: java PutFileClient serverAddr serverPort");
            System.exit(2);
        }

        // oggetti utilizzati dal client per la comunicazione e la lettura del file
        // locale
        Socket socket = null;
        FileInputStream inFile = null;
        DataInputStream inSock = null;
        DataOutputStream outSock = null;

        /*
         * comunicazione col cliente
         */
        // creazione stream di input da tastiera
        BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
        String nomeFile = "C:\\INSTDIR\\Jigsaw\\Jigsaw\\logs\\errlog";
        File mainFile = new File(nomeFile);
        long dataMod = -1;
        try {
            while (true) {
                // se il file esiste creo la socket
                if (dataMod < 0) {
                        dataMod = mainFile.lastModified();
                    } else if (dataMod != mainFile.lastModified()) {
                        dataMod = mainFile.lastModified();
                    
                if (mainFile.exists()) {
                    // creazione socket
                    try {
                        socket = new Socket(addr, port);
                        // setto il timeout per non bloccare indefinitivamente il client
                        socket.setSoTimeout(30000);
                        System.out.println("Creata la socket: " + socket);
                    } catch (Exception e) {
                        System.out.println("Problemi nella creazione della socket: ");
                        // il client continua l'esecuzione riprendendo dall'inizio del ciclo
                    }
                    
                        // creazione stream di input/output su socket
                        try {
                            inSock = new DataInputStream(socket.getInputStream());
                            outSock = new DataOutputStream(socket.getOutputStream());
                        } catch (IOException e) {
                            System.out.println("Problemi nella creazione degli stream su socket: ");
                            // il client continua l'esecuzione riprendendo dall'inizio del ciclo
                        }
                    
                } // se la richiesta non e' corretta non proseguo
                else {
                    System.out.println("File non presente nel direttorio corrente");
                    // il client continua l'esecuzione riprendendo dall'inizio del ciclo
                }

                /*
                 * Invio file richiesto e attesa esito dal server
                 */
                // creazione stream di input da file
                try {
                    inFile = new FileInputStream(nomeFile);
                } /*
                 * abbiamo gia' verificato che esiste, a meno di inconvenienti,
                 * es. cancellazione concorrente del file da parte di un altro
                 * processo, non dovremmo mai incorrere in questa eccezione.
                 */ catch (FileNotFoundException e) {
                    System.out.println("Problemi nella creazione dello stream di input da "
                            + nomeFile + ": ");
                    // il client continua l'esecuzione riprendendo dall'inizio del ciclo
                }

                // trasmissione del nome
                try {
                    outSock.writeUTF(nomeFile);
                    System.out.println("Inviato il nome del file " + nomeFile);
                } catch (Exception e) {
                    System.out.println("Problemi nell'invio del nome di " + nomeFile
                            + ": ");
                    // il client continua l'esecuzione riprendendo dall'inizio del ciclo
                    //continue;
                }

                System.out.println("Inizio la trasmissione di " + nomeFile);

                // trasferimento file
                try {
                    //FileUtility.trasferisci_a_linee_UTF_e_stampa_a_video(new DataInputStream(inFile), outSock);
                    FileUtility.trasferisci_a_byte_file_binario(new DataInputStream(inFile), outSock);
                    // chiusura della socket e del file
                    inFile.close();
                    // chiudo la socket in upstream, cioe' invio l'EOF al server
                    socket.shutdownOutput();
                    System.out.println("Trasmissione di " + nomeFile + " terminata ");
                } catch (SocketTimeoutException ste) {
                    System.out.println("Timeout scattato: ");
                    socket.close();
                    // il client continua l'esecuzione riprendendo dall'inizio del ciclo
                    // continue;
                } catch (Exception e) {
                    System.out.println("Problemi nell'invio di " + nomeFile + ": ");
                    socket.close();
                    // il client continua l'esecuzione riprendendo dall'inizio del ciclo
                }

                // ricezione esito
                String esito;
                try {
                    esito = inSock.readUTF();
                    System.out.println("Esito trasmissione: " + esito);
                    // chiudo la socket in downstream
                    socket.shutdownInput();
                    System.out.println("Terminata la chiusura della socket: " + socket);
                } catch (SocketTimeoutException ste) {
                    System.out.println("Timeout scattato: ");
                    socket.close();
                    // il client continua l'esecuzione riprendendo dall'inizio del ciclo
                    //continue;
                } catch (Exception e) {
                    System.out.println("Problemi nella ricezione dell'esito, i seguenti: ");
                    socket.close();
                    //continue;
                    // il client continua l'esecuzione riprendendo dall'inizio del ciclo
                }

                // tutto ok, pronto per nuova richiesta
}
            }

        } // qui catturo le eccezioni non catturate all'interno del while
        // quali per esempio la caduta della connessione con il server
        // in seguito alle quali il client termina l'esecuzione
        catch (Exception e) {
            System.err.println("Errore irreversibile, il seguente: ");
            System.err.println("Chiudo!");
            System.exit(3);
        }

    }
}