trunk contents moved to root

libsrc/jpproxy/src/com/jpexs/proxy/ByteArray.java

@@ -0,0 +1,129 @@
+package com.jpexs.proxy;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+public class ByteArray {
+    public byte[] bytes;
+    public int offset = 0;
+
+    /**
+     * Create a ByteArray with the default size.
+     */
+    public ByteArray() {
+        this(512);
+    }
+
+    /**
+     * Create a ByteArray with a specific default size.
+     */
+    public ByteArray(int size) {
+        bytes = new byte[size];
+    }
+
+    /**
+     * Create a ByteArray from a String.
+     */
+    public ByteArray(String s) {
+        this(s.length());
+        append(s);
+    }
+
+    /**
+     * Create a ByteArray from an array of bytes.
+     */
+    public ByteArray(byte[] b) {
+        this(b.length);
+        append(b);
+    }
+
+    /**
+     * Append a byte.
+     */
+    public void append(byte ch) {
+        if (offset == bytes.length) {
+            byte[] tmpbytes = bytes;
+            bytes = new byte[tmpbytes.length * 2];
+            System.arraycopy(tmpbytes, 0, bytes, 0, offset);
+        }
+        bytes[offset++] = ch;
+    }
+
+    /**
+     * Append a ByteArray.
+     */
+    public void append(ByteArray b) {
+        if (bytes.length - offset < b.length()) {
+            byte[] tmpbytes = bytes;
+            bytes = new byte[tmpbytes.length + b.length()];
+            System.arraycopy(tmpbytes, 0, bytes, 0, offset);
+        }
+        System.arraycopy(b.bytes, 0, bytes, offset, b.length());
+        offset += b.length();
+    }
+
+    /**
+     * Append an array of bytes.
+     */
+    public void append(byte[] b) {
+        if (bytes.length - offset < b.length) {
+            byte[] tmpbytes = bytes;
+            bytes = new byte[tmpbytes.length + b.length];
+            System.arraycopy(tmpbytes, 0, bytes, 0, offset);
+        }
+        System.arraycopy(b, 0, bytes, offset, b.length);
+        offset += b.length;
+    }
+
+    /**
+     * Append a String.
+     */
+    public void append(String s) {
+        append(s.getBytes());
+    }
+
+    /**
+     * Convert to String.
+     */
+    public String toString() {
+        return new String(bytes, 0, offset);
+    }
+
+    /**
+     * Return the bytes.
+     */
+    public byte[] getBytes() {
+        return bytes;
+    }
+
+    public void writeTo(OutputStream out)
+            throws IOException {
+        out.write(bytes, 0, offset);
+    }
+
+    public byte get(int i) {
+        return bytes[i];
+    }
+
+    /**
+     * Return the number of bytes.
+     */
+    public int length() {
+        return offset;
+    }
+
+    public void erase() {
+        offset = 0;
+    }
+
+    public void chop() {
+        chop(1);
+    }
+
+    public void chop(int i) {
+        offset -= i;
+        if (offset < 0) {
+            offset = 0;
+        }
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/CatchedListener.java

@@ -0,0 +1,19 @@
+package com.jpexs.proxy;
+
+import java.io.InputStream;
+
+/**
+ * Interface to catch contentTypes
+ *
+ * @author JPEXS
+ */
+public interface CatchedListener {
+    /**
+     * Method called when specified contentType is received
+     *
+     * @param contentType Content type
+     * @param url         URL of the method
+     * @param data        Data stream
+     */
+    public void catched(String contentType, String url, InputStream data);
+}

libsrc/jpproxy/src/com/jpexs/proxy/Cleanable.java

@@ -0,0 +1,6 @@
+package com.jpexs.proxy;
+
+public interface Cleanable
+{
+    public void clean();
+}

libsrc/jpproxy/src/com/jpexs/proxy/Client.java

@@ -0,0 +1,51 @@
+package com.jpexs.proxy;
+
+import java.io.*;
+import java.net.Socket;
+
+public class Client extends Connection
+{
+
+   @Override
+   public void promoteToServerSSL() {
+      super.promoteToServerSSL();
+      in = new BufferedInputStream(in);
+      out = new BufferedOutputStream(out);
+   }
+
+
+    /**
+     * Create a Client from a Socket.
+     */
+    Client(Socket s) throws IOException
+    {
+	super(s);
+	in = new BufferedInputStream(in);
+	//out = new DebugOutputStream(new BufferedOutputStream(out));
+	out = new BufferedOutputStream(out);
+    }
+
+
+    /**
+     * Read a Request.
+     *
+     * @returns a Request.
+     * @see Request
+     */
+    Request read() throws IOException
+    {
+	Request request = new Request(this);
+	request.read(getInputStream());   
+	return request;
+    }
+
+    /**
+     * Write a Reply
+     *
+     * @see Reply
+     */
+    void write(Reply reply) throws IOException
+    {
+	reply.write(getOutputStream());
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/Connection.java

@@ -0,0 +1,171 @@
+package com.jpexs.proxy;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.SocketException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLServerSocketFactory;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+
+class Connection
+{
+    Socket socket = null;
+    InputStream in = null;
+    OutputStream out = null;
+    static SSLSocketFactory sf;
+
+    static{
+       String ksName = ProxyConfig.httpsKeyStoreFile;      
+      if(ksName!=null){
+            char[] ksPass = ProxyConfig.httpsKeyStorePass.toCharArray();
+            char[] ctPass = ProxyConfig.httpsKeyPass.toCharArray();
+            try{
+               KeyStore ks = KeyStore.getInstance("JKS");
+               ks.load(new FileInputStream(ksName), ksPass);
+               KeyManagerFactory kmf =
+               KeyManagerFactory.getInstance("SunX509");
+               kmf.init(ks, ctPass);
+               SSLContext sc = SSLContext.getInstance("TLS");
+               sc.init(kmf.getKeyManagers(), null, null);
+               sf=sc.getSocketFactory();
+             }catch(Exception ex){
+
+             }
+       }
+    }
+
+    public void promoteToClientSSL(){
+       SSLSocketFactory f = (SSLSocketFactory) SSLSocketFactory.getDefault();
+      try {
+         socket = (SSLSocket) f.createSocket(socket,null,socket.getPort(),false);
+         in = socket.getInputStream();
+         out = socket.getOutputStream();
+      } catch (IOException ex) {
+
+      }
+
+    }
+
+    public void promoteToServerSSL(){
+       try{
+         socket=sf.createSocket(socket,null,socket.getPort(),false);
+         ((SSLSocket)socket).setUseClientMode(false);
+       }catch(Exception ex){
+         ex.printStackTrace();
+       }
+      try {
+         in = socket.getInputStream();
+         out = socket.getOutputStream();
+      } catch (IOException ex) {
+
+      }
+
+    }
+
+    /**
+     * Create a Connection from a Socket.
+     *
+     * @param socket a socket
+     */
+    Connection(Socket socket) throws IOException
+    {
+	this.socket = socket;
+	in = socket.getInputStream();
+	out = socket.getOutputStream();
+    }
+
+    /**
+     * Create a Connection from a hostname and port.
+     *
+     * @param host remote hostname
+     * @param port remote port
+     */
+    Connection(String host, int port) throws IOException
+    {
+	this(new Socket(InetAddress.getByName(host), port));
+    }
+
+    Connection()
+    {
+    }
+
+    /**
+     * Return the input stream.
+     */
+    InputStream getInputStream()
+    {
+	return in;
+    }
+
+    /**
+     * Return the output stream.
+     */
+    OutputStream getOutputStream()
+    {
+	return out;
+    }
+
+    void setInputStream(InputStream in)
+    {
+	this.in = in;
+    }
+    
+    void setOutputStream(OutputStream out)
+    {
+	this.out = out;
+    }
+
+    /**
+     * Close the connection.
+     */
+    void close()
+    {
+	if (socket != null)
+	{
+	    try
+	    {
+		socket.close();
+	    }
+	    catch (IOException e)
+	    {
+
+	    }
+	}
+    }
+
+    public Socket getSocket()
+    {
+	return socket;
+    }
+
+    public InetAddress getInetAddress()
+    {
+	return socket.getInetAddress();
+    }
+    
+    public int getPort()
+    {
+	return socket.getPort();
+    }
+
+    public String toString()
+    {
+	return getInetAddress().getHostAddress() + ":" + getPort();
+    }
+
+    public void setTimeout(int timeout)
+	throws SocketException
+    {
+	socket.setSoTimeout(timeout);
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/Copy.java

@@ -0,0 +1,39 @@
+package com.jpexs.proxy;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+import java.net.SocketException;
+
+class Copy implements Runnable
+{
+    InputStream in = null;
+    OutputStream out = null;
+    
+    Copy(InputStream in, OutputStream out)
+    {
+	this.in = in;
+	this.out = out;
+    }
+
+    public void run()
+    {
+	int n;
+	byte[] buffer = new byte[8192];
+
+	try
+	{
+	    while ((n = in.read(buffer, 0, buffer.length)) > 0)
+	    {
+		out.write(buffer, 0, n);
+		out.flush();
+	    }
+	    out.flush();
+	}catch(SocketException e){
+   }
+	catch (IOException e)
+	{
+	    //Ignore errors
+	}
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/Handler.java

@@ -0,0 +1,791 @@
+package com.jpexs.proxy;
+
+import java.io.*;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.zip.*;
+import java.net.Socket;
+import java.net.SocketTimeoutException;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.List;
+import java.util.Locale;
+import java.util.TimeZone;
+import javax.net.ssl.SSLHandshakeException;
+
+class Handler implements Runnable
+{
+    static final boolean DEBUG = false;
+    
+    Client client = null;
+    Socket socket = null;
+    Request request = null;
+    Reply reply = null;
+    HttpRelay http = null;
+    int currentLength = -1;
+    int contentLength = -1;
+    long idle = 0;
+    double bytesPerSecond = 0;
+
+    List<Replacement> replacements;
+    CatchedListener catchedListener;
+    List<String> catchedContentTypes;
+    ReplacedListener replacedListener;
+
+    static int curId=0;
+    int id;
+
+    /**
+     * Create a Handler.
+     */
+    Handler(Socket socket,List<Replacement> replacements, List<String> catchedContentTypes, CatchedListener catchedListener, ReplacedListener replacedListener)
+    {
+        curId++;
+        id=curId;
+        this.socket = socket;
+        this.replacements = replacements;
+        this.catchedListener = catchedListener;
+        this.catchedContentTypes = catchedContentTypes;
+        this.replacedListener = replacedListener;
+    }
+
+    /**
+     * Close all connections associated with this handler.
+     */
+    synchronized void close()
+    {
+	if (client != null)
+	{
+	    client.close();
+	    client = null;
+	}
+	if (http != null)
+	{
+	    http.close();
+	    http = null;
+	}
+    }
+
+    /**
+     * Flush all data to the client.
+     */
+    void flush()
+    {
+	if (client != null)
+	{
+	    try
+	    {
+		client.getOutputStream().flush();
+	    }
+	    catch (IOException e)
+	    {
+
+	    }
+	}
+    }
+
+    public void run()
+    {
+	boolean keepAlive = false;
+	Exception reason = null;
+
+	Thread.currentThread().setName("Handler("
+					 + socket.getInetAddress().getHostAddress()
+					 + ")");
+
+	try
+	{
+	    client = new Client(socket);
+	    client.setTimeout(ProxyConfig.readTimeout);
+	}
+	catch (IOException e)
+	{
+
+
+	    return;
+	}
+
+	try
+	{
+      boolean secure=false;
+      int securePort=443;
+      String secureServer="";
+	    do
+	    {
+		request = null;
+		reply = null;
+		idle = System.currentTimeMillis();
+
+		try
+		{
+		    request = client.read();
+          if(secure){
+             request.addSecureHostToURL(secureServer);
+          }
+		}
+      catch(SSLHandshakeException she)
+      {
+         she.printStackTrace();         
+         break;
+      }
+		catch (IOException e)
+		{
+
+		    break;
+		}
+
+      
+      if(request.getCommand().equals("CONNECT")){
+         secureServer=request.getHost();
+         securePort=request.getPort();
+         if((ProxyConfig.httpsMode==ProxyConfig.HTTPS_FILTER)||((ProxyConfig.httpsMode==ProxyConfig.HTTPS_FILTERLIST)&&(ProxyConfig.enabledHttpsServers.contains(secureServer)))){
+            secure=true;
+            reply=new Reply();
+            reply.statusLine = "HTTP/1.0 200 Connection established";
+            reply.setHeaderField("Proxy-agent", ProxyConfig.appName);
+            try {
+               client.write(reply);
+            } catch (IOException ex) {
+
+            }
+            client.promoteToServerSSL();
+            keepAlive=true;
+            continue;
+         }
+      }
+
+		idle = 0;
+
+		try
+		{
+		    keepAlive = processRequest(secure,secureServer,securePort);
+		}
+		catch (IOException ioe)
+		{
+		    reason = ioe;
+		    keepAlive = false;
+		}
+
+		if (request != null && reply != null)
+		{
+		    // XXX insert the number of bytes read into the
+		    // reply content-length for logging.
+		    if (reply != null && currentLength > 0)
+		    {
+			reply.setHeaderField("Content-length", currentLength);
+		    }
+
+		    
+		}
+	    }
+	    while (keepAlive);
+	}
+	finally
+	{
+	    
+	}
+
+	if (reason != null && reason.getMessage().indexOf("Broken pipe") == -1)
+	{
+	    if (client != null && request != null)
+	    {
+		error(client.getOutputStream(), reason, request);
+	    }
+
+	}
+	
+	close();
+    }
+
+    boolean processRequest(boolean secure,String secureHost,int securePort) throws IOException
+    {
+	boolean keepAlive = false;
+	
+	while (reply == null)
+	{
+	    //boolean secure = false;
+	    boolean uncompress = false;
+
+
+	    if (request.getCommand().equals("CONNECT"))
+	    {
+		secure = true;
+	    }
+	    else if (request.getURL().startsWith("/"))
+	    {
+		
+	    }
+	    else if (request.getURL().startsWith("https://")&&(secure))
+	    {
+
+	    }
+	    else if (! request.getURL().startsWith("http://"))
+	    {
+
+		return false;
+	    }
+
+	    /* Client wants Keep-Alive */
+	    if (ProxyConfig.proxyKeepAlive)
+	    {
+		keepAlive = (request.containsHeaderField("Proxy-Connection")
+			     && request.getHeaderField("Proxy-Connection").equals("Keep-Alive"));      
+	    }
+
+	    /* Filter the request. */
+       //deleted
+
+		/* None found.  Use http or https relay. */
+		if (secure)
+		{
+		    http = createHttpsRelay(secureHost,securePort);
+		}
+		else
+		{
+		    http = createHttpRelay();
+		}
+	    try
+	    {
+     http.sendRequest(request);
+		if (http instanceof Http)
+		{
+		    ((Http)http).setTimeout(ProxyConfig.readTimeout);
+		}
+		reply = http.recvReply(request);
+	    }
+	    catch (RetryRequestException e)
+	    {
+		http.close();
+		http = null;
+		continue; /* XXX */
+	    }
+
+	    /* Guess content-type if there aren't any headers.
+	       Probably an upgraded HTTP/0.9 reply. */
+	    if (reply.headerCount() == 0)
+	    {
+		String url = request.getURL();
+		if (url.endsWith("/")
+		    || url.endsWith(".html") || url.endsWith(".htm"))
+		{
+		    reply.setHeaderField("Content-type", "text/html");
+		}
+	    }
+
+
+
+	    /* Filter the reply. */
+	    if (false)
+	    {
+		/* uncompress gzip encoded html so it can be filtered */
+		if (!ProxyConfig.dontUncompress
+		    && "text/html".equals(reply.getHeaderField("Content-type")))
+		{
+		    String encoding = reply.getHeaderField("Content-Encoding");
+		    if (encoding != null && encoding.indexOf("gzip") != -1)
+		    {
+			reply.removeHeaderField("Content-Encoding");
+			reply.removeHeaderField("Content-length");
+			uncompress = true;
+		    }
+		}
+
+		//filter(reply);
+	    }
+
+
+       if(request.containsHeaderField("Connection")&&(request.getHeaderField("Connection").toLowerCase().equals("keep-alive"))&& reply.containsHeaderField("Connection")
+			     && reply.getHeaderField("Connection").equals("Keep-Alive")){
+         keepAlive=true;
+      }
+	    reply.removeHeaderField("Proxy-Connection");
+	    if (keepAlive && reply.containsHeaderField("Content-length"))
+	    {
+		reply.setHeaderField("Proxy-Connection", "Keep-Alive");
+	    }
+	    else
+	    {
+		keepAlive = false;
+	    }
+
+	    currentLength = -1;
+	    contentLength = -1;
+	    try
+	    {
+		contentLength = Integer.parseInt(reply.getHeaderField("Content-length"));
+	    }
+	    catch (NumberFormatException e)
+	    {
+	    }
+
+
+
+	    if (http instanceof HttpsThrough)
+	    {
+		HttpsThrough https = (HttpsThrough) http;
+		int timeout = ProxyConfig.readTimeout;
+		
+		client.write(reply);
+
+
+		try
+		{
+		    client.setTimeout(timeout);
+		    https.setTimeout(timeout);
+		
+		    Copy cp = new Copy(client.getInputStream(), https.getOutputStream());
+		    ReusableThread thread = Server.getThread();
+		    thread.setRunnable(cp);
+		    flushCopy(https.getInputStream(), client.getOutputStream(), -1, true);
+		    client.close();
+		}
+		catch (InterruptedIOException iioe)
+		{
+		    // ignore socket timeout exceptions
+		}
+	    }
+	    else if (reply.hasContent())
+	    {
+		 try
+		{
+		    processContent(uncompress);
+		}
+		catch (IOException e)
+		{
+		    if (http instanceof Http)
+		    {
+			((Http)http).reallyClose();
+		    }
+		    else
+		    {
+			http.close();
+		    }
+		    http = null;
+
+		    client.close();
+		    client = null;
+
+		    throw e;
+		    //return false; /* XXX */
+		}
+		/* Document contains no data. */
+		if (contentLength == 0)
+		{
+		    client.close();
+		}
+	    }
+	    else
+	    {
+		client.write(reply);
+	    }
+
+	    http.close();
+	}
+
+	return keepAlive;
+    }
+
+    HttpRelay createHttpsRelay(String secureHost,int securePort) throws IOException
+    {
+	HttpRelay http;
+
+   if((ProxyConfig.httpsMode==ProxyConfig.HTTPS_FILTER)||((ProxyConfig.httpsMode==ProxyConfig.HTTPS_FILTERLIST)&&(ProxyConfig.enabledHttpsServers.contains(secureHost))))
+      {
+         if(ProxyConfig.useHTTPSProxy){
+            http=Https.open(ProxyConfig.httpsProxyHost,ProxyConfig.httpsProxyPort,true);
+             Request connectReq=new Request(null);
+             connectReq.setStatusLine("CONNECT "+secureHost+":"+securePort+" HTTP/1.1");
+             connectReq.setCommand("CONNECT");
+             connectReq.setURL(secureHost+":"+securePort);
+             connectReq.setProtocol("HTTP/1.1");
+            try {
+               http.sendRequest(connectReq);
+               Reply rep=http.recvReply(connectReq);               
+            } catch (RetryRequestException ex) {
+
+            }
+            ((Https)http).promoteToClientSSL();
+         }else{
+          http=Https.open(secureHost,securePort,false);
+          ((Https)http).promoteToClientSSL();
+         }
+          /*http = new Http(request.getHost(),request.getPort(),ProxyConfig.useHTTPSProxy);
+          if(ProxyConfig.useHTTPSProxy){
+             Request connectReq=new Request(client);
+             connectReq.setCommand("CONNECT");
+             connectReq.setURL(secureHost+":"+securePort);
+             connectReq.setProtocol("HTTP/1.1");
+            try {
+               http.sendRequest(connectReq);
+               http.recvReply(connectReq);
+            } catch (RetryRequestException ex) {
+
+            }
+          }
+          ((Http)http).promoteToClientSSL();*/
+      }else{
+         if(ProxyConfig.useHTTPSProxy)
+         {
+            http = new HttpsThrough(ProxyConfig.httpsProxyHost,
+                  ProxyConfig.httpsProxyPort,
+                  true);
+         }else{
+            http = new HttpsThrough(secureHost,securePort);
+         }
+      }
+
+	    
+	
+
+	return http;
+    }
+    
+    HttpRelay createHttpRelay() throws IOException
+    {
+	HttpRelay http;
+	
+	if (ProxyConfig.useHTTPProxy)
+	{
+	    http = Http.open(ProxyConfig.httpProxyHost,
+			      ProxyConfig.httpProxyPort,
+			      true);
+	}
+	else
+	{
+	    http = Http.open(request.getHost(), request.getPort());
+	}
+
+	return http;
+    }
+
+    InputStream readChunkedTransfer(InputStream in) throws IOException
+    {
+	ByteArrayOutputStream chunks = new ByteArrayOutputStream(8192);
+	int size = 0;
+
+	contentLength = 0;
+	while ((size = reply.getChunkSize(in)) > 0)
+	{
+	    contentLength += size;
+	    copy(in, chunks, size, true);
+	    reply.readLine(in);
+	}
+	reply.getChunkedFooter(in);
+
+	reply.removeHeaderField("Transfer-Encoding");
+	reply.setHeaderField("Content-length", contentLength);
+
+	return new ByteArrayInputStream(chunks.toByteArray());
+    }
+
+private static DateFormat httpDateFormat() {
+        DateFormat httpDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US);
+        httpDateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
+        return httpDateFormat;
+    }
+
+void disableReplyCaching() {
+        reply.removeHeaderField("Cache-Control");
+        reply.removeHeaderField("Last-Modified");
+        reply.removeHeaderField("Expires");
+        reply.removeHeaderField("Date");
+        reply.removeHeaderField("ETag");
+        reply.removeHeaderField("Pragma");
+
+        reply.setHeaderField("Pragma", "no-cache");
+        reply.setHeaderField("Cache-Control", "no-cache, must-revalidate");
+        Calendar now = Calendar.getInstance();
+        reply.setHeaderField("Expires", httpDateFormat().format(now.getTime()));//"Sat, 26 Jul 1997 05:00:00 GMT");
+        reply.setHeaderField("Last-Modified", "Sat, 26 Jul 1997 05:00:00 GMT");
+    }
+
+void processContent(boolean uncompress) throws IOException
+    {
+	InputStream in;
+	boolean chunked = false;
+
+	if (reply.containsHeaderField("Transfer-Encoding")
+	    && reply.getTransferEncoding().equals("chunked"))
+	{
+	    in = readChunkedTransfer(reply.getContent());
+	    chunked = true;
+	}
+	else
+	{
+	    in = reply.getContent();
+	}
+
+	if (in == null)
+	{
+
+	    return;
+	}
+	else if (uncompress)
+	{
+	    in = new GZIPInputStream(in);
+	}
+
+	String url = request.getURL();
+        boolean replaced = false;
+        for (Replacement r : replacements) {
+            if (r.matches(url)) {
+                r.lastAccess = Calendar.getInstance();
+                ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+                try {
+                    FileInputStream fis = new FileInputStream(r.targetFile);
+                    byte[] buf = new byte[2048];
+                    int pos = 0;
+                    while ((pos = fis.read(buf)) > 0) {
+                        buffer.write(buf, 0, pos);
+                    }
+                    fis.close();
+                    buffer.close();
+                } catch (IOException ex) {
+                    
+                }
+                byte[] bytes = buffer.toByteArray();
+                contentLength = bytes.length;
+                reply.setHeaderField("Content-length", contentLength);
+                disableReplyCaching();
+                client.write(reply);
+                copy(new ByteArrayInputStream(bytes),
+                        client.getOutputStream(), contentLength, false);
+                replaced = true;
+                if (replacedListener != null) {
+                    replacedListener.replaced(r, request.getURL(), reply.getContentType());
+                }
+                break;
+            }
+        }
+
+        if (!replaced) {
+
+            String contentType = reply.getHeaderField("Content-type");
+            if (reply.getStatusCode() == 200) {
+                if (contentType != null) {
+                    for (String ct : catchedContentTypes) {
+                        String convContentType = contentType;
+                        if (convContentType.contains(";"))
+                            convContentType = convContentType.substring(0, convContentType.indexOf(";"));
+
+                        if (ct.toLowerCase().equals(convContentType.toLowerCase())) {
+                            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+                            copy(in, baos, contentLength, true);
+                            if (catchedListener != null) {
+                                catchedListener.catched(ct, request.getURL(), new ByteArrayInputStream(baos.toByteArray()));
+                            }
+                            in = new ByteArrayInputStream(baos.toByteArray());
+                            disableReplyCaching();
+                            break;
+                        }
+                    }
+                }
+            }
+            client.write(reply);
+            copy(in, client.getOutputStream(), contentLength, true);
+        }
+    }
+
+
+
+    /**
+     * Return the content length.
+     */
+    int getTotalBytes()
+    {
+	return contentLength > 0 ? contentLength : 0;
+    }
+
+    /**
+     * Return the number of bytes read so far.
+     */
+    int getCurrentBytes()
+    {
+	return currentLength > 0 ? currentLength : 0;
+    }
+
+    /**
+     * Send a error message to the client.
+     *
+     * @param out client
+     * @param e exception that occurred
+     * @param r request
+     */
+    void error(OutputStream out, Exception e, Request r)
+    {
+	StringBuffer buf = new StringBuffer();
+	buf.append("While trying to retrieve the URL: <a href=\""+r.getURL()+"\">"+r.getURL()+"</a>\r\n");
+	buf.append("<p>\r\nThe following error was encountered:\r\n<p>\r\n");
+	buf.append("<ul><li>" + e.toString() + "</ul>\r\n");
+	String s = new HttpError(400, buf.toString()).toString();
+	try
+	{
+	    out.write(s.getBytes(), 0, s.length());
+	    out.flush();
+	}
+	catch (Exception ex)
+	{
+	}
+    }
+
+    /**
+     * Copy in to out.
+     *
+     * @param in InputStream
+     * @param out OutputStream
+     * @param monitored Update the Monitor
+     */
+    void copy(InputStream in, OutputStream out, int length, boolean monitored)
+	throws IOException
+    {
+	if (length == 0)
+	{
+	    return;
+	}
+
+	int n;
+	byte[] buffer = new byte[8192];
+	long start = System.currentTimeMillis();
+	long now = 0, then = start;
+	
+	bytesPerSecond = 0;
+
+	if (monitored)
+	{
+	    currentLength = 0;
+	}
+	
+	for (;;)
+	{
+	    n = (length > 0) ? Math.min(length, buffer.length) : buffer.length;
+	    n = in.read(buffer, 0, n);
+	    if (n < 0)
+	    {
+		break;
+	    }
+	    
+	    out.write(buffer, 0, n);
+
+	    if (monitored)
+	    {
+		currentLength += n;
+
+	    }
+
+	    now = System.currentTimeMillis();
+	    bytesPerSecond = currentLength / ((now - start) / 1000.0);
+
+	    // flush after 1 second
+	    if (now - then > 1000)
+	    {
+		out.flush();
+	    }
+
+	    if (length != -1)
+	    {
+		length -= n;
+		if (length == 0)
+		{
+		    break;
+		}
+	    }
+
+	    then = now;
+	}
+
+	out.flush();
+
+    }
+
+    /**
+     * Copy in to out.
+     *
+     * @param in InputStream
+     * @param out OutputStream
+     * @param monitored Update the Monitor
+     */
+    void flushCopy(InputStream in, OutputStream out, int length, boolean monitored)
+	throws IOException
+    {
+	if (length == 0)
+	{
+	    return;
+	}
+
+	int n;
+	byte[] buffer = new byte[8192];
+	long start = System.currentTimeMillis();
+	bytesPerSecond = 0;
+	
+	if (monitored)
+	{
+	    currentLength = 0;
+	}
+	
+	for (;;)
+	{
+	    n = (length > 0) ? Math.min(length, buffer.length) : buffer.length;
+	    n = in.read(buffer, 0, n);
+	    if (n < 0)
+	    {
+		break;
+	    }
+
+	    out.write(buffer, 0, n);
+	    out.flush();
+	    if (monitored)
+	    {
+		currentLength += n;
+
+	    }
+	    bytesPerSecond = currentLength / ((System.currentTimeMillis() - start) / 1000.0);
+	    if (length != -1)
+	    {
+		length -= n;
+		if (length == 0)
+		{
+		    break;
+		}
+	    }
+	}
+	out.flush();
+
+    }
+
+
+    /**
+     * Return a string represenation of the hander's state.
+     */
+    public String toString()
+    {
+	StringBuffer str = new StringBuffer();
+	str.append("CLIENT ");
+	str.append(socket.getInetAddress().getHostAddress());
+	str.append(":");
+	str.append(socket.getPort());
+	str.append(" - ");
+	if (request == null)
+	{
+	    str.append("idle " + ((System.currentTimeMillis() - idle) / 1000.0) + " sec");
+	}
+	else
+	{
+	    if (reply != null && currentLength > 0)
+	    {
+		str.append("(");
+		str.append(currentLength);
+		if (contentLength > 0)
+		{
+		    str.append("/");
+		    str.append(contentLength);
+		}
+		str.append(" ");
+		str.append(((int)bytesPerSecond / 1024) + " kB/s");
+		str.append(") ");
+	    }
+	    str.append(request.getURL());
+	}
+	return str.toString();
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/Http.java

@@ -0,0 +1,357 @@
+package com.jpexs.proxy;
+
+import java.io.IOException;
+import java.net.Socket;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Vector;
+
+class Http extends HttpConnection
+{
+
+    /* XXX - more than 1 should work now. */
+    static final int MAX_PENDING_REQUESTS = 1;
+    
+    static Hashtable cache = new Hashtable(33);
+    private static Object httpLock = new Object();
+    
+
+    String host;
+    int port;
+    boolean proxy = false;
+    boolean persistent = false;
+    boolean closed = false;
+    long idle = 0;
+    Vector queue = new Vector();
+
+    public Http(String host, int port) throws IOException
+    {
+	this(host, port, false);
+    }
+    
+    public Http(String host, int port, boolean isProxy) throws IOException
+    {
+	super(host, port);
+	this.host = host;
+	this.port = port;
+	this.proxy = isProxy;
+    }
+
+    public Http(String host, int port, boolean isProxy,Socket sock) throws IOException
+    {
+	super(sock);
+	this.host = host;
+	this.port = port;
+	this.proxy = isProxy;
+    }
+
+    public synchronized void sendRequest(Request request)
+	throws IOException, RetryRequestException
+    {
+	queue.addElement(request);
+	
+	try
+	{
+       send(request);
+	}
+	catch (IOException e)
+	{
+	    if (persistent)
+	    {
+		persistent = false;
+		throw new RetryRequestException();
+	    }
+	    throw e;
+	}
+    }
+
+    public synchronized Reply recvReply(Request request)
+	throws IOException, RetryRequestException
+    {
+	while (queue.firstElement() != request)
+	{
+	    try
+	    {
+		wait();
+	    }
+	    catch (InterruptedException e)
+	    {
+	    }
+	}
+
+	if (closed)
+	{
+	    throw new RetryRequestException();
+	}
+
+	try
+	{
+       return recv();
+	}
+	catch (IOException e)
+	{
+	    if (persistent)
+	    {
+		persistent = false;
+		throw new RetryRequestException();
+	    }
+	    throw e;
+	}
+    }
+
+    public void reallyClose()
+    {
+	persistent = false;
+	close();
+    }
+
+    public synchronized void close()
+    {
+	if (persistent)
+	{
+	    idle = System.currentTimeMillis();
+	}
+	else
+	{
+	    cacheRemove(host, port, this);
+	    super.close();
+	    closed = true;
+	}
+
+	if (queue.size() > 0)
+	{
+	    queue.removeElementAt(0);
+	    
+	    notify();
+	}
+    }
+
+    private void send(Request request) throws IOException
+    {
+	
+	/* Prepare HTTP/1.1 request */
+   
+   request.removeHeaderField("Proxy-Connection");
+  
+
+   if(!proxy){
+      if(request.containsHeaderField("Connection")&&(request.getHeaderField("Connection").toLowerCase().equals("keep-alive"))){
+
+      }else{
+         request.setHeaderField("Connection", "open");
+      }
+      if (!request.containsHeaderField("Host"))
+      {
+          request.setHeaderField("Host", request.getHost());
+      }
+   }
+
+	if (proxy)
+	{
+         request.write(getOutputStream());
+	}
+	else
+	{
+	    String oldStatusLine = request.statusLine;
+	    StringBuffer head = new StringBuffer();
+	    head.append(request.getCommand());
+	    head.append(" ");
+       head.append(request.getPath());
+	    head.append(" ");
+	    head.append("HTTP/1.0");
+	    request.statusLine = head.toString();
+
+	    request.write(getOutputStream());
+
+	    /* flush? */
+	    
+	    request.statusLine = oldStatusLine;
+	}
+    }
+
+    private Reply recv() throws IOException
+    {
+	Reply reply = new Reply(getInputStream());
+	reply.read();
+
+	String conn = reply.getHeaderField("Connection");
+
+	
+	if (reply.containsHeaderField("Connection")
+	    && reply.getHeaderField("Connection").equals("close"))
+	{
+	    persistent = false;
+	}
+	else if (reply.getProtocol().equals("HTTP/1.1"))
+	{
+	    persistent = true;
+	}
+	else
+	{
+	    persistent = false;
+	}
+
+	/* Received HTTP/1.1 "Continue".  Read another Reply. */
+	if (reply.getStatusCode() == 100)
+	{
+	    reply = recv();
+	}
+
+	return reply;
+    }
+
+    protected boolean isBusy()
+    {
+	return queue.size() >= MAX_PENDING_REQUESTS;
+    }
+
+    protected boolean isPersistent()
+    {
+	return persistent;
+    }
+
+    private static String cacheKey(String host, int port)
+    {
+	return host.toLowerCase() + ":" + port;
+    }
+
+    private static Vector cacheLookup(String host, int port)
+    {
+	Vector v = (Vector) cache.get(cacheKey(host, port));
+	return v;
+    }
+
+    private static boolean cacheContains(Http http)
+    {
+	Vector v = (Vector) cache.get(cacheKey(http.host, http.port));
+	return v != null ? v.contains(http) : false;
+    }
+
+    private static void cacheInsert(String host, int port, Http http)
+    {
+	String key = cacheKey(host, port);
+	Vector v = (Vector) cache.get(key);
+	if (v == null)
+	{
+	    v = new Vector();
+	}
+	v.addElement(http);
+	cache.put(key, v);
+    }
+
+    private static void cacheRemove(String host, int port, Http http)
+    {
+	Vector v = (Vector) cache.get(cacheKey(host, port));
+	if (v != null)
+	{
+	    v.removeElement(http);
+	    if (v.isEmpty())
+	    {
+		cache.remove(cacheKey(host, port));
+	    }
+	}
+    }
+
+    private static void cacheClean()
+    {
+	long now = System.currentTimeMillis();
+	Enumeration e = cache.keys();
+	while (e.hasMoreElements())
+	{
+	    Vector v = (Vector) cache.get(e.nextElement());
+	    for (int i = 0; i < v.size(); i++)
+	    {
+		Http http = (Http) v.elementAt(i);
+		if (http.idle > 0 && now - http.idle > 30000) /* 30 seconds */
+		{
+		    http.persistent = false;
+		    http.close();
+		}
+	    }
+	}
+    }
+
+    static Http open(String host, int port, boolean isProxy)
+	throws IOException
+    {
+	Http http = null;
+
+	synchronized (httpLock)
+	{
+	    Vector v = cacheLookup(host, port);
+	    if (v != null)
+	    {
+		for (int i = 0; i < v.size(); i++)
+		{
+		    Http pick = (Http) v.elementAt(i);
+
+		    /* find an http connection that isn't busy */
+		    if (pick.isPersistent() && !pick.isBusy())
+		    {
+			http = pick;
+			break;
+		    }
+		}
+
+		if (http != null)
+		{
+		    http.idle = 0;		   
+		}
+	    }
+	}
+	
+	if (http == null)
+	{
+	    http = new Http(host, port, isProxy);
+	    cacheInsert(host, port, http);
+	}
+	
+	return http;
+    }
+
+    static Http open(String host, int port) throws IOException
+    {
+	return open(host, port, false);
+    }
+
+    static Enumeration enumerate()
+    {
+	Vector list = new Vector();
+	Enumeration e = cache.keys();
+	while (e.hasMoreElements())
+	{
+	    Vector v = (Vector) cache.get(e.nextElement());
+	    for (int i = 0; i < v.size(); i++)
+	    {
+		list.addElement(v.elementAt(i));
+	    }
+	}
+	return list.elements();
+    }
+
+    static synchronized void clean()
+    {
+	cacheClean();
+    }
+
+    public String toString()
+    {
+	StringBuffer buf = new StringBuffer();
+	buf.append("SERVER ");
+	buf.append(super.toString());
+	if (isPersistent())
+	{
+	    buf.append(" - ");
+	    if (queue.size() > 0)
+	    {
+		buf.append(queue.size());
+		buf.append(" pending");
+	    }
+	    else
+	    {
+		buf.append("idle " + ((System.currentTimeMillis() - idle) / 1000.0) + " sec");
+	    }
+	}
+	return buf.toString();
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/HttpConnection.java

@@ -0,0 +1,58 @@
+package com.jpexs.proxy;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+import java.net.Socket;
+
+abstract class HttpConnection extends Connection implements HttpRelay
+{
+    HttpConnection(String host, int port) throws IOException
+    {
+	super(host, port);
+    }
+
+    HttpConnection(Socket s) throws IOException
+    {
+	super(s);
+    }
+
+    public void sendRequest(Request request)
+	throws IOException, RetryRequestException
+    {
+	request.write(getOutputStream());
+    }
+    
+    public Reply recvReply(Request request)
+	throws IOException, RetryRequestException
+    {
+	Reply reply = new Reply(getInputStream());
+	reply.read();
+	return reply;
+    }
+    
+    public void setInputStream(InputStream in)
+    {
+	super.setInputStream(in);
+    }
+    
+    public void setOutputStream(OutputStream out)
+    {
+	super.setOutputStream(out);
+    }
+
+    public InputStream getInputStream()
+    {
+	return super.getInputStream();
+    }
+    
+    public OutputStream getOutputStream()
+    {
+	return super.getOutputStream();
+    }
+
+    public void close()
+    {
+	super.close();
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/HttpError.java

@@ -0,0 +1,70 @@
+package com.jpexs.proxy;
+
+class HttpError
+{
+    StringBuffer content = null;
+    Reply reply = null;
+    
+    HttpError(int code, String message)
+    {
+	String error;
+	switch (code)
+	{
+	case 400:
+	    error = "Bad Request";
+	    break;
+
+	case 403:
+	    error = "Forbidden";
+	    break;
+
+	case 404:
+	    error = "Not found";
+	    break;
+
+	case 503:
+	    error = "Service Unavailable";
+	    break;
+
+	default:
+	    error = "Error";
+	    break;
+	}
+
+	reply = new Reply();
+	reply.statusLine = "HTTP/1.0 " + code + " " + error;
+	reply.setHeaderField("Content-type", "text/html");
+	reply.setHeaderField("Server", ProxyConfig.appName+"/" +ProxyConfig.appVersion);
+
+	content = new StringBuffer();
+	content.append(message);
+    }
+
+    Reply getReply()
+    {
+	return reply;
+    }
+
+    String getContent()
+    {
+	if (content == null)
+	{
+	    return null;
+	}
+	return content.toString();
+    }
+
+    public String toString()
+    {
+	StringBuffer buf = new StringBuffer();
+	if (reply != null)
+	{
+	    buf.append(reply.toString());
+	}
+	if (content != null)
+	{
+	    buf.append(content.toString());
+	}
+	return buf.toString();
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/HttpRelay.java

@@ -0,0 +1,12 @@
+package com.jpexs.proxy;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+public interface HttpRelay
+{
+    void sendRequest(Request request) throws IOException, RetryRequestException;
+    Reply recvReply(Request request) throws IOException, RetryRequestException;
+    void close();
+}

libsrc/jpproxy/src/com/jpexs/proxy/Https.java

@@ -0,0 +1,152 @@
+package com.jpexs.proxy;
+
+import java.io.IOException;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Vector;
+
+/**
+ *
+ * @author JPEXS
+ */
+public class Https extends Http {
+   /* XXX - more than 1 should work now. */
+    static final int MAX_PENDING_REQUESTS = 1;
+
+    static Hashtable cache = new Hashtable(33);
+    private static Object httpLock = new Object();
+
+   public Https(String host, int port) throws IOException
+    {
+	this(host, port, false);
+    }
+
+    public Https(String host, int port, boolean isProxy) throws IOException
+    {
+         super(host, port,isProxy);         
+    }
+
+    private static String cacheKey(String host, int port)
+    {
+	return host.toLowerCase() + ":" + port;
+    }
+
+    private static Vector cacheLookup(String host, int port)
+    {
+	Vector v = (Vector) cache.get(cacheKey(host, port));
+	return v;
+    }
+
+    private static boolean cacheContains(Https http)
+    {
+	Vector v = (Vector) cache.get(cacheKey(http.host, http.port));
+	return v != null ? v.contains(http) : false;
+    }
+
+    private static void cacheInsert(String host, int port, Https http)
+    {
+	String key = cacheKey(host, port);
+	Vector v = (Vector) cache.get(key);
+	if (v == null)
+	{
+	    v = new Vector();
+	}
+	v.addElement(http);
+	cache.put(key, v);
+    }
+
+    private static void cacheRemove(String host, int port, Https http)
+    {
+	Vector v = (Vector) cache.get(cacheKey(host, port));
+	if (v != null)
+	{
+	    v.removeElement(http);
+	    if (v.isEmpty())
+	    {
+		cache.remove(cacheKey(host, port));
+	    }
+	}
+    }
+
+    private static void cacheClean()
+    {
+	long now = System.currentTimeMillis();
+	Enumeration e = cache.keys();
+	while (e.hasMoreElements())
+	{
+	    Vector v = (Vector) cache.get(e.nextElement());
+	    for (int i = 0; i < v.size(); i++)
+	    {
+		Https http = (Https) v.elementAt(i);
+		if (http.idle > 0 && now - http.idle > 30000) /* 30 seconds */
+		{
+		    http.persistent = false;
+		    http.close();
+		}
+	    }
+	}
+    }
+
+    static Https open(String host, int port, boolean isProxy)
+	throws IOException
+    {
+	Https http = null;
+
+	synchronized (httpLock)
+	{
+	    Vector v = cacheLookup(host, port);
+	    if (v != null)
+	    {
+		for (int i = 0; i < v.size(); i++)
+		{
+		    Https pick = (Https) v.elementAt(i);
+
+		    /* find an http connection that isn't busy */
+		    if (pick.isPersistent() && !pick.isBusy())
+		    {
+			http = pick;
+			break;
+		    }
+		}
+
+		if (http != null)
+		{
+		    http.idle = 0;		    
+		}
+	    }
+	}
+
+	if (http == null)
+	{
+	    http = new Https(host, port, isProxy);
+	    cacheInsert(host, port, http);
+	}
+
+	return http;
+    }
+
+    static Https open(String host, int port) throws IOException
+    {
+	return open(host, port, false);
+    }
+
+    static Enumeration enumerate()
+    {
+	Vector list = new Vector();
+	Enumeration e = cache.keys();
+	while (e.hasMoreElements())
+	{
+	    Vector v = (Vector) cache.get(e.nextElement());
+	    for (int i = 0; i < v.size(); i++)
+	    {
+		list.addElement(v.elementAt(i));
+	    }
+	}
+	return list.elements();
+    }
+
+    static synchronized void clean()
+    {
+	cacheClean();
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/HttpsThrough.java

@@ -0,0 +1,39 @@
+package com.jpexs.proxy;
+
+import java.io.IOException;
+
+class HttpsThrough extends HttpConnection {
+
+   boolean proxy = false;
+
+   HttpsThrough(String host, int port) throws IOException {
+      super(host, port);
+   }
+
+   HttpsThrough(String host, int port, boolean isProxy) throws IOException {
+      this(host, port);
+      proxy = isProxy;
+   }
+
+   public void sendRequest(Request request)
+           throws IOException, RetryRequestException {
+      if (proxy) {
+         super.sendRequest(request);
+      } else {
+         /* nothing */
+      }
+   }
+
+   public Reply recvReply(Request request)
+           throws java.io.IOException, RetryRequestException {
+      Reply reply = new Reply(getInputStream());
+      if (proxy) {
+         reply.read();
+      } else {
+         reply.statusLine = "HTTP/1.0 200 Connection established";
+         reply.setHeaderField("Proxy-agent", ProxyConfig.appName);
+      }
+
+      return reply;
+   }
+}

libsrc/jpproxy/src/com/jpexs/proxy/Janitor.java

@@ -0,0 +1,41 @@
+package com.jpexs.proxy;
+
+import java.util.Enumeration;
+import java.util.Vector;
+
+class Janitor implements Runnable
+{
+    private Vector cleanable = new Vector();
+    
+    public void add(Cleanable c)
+    {
+	cleanable.addElement(c);
+    }
+    
+    public void run()
+    {
+	Thread.currentThread().setName("Janitor");
+	
+	for (;;)
+	{
+	    try
+	    {
+		Thread.sleep(30 * 1000); /* 30 seconds */
+	    }
+	    catch (Exception e)
+	    {
+		
+	    }
+
+	    for (Enumeration e = cleanable.elements();
+		 e.hasMoreElements(); )
+	    {
+		((Cleanable)e.nextElement()).clean();
+	    }
+
+	    Http.clean();
+
+	  
+	}
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/Key.java

@@ -0,0 +1,34 @@
+package com.jpexs.proxy;
+
+class Key {
+    private String name = null;
+
+    /**
+     * Create a Key.
+     */
+    Key(String name) {
+        this.name = name;
+    }
+
+    /**
+     * Return a lowercase hashCode.
+     */
+    public int hashCode() {
+        String s = name.toLowerCase();
+        return s.hashCode();
+    }
+
+    /**
+     * Return a lowercase equals.
+     */
+    public boolean equals(Object obj) {
+        return name.equalsIgnoreCase(obj.toString());
+    }
+
+    /**
+     * Return the key.
+     */
+    public String toString() {
+        return name;
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/Main.java

@@ -0,0 +1,64 @@
+package com.jpexs.proxy;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Main
+{
+
+    public static final String REPLACEMENTSFILE = "." + File.separator + "config" + File.separator + "replacements.ini";
+    public static boolean DEBUG_MODE = false;
+
+    public static void main(String[] argv)
+    {
+	List<Replacement> replacements = new ArrayList<Replacement>();
+        if ((new File(REPLACEMENTSFILE)).exists()) {
+            try {
+                BufferedReader br = new BufferedReader(new FileReader(REPLACEMENTSFILE));
+                String s = "";
+                while ((s = br.readLine()) != null) {
+                    String fileName = br.readLine();
+                    if (fileName == null) break;
+                    fileName = fileName.replaceAll("[\\\\/]", File.separator);
+                    Replacement r = new Replacement(s, fileName);
+                    if (DEBUG_MODE) {
+                        System.out.println("Added Replacement: " + r.urlPattern + " => " + r.targetFile);
+                    }
+                    replacements.add(r);
+                }
+                br.close();
+            } catch (IOException e) {
+
+            }
+        } else {
+            if (DEBUG_MODE) {
+                System.out.println("WARNING:REPLACEMENTS FILE NOT FOUND.");
+            }
+        }
+         Server.startServer(ProxyConfig.port, replacements, new ArrayList<String>(), new CatchedListener() {
+
+            /**
+             * Method called when specified contentType is received
+             *
+             * @param contentType Content type
+             * @param url         URL of the method
+             * @param data        Data stream
+             */
+            public void catched(String contentType, String url, InputStream data) {
+            }
+         }, new ReplacedListener() {
+
+            public void replaced(Replacement replacement, String url, String contentType) {
+               if (DEBUG_MODE) {
+                  System.out.println("REPLACED:" + url + " (Content-type:" + contentType + ") WITH FILE " + replacement.targetFile);
+               }
+            }
+         });
+
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/Message.java

@@ -0,0 +1,297 @@
+package com.jpexs.proxy;
+
+import java.util.Hashtable;
+import java.util.Enumeration;
+import java.util.Vector;
+import java.io.*;
+
+public abstract class Message
+{
+    /**
+     * Hashtable used to store message headers.
+     */
+    private Hashtable headers = new Hashtable(33);
+
+    /**
+     *
+     */
+    String statusLine = null;
+
+    public String readLine(InputStream in) throws IOException
+    {
+	char[] buf = new char[128];
+	int offset = 0;
+	int ch;
+
+	for (;;)
+	{
+	    ch = in.read();
+	    if (ch == -1 || ch == '\n')
+	    {
+		break;
+	    }
+	    else if (ch == '\r')
+	    {
+		int tmpch = in.read();
+		if (tmpch != '\n')
+		{
+		    if (! (in instanceof PushbackInputStream))
+		    {
+			in = new PushbackInputStream(in);
+		    }
+		    ((PushbackInputStream) in).unread(tmpch);
+		}
+		break;
+	    }
+	    else
+	    {
+		if (offset == buf.length)
+		{
+		    char[] tmpbuf = buf;
+		    buf = new char[tmpbuf.length * 2];
+		    System.arraycopy(tmpbuf, 0, buf, 0, offset);
+		}
+		buf[offset++] = (char) ch;
+	    }
+	}
+	return String.copyValueOf(buf, 0, offset);
+    }
+
+    /**
+     * Read headers and store them in the hashtable.
+     */
+    void readHeaders(InputStream in) throws IOException
+    {
+	int i;
+	Key key = null;
+	
+	for (;;)
+	{
+	    String s = readLine(in);
+	    if (s == null)
+	    {
+		break;
+	    }
+	    i = s.indexOf(':');
+	    if (i == -1)
+	    {
+		/* end of header */
+		if (s.length() == 0)
+		{
+		    break;
+		}
+		/* multi-line headers */
+		else if (key != null
+			 && (s.startsWith(" ") || s.startsWith("\t")))
+		{
+		    int index = getHeaderValueCount(key.toString());
+		    index--;
+		    Vector v = (Vector) headers.get(key);
+		    v.setElementAt(v.elementAt(index) + "\n" + s, index);
+		}
+	    }
+	    else
+	    {
+		key = new Key(s.substring(0, i));
+		Vector v;
+		if (headers.containsKey(key))
+		{
+		    v = (Vector) headers.get(key);
+		}
+		else
+		{
+		    v = new Vector();
+		}
+		v.addElement(s.substring(i+1).trim());
+		headers.put(key, v);
+	    }
+	}
+    }
+
+    public int headerCount()
+    {
+	return headers.size();
+    }
+
+    /**
+     * Set the Status line.
+     */
+    public void setStatusLine(String l)
+    {
+        statusLine = l;
+    }
+
+    public int getHeaderValueCount(String name)
+    {
+	Vector v = (Vector) headers.get(new Key(name));
+	return v.size();
+    }
+    
+    public String getHeaderField(String name)
+    {
+	return getHeaderField(name, 0);
+    }
+    
+    public String getHeaderField(String name, int index)
+    {
+	Vector v = (Vector) headers.get(new Key(name));
+	if (v == null)
+	{
+	    return null;
+	}
+	return (String) v.elementAt(index);
+    }
+
+    public void setHeaderField(String name, String value)
+    {
+	setHeaderField(name, value, 0);
+    }
+
+    public void setHeaderField(String name, String value, int index)
+    {
+	Vector v;
+	Key key = new Key(name);
+	
+	if (headers.containsKey(key))
+	{
+	    v = (Vector) headers.get(key);
+	}
+	else
+	{
+	    v = new Vector();
+	    if (index == 0)
+	    {
+		v.addElement("");
+	    }
+	    headers.put(key, v);
+	}
+	v.setElementAt(value, index);
+    }
+    
+    public void setHeaderField(String name, int value)
+    {
+	setHeaderField(name, value, 0);
+    }
+
+    public void setHeaderField(String name, int value, int index)
+    {
+	setHeaderField(name, new Integer(value).toString(), index);
+    }
+
+    /**
+     * Set all header fields with the give name to the
+     * specified value.
+     */
+    public void setHeaderFields(String name, String value)
+    {
+	Vector v;
+	Key key = new Key(name);
+
+	v = (Vector) headers.get(key);
+	if (v != null)
+	{
+	    for (int i = 0; i < v.size(); i++)
+	    {
+		v.setElementAt(value, i);
+	    }
+	}
+    }
+
+    public void appendHeaderField(String name, String value)
+    {
+	appendHeaderField(name, value, 0);
+    }
+    
+    public void appendHeaderField(String name, String value, int index)
+    {
+	setHeaderField(name, getHeaderField(name, index) + value, index);
+    }
+    
+    public void removeHeaderField(String name)
+    {
+	headers.remove(new Key(name));
+    }
+
+    /**
+     * Return whether or not a header exists.
+     *
+     * @param name header name
+     */
+    public boolean containsHeaderField(String name)
+    {
+	return headers.containsKey(new Key(name));
+    }
+
+    /**
+     * @return an Enumeration of Strings
+     */
+    public Enumeration getHeaders()
+    {
+	Vector v = new Vector();
+
+	for (Enumeration e = headers.keys(); e.hasMoreElements(); )
+	{
+	    v.addElement(e.nextElement().toString());
+	}
+
+	return v.elements();
+    }
+
+    private final static byte[] COLON_SPACE = ": ".getBytes();
+    private final static byte[] CRLF = "\r\n".getBytes();
+    
+    private ByteArray toByteArray(byte[] sep)
+    {
+	ByteArray buf = new ByteArray();
+	Key key;
+	String value;
+	Vector v;
+	int i = 0;
+	
+	buf.append(statusLine);
+	buf.append(sep);
+	
+	for (Enumeration e = headers.keys(); e.hasMoreElements(); )
+	{
+	    key = (Key) e.nextElement();
+	    v = (Vector) headers.get(key);
+	    for (i = 0; i < v.size(); i++)
+	    {
+		buf.append(key.toString());
+		buf.append(COLON_SPACE);
+		buf.append(v.elementAt(i).toString());
+		buf.append(sep);
+	    }
+	}
+	buf.append(sep);
+
+	return buf;
+    }
+
+    private ByteArray toByteArray()
+    {
+	return toByteArray(CRLF);
+    }
+
+    private ByteArray toByteArray(String sep)
+    {
+	return toByteArray(sep.getBytes());
+    }
+    
+    public String toString()
+    {
+	return toByteArray().toString();
+    }
+    
+    public String toString(String sep)
+    {
+	return toByteArray(sep).toString();
+    }
+
+    public void write(OutputStream out)
+	throws IOException
+    {
+	toByteArray().writeTo(out);
+	out.flush();
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/ProxyConfig.java

@@ -0,0 +1,43 @@
+package com.jpexs.proxy;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ *
+ * @author JPEXS
+ */
+public class ProxyConfig {
+
+   public static boolean dontLogFilters=false;
+
+   public static String appVersion="1.1";
+   public static String appName="JPProxy";
+   public static int port=55555;
+   public static String bindAddress;
+
+   public static int readTimeout=50000;
+   public static boolean proxyKeepAlive=false;
+   public static boolean dontUncompress=false;
+
+   public static final int HTTPS_PASSTHRU=0;
+   public static final int HTTPS_FILTER=1;
+   public static final int HTTPS_FILTERLIST=2;
+
+   public static int httpsMode=HTTPS_PASSTHRU;
+
+   public static List<String> enabledHttpsServers=new ArrayList<String>();
+
+   public static boolean useHTTPSProxy=false;
+   public static String httpsProxyHost="";
+   public static int httpsProxyPort=0;
+
+   public static boolean useHTTPProxy=false;
+   public static String httpProxyHost="";
+   public static int httpProxyPort=0;
+
+   public static String httpsKeyStoreFile=null;
+   public static String httpsKeyStorePass=null;
+   public static String httpsKeyPass=null;
+
+}

libsrc/jpproxy/src/com/jpexs/proxy/ReplacedListener.java

@@ -0,0 +1,5 @@
+package com.jpexs.proxy;
+
+public interface ReplacedListener {
+    public void replaced(Replacement replacement, String url, String contentType);
+}

libsrc/jpproxy/src/com/jpexs/proxy/Replacement.java

@@ -0,0 +1,63 @@
+package com.jpexs.proxy;
+
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.regex.Pattern;
+
+/**
+ * Replacement of URL with local file
+ */
+public class Replacement {
+
+    /**
+     * URL pattern, can contain * wild-cards
+     */
+    public String urlPattern;
+    /**
+     * Filename to replace content with
+     */
+    public String targetFile;
+    /**
+     * Date of last accesing this url
+     */
+    public Calendar lastAccess;
+
+    /**
+     * Constructor
+     *
+     * @param urlPattern URL pattern, can contain * wild-cards
+     * @param targetFile Filename to replace content with
+     */
+    public Replacement(String urlPattern, String targetFile) {
+        this.urlPattern = urlPattern;
+        this.targetFile = targetFile;
+    }
+
+    /**
+     * Returns true when urlPattern matches specified url
+     *
+     * @param url Url to test match
+     * @return True when matches
+     */
+    public boolean matches(String url) {
+        String pat = Pattern.quote(urlPattern);
+        pat = pat.replace("*", "\\E.*\\Q");
+        return Pattern.matches(pat, url);
+    }
+
+    /**
+     * Returns a string representation of the object.
+     *
+     * @return a string representation of the object.
+     */
+    @Override
+    public String toString() {
+        SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");
+
+        if (lastAccess == null) {
+            return "         " + urlPattern;
+        } else {
+            return format.format(lastAccess.getTime()) + " " + urlPattern;
+        }
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/Reply.java

@@ -0,0 +1,245 @@
+package com.jpexs.proxy;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+import java.io.StringBufferInputStream;
+import java.io.SequenceInputStream;
+import java.util.Hashtable;
+import java.util.StringTokenizer;
+
+public class Reply extends Message
+{
+    InputStream in = null;
+    int statusCode = -1;
+
+    public Reply()
+    {
+    }
+
+    public Reply(InputStream in)
+    {
+	setContent(in);
+    }
+
+    public void setContent(InputStream in)
+    {
+	this.in = in;
+    }
+
+    public InputStream getContent()
+    {
+	return in;
+    }
+    
+    void read() throws IOException
+    {
+	if (in != null)
+	{
+	    read(in);
+	}
+    }
+    
+    void read(InputStream in) throws IOException
+    {
+	statusLine = readLine(in);
+	if (statusLine == null || statusLine.length() == 0)
+	{
+	    throw new IOException("Missing HTTP status line");
+	}
+
+	/* Look for HTTP/0.9 */
+	if (!statusLine.startsWith("HTTP"))
+	{
+	    /* Put back the line */
+	    if (this.in != null)
+	    {
+		String putback = new String(statusLine + "\n");
+		this.in = new SequenceInputStream(new StringBufferInputStream(putback), in);
+	    }
+	    /* Fake a status line and upgrade to HTTP/1.0 */
+	    statusLine = "HTTP/1.0 200 OK";
+	    return;
+	}
+	
+	readHeaders(in);
+	int code = getStatusCode();
+
+	/* RFC 2068: 204 and 304 MUST NOT contain a message body. */
+	switch (code)
+	{
+	case 204: /* No Content */
+	case 304: /* Not Modified */
+	    /* Ignore the message body if it exists */
+	    if (containsHeaderField("Content-length"))
+	    {		
+		int contentLength = 0;
+		try 
+		{
+		    contentLength = Integer.parseInt(getHeaderField("Content-length"));
+		}
+		catch (NumberFormatException e)
+		{
+		}
+		int n;
+		byte[] buffer = new byte[8192];
+		while ((n = in.read(buffer, 0, buffer.length)) > 0)
+		{
+		    /* ignore */
+		}
+		removeHeaderField("Content-length");
+	    }
+	    break;
+	}
+    }
+
+    public boolean hasContent()
+    {
+	switch (getStatusCode())
+	{
+	case 204:
+	case 304:
+	    return false;
+
+	default:
+	    return true;
+	}
+    }
+
+    public String getProtocol()
+    {
+	StringTokenizer st = new StringTokenizer(statusLine);
+	String protocol = (String) st.nextToken();
+	return protocol;
+    }
+
+    public int getStatusCode()
+    {
+	if (statusCode == -1)
+	{
+	    StringTokenizer st = new StringTokenizer(statusLine);
+	    String protocol = (String) st.nextToken();
+	    String status = (String) st.nextToken();
+
+	    try
+	    {
+		statusCode = Integer.parseInt(status);
+	    }
+	    catch (NumberFormatException e)
+	    {
+		System.out.println("Malformed or missing status code");
+		statusCode = 0;
+	    }
+	}
+	
+	return statusCode;
+    }
+
+    private Hashtable headerParser(String header)
+    {
+	Hashtable table = new Hashtable();
+	String type = getHeaderField(header);
+	if (type == null)
+	{
+	    return table;
+	}
+
+	StringTokenizer st = new StringTokenizer(type, ";");
+	int count = 0;
+	while (st.hasMoreTokens())
+	{
+	    String token = st.nextToken();
+	    token = token.trim();
+	    String name;
+	    String value;
+	    int i = token.indexOf('=');
+	    if (i != -1)
+	    {
+		name = token.substring(0, i);
+		value = token.substring(i+1);
+	    }
+	    else
+	    {
+		name = token;
+		value = "";
+	    }
+
+	    if (count == 0)
+	    {
+		table.put(header, name);
+	    }
+	    else
+	    {
+		table.put(name, value);
+	    }
+
+	    count++;
+	}
+
+	return table;
+    }
+
+    public String getContentType()
+    {
+	Hashtable table = headerParser("Content-type");
+	return(String) table.get("Content-type");
+    }
+
+    public String getBoundary()
+    {
+	Hashtable table = headerParser("Content-type");
+	return(String) table.get("boundary");
+    }
+
+    public String getTransferEncoding()
+    {
+	Hashtable table = headerParser("Transfer-Encoding");
+	return(String) table.get("Transfer-Encoding");
+    }
+
+    public int getChunkSize(InputStream in) throws IOException
+    {
+	String line = readLine(in);
+	line = line.trim(); /* apache can have trailing spaces */
+	int size = -1;
+	try
+	{
+	    size = Integer.valueOf(line, 16).intValue();
+	}
+	catch (NumberFormatException e)
+	{
+	    System.out.println(e);
+	}
+	return size;
+    }
+
+    public void getChunkedFooter(InputStream in) throws IOException
+    {
+	for (;;)
+	{
+	    String line = readLine(in);
+	    if (line == null)
+	    {
+		break;
+	    }
+	    int i = line.indexOf(':');
+	    if (i == -1)
+	    {
+		break;
+	    }
+	}
+    }
+
+    public void setStatusLine(String line)
+    {
+	this.statusLine = line;
+    }
+
+    public static Reply createRedirect(String url)
+    {
+	Reply r = new Reply();
+	r.setStatusLine("HTTP/1.0 302 Moved Temporarily");
+	r.setHeaderField("Location", url);
+	return r;
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/Request.java

@@ -0,0 +1,281 @@
+package com.jpexs.proxy;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+import java.util.StringTokenizer;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Vector;
+
+public class Request extends Message
+{
+    
+    private String command = null;
+    private String url = null;
+    private String protocol = null;
+    private byte[] data = null;
+    private Client client = null;
+    private Hashtable log;
+    private Vector logHeaders;
+    public boolean hadKeepalive=false;
+
+
+    Request(Client c)
+    {
+	client = c;
+    }
+
+    void read(InputStream in) throws IOException
+    {
+	statusLine = readLine(in);
+	if (statusLine == null || statusLine.length() == 0)
+	{
+	    throw new IOException("Empty request");
+	}
+
+	StringTokenizer st = new StringTokenizer(statusLine);
+	command = (String) st.nextToken();
+	url = (String) st.nextToken();
+	protocol = (String) st.nextToken();
+
+	if (!url.startsWith("http"))
+	{
+	    //TODO do something here
+	}
+
+	readHeaders(in);
+
+	if ("POST".equals(command) || "PUT".equals(command))
+	{
+	    try
+	    {
+		int n = Integer.parseInt(getHeaderField("Content-length"));
+		data = new byte[n];
+		int offset = 0;
+		while (offset < data.length)
+		{
+		    n = in.read(data, offset, data.length - offset);
+		    if (n < 0)
+		    {
+			throw new IOException("Not enough " + command + " data");
+		    }
+		    offset += n;
+		}
+	    }
+	    catch (NumberFormatException e)
+	    {
+		
+	    }
+	}
+    }
+
+    public void write(OutputStream out)
+	throws IOException
+    {
+	super.write(out);
+	if (data != null)
+	{
+	    out.write(data);
+	    out.flush();
+	}
+    }
+
+    public String getRequest()
+    {
+	return statusLine;
+    }
+
+    public String getCommand()
+    {
+	return command;
+    }
+    
+    public void setCommand(String command)
+    {
+	this.command = command;
+    }
+
+    public String getURL()
+    {
+	return url;
+    }
+
+    public void setURL(String url)
+    {
+	this.url = url;
+    }
+
+    public String getProtocol()
+    {
+	return protocol;
+    }
+
+    public void setProtocol(String protocol)
+    {
+	this.protocol = protocol;
+    }
+
+    public void addSecureHostToURL(String host){
+       url="https://"+host+url;
+    }
+
+    public String getHost()
+    {
+	String url = getURL();
+	String s;
+
+	if (url.startsWith("http://"))
+	{
+	    s = url.substring(7, url.indexOf('/', 7));
+	}
+	else if (url.startsWith("https://"))
+	{
+	    s = url.substring(8, url.indexOf('/', 8));
+	}
+	else
+	{
+	    s = url;
+	}
+
+	int at = s.indexOf('@');
+	if (at != -1 )
+	{
+	    s = s.substring(at+1);
+	}
+
+	if (s.indexOf(':') != -1)
+	{
+	    return s.substring(0, s.indexOf(':'));
+	}
+
+	return s;
+    }
+
+    public int getPort()
+    {
+	int port = 80;
+	String url = getURL();
+	String s;
+
+	if (url.startsWith("http://"))
+	{
+	    s = url.substring(7, url.indexOf('/', 7));
+	}
+	else if (url.startsWith("https://"))
+	{
+	    s = url.substring(8, url.indexOf('/', 8));
+       port=443;
+	}
+	else
+	{
+	    s = url;
+	}
+
+	int at = s.indexOf('@');
+	if (at != -1 )
+	{
+	    s = s.substring(at+1);
+	}
+
+	if (s.indexOf(':') != -1)
+	{
+	    try
+	    {
+		port = Integer.parseInt(s.substring(s.indexOf(':') + 1));
+	    }
+	    catch (NumberFormatException e)
+	    {
+		
+	    }
+	}
+	return port;
+    }
+
+    public String getData()
+    {
+	if (data == null)
+	{
+	    return null;
+	}
+	return new String(data);
+    }
+
+    public String getPath()
+    {	
+	String str = getURL();
+	int pos = 0;
+	for (int i = 0; i < 3; i++)
+	{
+	    pos = str.indexOf('/', pos);
+	    pos++;
+	}
+	pos--;
+	return str.substring(pos);
+    }
+    
+    public String getDocument()
+    {
+	String path = getPath();
+	int n = path.lastIndexOf('/');
+	if (n == path.length() - 1)
+	{
+	    n = path.lastIndexOf('/', n - 1);
+	}
+	if (n < 0)
+	{
+	    return "/";
+	}
+	else
+	{
+	    return path.substring(n + 1);
+	}
+    }
+
+    public Client getClient()
+    {
+	return client;
+    }
+
+    public String getQueryString()
+    {
+	String path = getPath();
+	int n = path.indexOf('?');
+	if (n < 0)
+	{
+	    return null;
+	}
+	return path.substring(n + 1);
+    }
+
+    public synchronized void addLogEntry(String header,
+					 String message)
+    {
+	if (log == null)
+	{
+	    log = new Hashtable();
+	    logHeaders = new Vector();
+	}
+
+	Vector v = (Vector)log.get(header);
+	if (log.get(header) == null)
+	{
+	    v = new Vector();
+	    log.put(header, v);
+	    logHeaders.addElement(header);
+	}
+	v.addElement(message);
+    }
+
+    public Enumeration getLogHeaders()
+    {
+	return logHeaders != null ? logHeaders.elements() : null;
+    }
+
+    public Enumeration getLogEntries(String header)
+    {
+	return log != null ? ((Vector)log.get(header)).elements() : null;
+    }
+
+
+}

libsrc/jpproxy/src/com/jpexs/proxy/RetryRequestException.java

@@ -0,0 +1,14 @@
+package com.jpexs.proxy;
+
+class RetryRequestException extends Exception
+{
+    RetryRequestException()
+    {
+	super();
+    }
+    
+    RetryRequestException(String message)
+    {
+	super(message);
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/ReusableThread.java

@@ -0,0 +1,70 @@
+package com.jpexs.proxy;
+
+public class ReusableThread extends Thread
+{
+    private ThreadPool pool = null;
+    private Runnable runnable = null;
+    private boolean alive = true;
+    private long lastrun = 0;
+    private int used = 0;
+
+    public ReusableThread(ThreadPool pool)
+    {
+	this.pool = pool;
+    }
+
+    public synchronized void setRunnable(Runnable runnable)
+    {
+	this.runnable = runnable;
+	notify();
+    }
+
+    public synchronized void terminate()
+    {
+	alive = false;
+	notify();
+    }
+
+    public long getLastRunTime()
+    {
+	return lastrun;
+    }
+
+    public int useCount()
+    {
+	return used;
+    }
+    
+    public void run()
+    {
+	while (alive)
+	{
+	    setName("ReusableThread: idle");
+	    
+	    while (runnable == null && alive)
+	    {
+		synchronized (this)
+		{
+		    try
+		    {
+			wait();
+		    }
+		    catch (InterruptedException ie)
+		    {
+		    }
+		}
+	    }
+
+	    if (alive)
+	    {
+		setName("ReusableThread: busy");
+		setPriority(Thread.NORM_PRIORITY);
+		lastrun = System.currentTimeMillis();
+		used++;
+		runnable.run();
+		runnable = null;
+		pool.put(this);
+	    }
+	}
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/Server.java

@@ -0,0 +1,161 @@
+package com.jpexs.proxy;
+
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.ServerSocket;
+import java.io.IOException;
+import java.io.DataOutputStream;
+import java.util.List;
+
+public class Server implements Runnable
+{
+    ServerSocket server = null;
+    boolean running = false;
+
+    private List<String> catchedContentTypes;
+    private CatchedListener catchedListener;
+    private ReplacedListener replacedListener;
+    private List<Replacement> replacements;
+
+     static ThreadPool pool;
+
+    static Server myServer;
+    static boolean serverRunning=false;
+
+    static boolean stopping=false;
+
+    public static ReusableThread getThread()
+    {
+       return pool.get();
+    }
+
+    /**
+     * Starts proxy server
+     *
+     * @param port                Listening port
+     * @param replacements        List of replacements
+     * @param catchedContentTypes Content types to sniff
+     * @param catchedListener     Catched listener
+     */
+    public static boolean startServer(int port, List<Replacement> replacements, List<String> catchedContentTypes, CatchedListener catchedListener, ReplacedListener replacedListener) {
+        stopServer();
+      try {
+         myServer = new Server(port, replacements, catchedContentTypes, catchedListener, replacedListener);
+      } catch (IOException ex) {
+         return false;
+      }
+        pool = new ThreadPool(ProxyConfig.appName+" Threads");
+        /* Startup the Janitor */
+         Janitor j = new Janitor();
+         j.add(pool);
+         getThread().setRunnable(j);
+         serverRunning=true;
+         getThread().setRunnable(myServer);
+         return true;
+    }
+
+
+    public static void stopServer()
+    {
+      if(serverRunning){
+         serverRunning=false;
+         try {
+            myServer.server.close();
+         } catch (IOException ex) {
+
+         }
+         pool.clean();
+      }
+    }
+    Server(int port,List<Replacement> replacements, List<String> catchedContentTypes, CatchedListener catchedListener, ReplacedListener replacedListener) throws IOException
+    {
+
+       this.replacements = replacements;
+       this.catchedContentTypes = catchedContentTypes;
+        this.catchedListener = catchedListener;
+        this.replacedListener = replacedListener;
+	
+	try
+	{
+	    String bindaddr = ProxyConfig.bindAddress;
+	    if (bindaddr != null && bindaddr.length() > 0)
+	    {
+		server = new ServerSocket(port, 512,
+					  InetAddress.getByName(bindaddr));
+	    }
+	    else
+	    {
+		server = new ServerSocket(port, 512);
+	    }
+	}
+	catch (IOException e)
+	{
+	    throw e;
+	}
+
+	/* Initialize internal Httpd */
+    }
+
+    synchronized void suspend()
+    {
+	running = false;
+    }
+
+    synchronized void resume()
+    {
+	running = true;
+    }
+
+
+    public void run()
+    {
+	Thread.currentThread().setName(ProxyConfig.appName+" Server");
+	running = true;
+	for (;;)
+	{
+	    Socket socket;
+
+	    try
+	    {
+		socket = server.accept();
+	    }
+	    catch (IOException e)
+	    {
+       if(stopping){
+          break;
+       }
+		continue;
+	    }
+
+       if(stopping){
+          break;
+       }
+
+	    if (running)
+	    {
+		Handler h = new Handler(socket,replacements,catchedContentTypes,catchedListener,replacedListener);
+		ReusableThread rt = getThread();
+		rt.setRunnable(h);
+	    }
+	    else
+	    {
+		error(socket, 503, ProxyConfig.appName+" proxy service is suspended.");
+	    }
+	}
+    }
+
+    void error(Socket socket, int code, String message)
+    {
+	try
+	{
+	    DataOutputStream out = new DataOutputStream(socket.getOutputStream());
+	    out.writeBytes((new HttpError(code, message)).toString());
+	    out.close();
+	    socket.close();
+	}
+	catch (IOException e)
+	{
+	    e.printStackTrace();
+	}
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/ThreadPool.java

@@ -0,0 +1,53 @@
+package com.jpexs.proxy;
+
+import java.util.*;
+
+public class ThreadPool implements Cleanable
+{
+    private String name;
+    private Vector pool = new Vector();
+    
+    public ThreadPool(String name)
+    {
+	this.name = name;
+    }
+
+    public synchronized ReusableThread get()
+    {
+	ReusableThread rt = null;
+
+	if (pool.size() > 0)
+	{
+	    rt = (ReusableThread)pool.firstElement();
+	    pool.removeElement(rt);
+	}
+
+	if (rt == null)
+	{
+	    rt = new ReusableThread(this);
+	    rt.start();
+	}
+
+	return rt;
+    }
+
+    public synchronized void put(ReusableThread rt)
+    {
+	pool.addElement(rt);
+    }
+
+    public synchronized void clean()
+    {
+	long now = System.currentTimeMillis();
+	
+	for (Enumeration e = pool.elements(); e.hasMoreElements(); )
+	{
+	    ReusableThread rt = (ReusableThread) e.nextElement();
+	    if (now - rt.getLastRunTime() >= 30000)
+	    {
+		rt.terminate();
+		pool.removeElement(rt);
+	    }
+	}
+    }
+}

libsrc/jpproxy/src/com/jpexs/proxy/WorkerThread.java

@@ -0,0 +1,133 @@
+package com.jpexs.proxy;
+
+import java.util.*;
+
+
+public class WorkerThread extends Thread {
+
+private Runnable task;
+private String name;
+
+private static int nactive = 0;
+private static Vector list = new Vector();
+private static int max = 10;
+private static long lifetime = 900 * 1000; /* 15 minute default */
+
+private
+WorkerThread() {
+	setDaemon(true);
+}
+
+/**
+ * Sets the lifetime of an idle WorkerThread (in ms).  A WorkerThread
+ * will remain on the idle list for this much time before exiting.  This
+ * does not affect WorkerThreads currently idling.
+ */
+synchronized static void
+setLifetime(long time) {
+	lifetime = time;
+}
+
+/**
+ * Sets the maximum number of WorkerThreads that can exist at any given
+ * time.  If this value is decreased below the current number of
+ * WorkerThreads, this will not take effect immediately.
+ */
+synchronized static void
+setMaxThreads(int maxThreads) {
+	max = maxThreads;
+}
+
+/**
+ * Obtains a WorkerThread to which a task can be assigned.  If an idle
+ * WorkerThread is present, it is removed from the idle list and returned.
+ * If not, and the maximum number of WorkerThreads has not been reached,
+ * a new WorkerThread is created.  If the maximum number has been reached,
+ * this blocks until a WorkerThread is free.
+ */
+static WorkerThread
+getThread() {
+	WorkerThread t;
+	synchronized (list) {
+		if (list.size() > 0) {
+			t = (WorkerThread) list.firstElement();
+			list.removeElement(t);
+		}
+		else if (nactive >= max) {
+			while (true) {
+				try {
+					list.wait();
+				}
+				catch (InterruptedException e) {
+				}
+				if (list.size() == 0)
+					continue;
+				t = (WorkerThread) list.firstElement();
+				list.removeElement(t);
+				break;
+			}
+		}
+		else
+			t = new WorkerThread();
+		nactive++;
+	}
+	return t;
+}
+
+/**
+ * Assigns a task to a WorkerThread
+ * @param task The task to be run
+ * @param name The name of the task
+ */
+public static void
+assignThread(Runnable task, String name) {
+	while (true) {
+		try {
+			WorkerThread t = getThread();
+			synchronized (t) {
+				t.task = task;
+				t.name = name;
+				if (!t.isAlive())
+					t.start();
+				else
+					t.notify();
+			}
+			return;
+		}
+		catch (IllegalThreadStateException e) {
+		}
+	}
+}
+
+/** Performs the task */
+synchronized public void
+run() {
+	while (true) {
+		setName(name);
+		try {
+			task.run();
+		}
+		catch (Throwable t) {
+			System.err.println(t);
+		}
+		setName("idle thread");
+		synchronized (list) {
+			list.addElement(this);
+			if (nactive >= max)
+				list.notify();
+			nactive--;
+		}
+		task = null;
+		try {
+			wait(lifetime);
+		}
+		catch (InterruptedException e) {
+		}
+		if (task == null) {
+			list.removeElement(this);
+			return;
+		}
+	}
+}
+
+}