From fb1bdb209477acc5a5b40862089c80ebf753df97 Mon Sep 17 00:00:00 2001
From: Nathan Freitas <nathan@freitas.net>
Date: Mon, 30 Nov 2009 16:50:26 +0000
Subject: [PATCH] fixing sh*t I broke due to strange Android build process
 (re-adding src files)

svn:r21068
---
 .../src/org/torproject/android/HttpProxy.java | 639 ++++++++++++++++++
 .../org/torproject/android/SocksClient.java   | 129 ++++
 .../android/TorBinaryInstaller.java           | 160 +++++
 .../org/torproject/android/TorConstants.java  |  75 ++
 .../torproject/android/TorControlPanel.java   | 587 ++++++++++++++++
 .../org/torproject/android/TorService.java    | 617 +++++++++++++++++
 6 files changed, 2207 insertions(+)
 create mode 100644 Orbot/src/org/torproject/android/HttpProxy.java
 create mode 100644 Orbot/src/org/torproject/android/SocksClient.java
 create mode 100644 Orbot/src/org/torproject/android/TorBinaryInstaller.java
 create mode 100644 Orbot/src/org/torproject/android/TorConstants.java
 create mode 100644 Orbot/src/org/torproject/android/TorControlPanel.java
 create mode 100644 Orbot/src/org/torproject/android/TorService.java

diff --git a/Orbot/src/org/torproject/android/HttpProxy.java b/Orbot/src/org/torproject/android/HttpProxy.java
new file mode 100644
index 00000000..1da7c719
--- /dev/null
+++ b/Orbot/src/org/torproject/android/HttpProxy.java
@@ -0,0 +1,639 @@
+package org.torproject.android;
+/* <!-- in case someone opens this in a browser... --> <pre> */
+/*
+ * This is a simple multi-threaded Java proxy server
+ * for HTTP requests (HTTPS doesn't seem to work, because
+ * the CONNECT requests aren't always handled properly).
+ * I implemented the class as a thread so you can call it 
+ * from other programs and kill it, if necessary (by using 
+ * the closeSocket() method).
+ *
+ * We'll call this the 1.1 version of this class. All I 
+ * changed was to separate the HTTP header elements with
+ * \r\n instead of just \n, to comply with the official
+ * HTTP specification.
+ *  
+ * This can be used either as a direct proxy to other
+ * servers, or as a forwarding proxy to another proxy
+ * server. This makes it useful if you want to monitor
+ * traffic going to and from a proxy server (for example,
+ * you can run this on your local machine and set the
+ * fwdServer and fwdPort to a real proxy server, and then
+ * tell your browser to use "localhost" as the proxy, and
+ * you can watch the browser traffic going in and out).
+ *
+ * One limitation of this implementation is that it doesn't 
+ * close the ProxyThread socket if the client disconnects
+ * or the server never responds, so you could end up with
+ * a bunch of loose threads running amuck and waiting for
+ * connections. As a band-aid, you can set the server socket
+ * to timeout after a certain amount of time (use the
+ * setTimeout() method in the ProxyThread class), although
+ * this can cause false timeouts if a remote server is simply
+ * slow to respond.
+ *
+ * Another thing is that it doesn't limit the number of
+ * socket threads it will create, so if you use this on a
+ * really busy machine that processed a bunch of requests,
+ * you may have problems. You should use thread pools if
+ * you're going to try something like this in a "real"
+ * application.
+ *
+ * Note that if you're using the "main" method to run this
+ * by itself and you don't need the debug output, it will
+ * run a bit faster if you pipe the std output to 'nul'.
+ *
+ * You may use this code as you wish, just don't pretend 
+ * that you wrote it yourself, and don't hold me liable for 
+ * anything that it does or doesn't do. If you're feeling 
+ * especially honest, please include a link to nsftools.com
+ * along with the code. Thanks, and good luck.
+ *
+ * Julian Robichaux -- http://www.nsftools.com
+ */
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.lang.reflect.Array;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+import net.sourceforge.jsocks.socks.Socks5Proxy;
+import net.sourceforge.jsocks.socks.SocksSocket;
+
+
+public class HttpProxy extends Thread
+{
+	public static final int DEFAULT_PORT = 8888;
+	
+	private ServerSocket server = null;
+	private int thisPort = DEFAULT_PORT;
+	private String fwdServer = "";
+	private int fwdPort = 0;
+	private int ptTimeout = ProxyThread.DEFAULT_TIMEOUT;
+	private int debugLevel = 1;
+	private PrintStream debugOut = System.out;
+	private boolean keepRunning = true;
+	private boolean doSocks = false;
+	
+	private Socks5Proxy sProxy = null;
+	
+	/**
+	 * @return the doSocks
+	 */
+	public boolean isDoSocks() {
+		return doSocks;
+	}
+
+
+	/**
+	 * @param doSocks the doSocks to set
+	 */
+	public void setDoSocks(boolean doSocks) {
+		this.doSocks = doSocks;
+	}
+
+
+	/* here's a main method, in case you want to run this by itself */
+	public static void main (String args[])
+	{
+		int port = 0;
+		String fwdProxyServer = "";
+		int fwdProxyPort = 0;
+		
+		if (args.length == 0)
+		{
+			System.err.println("USAGE: java jProxy <port number> [<fwd proxy> <fwd port>]");
+			System.err.println("  <port number>   the port this service listens on");
+			System.err.println("  <fwd proxy>     optional proxy server to forward requests to");
+			System.err.println("  <fwd port>      the port that the optional proxy server is on");
+			System.err.println("\nHINT: if you don't want to see all the debug information flying by,");
+			System.err.println("you can pipe the output to a file or to 'nul' using \">\". For example:");
+			System.err.println("  to send output to the file prox.txt: java jProxy 8080 > prox.txt");
+			System.err.println("  to make the output go away: java jProxy 8080 > nul");
+			return;
+		}
+		
+		// get the command-line parameters
+		port = Integer.parseInt(args[0]);
+		if (args.length > 2)
+		{
+			fwdProxyServer = args[1];
+			fwdProxyPort = Integer.parseInt(args[2]);
+		}
+		
+		// create and start the jProxy thread, using a 20 second timeout
+		// value to keep the threads from piling up too much
+		System.err.println("  **  Starting jProxy on port " + port + ". Press CTRL-C to end.  **\n");
+		HttpProxy jp = new HttpProxy(port, fwdProxyServer, fwdProxyPort, 20);
+		jp.setDebug(1, System.out);		// or set the debug level to 2 for tons of output
+		jp.start();
+		
+		// run forever; if you were calling this class from another
+		// program and you wanted to stop the jProxy thread at some
+		// point, you could write a loop that waits for a certain
+		// condition and then calls jProxy.closeSocket() to kill
+		// the running jProxy thread
+		while (true)
+		{
+			try { Thread.sleep(3000); } catch (Exception e) {}
+		}
+		
+		// if we ever had a condition that stopped the loop above,
+		// we'd want to do this to kill the running thread
+		//jp.closeSocket();
+		//return;
+	}
+	
+	
+	/* the proxy server just listens for connections and creates
+	 * a new thread for each connection attempt (the ProxyThread
+	 * class really does all the work)
+	 */
+	public HttpProxy (int port)
+	{
+		thisPort = port;
+		
+		try {
+			sProxy = new Socks5Proxy(TorConstants.IP_LOCALHOST,TorConstants.PORT_SOCKS);
+		} catch (UnknownHostException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		sProxy.resolveAddrLocally(false);
+		
+		
+	}
+	
+	public HttpProxy (int port, String proxyServer, int proxyPort)
+	{
+		thisPort = port;
+		fwdServer = proxyServer;
+		fwdPort = proxyPort;
+	}
+	
+	public HttpProxy (int port, String proxyServer, int proxyPort, int timeout)
+	{
+		thisPort = port;
+		fwdServer = proxyServer;
+		fwdPort = proxyPort;
+		ptTimeout = timeout;
+	}
+	
+	
+	/* allow the user to decide whether or not to send debug
+	 * output to the console or some other PrintStream
+	 */
+	public void setDebug (int level, PrintStream out)
+	{
+		debugLevel = level;
+		debugOut = out;
+	}
+	
+	
+	/* get the port that we're supposed to be listening on
+	 */
+	public int getPort ()
+	{
+		return thisPort;
+	}
+	 
+	
+	/* return whether or not the socket is currently open
+	 */
+	public boolean isRunning ()
+	{
+		if (server == null)
+			return false;
+		else
+			return true;
+	}
+	 
+	
+	/* closeSocket will close the open ServerSocket; use this
+	 * to halt a running jProxy thread
+	 */
+	public void closeSocket ()
+	{
+		try {
+			keepRunning = false;
+			// close the open server socket
+			server.close();
+			// send it a message to make it stop waiting immediately
+			// (not really necessary)
+			/*Socket s = new Socket("localhost", thisPort);
+			OutputStream os = s.getOutputStream();
+			os.write((byte)0);
+			os.close();
+			s.close();*/
+		}  catch(Exception e)  { 
+			if (debugLevel > 0)
+				debugOut.println(e);
+		}
+		
+		server = null;
+	}
+	
+	
+	public void run()
+	{
+		try {
+			// create a server socket, and loop forever listening for
+			// client connections
+			server = new ServerSocket(thisPort);
+			
+			while (keepRunning)
+			{
+				Socket client = server.accept();
+				ProxyThread t = new ProxyThread(client, doSocks, sProxy);
+				//t.setDebug(debugLevel, debugOut);
+				//t.setTimeout(ptTimeout);
+				t.start();
+			}
+		}  catch (Exception e)  {
+			if (debugLevel > 0)
+				debugOut.println("jProxy Thread error: " + e);
+		}
+		
+		closeSocket();
+	}
+	
+}
+
+
+/* 
+ * The ProxyThread will take an HTTP request from the client
+ * socket and send it to either the server that the client is
+ * trying to contact, or another proxy server
+ */
+class ProxyThread extends Thread
+{
+	private Socket pSocket;
+	private String fwdServer = "";
+	private int fwdPort = 0;
+	private int debugLevel = 0;
+	private PrintStream debugOut = System.out;
+	
+	// the socketTimeout is used to time out the connection to
+	// the remote server after a certain period of inactivity;
+	// the value is in milliseconds -- use zero if you don't want 
+	// a timeout
+	public static final int DEFAULT_TIMEOUT = 20 * 1000;
+	private int socketTimeout = DEFAULT_TIMEOUT;
+	
+	private boolean doSocks = false;
+	
+	private static Socks5Proxy sProxy = null;
+	
+	public ProxyThread(Socket s, boolean doSocks, Socks5Proxy sProxy)
+	{
+		pSocket = s;
+		
+		this.sProxy = sProxy;
+		this.doSocks = doSocks;
+	}
+
+	public ProxyThread(Socket s, String proxy, int port)
+	{
+		pSocket = s;
+		fwdServer = proxy;
+		fwdPort = port;
+	}
+	
+	
+	public void setTimeout (int timeout)
+	{
+		// assume that the user will pass the timeout value
+		// in seconds (because that's just more intuitive)
+		socketTimeout = timeout * 1000;
+	}
+
+
+	public void setDebug (int level, PrintStream out)
+	{
+		debugLevel = level;
+		debugOut = out;
+	}
+
+
+	public void run()
+	{
+		try
+		{
+			long startTime = System.currentTimeMillis();
+			
+			// client streams (make sure you're using streams that use
+			// byte arrays, so things like GIF and JPEG files and file
+			// downloads will transfer properly)
+			BufferedInputStream clientIn = new BufferedInputStream(pSocket.getInputStream());
+			BufferedOutputStream clientOut = new BufferedOutputStream(pSocket.getOutputStream());
+			
+			// the socket to the remote server
+			Socket server = null;
+			
+			// other variables
+			byte[] request = null;
+			byte[] response = null;
+			int requestLength = 0;
+			int responseLength = 0;
+			int pos = -1;
+			StringBuffer host = new StringBuffer("");
+			String hostName = "";
+			int hostPort = 80;
+			
+			// get the header info (the web browser won't disconnect after
+			// it's sent a request, so make sure the waitForDisconnect
+			// parameter is false)
+			request = getHTTPData(clientIn, host, false);
+			requestLength = Array.getLength(request);
+			
+			// separate the host name from the host port, if necessary
+			// (like if it's "servername:8000")
+			hostName = host.toString();
+			pos = hostName.indexOf(":");
+			if (pos > 0)
+			{
+				try { hostPort = Integer.parseInt(hostName.substring(pos + 1)); 
+					}  catch (Exception e)  { }
+				hostName = hostName.substring(0, pos);
+			}
+			
+			// either forward this request to another proxy server or
+			// send it straight to the Host
+			try
+			{
+				
+				if (!doSocks)
+				{
+					if ((fwdServer.length() > 0) && (fwdPort > 0))
+					{
+						server = new Socket(fwdServer, fwdPort);
+					}  else  {
+						server = new Socket(hostName, hostPort);
+					}
+				}
+				else
+				{
+					
+					server =  new SocksSocket(sProxy,hostName, hostPort);
+				}
+				
+			}  catch (Exception e)  {
+				// tell the client there was an error
+				String errMsg = "HTTP/1.0 500\nContent Type: text/plain\n\n" + 
+								"Error connecting to the server:\n" + e + "\n";
+				clientOut.write(errMsg.getBytes(), 0, errMsg.length());
+			}
+			
+			if (server != null)
+			{
+				server.setSoTimeout(socketTimeout);
+				BufferedInputStream serverIn = new BufferedInputStream(server.getInputStream());
+				BufferedOutputStream serverOut = new BufferedOutputStream(server.getOutputStream());
+				
+				// send the request out
+				serverOut.write(request, 0, requestLength);
+				serverOut.flush();
+				
+				// and get the response; if we're not at a debug level that
+				// requires us to return the data in the response, just stream
+				// it back to the client to save ourselves from having to
+				// create and destroy an unnecessary byte array. Also, we
+				// should set the waitForDisconnect parameter to 'true',
+				// because some servers (like Google) don't always set the
+				// Content-Length header field, so we have to listen until
+				// they decide to disconnect (or the connection times out).
+				if (debugLevel > 1)
+				{
+					response = getHTTPData(serverIn, true);
+					responseLength = Array.getLength(response);
+				}  else  {
+					responseLength = streamHTTPData(serverIn, clientOut, true);
+				}
+				
+				serverIn.close();
+				serverOut.close();
+			}
+			
+			// send the response back to the client, if we haven't already
+			if (debugLevel > 1)
+				clientOut.write(response, 0, responseLength);
+			
+			// if the user wants debug info, send them debug info; however,
+			// keep in mind that because we're using threads, the output won't
+			// necessarily be synchronous
+			if (debugLevel > 0)
+			{
+				long endTime = System.currentTimeMillis();
+				debugOut.println("Request from " + pSocket.getInetAddress().getHostAddress() + 
+									" on Port " + pSocket.getLocalPort() + 
+									" to host " + hostName + ":" + hostPort + 
+									"\n  (" + requestLength + " bytes sent, " + 
+									responseLength + " bytes returned, " + 
+									Long.toString(endTime - startTime) + " ms elapsed)");
+				debugOut.flush();
+			}
+			if (debugLevel > 1)
+			{
+				debugOut.println("REQUEST:\n" + (new String(request)));
+				debugOut.println("RESPONSE:\n" + (new String(response)));
+				debugOut.flush();
+			}
+			
+			// close all the client streams so we can listen again
+			clientOut.close();
+			clientIn.close();
+			pSocket.close();
+		}  catch (Exception e)  {
+			if (debugLevel > 0)
+				debugOut.println("Error in ProxyThread: " + e);
+			//e.printStackTrace();
+		}
+
+	}
+	
+	
+	private byte[] getHTTPData (InputStream in, boolean waitForDisconnect)
+	{
+		// get the HTTP data from an InputStream, and return it as
+		// a byte array
+		// the waitForDisconnect parameter tells us what to do in case
+		// the HTTP header doesn't specify the Content-Length of the
+		// transmission
+		StringBuffer foo = new StringBuffer("");
+		return getHTTPData(in, foo, waitForDisconnect);
+	}
+	
+	
+	private byte[] getHTTPData (InputStream in, StringBuffer host, boolean waitForDisconnect)
+	{
+		// get the HTTP data from an InputStream, and return it as
+		// a byte array, and also return the Host entry in the header,
+		// if it's specified -- note that we have to use a StringBuffer
+		// for the 'host' variable, because a String won't return any
+		// information when it's used as a parameter like that
+		ByteArrayOutputStream bs = new ByteArrayOutputStream();
+		streamHTTPData(in, bs, host, waitForDisconnect);
+		return bs.toByteArray();
+	}
+	
+
+	private int streamHTTPData (InputStream in, OutputStream out, boolean waitForDisconnect)
+	{
+		StringBuffer foo = new StringBuffer("");
+		return streamHTTPData(in, out, foo, waitForDisconnect);
+	}
+	
+	private int streamHTTPData (InputStream in, OutputStream out, 
+									StringBuffer host, boolean waitForDisconnect)
+	{
+		// get the HTTP data from an InputStream, and send it to
+		// the designated OutputStream
+		StringBuffer header = new StringBuffer("");
+		String data = "";
+		int responseCode = 200;
+		int contentLength = 0;
+		int pos = -1;
+		int byteCount = 0;
+
+		try
+		{
+			// get the first line of the header, so we know the response code
+			data = readLine(in);
+			if (data != null)
+			{
+				header.append(data + "\r\n");
+				pos = data.indexOf(" ");
+				if ((data.toLowerCase().startsWith("http")) && 
+					(pos >= 0) && (data.indexOf(" ", pos+1) >= 0))
+				{
+					String rcString = data.substring(pos+1, data.indexOf(" ", pos+1));
+					try
+					{
+						responseCode = Integer.parseInt(rcString);
+					}  catch (Exception e)  {
+						if (debugLevel > 0)
+							debugOut.println("Error parsing response code " + rcString);
+					}
+				}
+			}
+			
+			// get the rest of the header info
+			while ((data = readLine(in)) != null)
+			{
+				// the header ends at the first blank line
+				if (data.length() == 0)
+					break;
+				header.append(data + "\r\n");
+				
+				// check for the Host header
+				pos = data.toLowerCase().indexOf("host:");
+				if (pos >= 0)
+				{
+					host.setLength(0);
+					host.append(data.substring(pos + 5).trim());
+				}
+				
+				// check for the Content-Length header
+				pos = data.toLowerCase().indexOf("content-length:");
+				if (pos >= 0)
+					contentLength = Integer.parseInt(data.substring(pos + 15).trim());
+			}
+			
+			// add a blank line to terminate the header info
+			header.append("\r\n");
+			
+			// convert the header to a byte array, and write it to our stream
+			out.write(header.toString().getBytes(), 0, header.length());
+			
+			// if the header indicated that this was not a 200 response,
+			// just return what we've got if there is no Content-Length,
+			// because we may not be getting anything else
+			if ((responseCode != 200) && (contentLength == 0))
+			{
+				out.flush();
+				return header.length();
+			}
+
+			// get the body, if any; we try to use the Content-Length header to
+			// determine how much data we're supposed to be getting, because 
+			// sometimes the client/server won't disconnect after sending us
+			// information...
+			if (contentLength > 0)
+				waitForDisconnect = false;
+			
+			if ((contentLength > 0) || (waitForDisconnect))
+			{
+				try {
+					byte[] buf = new byte[4096];
+					int bytesIn = 0;
+					while ( ((byteCount < contentLength) || (waitForDisconnect)) 
+							&& ((bytesIn = in.read(buf)) >= 0) )
+					{
+						out.write(buf, 0, bytesIn);
+						byteCount += bytesIn;
+					}
+				}  catch (Exception e)  {
+					String errMsg = "Error getting HTTP body: " + e;
+					if (debugLevel > 0)
+						debugOut.println(errMsg);
+					//bs.write(errMsg.getBytes(), 0, errMsg.length());
+				}
+			}
+		}  catch (Exception e)  {
+			if (debugLevel > 0)
+				debugOut.println("Error getting HTTP data: " + e);
+		}
+		
+		//flush the OutputStream and return
+		try  {  out.flush();  }  catch (Exception e)  {}
+		return (header.length() + byteCount);
+	}
+	
+	
+	private String readLine (InputStream in)
+	{
+		// reads a line of text from an InputStream
+		StringBuffer data = new StringBuffer("");
+		int c;
+		
+		try
+		{
+			// if we have nothing to read, just return null
+			in.mark(1);
+			if (in.read() == -1)
+				return null;
+			else
+				in.reset();
+			
+			while ((c = in.read()) >= 0)
+			{
+				// check for an end-of-line character
+				if ((c == 0) || (c == 10) || (c == 13))
+					break;
+				else
+					data.append((char)c);
+			}
+		
+			// deal with the case where the end-of-line terminator is \r\n
+			if (c == 13)
+			{
+				in.mark(1);
+				if (in.read() != 10)
+					in.reset();
+			}
+		}  catch (Exception e)  {
+			if (debugLevel > 0)
+				debugOut.println("Error getting header: " + e);
+		}
+		
+		// and return what we have
+		return data.toString();
+	}
+	
+}
+
diff --git a/Orbot/src/org/torproject/android/SocksClient.java b/Orbot/src/org/torproject/android/SocksClient.java
new file mode 100644
index 00000000..188ebc1e
--- /dev/null
+++ b/Orbot/src/org/torproject/android/SocksClient.java
@@ -0,0 +1,129 @@
+/* Copyright (c) 2009, Nathan Freitas, The Guardian Project - http://openideals.com/guardian */
+/* See LICENSE for licensing information */
+/** SOCKS aware echo client*/
+
+package org.torproject.android;
+
+import java.io.*;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+import net.sourceforge.jsocks.socks.*;
+
+
+public class SocksClient implements Runnable {
+  
+   private int port;
+   private InetAddress hostIP;
+
+   private Socket ss;
+   private InputStream in;
+   private OutputStream out;
+
+   private static final int BUF_SIZE = 1024;
+
+   public SocksClient(String host,int port) 
+	  throws IOException,UnknownHostException,SocksException{
+      this.port = port;
+
+      ss = new SocksSocket(host, port);
+      out = ss.getOutputStream();
+      in  = ss.getInputStream();
+      System.out.println("Connected...");
+      System.out.println("TO: "+host+":"+port);
+      System.out.println("ViaProxy: "+ss.getLocalAddress().getHostAddress()
+                                 +":"+ss.getLocalPort());
+
+   }
+
+   public void close()throws IOException{
+     ss.close();
+   }
+   public void send(String s) throws IOException{
+      out.write(s.getBytes());
+   }
+
+   public void run(){
+      byte[] buf = new byte[1024];
+      int bytes_read;
+      try{
+	  while((bytes_read = in.read(buf)) > 0){
+	     System.out.write(buf,0,bytes_read);
+	  }
+      }catch(IOException io_ex){
+	 io_ex.printStackTrace();
+      }
+   }
+
+   public static void usage(){
+      System.err.print(
+      "Usage: java SocksTest host port [socksHost socksPort]\n");
+   }
+
+
+   public static void main(String args[]){
+      int port;
+      String host;
+      int proxyPort;
+      String proxyHost;
+
+      if(args.length > 1 && args.length < 5){
+	 try{
+
+	     host = args[0];
+	     port = Integer.parseInt(args[1]);
+
+	     proxyPort =(args.length > 3)? Integer.parseInt(args[3])	     
+	                                 : TorConstants.PORT_SOCKS;
+
+	     host = args[0];
+	     proxyHost =(args.length > 2)? args[2]
+	                                 : TorConstants.IP_LOCALHOST;
+
+	     Proxy.setDefaultProxy(proxyHost,proxyPort,"KOUKY001");
+	     //Proxy.setDefaultProxy(proxyHost,proxyPort);
+	     InetRange inetRange = new InetRange();
+	     inetRange.add(InetAddress.getByName("localhost"));
+	     Proxy.getDefaultProxy().setDirect(inetRange);
+
+
+	     SocksClient st = new SocksClient(host,port);
+	     Thread thread = new Thread(st);
+	     thread.start();
+
+	     BufferedReader in = new BufferedReader(
+				 new InputStreamReader(System.in));
+             String s;
+
+             s = in.readLine();
+	     while(s != null){
+                st.send(s+"\r\n");
+		//try{
+		   //Thread.currentThread().sleep(10);
+		//}catch(InterruptedException i_ex){
+		//}
+                s = in.readLine();
+	     }
+	     st.close();
+	     System.exit(1);
+
+	 }catch(SocksException s_ex){
+	   System.err.println("SocksException:"+s_ex);
+	   s_ex.printStackTrace();
+	   System.exit(1); 
+	 }catch(IOException io_ex){
+	   io_ex.printStackTrace();
+	   System.exit(1);
+	 }catch(NumberFormatException num_ex){
+	   usage();
+	   num_ex.printStackTrace();
+	   System.exit(1);
+	 }
+
+      }else{
+	usage();
+      }
+   }
+
+}//End of class
diff --git a/Orbot/src/org/torproject/android/TorBinaryInstaller.java b/Orbot/src/org/torproject/android/TorBinaryInstaller.java
new file mode 100644
index 00000000..e69af7b1
--- /dev/null
+++ b/Orbot/src/org/torproject/android/TorBinaryInstaller.java
@@ -0,0 +1,160 @@
+/* Copyright (c) 2009, Nathan Freitas, The Guardian Project - http://openideals.com/guardian */
+/* See LICENSE for licensing information */
+
+package org.torproject.android;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import android.util.Log;
+
+public class TorBinaryInstaller implements TorConstants {
+
+	private final static String LOG_TAG = "Tor";
+
+	
+	public TorBinaryInstaller ()
+	{
+	}
+	
+	/*
+	 * Start the binary installation if the file doesn't exist or is forced
+	 */
+	public void start (boolean force)
+	{
+		boolean binaryExists = new File(TOR_BINARY_INSTALL_PATH).exists();
+		
+		Log.i(LOG_TAG,"Tor binary exists=" + binaryExists);
+		
+		if (!binaryExists || force)
+			installFromZip ();
+		
+	}
+	
+	/*
+	 * Extract the Tor binary from the APK file using ZIP
+	 */
+	private void installFromZip ()
+	{
+		
+		try
+		{
+			ZipFile zip = new ZipFile(APK_PATH);
+	
+			ZipEntry zipen = zip.getEntry(TOR_BINARY_ZIP_KEY);
+			streamToFile(zip.getInputStream(zipen),TOR_BINARY_INSTALL_PATH);
+			
+			zipen = zip.getEntry(TORRC_ZIP_KEY);
+			streamToFile(zip.getInputStream(zipen),TORRC_INSTALL_PATH);
+			
+			zip.close();
+			
+			Log.i(LOG_TAG,"SUCCESS: unzipped tor binary from apk");
+	
+		}
+		catch (IOException ioe)
+		{
+			Log.i(LOG_TAG,"FAIL: unable to unzip tor binary from apk",ioe);
+		
+		}
+	}
+	
+	/*
+	 * Write the inputstream contents to the file
+	 */
+    private static void streamToFile(InputStream stm, String targetFilename)
+
+    {
+
+        FileOutputStream stmOut = null;
+
+        byte[] buffer = new byte[FILE_WRITE_BUFFER_SIZE];
+
+        int bytecount;
+
+       
+        File outFile = new File(targetFilename);
+        
+        try {
+            outFile.createNewFile();
+
+        	stmOut = new FileOutputStream(outFile);
+        }
+
+        catch (java.io.IOException e)
+
+        {
+
+        	Log.i(LOG_TAG,"Error opening output file " + targetFilename,e);
+
+        	return;
+        }
+
+       
+
+        try
+
+        {
+
+            while ((bytecount = stm.read(buffer)) > 0)
+
+            {
+
+                stmOut.write(buffer, 0, bytecount);
+
+            }
+
+            stmOut.close();
+
+        }
+
+        catch (java.io.IOException e)
+
+        {
+
+            Log.i(LOG_TAG,"Error writing output file '" + targetFilename + "': " + e.toString());
+
+            return;
+
+        }
+
+    }
+	
+    //copy the file from inputstream to File output - alternative impl
+	public void copyFile (InputStream is, File outputFile)
+	{
+		
+		try {
+			outputFile.createNewFile();
+			DataOutputStream out = new DataOutputStream(new FileOutputStream(outputFile));
+			DataInputStream in = new DataInputStream(is);
+			
+			int b;
+			byte[] data = new byte[1024];
+			
+			while ((b = in.read(data)) != -1) {
+				out.write(data);
+			}
+			//
+			out.flush();
+			out.close();
+			in.close();
+			// chmod?
+			
+			
+			
+		} catch (IOException ex) {
+			Log.e(LOG_TAG, "error copying binary", ex);
+		}
+
+	}
+	
+	
+
+}
diff --git a/Orbot/src/org/torproject/android/TorConstants.java b/Orbot/src/org/torproject/android/TorConstants.java
new file mode 100644
index 00000000..92b34efb
--- /dev/null
+++ b/Orbot/src/org/torproject/android/TorConstants.java
@@ -0,0 +1,75 @@
+/* Copyright (c) 2009, Nathan Freitas, The Guardian Project - http://openideals.com/guardian */
+/* See LICENSE for licensing information */
+
+package org.torproject.android;
+
+public interface TorConstants {
+
+	//home directory of Android application
+	public final static String TOR_HOME = "/data/data/org.torproject.android/";
+
+	//name of the tor C binary
+	public final static String TOR_BINARY_ASSET_KEY = "tor";	
+	
+	//path to install the Tor binary too
+	public final static String TOR_BINARY_INSTALL_PATH = TOR_HOME + TOR_BINARY_ASSET_KEY;
+	
+	//key of the tor binary in the Zip file
+	public final static String TOR_BINARY_ZIP_KEY = "assets/" + TOR_BINARY_ASSET_KEY;
+	
+	//torrc file name
+	public final static String TORRC_ASSET_KEY = "torrc";
+	
+	//path to install torrc to within the android app data folder
+	public final static String TORRC_INSTALL_PATH = TOR_HOME + TORRC_ASSET_KEY;
+	
+	//key of the torrc file in the Zip file
+	public final static String TORRC_ZIP_KEY = "assets/" + TORRC_ASSET_KEY;
+
+	//where to send the notices log
+	public final static String TOR_LOG_PATH = TOR_HOME + "notices.log";
+	
+	//control port cookie path
+	public final static String TOR_CONTROL_AUTH_COOKIE = TOR_HOME + "data/control_auth_cookie";
+
+	//how to launch tor
+	public final static String TOR_COMMAND_LINE_ARGS = "-f " + TORRC_INSTALL_PATH;
+	
+	//various console cmds
+	public final static String SHELL_CMD_CHMOD = "/system/bin/chmod";
+	public final static String SHELL_CMD_KILL = "/system/bin/kill";
+	public final static String SHELL_CMD_RM = "/system/bin/rm";
+	public final static String SHELL_CMD_PS = "ps";
+	public final static String CHMOD_EXE_VALUE = "777";
+	
+	//path of the installed APK file
+	public final static String APK_PATH = "/data/app/org.torproject.android.apk";
+	
+	//path to check Tor against
+	public final static String URL_TOR_CHECK = "http://check.torproject.org";
+	
+	public final static int FILE_WRITE_BUFFER_SIZE = 2048;
+	
+	//HTTP Proxy server port
+	public final static int PORT_HTTP = 8118; //just like Privoxy!
+	
+	//Socks port client connects to, server is the Tor binary
+	public final static int PORT_SOCKS = 9050;
+	
+	//what is says!
+	public final static String IP_LOCALHOST = "127.0.0.1";
+	public final static int TOR_CONTROL_PORT = 9051;
+	public final static int UPDATE_TIMEOUT = 3000;
+	
+	public final static String DEFAULT_HOME_PAGE = "file:///android_asset/help.html";// "http://check.torproject.org";
+	
+	//status to communicate state
+    public final static int STATUS_OFF = 0;
+    public final static int STATUS_ON = 1;
+    public final static int STATUS_STARTING_UP = 2;
+    public final static int STATUS_SHUTTING_DOWN = 3;
+    
+    //control port 
+    public final static String TOR_CONTROL_PORT_MSG_BOOTSTRAP_DONE = "Bootstrapped 100%";
+    
+}
diff --git a/Orbot/src/org/torproject/android/TorControlPanel.java b/Orbot/src/org/torproject/android/TorControlPanel.java
new file mode 100644
index 00000000..546cc00b
--- /dev/null
+++ b/Orbot/src/org/torproject/android/TorControlPanel.java
@@ -0,0 +1,587 @@
+/* Copyright (c) 2009, Nathan Freitas, The Guardian Project - http://openideals.com/guardian */
+/* See LICENSE for licensing information */
+
+package org.torproject.android;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.List;
+
+
+import net.freehaven.tor.control.EventHandler;
+
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.webkit.JsResult;
+import android.webkit.WebChromeClient;
+import android.webkit.WebSettings;
+import android.webkit.WebView;
+import android.widget.Button;
+import android.widget.ImageView;
+import android.widget.TextView;
+import android.widget.Toast;
+
+public class TorControlPanel extends Activity implements OnClickListener, TorConstants, EventHandler
+{
+	
+	private final static String TAG = "Tor";
+	
+	private static Intent torService = null;
+	
+	private boolean updateLog = false;
+	private boolean updateStatus = false;
+	
+	private TextView lblStatus = null;
+	private ImageView imgStatus = null;
+	private String txtStatus = "";
+	private int torStatus = STATUS_OFF;
+	
+	private Thread threadStatus = null;
+	
+    private WebView mWebView;
+
+	private int currentView = 0;
+	
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+    	setTheme(android.R.style.Theme_Black);
+
+        
+        showMain();
+
+      
+    }
+    
+    
+    public boolean onCreateOptionsMenu(Menu menu) {
+        super.onCreateOptionsMenu(menu);
+        
+        MenuItem mItem = menu.add(0, 1, Menu.NONE, "Home");
+        MenuItem mItem2 = menu.add(0, 2, Menu.NONE, "Settings");
+        MenuItem mItem3 = menu.add(0, 3, Menu.NONE, "Log");
+       MenuItem mItem4 = menu.add(0, 4, Menu.NONE, "Help");
+       
+      mItem.setIcon(R.drawable.ic_menu_home);
+       mItem2.setIcon(R.drawable.ic_menu_register);
+       mItem3.setIcon(R.drawable.ic_menu_reports);
+       mItem4.setIcon(R.drawable.ic_menu_about);
+       
+        return true;
+    }
+    
+    /* (non-Javadoc)
+	 * @see android.app.Activity#onMenuItemSelected(int, android.view.MenuItem)
+	 */
+	@Override
+	public boolean onMenuItemSelected(int featureId, MenuItem item) {
+		
+		super.onMenuItemSelected(featureId, item);
+		
+		if (item.getItemId() == 1)
+		{
+			this.showMain();
+		}
+		else if (item.getItemId() == 2)
+		{
+			this.showSettings();
+		}
+		else if (item.getItemId() == 3)
+		{
+			this.showMessageLog();
+		}
+		else if (item.getItemId() == 4)
+		{
+			this.showWeb(DEFAULT_HOME_PAGE);
+		}
+		
+        return true;
+	}
+	
+	public boolean onKeyDown(int keyCode, KeyEvent event){
+		if(keyCode==KeyEvent.KEYCODE_BACK){
+			if(currentView != R.layout.layout_main){
+					
+					showMain ();
+					
+					return true;
+			}
+			else{
+				return super.onKeyDown(keyCode, event);
+			}
+		}
+	
+		return super.onKeyDown(keyCode, event);
+		
+	}
+ 
+    /* (non-Javadoc)
+	 * @see android.app.Activity#onPause()
+	 */
+	@Override
+	protected void onPause() {
+		// TODO Auto-generated method stub
+		super.onPause();
+		
+		TorService.setStatus(torStatus);
+	}
+
+
+
+
+	/* (non-Javadoc)
+	 * @see android.app.Activity#onResume()
+	 */
+	@Override
+	protected void onResume() {
+		// TODO Auto-generated method stub
+		super.onResume();
+		
+		torStatus = TorService.getStatus();
+		
+		updateStatus ();
+	}
+
+
+
+
+	/* (non-Javadoc)
+	 * @see android.app.Activity#onStart()
+	 */
+	@Override
+	protected void onStart() {
+		// TODO Auto-generated method stub
+		super.onStart();
+		
+		torStatus = TorService.getStatus();
+
+		
+		updateStatus ();
+	}
+
+
+
+
+	/* (non-Javadoc)
+	 * @see android.app.Activity#onStop()
+	 */
+	@Override
+	protected void onStop() {
+		// TODO Auto-generated method stub
+		super.onStop();
+		
+		TorService.setStatus(torStatus);
+	}
+
+
+
+	/*
+	 * Show the main form UI
+	 */
+	private void showMain ()
+    {
+		updateLog = false;
+		updateStatus = true;
+		
+		currentView = R.layout.layout_main;
+    	setContentView(currentView);
+    	
+    	findViewById(R.id.imgStatus).setOnClickListener(this);
+    	
+    	lblStatus = (TextView)findViewById(R.id.lblStatus);
+    	imgStatus = (ImageView)findViewById(R.id.imgStatus);
+    	
+    	updateStatus();
+    }
+	
+	private void showWeb (String url)
+	{
+		
+		
+		currentView =R.layout.layout_web;
+		 setContentView(currentView);
+	        
+	        mWebView = (WebView) findViewById(R.id.webview);
+
+	        WebSettings webSettings = mWebView.getSettings();
+	        webSettings.setSavePassword(false);
+	        webSettings.setSaveFormData(false);
+	        webSettings.setJavaScriptEnabled(true);
+	      
+
+	        mWebView.setWebChromeClient(new MyWebChromeClient());
+	        
+	        mWebView.loadUrl(url);
+	
+		
+	}
+	
+	
+	/*
+	 * Show the message log UI
+	 */
+	private void showMessageLog ()
+	{
+		currentView = R.layout.layout_log;
+		setContentView(currentView);
+		((Button)findViewById(R.id.btnLogClear)).setOnClickListener(this);
+
+		updateStatus = false;
+		updateLog = true;
+		
+		Thread thread = new Thread ()
+		{
+			public void run ()
+			{
+				
+				while (updateLog)
+				{
+					
+					try {
+						Thread.sleep(UPDATE_TIMEOUT);
+					} catch (InterruptedException e) {
+						// TODO Auto-generated catch block
+						e.printStackTrace();
+					}
+					
+					handler.sendEmptyMessage(0);
+				}
+			}
+		};
+		
+		thread.start();
+		
+	}
+	
+	/*
+	 * Load the Tor log and display it in a text field
+	 */
+	private void updateMessageLog ()
+	{
+				
+		TextView tvLog = (TextView)findViewById(R.id.messageLog);
+    	
+		if (tvLog != null)
+		{
+			String output = loadTextFile(TOR_LOG_PATH);
+		
+			tvLog.setText(output);
+		}
+	
+	}
+	
+	/*
+	 * Handle to reload Tor debug log every few seconds while viewing it
+	 */
+	private Handler handler = new Handler() {
+	
+	        @Override
+		    public void handleMessage(Message msg) {
+	
+	        	updateMessageLog ();
+	
+	        }
+	
+	    };
+	    
+	    /*
+		 * Handle to reload Tor debug log every few seconds while viewing it
+		 */
+		private Handler handlerStatus = new Handler() {
+		
+		        @Override
+			    public void handleMessage(Message msg) {
+		
+		        	updateStatus();
+		        	
+		        	// Toast.makeText(this,txtStatus, Toast.LENGTH_SHORT).show();
+		        }
+		
+		    };
+		
+	
+    /*
+     * Load the basic settings application to display torrc
+     * TODO: these needs to be improved into an actual form GUI
+     */
+	private void showSettings ()
+	{
+		updateStatus = false;
+		updateLog = false;
+		
+		currentView = R.layout.layout_settings;
+		setContentView(currentView);
+
+		
+		String output = loadTextFile(TORRC_INSTALL_PATH);
+
+		TextView tvSettings = (TextView)findViewById(R.id.textSettings);
+    	((Button)findViewById(R.id.btnSettingsSave)).setOnClickListener(this);
+		tvSettings.setText(output);
+		
+	}
+	
+	
+    /*
+     * Set the state of the running/not running graphic and label
+     */
+    public void updateStatus ()
+    {
+    	
+    	if (imgStatus != null)
+    	{
+    		
+	    	if (torStatus == STATUS_ON)
+	    	{
+	    		imgStatus.setImageResource(R.drawable.toron);
+	    		lblStatus.setText("ORbot is running\n- touch the bot to stop -");
+	    		updateStatus = false;
+	    	}
+	    	else if (torStatus == STATUS_STARTING_UP)
+	    	{
+	    		imgStatus.setImageResource(R.drawable.torstarting);
+	    		
+	    		lblStatus.setText("ORbot reports:\n\"" + txtStatus + "\"");
+	    		
+	    	
+	    	}
+	    	else if (torStatus == STATUS_SHUTTING_DOWN)
+	    	{
+	    		imgStatus.setImageResource(R.drawable.torstopping);
+	    		lblStatus.setText("ORbot is shutting down\nplease wait...");
+	    		
+	    	}
+	    	else
+	    	{
+	    		imgStatus.setImageResource(R.drawable.toroff);
+	    		lblStatus.setText("ORbot is not running\n- touch the bot to start -");
+	    		updateStatus = false;
+	    	}
+    	}
+    	
+        
+        
+    }
+  
+    /*
+     * (non-Javadoc)
+     * @see android.view.View.OnClickListener#onClick(android.view.View)
+     */
+	public void onClick(View view) {
+		
+		// the start button
+		if (view.getId()==R.id.imgStatus)
+		{
+			//if Tor binary is not running, then start the service up
+			if (TorService.getStatus()==STATUS_OFF)
+			{
+				torStatus = STATUS_STARTING_UP;
+				txtStatus = "Connecting to Tor...";
+				updateStatus();
+				
+				startTorService ();
+				
+				
+			}
+			else
+			{
+				
+				torStatus = STATUS_SHUTTING_DOWN;
+				updateStatus();
+				
+				stopService(torService);
+				
+				torStatus = STATUS_OFF;
+				
+				updateStatus();
+			}
+			
+		}
+		else if (view.getId()==R.id.btnLogClear)
+		{
+		
+			saveTextFile(TOR_LOG_PATH,"");
+		}
+		else if (view.getId()==R.id.btnSettingsSave)
+		{
+		
+			TextView tvSettings = (TextView)findViewById(R.id.textSettings);
+			String newSettings =  tvSettings.getText().toString();
+			saveTextFile(TORRC_INSTALL_PATH, newSettings);
+			
+		}
+		
+		
+	}
+	
+	private void startTorService ()
+	{
+		if (torService == null)
+		{
+			torService = new Intent(this, TorService.class);
+			//torService.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+			TorService.setActivity(this);
+		}
+		
+		startService(torService);
+		
+	
+		
+	}
+	
+	/*
+	 * Load the log file text
+	 */
+	 public static String loadTextFile (String path)
+	    {
+	    	String line = null;
+	    
+	    	StringBuffer out = new StringBuffer();
+	    	
+	    	try {
+		    	BufferedReader reader = new BufferedReader((new FileReader(new File(path))));
+
+				while ((line = reader.readLine()) != null)
+				{
+					out.append(line);
+					out.append('\n');
+					
+				}
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+			
+			return out.toString();
+	    	
+	    }
+	 
+
+		/*
+		 * Load the log file text
+		 */
+		 public static boolean saveTextFile (String path, String contents)
+		    {
+			 	
+		    	try {
+		    		
+		    		 FileWriter writer = new FileWriter( path, false );
+                     writer.write( contents );
+                     
+                     writer.close();
+
+                     
+		    		
+		    		return true;
+			    	
+				} catch (IOException e) {
+				//	Log.i(TAG, "error writing file: " + path, e);
+						e.printStackTrace();
+					return false;
+				}
+				
+				
+		    	
+		    }
+	
+
+	@Override
+	public void bandwidthUsed(long read, long written) {
+		Log.i(TAG,"BW Used: read=" + read + " written=" + written);
+		
+	}
+
+
+	@Override
+	public void circuitStatus(String status, String circID, String path) {
+		Log.i(TAG,"CircuitStatus=" + status + ": " + circID);
+		
+	}
+
+
+	@Override
+	public void message(String severity, String msg) {
+		
+        	 // Log.println(priority, tag, msg)("["+severity+"] "+msg);
+              //Toast.makeText(, text, duration)
+        //      Toast.makeText(ACTIVITY, severity + ": " + msg, Toast.LENGTH_SHORT);
+              Log.i(TAG, "[Tor Control Port] " + severity + ": " + msg);
+              
+              if (msg.indexOf(TOR_CONTROL_PORT_MSG_BOOTSTRAP_DONE)!=-1)
+              {
+            	  torStatus = STATUS_ON;
+            	  
+            	  
+            	  
+            	  //setupWebProxy(true);
+
+              }
+              
+      
+              txtStatus = msg;
+              handlerStatus.sendEmptyMessage(0);
+	
+             
+	}
+
+
+	@Override
+	public void newDescriptors(List<String> orList) {
+		// TODO Auto-generated method stub
+		
+	}
+
+
+	@Override
+	public void orConnStatus(String status, String orName) {
+		
+		Log.i(TAG,"OrConnStatus=" + status + ": " + orName);
+		
+	}
+
+
+	@Override
+	public void streamStatus(String status, String streamID, String target) {
+		Log.i(TAG,"StreamStatus=" + status + ": " + streamID);
+		
+	}
+
+
+	@Override
+	public void unrecognized(String type, String msg) {
+		Log.i(TAG,"unrecognized log=" + type + ": " + msg);
+		
+	}
+	 
+	
+	/**
+     * Provides a hook for calling "alert" from javascript. Useful for
+     * debugging your javascript.
+     */
+    final class MyWebChromeClient extends WebChromeClient {
+        @Override
+        public boolean onJsAlert(WebView view, String url, String message, JsResult result) {
+            Log.d(TAG, message);
+            result.confirm();
+            return true;
+        }
+        
+        
+    }
+	
+}
\ No newline at end of file
diff --git a/Orbot/src/org/torproject/android/TorService.java b/Orbot/src/org/torproject/android/TorService.java
new file mode 100644
index 00000000..bb1cca97
--- /dev/null
+++ b/Orbot/src/org/torproject/android/TorService.java
@@ -0,0 +1,617 @@
+/* Copyright (c) 2009, Nathan Freitas, The Guardian Project - http://openideals.com/guardian */
+/* See LICENSE for licensing information */
+
+package org.torproject.android;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.ConnectException;
+import java.net.Socket;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import net.freehaven.tor.control.EventHandler;
+import net.freehaven.tor.control.NullEventHandler;
+import net.freehaven.tor.control.TorControlConnection;
+import net.sourceforge.jsocks.socks.Proxy;
+import android.app.Service;
+import android.content.Intent;
+import android.os.IBinder;
+import android.util.Log;
+import android.widget.Toast;
+
+public class TorService extends Service implements TorConstants
+{
+	
+	private static TorControlPanel ACTIVITY = null;
+	
+	private final static String TAG = "TorService";
+	
+	private static HttpProxy webProxy = null;
+	
+	private static int currentStatus = STATUS_OFF;
+	
+	private TorControlConnection conn = null;
+	
+	private Timer timer = new Timer ();
+	private final static int UPDATE_INTERVAL = 60000;
+	
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate() {
+    	super.onCreate();
+       
+    	Log.i(TAG,"TorService: onCreate");
+    	
+    	 timer.scheduleAtFixedRate(
+    		      new TimerTask() {
+    		        public void run() {
+    		         
+    		        	//do nothing
+    		        //	Log.i(TAG,"TorService: task is running");
+    		        }
+    		      },
+    		      0,
+    		      UPDATE_INTERVAL);
+    	 
+    	 
+    	 int procId = findProcessId(TorConstants.TOR_BINARY_INSTALL_PATH);
+
+ 		if (procId != -1)
+ 		{
+ 			Log.i(TAG,"Found existing Tor process");
+ 			
+ 			try {
+ 				currentStatus = STATUS_STARTING_UP;
+				
+ 				initControlConnection();
+				
+				getTorStatus();
+				
+				if (webProxy != null)
+				{
+					if (webProxy.isRunning())
+					{
+						//do nothing
+						Log.i(TAG, "Web Proxy is already running");
+					}
+					else
+					{
+						//do nothing
+						Log.i(TAG, "killing Web Proxy");
+						webProxy.closeSocket();
+						setupWebProxy(true);
+					}
+				}
+				else  //do something
+				{
+					setupWebProxy(true);
+				}
+				
+				currentStatus = STATUS_ON;
+				
+			} catch (RuntimeException e) {
+				Log.i(TAG,"Unable to connect to existing Tor instance,",e);
+				currentStatus = STATUS_OFF;
+				this.stopTor();
+				
+			} catch (Exception e) {
+				Log.i(TAG,"Unable to connect to existing Tor instance,",e);
+				currentStatus = STATUS_OFF;
+				this.stopTor();
+				
+			}
+ 		}
+    	 
+    }
+    
+
+    /* (non-Javadoc)
+	 * @see android.app.Service#onLowMemory()
+	 */
+	@Override
+	public void onLowMemory() {
+		// TODO Auto-generated method stub
+		super.onLowMemory();
+	}
+
+
+	/* (non-Javadoc)
+	 * @see android.app.Service#onUnbind(android.content.Intent)
+	 */
+	@Override
+	public boolean onUnbind(Intent intent) {
+		// TODO Auto-generated method stub
+		return super.onUnbind(intent);
+	}
+
+
+	public static int getStatus ()
+    {
+    	
+    	return currentStatus;
+    	
+    }
+    
+	public static void setStatus (int newStatus)
+	{
+		currentStatus = newStatus;
+	}
+   
+    
+    /* (non-Javadoc)
+	 * @see android.app.Service#onRebind(android.content.Intent)
+	 */
+	@Override
+	public void onRebind(Intent intent) {
+		// TODO Auto-generated method stub
+		super.onRebind(intent);
+		
+		  Log.i(TAG,"on rebind");
+	}
+
+
+	/* (non-Javadoc)
+	 * @see android.app.Service#onStart(android.content.Intent, int)
+	 */
+	@Override
+	public void onStart(Intent intent, int startId) {
+		// TODO Auto-generated method stub
+		super.onStart(intent, startId);
+		
+	     Log.i(TAG,"onStart called");
+	     
+		   initTor();
+		   
+		   setupWebProxy (true);
+	}
+
+	
+    public void onDestroy ()
+    {
+    	super.onDestroy();
+    	
+    	Log.i(TAG,"onDestroy called");
+	     
+    	if (timer != null) timer.cancel();
+
+    	stopTor();
+    }
+    
+    private void stopTor ()
+    {
+    	currentStatus = STATUS_SHUTTING_DOWN;
+    	
+    	setupWebProxy(false);  
+    			
+		killTorProcess ();
+				
+		currentStatus = STATUS_OFF;
+    	
+    }
+    
+ 
+    public static void setActivity(TorControlPanel activity) {
+    	ACTIVITY = activity;
+    }
+   
+    private void setupWebProxy (boolean enabled)
+    {
+    	if (enabled)
+    	{
+    		
+    		if (webProxy != null)
+    		{
+    			webProxy.closeSocket();
+    			webProxy = null;
+    			
+    		}
+    		
+	    	Log.i(TAG,"Starting up Web Proxy on port: " + PORT_HTTP);
+	    	//httpd s
+	    	webProxy = new HttpProxy(PORT_HTTP);
+	    	webProxy.setDoSocks(true);
+	    	webProxy.start();
+	    	
+	    	//socks
+	    	try
+	    	{
+	    		
+	    		Proxy.setDefaultProxy(IP_LOCALHOST,PORT_SOCKS);
+	    		
+	    		
+	    	}
+	    	catch (Exception e)
+	    	{
+	    		Log.w(TAG,e.getMessage());
+	    	}
+	    	
+	    	Log.i(TAG,"Web Proxy enabled...");
+
+    	
+	    	//Settings.System.putString(getContentResolver(), Settings.System.HTTP_PROXY, proxySetting);//enable proxy
+	    	//	Settings.Secure.putString(getContentResolver(), Settings.Secure.HTTP_PROXY, proxySetting);//enable proxy
+    		
+    	}
+    	else
+    	{
+	    	//Log.i(TAG,"Turning off Socks/Tor routing on Web Proxy");
+
+    		if (webProxy != null)
+    		{
+    			//logNotice("Tor is disabled - browsing is not anonymous!");
+    			//webProxy.setDoSocks(false);
+    			
+    			webProxy.closeSocket();
+    			webProxy = null;
+    			Log.i(TAG,"WebProxy ServerSocket closed");
+    		}
+    	}
+    	
+    }
+    
+    public void reloadConfig ()
+    {
+    	try
+		{
+	    	if (conn == null)
+			{
+				initControlConnection ();
+			}
+		
+			if (conn != null)
+			{
+				 conn.signal("RELOAD");
+			}
+		}
+    	catch (Exception e)
+    	{
+    		Log.i(TAG,"Unable to reload configuration",e);
+    	}
+    }
+    
+    private void killTorProcess ()
+    {
+		
+    	if (conn != null)
+		{
+			try {
+				Log.i(TAG,"sending SHUTDOWN signal");
+				conn.signal("SHUTDOWN");
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				Log.i(TAG,"error shutting down Tor via connection",e);
+			}
+			conn = null;
+		}
+    	
+    	try {
+			Thread.sleep(500);
+		} catch (InterruptedException e) {
+			
+		}
+    	
+		int procId = findProcessId(TorConstants.TOR_BINARY_INSTALL_PATH);
+
+		while (procId != -1)
+		{
+			
+			Log.i(TAG,"Found Tor PID=" + procId + " - killing now...");
+			
+			doCommand(SHELL_CMD_KILL, procId + "");
+
+			procId = findProcessId(TorConstants.TOR_BINARY_INSTALL_PATH);
+		}
+		
+		
+    }
+   
+    private static void logNotice (String msg)
+    {
+
+    	Log.i(TAG, msg);
+		
+    }
+    
+    private void checkBinary ()
+    {
+
+		boolean binaryExists = new File(TOR_BINARY_INSTALL_PATH).exists();
+		
+		if (!binaryExists)
+		{
+			killTorProcess ();
+			
+			TorBinaryInstaller installer = new TorBinaryInstaller(); 
+			installer.start(true);
+		
+			binaryExists = new File(TOR_BINARY_INSTALL_PATH).exists();
+    		if (binaryExists)
+    		{
+    			logNotice("Tor binary installed!");
+    			
+    		}
+    		else
+    		{
+    			logNotice("Tor binary install FAILED!");
+    			return;
+    		}
+		}
+		
+		Log.i(TAG,"Setting permission on Tor binary");
+		doCommand(SHELL_CMD_CHMOD, CHMOD_EXE_VALUE + ' ' + TOR_BINARY_INSTALL_PATH);
+    }
+    
+    public void initTor ()
+    {
+    	try {
+    		
+    		currentStatus = STATUS_STARTING_UP;
+
+    		killTorProcess ();
+    		
+    		checkBinary ();
+    		
+    		doCommand(SHELL_CMD_RM,TOR_LOG_PATH);
+    		
+    		Log.i(TAG,"Starting tor process");
+    		doCommand(TOR_BINARY_INSTALL_PATH, TOR_COMMAND_LINE_ARGS);
+		
+    		int procId = findProcessId(TorConstants.TOR_BINARY_INSTALL_PATH);
+
+    		if (procId == -1)
+    		{
+    			doCommand(TOR_BINARY_INSTALL_PATH, TOR_COMMAND_LINE_ARGS);
+    			procId = findProcessId(TorConstants.TOR_BINARY_INSTALL_PATH);
+    		}
+    		
+    		Log.i(TAG,"Tor process id=" + procId);
+    		
+    		currentStatus = STATUS_STARTING_UP;
+    		logNotice("Tor is starting up...");
+			
+			Thread.sleep(500);
+			initControlConnection ();
+		
+    	} catch (Exception e) {
+			
+			Log.w(TAG,"unable to start Tor Process",e);
+		
+			e.printStackTrace();
+			
+		}
+    	
+    }
+    
+    private static void logStream (InputStream is)
+    {
+    	BufferedReader reader = new BufferedReader(new InputStreamReader(is));
+    	String line = null;
+    
+    	
+    	try {
+			while ((line = reader.readLine()) != null)
+			{
+				Log.i(TAG, line);
+				
+			}
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		
+    	
+    }
+    
+	
+	
+	@Override
+	public IBinder onBind(Intent arg0) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+	
+	public static int findProcessId(String command) 
+	{
+		int procId = -1;
+		
+		Runtime r = Runtime.getRuntime();
+		    	
+		Process procPs = null;
+		
+        try {
+            
+            procPs = r.exec(SHELL_CMD_PS);
+            
+            BufferedReader reader = new BufferedReader(new InputStreamReader(procPs.getInputStream()));
+            String line = null;
+            
+            while ((line = reader.readLine())!=null)
+            {
+            	if (line.indexOf(command)!=-1)
+            	{
+            		
+            		StringTokenizer st = new StringTokenizer(line," ");
+            		st.nextToken(); //proc owner
+            		
+            		procId = Integer.parseInt(st.nextToken().trim());
+            		
+            		break;
+            	}
+            }
+            
+        } catch (Exception e) {
+            Log.e(TAG, "error: " + e.getMessage(), e);
+        }
+        
+        return procId;
+
+	}
+	
+	public static Process doCommand(String command, String arg1) 
+	{
+		
+		Runtime r = Runtime.getRuntime();
+		    	
+		Process child = null;
+		
+        try {
+            if(child != null) {
+            	child.destroy();
+            	child = null;
+            }
+            
+            child = r.exec(command + ' ' + arg1);
+            
+            
+            
+        } catch (Exception e) {
+            Log.e(TAG, "error: " + e.getMessage());
+        }
+        
+        return child;
+
+	}
+	
+	public static String generateHashPassword ()
+	{
+		/*
+		PasswordDigest d = PasswordDigest.generateDigest();
+	      byte[] s = d.getSecret(); // pass this to authenticate
+	      String h = d.getHashedPassword(); // pass this to the Tor on startup.
+*/
+		return null;
+	}
+	
+	public void initControlConnection () throws Exception, RuntimeException
+	{
+			for (int i = 0; i < 50; i++)
+			{
+				try
+				{
+					Log.i(TAG,"Connecting to control port: " + TOR_CONTROL_PORT);
+					Socket s = new Socket(IP_LOCALHOST, TOR_CONTROL_PORT);
+			        conn = TorControlConnection.getConnection(s);
+			      //  conn.authenticate(new byte[0]); // See section 3.2
+			        
+			        Log.i(TAG,"SUCCESS connected to control port");
+			        
+			        //
+			        File fileCookie = new File(TOR_CONTROL_AUTH_COOKIE);
+			        byte[] cookie = new byte[(int)fileCookie.length()];
+			        new FileInputStream(new File(TOR_CONTROL_AUTH_COOKIE)).read(cookie);
+			        conn.authenticate(cookie);
+			        
+			        Log.i(TAG,"SUCCESS authenticated to control port");
+			        
+			        addEventHandler();
+			        
+			        break; //don't need to retry
+				}
+				catch (ConnectException ce)
+				{
+					Log.i(TAG,"Attempt " + i + ": Error connecting to control port; retrying...");
+					Thread.sleep(1000);
+				}	
+			}
+		
+		
+
+	}
+	
+	public void modifyConf () throws IOException
+	{
+	       // Get one configuration variable.
+	       List options = conn.getConf("contact");
+	       // Get a set of configuration variables.
+	      // List options = conn.getConf(Arrays.asList(new String[]{
+	           //   "contact", "orport", "socksport"}));
+	       // Change a single configuration variable
+	       conn.setConf("BandwidthRate", "1 MB");
+	       // Change several configuration variables
+	       conn.setConf(Arrays.asList(new String[]{
+	              "HiddenServiceDir /home/tor/service1",
+	              "HiddenServicePort 80",
+	       }));
+	       // Reset some variables to their defaults
+	       conn.resetConf(Arrays.asList(new String[]{
+	              "contact", "socksport"
+	       }));
+	       // Flush the configuration to disk.
+	       conn.saveConf();
+
+	}
+	
+	private void getTorStatus () throws IOException
+	{
+		try
+		{
+			 
+			
+			
+		
+			if (conn != null)
+			{
+				 // get a single value.
+			      
+			       // get several values
+			       
+			       if (currentStatus == STATUS_STARTING_UP)
+			       {
+				       //Map vals = conn.getInfo(Arrays.asList(new String[]{
+				         // "status/bootstrap-phase", "status","version"}));
+			
+				       String bsPhase = conn.getInfo("status/bootstrap-phase");
+				    //   Log.i(TAG, "bootstrap-phase: " + bsPhase);
+				       
+				       if (bsPhase.indexOf("PROGRESS=100")!=-1)
+				       {
+				    	   currentStatus = STATUS_ON;
+				       }
+			       }
+			       else
+			       {
+			    	 //  String status = conn.getInfo("status/circuit-established");
+			    	 //  Log.i(TAG, "status/circuit-established=" + status);
+			       }
+			}
+			else
+			{
+				currentStatus = STATUS_OFF;
+			}
+		}
+		catch (Exception e)
+		{
+			Log.i(TAG, "Unable to get Tor status from control port");
+		}
+		
+	}
+	
+	
+	public void addEventHandler () throws IOException
+	{
+	       // We extend NullEventHandler so that we don't need to provide empty
+	       // implementations for all the events we don't care about.
+	       // ...
+        Log.i(TAG,"adding control port event handler");
+
+		conn.setEventHandler(ACTIVITY);
+	    
+		conn.setEvents(Arrays.asList(new String[]{
+	          "ORCONN", "CIRC", "NOTICE", "ERR"}));
+	      // conn.setEvents(Arrays.asList(new String[]{
+	        //  "DEBUG", "INFO", "NOTICE", "WARN", "ERR"}));
+
+	    Log.i(TAG,"SUCCESS added control port event handler");
+
+	}
+}
\ No newline at end of file