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");
}
}
Salve ragazzi urge il vostro aiuto..
Rispondi quotando
