Initial import

1 files changed, 203 insertions, 0 deletions

diff --git a/src/de/blinkt/openvpn/OpenVpnService.java b/src/de/blinkt/openvpn/OpenVpnService.java
new file mode 100644
index 00000000..e8174bcb
--- /dev/null
+++ b/src/de/blinkt/openvpn/OpenVpnService.java
@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package de.blinkt.openvpn;
+
+import java.io.IOException;
+import java.net.UnknownHostException;
+import java.util.Arrays;
+
+import android.app.PendingIntent;
+import android.content.Intent;
+import android.net.LocalSocket;
+import android.net.LocalSocketAddress;
+import android.net.VpnService;
+import android.os.Handler;
+import android.os.Message;
+import android.os.ParcelFileDescriptor;
+import android.util.Log;
+import android.widget.Toast;
+
+public class OpenVpnService extends VpnService implements Handler.Callback, Runnable {
+    private static final String TAG = "OpenVpnService";
+
+    private String[] mArgv;
+
+    private Handler mHandler;
+    private Thread mThread;
+
+    private ParcelFileDescriptor mInterface;
+
+    @Override
+    public void onRevoke() {
+    	managmentCommand("signal SIGINT\n");
+    	mThread=null;
+    	stopSelf();
+    };
+    
+	
+	public void managmentCommand(String cmd) {
+		LocalSocket mgmtsocket;
+		try {
+			byte[] buffer = new byte[400];
+			mgmtsocket = new LocalSocket();
+					
+			mgmtsocket.connect(new LocalSocketAddress(getCacheDir().getAbsolutePath() + "/" +  "mgmtsocket", 
+					LocalSocketAddress.Namespace.FILESYSTEM)); 
+			//mgmtsocket  = new Dat("127.0.0.1",OpenVPNClient.MANAGMENTPORT));
+			
+			//OutputStreamWriter outw = new OutputStreamWriter(mgmtsocket.getOutputStream());
+			mgmtsocket.getInputStream().read(buffer);
+			try {
+				Thread.sleep(1000);
+			} catch (InterruptedException e) {
+			}
+			//outw.write(cmd);
+			mgmtsocket.getOutputStream().write(cmd.getBytes());
+			//outw.flush();
+			try {
+				Thread.sleep(400);
+			} catch (InterruptedException e) {
+			}
+
+			mgmtsocket.close();
+		} catch (UnknownHostException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+    
+    
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        // The handler is only used to show messages.
+        if (mHandler == null) {
+            mHandler = new Handler(this);
+        }
+
+        // Stop the previous session by interrupting the thread.
+        if (mThread != null) {
+        	managmentCommand("signal SIGINT\n");
+            mThread.interrupt();
+        }
+
+        // Thread already running, reuse existing,  
+        
+        // Extract information from the intent.
+        String prefix = getPackageName();
+        mArgv = intent.getStringArrayExtra(prefix + ".ARGV");
+        
+
+        // Start a new session by creating a new thread.
+        mThread = new Thread(this, "OpenVPNThread");
+        mThread.start();
+        
+        if(intent.hasExtra(prefix +".PKCS12PASS"))
+        {
+        	try {
+        		String pkcs12password = intent.getStringExtra(prefix +".PKCS12PASS");
+				Thread.sleep(3000);
+				
+				managmentCommand("password 'Private Key' " + pkcs12password + "\n");
+			} catch (InterruptedException e) {
+			}
+        	
+        }
+        
+        
+        
+        return START_STICKY;
+    }
+
+    @Override
+    public void onDestroy() {
+        if (mThread != null) {
+        	managmentCommand("signal SIGINT\n");
+
+            mThread.interrupt();
+        }
+    }
+
+    @Override
+    public boolean handleMessage(Message message) {
+        if (message != null) {
+            Toast.makeText(this, message.what, Toast.LENGTH_SHORT).show();
+        }
+        return true;
+    }
+
+    @Override
+    public synchronized void run() {
+        try {
+            Log.i(TAG, "Starting o");
+
+            
+            OpenVPN.setCallback(this);
+
+
+            // We try to create the tunnel for several times. The better way
+            // is to work with ConnectivityManager, such as trying only when
+            // the network is avaiable. Here we just use a counter to keep
+            // things simple.
+            //for (int attempt = 0; attempt < 10; ++attempt) {
+                mHandler.sendEmptyMessage(R.string.connecting);
+
+                // Log argv
+                
+                OpenVPN.logMessage(0, "argv:" , Arrays.toString(mArgv));
+                
+                OpenVPN.startOpenVPNThreadArgs(mArgv);
+                
+                
+                
+                // Sleep for a while. This also checks if we got interrupted.
+                Thread.sleep(3000);
+            //}
+            Log.i(TAG, "Giving up");
+        } catch (Exception e) {
+            Log.e(TAG, "Got " + e.toString());
+        } finally {
+            try {
+                mInterface.close();
+            } catch (Exception e) {
+                // ignore	
+            }
+            mInterface = null;
+            
+
+            mHandler.sendEmptyMessage(R.string.disconnected);
+            Log.i(TAG, "Exiting");
+        }
+    }
+
+
+	public ParcelFileDescriptor openTun(String localip) {
+		// FIXME: hardcoded assumptions
+        Builder builder = new Builder();
+        builder.addRoute("0.0.0.0", 0);
+        builder.addAddress(localip, 24 );
+        builder.addDnsServer("131.234.137.23");
+        builder.addSearchDomain("blinkt.de");
+        builder.setSession("OpenVPN - " + localip);
+        Intent intent = new Intent(getBaseContext(),LogWindow.class);
+        PendingIntent startLW = PendingIntent.getActivity(getApplicationContext(), 0, intent, 0);
+        builder.setConfigureIntent(startLW);
+        mInterface = builder.establish();
+        return mInterface;
+
+	}
+}