package proxyrtsp;

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

public class ProxyRTSP implements Runnable{

public static final int CLIENT=0; // Queste due costanti servono per distinguere
//il thread di connessione server da client
public static final int SERVER=1; //perchè la classe ThreadDiConnessione è unica!

public static final int OPEN=0;

public static final int CLOSE=1;

public static final int STOP=2;

private Thread portaInAttesa=null;

private ServerSocket scktPortaInAttesa;

private int portaProxy=1080;

private String indirizzoServer="127.0.0.1";

private int portaServer=80;

private boolean logFlag=false;

// private String lingua="it";



public static void main(String[] ingressi){

ProxyRTSP amedeo = new ProxyRTSP(ingressi);

}

private ProxyRTSP(String[] ingressi){

try{
if ( ingressi.length > 0) {

portaProxy = Integer.parseInt(ingressi[0]);

if ( ingressi.length > 1) {

indirizzoServer = ingressi[1];

if ( ingressi.length > 2) {

portaServer = Integer.parseInt(ingressi[2]);

if ( ingressi.length > 3)

logFlag = (Integer.parseInt(ingressi[3])!=0);

//if ( (ingressi.length > 4)&&(ingressi[4]=="en"))

// lingua = ingressi[4];


}

}

}

scktPortaInAttesa = new ServerSocket(portaProxy); //attivo il socket in ascolto del proxy

}catch(Exception e){

e.printStackTrace();

return;

}

portaInAttesa = new Thread(this); //sto creando l'oggetto portaInAttesa di tipo Tread

portaInAttesa.start();

System.out.println("ProxyRTSP activated on port " + portaProxy + " for " + indirizzoServer + ":" + portaServer);

System.out.println("Programm relased by Amedeo Michelin-Salomon");

System.out.println("Progetto nella materia di Sistemi di Elaborazione(Ing. Elettronica) ");

System.out.println("Prof. Antonio Puliafito");

System.out.println("Messina(Papardo), Settembre 2002");

}

public void run(){

while(Thread.currentThread()==portaInAttesa){

try{

Socket s=scktPortaInAttesa.accept(); //Appena un client si collega alla porta creo un nuovo socket

TwinsThread sessioneRTSP=new TwinsThread (s); //che poi verrà passato a TwinsThread che provvederà alla comunicazione interna

}catch(Exception e){

e.printStackTrace();

return;

}

}

}

class TwinsThread {

Socket clientC,
serverS;

/* InputStreamReader clientIs,
serverIs; */

/*OutputStreamWriter clientOs,
serverOs;*/

RetFlag cont=new RetFlag(OPEN); // ?

ThreadDiConnessione client,
server;

boolean active=true;

TwinsThread(Socket s) throws Exception{

clientC = s;

s.setSoTimeout(0);

/* InputStream iC = clientC.getInputStream ();

OutputStream oC = clientC.getOutputStream ();

PrintStream pC = new PrintStream (oC); */


InputStream is0=clientC.getInputStream();

InputStreamReader ir0 = new InputStreamReader(is0);

BufferedReader inr0 = new BufferedReader(ir0);

OutputStream os0=clientC.getOutputStream();

OutputStreamWriter or0 = new OutputStreamWriter(os0);

BufferedWriter outr0 = new BufferedWriter(or0);


/* DataInputStream clientIs = new DataInputStream(s.getInputStream()); //converte il flusso entrante di byte nel client

PrintWriter clientOs = new PrintWriter(s.getOutputStream()); */

System.out.println("Connection with client accepted!");

serverS = new Socket(indirizzoServer, portaServer);

serverS.setSoTimeout(0);

/* InputStream iS = serverS.getInputStream ();

OutputStream oS = serverS.getOutputStream ();

PrintStream pS = new PrintStream (oS); */

InputStream is1=serverS.getInputStream();

InputStreamReader ir1 = new InputStreamReader(is1);

BufferedReader inr1 = new BufferedReader(ir1);

OutputStream os1=serverS.getOutputStream();

OutputStreamWriter or1 = new OutputStreamWriter(os1);

BufferedWriter outr1 = new BufferedWriter(or1);


/* DataInputStream serverIs = new DataInputStream(serverS.getInputStream()); //forse si deve utilizzare il BufferedReader

PrintWriter serverOs = new PrintWriter(serverS.getOutputStream()); */

System.out.println("Connection accepted by server!");

client=new ThreadDiConnessione(SERVER, inr0, outr1 ); // Il ThreadDiConnessione ha il compito alla connessione

server=new ThreadDiConnessione(CLIENT, inr1, outr0);

}


class ThreadDiConnessione extends Thread{

int tipo;

BufferedReader is;

BufferedWriter os;

ThreadDiConnessione(int tipo, BufferedReader is, BufferedWriter os) throws Exception{

ByteArrayOutputStream command = new ByteArrayOutputStream();

this.tipo=tipo;

this.is=is;

this.os=os;

setDaemon(true);

start();

}

public void run(){

try {while(active){

String line = is.readLine();

line = line + "\n\r";

if(tipo==SERVER) System.out.println("C>" + line);

else System.out.println("S>" + line);

os.write(line, 0 , line.length());

os.flush();

}

}

catch(Exception e){

e.printStackTrace();

return;

};

}

}

}


class RetFlag{

int command;

public RetFlag(int init){command=init;}

public void setValue(int cmd){command=cmd;}

public int getValue(){return command;}

}

}