SERVER
codice:
package progettois;

// PutFileServer Sequenziale

import java.io.*;
import java.net.*;

public class PutFileServerSeq {
  // porta al di fuori del range 1-1024!
  // dichiarata come statica perch� 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;

    /* 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: ");
      e.printStackTrace();
      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());
      e.printStackTrace();
      System.exit(2);
    }
    try {
      while (true) {
        Socket clientSocket = null;
        DataInputStream inSock = null;
        DataOutputStream outSock = null;

        System.out.println("\nIn attesa di richieste...");
        try {
          // bloccante finch� non avviene una connessione
         clientSocket = serverSocket.accept();
          // visto che il server � 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());
          e.printStackTrace();
          // 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: ");
          e.printStackTrace();
          // 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: ");
          ste.printStackTrace();
          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: ");
          e.printStackTrace();
          // 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(nomeFile);
          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: ");
              e.printStackTrace();
              // servo nuove richieste
              continue;
            }
          } 
          else esito = "Creato nuovo file";
          outFile = new FileOutputStream(nomeFile);
        }
        //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: ");
          ste.printStackTrace();
          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());
          e.printStackTrace();
          clientSocket.close();
          System.out.println("Terminata connessione con " + clientSocket);
          continue;
          // il server continua a fornire il servizio ricominciando
          // dall'inizio del ciclo esterno
        }
      } // while (true)
    }
    // qui catturo le eccezioni non catturate all'interno del while
    // in seguito alle quali il server termina l'esecuzione
    catch (Exception e) {
      e.printStackTrace();
      // chiusura di stream e socket
      System.out.println("Errore irreversibile, PutFileServerSeq: termino...");
      System.exit(3);
    }
  } // main

} // PutFileServerSeq
PROXY
codice:
package progettois;

import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.Logger;



public class Proxy {

public static final int listenPort = 465, // port to listen on
        remotePort = 465;   // port to connect to
public static final String remoteH = "";// my mail server hostname here

public static void main(String[] args) {
    ExecutorService tm = Executors.newCachedThreadPool();
    try {
        ServerSocket ss = new ServerSocket(listenPort);
        while (true) {
            try {
                Socket client = ss.accept();
                tm.submit(new ProxyWorkerImpl(client));
            } catch (Exception e) {
                System.out.println("error " + e);
            }
        }
    } catch (Exception e) {
        System.out.println("error " + e);
    }
}

    private static class ProxyWorkerImpl extends ProxyWorker {

        public ProxyWorkerImpl(Socket c) {
            super(c);
        }

        @Override
        public void run() {
            throw new UnsupportedOperationException("Not supported yet.");
        }
    }
}

abstract class ProxyWorker implements Runnable {

Socket client, server;
OutputStream serverOut = null, clientOut = null;
InputStream serverIn = null, clientIn = null;


ProxyWorker(Socket c) {
        try {
            client = c;
            server = new Socket(Proxy.remoteH, Proxy.remotePort);
            serverOut = server.getOutputStream();
            serverIn = server.getInputStream();


            clientOut = client.getOutputStream();
            clientIn = client.getInputStream();
        } catch (UnknownHostException ex) {
            Logger.getLogger(ProxyWorker.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(ProxyWorker.class.getName()).log(Level.SEVERE, null, ex);
        }
catch (Exception e) {
System.out.println("error\n" + e.toString());
System.exit(0);

}


}


    @Override
public void run() {
    System.out.println("listening runner activated");
    try {
       //the assigned value is never used?
        byte[] b;
        BufferedOutputStream bos = new BufferedOutputStream(System.out);
        while (true) {
            int clientReady = clientIn.available();
            while (clientReady > 0) {
                b = new byte[clientReady];
                clientIn.read(b, 0, clientReady);
                serverOut.write(b);
                bos.write(b);
                bos.flush();
                clientReady = clientIn.available();
            }
            Thread.sleep(100);
            int serverReady = serverIn.available();
            while (serverReady > 0) {
                b = new byte[serverReady];
                serverIn.read(b, 0, serverReady);
                clientOut.write(b);
                bos.write(b);
                bos.flush();
                serverReady = serverIn.available();
            }
            if(server.isClosed()||client.isClosed()){
                break;
            }
        }
    } catch (NullPointerException e) {
        System.err.println("NPE:\n"+e.getMessage());
        System.err.println(e.toString());
    } catch (Exception e) {
        System.out.println(e);
    } finally {
        try {
            server.close();
            client.close();
        } catch (IOException ex) {
            System.out.println("could not close sockets");
        }
    }
    System.out.println("Thread Exiting Now");
}
}