Help request on proxy for socket I/O

[Steve Wang]

I am writing a proxy server using pure Java socket (no URL-related classes is allowed). Basically the proxy reads request from browser and forward to appropriate server. Then it reads response back from server and writes to browser. This is the first step. I am having troubles in getting this step to work out .

Since read/write from/to socket is byte-oriented I/O operations. So I used InputStream-derived classes (like BufferedInputStream ...) to read from browser
readByteFromBrowser = new BufferedInputStream (clientSocket.getInputStream());
For writing operation I used OuputStream-derived class (like BufferedOutputStream...) to read response from server.
My question is:
(1) should I use InputStream/OutputStream-derived classes to deal with I/O operations?
(2) My proxy works sometims ok for pure-text, and sucks on mixed content-type.
I posted the code that I am running and hope someone could give me some hint. I would appreciate it.

 
import java.io.*;
import java.net.*;
import java.util.regex.*;
import java.util.*;
public class MyPoorProxy_OK {

public static void main (String[] args) throws IOException {
new MyPoorProxy_OK().startProxyServer();
}

public void startProxyServer()  throws IOException {
File f=new File("request.txt");
if (f.exists()) f.delete();
f=new File("response.txt");
if (f.exists()) f.delete();

ServerSocket server_socket;

server_socket = new ServerSocket (2189);
boolean b=true;
int count = 0;
ProxyThread proxy= new ProxyThread();
while(b)
{
Socket client_socket = server_socket.accept();
System.out.println("a new client_socket = " + count++);
proxy.setClientSocket(client_socket);
//Thread t = new Thread (new ProxyThread(client_socket));
Thread t = new Thread (proxy);
t.start();
}
server_socket.close();
 }
}
class ProxyThread implements Runnable {
private Socket clientSocket;
private String host;
private final int NUM_OF_BYTES_PER_READ = 64000;
private BufferedOutputStream writeByteToRemoteServer, writeByteToBrowser;
private BufferedInputStream readByteFromBrowser,readByteFromRemoteServer;

public ProxyThread(){}

public synchronized void setClientSocket(Socket clientSocket) throws IOException {
this.clientSocket = clientSocket;
readByteFromBrowser = new BufferedInputStream(this.clientSocket.getInputStream());
//set data-writing stream to client socket
writeByteToBrowser = new BufferedOutputStream (this.clientSocket.getOutputStream());
}

public synchronized void run() {

try{
Socket socketConnectToRemoteHost=null;
writeByteToRemoteServer = null;

BufferedOutputStream out = new BufferedOutputStream(new DataOutputStream (new FileOutputStream("request.txt", true)));

int availBytes = NUM_OF_BYTES_PER_READ; //  readByteFromBrowser.available();
byte[]requestArray = new byte[NUM_OF_BYTES_PER_READ];
int numOfReads = 0;
do {
int offset = 0; //numOfReads * NUM_OF_BYTES_PER_READ;
//requestArray = new byte[offset+NUM_OF_BYTES_PER_READ];

availBytes = readByteFromBrowser.read(requestArray, offset, NUM_OF_BYTES_PER_READ);

if (availBytes <=0) 
break;
if (numOfReads==0) 
{
ArrayList splitedHeader = new ArrayList();
String requestFromBrowser = translateByteArrayToString(requestArray, availBytes);
parseString(requestFromBrowser,"[/]+", splitedHeader);//parse browser's header info to get host's name 
host = (String)(splitedHeader.get(1));
splitedHeader.clear();
socketConnectToRemoteHost = new Socket(host , 80);
writeByteToRemoteServer = new BufferedOutputStream (socketConnectToRemoteHost.getOutputStream());
}
writeByteToRemoteServer.write(requestArray, offset, availBytes);
out.write(requestArray, offset, availBytes);

numOfReads++;
} while (availBytes == NUM_OF_BYTES_PER_READ);

writeByteToRemoteServer.flush();
out.flush();
out.close();

BufferedOutputStream outResponse = new BufferedOutputStream(new DataOutputStream (new FileOutputStream("response.txt", true)));

// read header info from remote server, and write back to browser 
readByteFromRemoteServer = new BufferedInputStream(socketConnectToRemoteHost.getInputStream());
byte[] responseArray = new byte[NUM_OF_BYTES_PER_READ];
int counter = 0;

do{
int offset = 0; // counter * NUM_OF_BYTES_PER_READ;
// responseArray = new byte[offset+NUM_OF_BYTES_PER_READ];
availBytes = readByteFromRemoteServer.read(responseArray, offset, NUM_OF_BYTES_PER_READ);

/*// processing response
String requestFromServer = translateByteArrayToString(responseArray, availBytes);


if (counter ==0) 
{
ArrayList lineSplit = new ArrayList();
//parseString(requestFromServer,"[[\r\n]\r\n]", lineSplit);//parse browser's header info to get host's name 
System.out.println(requestFromServer);
for (int k=0; k< lineSplit.size(); k++)
//System.out.println(">>>> line =  " + k + "   " + lineSplit.get(k));
lineSplit.clear();
}*/



System.out.println ("counter = " + counter + ",   response bytes = " +availBytes);

writeByteToBrowser.write(responseArray, offset, availBytes);
counter++;
//System.out.println (translateByteArrayToString(responseArray, availBytes));
outResponse.write(responseArray, offset, availBytes);
outResponse.flush();
} while (availBytes == NUM_OF_BYTES_PER_READ );

writeByteToBrowser.flush();

System.out.println ("..........Done..........");
 
//writeByteToBrowser.close();
readByteFromRemoteServer.close();
writeByteToRemoteServer.close();

outResponse.close();

}catch (IOException e){
}
}

public String translateByteArrayToString(byte[] requestArray, int avaiBytes) {
ByteArrayOutputStream byteToStringConverter = new ByteArrayOutputStream();
byteToStringConverter.write(requestArray, 0, avaiBytes);
return byteToStringConverter.toString();
}

    private void parseString(String s, String pattern, ArrayList splitedHeader){
  //System.out.println (".........."+ s + "____" + pattern);
Pattern p;
Matcher m;
  p = Pattern.compile(pattern);
//m = p.matcher(line);
String []tempStr = p.split(s);
for (int i = 0; i < tempStr.length; i++)
{
splitedHeader.add(tempStr[i]); 
}
}
}