summaryrefslogtreecommitdiff
path: root/src/de/blinkt/openvpn/OpenVPN.java
blob: 3e660bce411933ae88a6f5d6424678dc22de06af (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
package de.blinkt.openvpn;

import java.util.LinkedList;
import java.util.Vector;

import android.util.Log;

public class OpenVPN {
	private static OpenVpnService mOpenVpnService;
	private static final int MAXLOGENTRIES = 500;
	public static native int startOpenVPNThread();
	public static native int startOpenVPNThreadArgs(String argv[]);
	private static final String TAG = "OpenVpn";


	public static LinkedList<String> logbuffer = new LinkedList<String>();
	private static int counter=0;

	private static Vector<LogListener> logListener=new Vector<OpenVPN.LogListener>();
	private static String[] mBconfig;

	public interface LogListener {
		void newLog(String logmessage);
	}

	static {
		System.loadLibrary("crypto");
		System.loadLibrary("ssl");
		System.loadLibrary("lzo");
		System.loadLibrary("openvpn");
	}

	static void addRoute(String dest,String mask, String gw) {
		Log.i("openvpn" ,"Got Routing information " + dest + " " + mask + "  " + gw  );	
		mOpenVpnService.addRoute(dest,mask);
	}

	synchronized static void logMessage(int level,String prefix, String message)
	{
		logbuffer.addLast(prefix + " " + message);
		if(logbuffer.size()>MAXLOGENTRIES)
			logbuffer.removeFirst();

		// The garbage collector does not collect the String from native
		// but kills me for logging 100 messages with too many references :(
		// Force GC how and then to kill loose ends
		if(counter++ % 50==0) {
			System.gc();
		}

		for (LogListener ll : logListener) {
			ll.newLog(prefix + "  "  + message);
		}

	}

	synchronized static void clearLog() {
		logbuffer.clear();
	}

	synchronized static void addLogListener(LogListener ll){
		logListener.add(ll);
	}

	synchronized static void removeLogListener(LogListener ll) {
		logListener.remove(ll);
	}


	static void addInterfaceInfo(int mtu, String local, String netmask)
	{
		Log.i("openvpn","Got interface info M"  + mtu + " L: " + local + "NM: " + netmask);
		mOpenVpnService.setLocalIP(local,netmask);
	}

	static void addDns(String dns) {
		Log.i("openvpn","Got DNS Server: " + dns);
		mOpenVpnService.addDNS(dns);
	}


	static void addDomain(String domain) {
		Log.i("openvpn","Got DNS Domain: " + domain);
		mOpenVpnService.setDomain(domain);
	}


	public static void setCallback(OpenVpnService openVpnService) {
		mOpenVpnService = openVpnService;
	}

	public static boolean protectSocket (int sockfd)
	{
		boolean p = mOpenVpnService.protect(sockfd);
		if(p)
			Log.d("openvpn","Protected socket "+ sockfd);
		else
			Log.e("openvpn","Error protecting socket "+ sockfd);
		return p;
	}

	public static int openTunDevice() {
		Log.d(TAG,"Opening tun device");
		return mOpenVpnService.openTun();
	}
	//! Dummy method being called to force loading of JNI Libraries
	public static void foo() {	}

	synchronized public static String[] getlogbuffer() {

		// The stoned way of java to return an array from a vector
		// brought to you by eclipse auto complete
		return (String[]) logbuffer.toArray(new String[logbuffer.size()]);

	}
	public static void logBuilderConfig(String[] bconfig) {
		mBconfig =bconfig;
	}
	public static void triggerLogBuilderConfig() {
		if(mBconfig==null) {
			logMessage(0, "", "No active interface");
		} else {
			for (String item : mBconfig) {
				logMessage(0, "", item);
			}	
		}

	}
}