summaryrefslogtreecommitdiff
path: root/app/src/main/java/se
diff options
context:
space:
mode:
authorfupduck <fupduck@riseup.net>2018-03-23 07:09:21 -0700
committerfupduck <fupduck@riseup.net>2018-03-23 07:09:21 -0700
commit434c1dd799b11770db148c405845c790b9e2e469 (patch)
tree971a737e6d0539bd06f36522672ae13cd313f7f6 /app/src/main/java/se
parent5122945a6860caeb46359540ae2a1382f8aab415 (diff)
parent3b57bb6011135c793ca3d81c4034890c79064a54 (diff)
Merge branch '#8876_eip_service' into 'master'
#8876 eip service See merge request leap/bitmask_android!66
Diffstat (limited to 'app/src/main/java/se')
-rw-r--r--app/src/main/java/se/leap/bitmaskclient/ConfigHelper.java29
-rw-r--r--app/src/main/java/se/leap/bitmaskclient/EipFragment.java19
-rw-r--r--app/src/main/java/se/leap/bitmaskclient/MainActivity.java77
-rw-r--r--app/src/main/java/se/leap/bitmaskclient/eip/EIP.java563
-rw-r--r--app/src/main/java/se/leap/bitmaskclient/eip/EipCommand.java4
-rw-r--r--app/src/main/java/se/leap/bitmaskclient/eip/GatewaysManager.java110
6 files changed, 497 insertions, 305 deletions
diff --git a/app/src/main/java/se/leap/bitmaskclient/ConfigHelper.java b/app/src/main/java/se/leap/bitmaskclient/ConfigHelper.java
index aaff9ebc..bfc77261 100644
--- a/app/src/main/java/se/leap/bitmaskclient/ConfigHelper.java
+++ b/app/src/main/java/se/leap/bitmaskclient/ConfigHelper.java
@@ -18,22 +18,20 @@ package se.leap.bitmaskclient;
import android.content.Context;
import android.content.SharedPreferences;
+import android.os.Looper;
import android.preference.PreferenceManager;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
-import android.util.Log;
import org.json.JSONException;
import org.json.JSONObject;
import org.spongycastle.util.encoders.Base64;
-import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
-import java.io.InputStreamReader;
import java.math.BigInteger;
import java.net.MalformedURLException;
import java.net.URL;
@@ -51,13 +49,10 @@ import java.security.interfaces.RSAPrivateKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.util.ArrayList;
-import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
-import java.util.Set;
-import static android.R.attr.name;
import static se.leap.bitmaskclient.Constants.ALWAYS_ON_SHOW_DIALOG;
import static se.leap.bitmaskclient.Constants.DEFAULT_SHARED_PREFS_BATTERY_SAVER;
import static se.leap.bitmaskclient.Constants.PREFERENCES_APP_VERSION;
@@ -442,4 +437,26 @@ public class ConfigHelper {
SharedPreferences preferences = context.getSharedPreferences(SHARED_PREFERENCES, Context.MODE_PRIVATE);
return preferences.getBoolean(ALWAYS_ON_SHOW_DIALOG, true);
}
+
+ public static JSONObject getEipDefinitionFromPreferences(SharedPreferences preferences) {
+ JSONObject result = new JSONObject();
+ try {
+ String eipDefinitionString = preferences.getString(PROVIDER_EIP_DEFINITION, "");
+ if (!eipDefinitionString.isEmpty()) {
+ result = new JSONObject(eipDefinitionString);
+ }
+ } catch (JSONException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ return result;
+ }
+
+ public static void ensureNotOnMainThread(@NonNull Context context) throws IllegalStateException{
+ Looper looper = Looper.myLooper();
+ if (looper != null && looper == context.getMainLooper()) {
+ throw new IllegalStateException(
+ "calling this from your main thread can lead to deadlock");
+ }
+ }
}
diff --git a/app/src/main/java/se/leap/bitmaskclient/EipFragment.java b/app/src/main/java/se/leap/bitmaskclient/EipFragment.java
index 9fcdcac9..098418a9 100644
--- a/app/src/main/java/se/leap/bitmaskclient/EipFragment.java
+++ b/app/src/main/java/se/leap/bitmaskclient/EipFragment.java
@@ -280,24 +280,11 @@ public class EipFragment extends Fragment implements Observer {
protected void stopEipIfPossible() {
Context context = getContext();
- if (context != null) {
- if (isOpenVpnRunningWithoutNetwork()) {
- // TODO move to EIP
- // TODO see stopEIP function
- Bundle resultData = new Bundle();
- resultData.putString(EIP_REQUEST, EIP_ACTION_STOP);
- Intent intentUpdate = new Intent(BROADCAST_EIP_EVENT);
- intentUpdate.addCategory(Intent.CATEGORY_DEFAULT);
- intentUpdate.putExtra(BROADCAST_RESULT_CODE, Activity.RESULT_OK);
- intentUpdate.putExtra(BROADCAST_RESULT_KEY, resultData);
- Log.d(TAG, "sending broadcast");
- LocalBroadcastManager.getInstance(getActivity()).sendBroadcast(intentUpdate);
- } else {
- EipCommand.stopVPN(getContext());
- }
- } else {
+ if (context == null) {
Log.e(TAG, "context is null when trying to stop EIP");
+ return;
}
+ EipCommand.stopVPN(context);
}
private void askPendingStartCancellation() {
diff --git a/app/src/main/java/se/leap/bitmaskclient/MainActivity.java b/app/src/main/java/se/leap/bitmaskclient/MainActivity.java
index d9917799..33ecf85a 100644
--- a/app/src/main/java/se/leap/bitmaskclient/MainActivity.java
+++ b/app/src/main/java/se/leap/bitmaskclient/MainActivity.java
@@ -18,15 +18,11 @@ package se.leap.bitmaskclient;
import android.content.BroadcastReceiver;
-import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
-import android.content.ServiceConnection;
import android.content.SharedPreferences;
import android.os.Bundle;
-import android.os.IBinder;
-import android.os.RemoteException;
import android.support.v4.app.DialogFragment;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentTransaction;
@@ -39,17 +35,8 @@ import android.util.Log;
import org.json.JSONException;
import org.json.JSONObject;
-import java.util.Observable;
-import java.util.Observer;
-
-import de.blinkt.openvpn.core.IOpenVPNServiceInternal;
-import de.blinkt.openvpn.core.OpenVPNService;
-import de.blinkt.openvpn.core.ProfileManager;
-import de.blinkt.openvpn.core.VpnStatus;
import se.leap.bitmaskclient.drawer.NavigationDrawerFragment;
import se.leap.bitmaskclient.eip.EipCommand;
-import se.leap.bitmaskclient.eip.EipStatus;
-import se.leap.bitmaskclient.eip.VoidVpnService;
import se.leap.bitmaskclient.fragments.LogFragment;
import static android.content.Intent.CATEGORY_DEFAULT;
@@ -59,9 +46,7 @@ import static se.leap.bitmaskclient.Constants.BROADCAST_RESULT_CODE;
import static se.leap.bitmaskclient.Constants.BROADCAST_RESULT_KEY;
import static se.leap.bitmaskclient.Constants.EIP_ACTION_START;
import static se.leap.bitmaskclient.Constants.EIP_ACTION_STOP;
-import static se.leap.bitmaskclient.Constants.EIP_ACTION_STOP_BLOCKING_VPN;
import static se.leap.bitmaskclient.Constants.EIP_REQUEST;
-import static se.leap.bitmaskclient.Constants.EIP_RESTART_ON_BOOT;
import static se.leap.bitmaskclient.Constants.PROVIDER_KEY;
import static se.leap.bitmaskclient.Constants.REQUEST_CODE_CONFIGURE_LEAP;
import static se.leap.bitmaskclient.Constants.REQUEST_CODE_LOG_IN;
@@ -78,31 +63,15 @@ import static se.leap.bitmaskclient.R.string.downloading_vpn_certificate_failed;
import static se.leap.bitmaskclient.R.string.vpn_certificate_user_message;
-public class MainActivity extends AppCompatActivity implements Observer {
+public class MainActivity extends AppCompatActivity {
public final static String TAG = MainActivity.class.getSimpleName();
private Provider provider = new Provider();
private SharedPreferences preferences;
- private EipStatus eipStatus;
private NavigationDrawerFragment navigationDrawerFragment;
private MainActivityBroadcastReceiver mainActivityBroadcastReceiver;
- private IOpenVPNServiceInternal mService;
- private ServiceConnection openVpnConnection = new ServiceConnection() {
- @Override
- public void onServiceConnected(ComponentName className,
- IBinder service) {
- mService = IOpenVPNServiceInternal.Stub.asInterface(service);
- }
-
- @Override
- public void onServiceDisconnected(ComponentName arg0) {
- mService = null;
- }
-
- };
-
public final static String ACTION_SHOW_VPN_FRAGMENT = "action_show_vpn_fragment";
public final static String ACTION_SHOW_LOG_FRAGMENT = "action_show_log_fragment";
@@ -130,14 +99,12 @@ public class MainActivity extends AppCompatActivity implements Observer {
R.id.navigation_drawer,
(DrawerLayout) findViewById(R.id.drawer_layout));
- eipStatus = EipStatus.getInstance();
handleIntentAction(getIntent());
}
@Override
protected void onResume() {
super.onResume();
- bindOpenVpnService();
}
@Override
@@ -239,7 +206,6 @@ public class MainActivity extends AppCompatActivity implements Observer {
@Override
protected void onPause() {
super.onPause();
- unbindService(openVpnConnection);
}
@Override
@@ -249,14 +215,6 @@ public class MainActivity extends AppCompatActivity implements Observer {
super.onDestroy();
}
-
- @Override
- public void update(Observable observable, Object data) {
- if (observable instanceof EipStatus) {
- eipStatus = (EipStatus) observable;
- }
- }
-
private void setUpBroadcastReceiver() {
IntentFilter updateIntentFilter = new IntentFilter(BROADCAST_EIP_EVENT);
updateIntentFilter.addAction(BROADCAST_PROVIDER_API_EVENT);
@@ -317,7 +275,6 @@ public class MainActivity extends AppCompatActivity implements Observer {
case EIP_ACTION_STOP:
switch (resultCode) {
case RESULT_OK:
- stop();
break;
case RESULT_CANCELED:
break;
@@ -378,38 +335,6 @@ public class MainActivity extends AppCompatActivity implements Observer {
}
- private void stop() {
- preferences.edit().putBoolean(EIP_RESTART_ON_BOOT, false).apply();
- if (eipStatus.isBlockingVpnEstablished()) {
- stopBlockingVpn();
- }
- disconnect();
- }
-
- private void stopBlockingVpn() {
- Log.d(TAG, "stop VoidVpn!");
- Intent stopVoidVpnIntent = new Intent(this, VoidVpnService.class);
- stopVoidVpnIntent.setAction(EIP_ACTION_STOP_BLOCKING_VPN);
- startService(stopVoidVpnIntent);
- }
-
- private void disconnect() {
- ProfileManager.setConntectedVpnProfileDisconnected(this);
- if (mService != null) {
- try {
- mService.stopVPN(false);
- } catch (RemoteException e) {
- VpnStatus.logException(e);
- }
- }
- }
-
- private void bindOpenVpnService() {
- Intent intent = new Intent(this, OpenVPNService.class);
- intent.setAction(OpenVPNService.START_SERVICE);
- bindService(intent, openVpnConnection, Context.BIND_AUTO_CREATE);
- }
-
private void askUserToLogIn(String userMessage) {
Intent intent = new Intent(this, LoginActivity.class);
intent.putExtra(PROVIDER_KEY, provider);
diff --git a/app/src/main/java/se/leap/bitmaskclient/eip/EIP.java b/app/src/main/java/se/leap/bitmaskclient/eip/EIP.java
index 665e0ebd..92bd5929 100644
--- a/app/src/main/java/se/leap/bitmaskclient/eip/EIP.java
+++ b/app/src/main/java/se/leap/bitmaskclient/eip/EIP.java
@@ -16,25 +16,46 @@
*/
package se.leap.bitmaskclient.eip;
-import android.app.IntentService;
+import android.annotation.SuppressLint;
+import android.app.Service;
+import android.content.ComponentName;
+import android.content.Context;
import android.content.Intent;
+import android.content.ServiceConnection;
import android.content.SharedPreferences;
import android.os.Bundle;
+import android.os.IBinder;
+import android.os.RemoteException;
import android.os.ResultReceiver;
+import android.os.SystemClock;
+import android.support.annotation.Nullable;
+import android.support.annotation.StringRes;
+import android.support.annotation.WorkerThread;
import android.support.v4.content.LocalBroadcastManager;
import android.util.Log;
import org.json.JSONException;
import org.json.JSONObject;
+import java.io.Closeable;
import java.lang.ref.WeakReference;
+import java.util.Observable;
+import java.util.Observer;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.atomic.AtomicInteger;
import de.blinkt.openvpn.LaunchVPN;
+import de.blinkt.openvpn.core.IOpenVPNServiceInternal;
+import de.blinkt.openvpn.core.OpenVPNService;
+import de.blinkt.openvpn.core.ProfileManager;
+import de.blinkt.openvpn.core.VpnStatus;
import se.leap.bitmaskclient.OnBootReceiver;
import static android.app.Activity.RESULT_CANCELED;
import static android.app.Activity.RESULT_OK;
import static android.content.Intent.CATEGORY_DEFAULT;
+import static se.leap.bitmaskclient.ConfigHelper.ensureNotOnMainThread;
import static se.leap.bitmaskclient.Constants.BROADCAST_EIP_EVENT;
import static se.leap.bitmaskclient.Constants.BROADCAST_RESULT_CODE;
import static se.leap.bitmaskclient.Constants.BROADCAST_RESULT_KEY;
@@ -43,11 +64,11 @@ import static se.leap.bitmaskclient.Constants.EIP_ACTION_IS_RUNNING;
import static se.leap.bitmaskclient.Constants.EIP_ACTION_START;
import static se.leap.bitmaskclient.Constants.EIP_ACTION_START_ALWAYS_ON_VPN;
import static se.leap.bitmaskclient.Constants.EIP_ACTION_STOP;
+import static se.leap.bitmaskclient.Constants.EIP_ACTION_STOP_BLOCKING_VPN;
import static se.leap.bitmaskclient.Constants.EIP_EARLY_ROUTES;
import static se.leap.bitmaskclient.Constants.EIP_RECEIVER;
import static se.leap.bitmaskclient.Constants.EIP_REQUEST;
import static se.leap.bitmaskclient.Constants.EIP_RESTART_ON_BOOT;
-import static se.leap.bitmaskclient.Constants.PROVIDER_EIP_DEFINITION;
import static se.leap.bitmaskclient.Constants.PROVIDER_VPN_CERTIFICATE;
import static se.leap.bitmaskclient.Constants.SHARED_PREFERENCES;
import static se.leap.bitmaskclient.MainActivityErrorDialog.DOWNLOAD_ERRORS.ERROR_INVALID_VPN_CERTIFICATE;
@@ -56,227 +77,443 @@ import static se.leap.bitmaskclient.R.string.vpn_certificate_is_invalid;
/**
* EIP is the abstract base class for interacting with and managing the Encrypted
* Internet Proxy connection. Connections are started, stopped, and queried through
- * this IntentService.
+ * this Service.
* Contains logic for parsing eip-service.json from the provider, configuring and selecting
* gateways, and controlling {@link de.blinkt.openvpn.core.OpenVPNService} connections.
*
* @author Sean Leonard <meanderingcode@aetherislands.net>
* @author Parménides GV <parmegv@sdf.org>
*/
-public final class EIP extends IntentService {
+public final class EIP extends Service implements Observer {
public final static String TAG = EIP.class.getSimpleName(),
SERVICE_API_PATH = "config/eip-service.json",
ERRORS = "errors",
ERROR_ID = "errorID";
- private WeakReference<ResultReceiver> mReceiverRef = new WeakReference<>(null);
- private SharedPreferences preferences;
+ private volatile SharedPreferences preferences;
+ private AtomicInteger processCounter;
+ private volatile EipStatus eipStatus;
+ private final Object lock = new Object();
- public EIP() {
- super(TAG);
+ // Service connection to OpenVpnService, shared between threads
+ private volatile OpenvpnServiceConnection openvpnServiceConnection;
+
+ @Nullable
+ @Override
+ public IBinder onBind(Intent intent) {
+ return null;
}
@Override
public void onCreate() {
super.onCreate();
+ eipStatus = EipStatus.getInstance();
+ eipStatus.addObserver(this);
+ processCounter = new AtomicInteger(0);
preferences = getSharedPreferences(SHARED_PREFERENCES, MODE_PRIVATE);
}
@Override
- protected void onHandleIntent(Intent intent) {
- String action = intent.getAction();
- if (intent.getParcelableExtra(EIP_RECEIVER) != null) {
- mReceiverRef = new WeakReference<>((ResultReceiver) intent.getParcelableExtra(EIP_RECEIVER));
+ public void onDestroy() {
+ super.onDestroy();
+ eipStatus.deleteObserver(this);
+ if (openvpnServiceConnection != null) {
+ openvpnServiceConnection.close();
+ openvpnServiceConnection = null;
}
+ }
- if (action == null) {
- return;
+ /**
+ * update eipStatus whenever it changes
+ */
+ @Override
+ public void update(Observable observable, Object data) {
+ if (observable instanceof EipStatus) {
+ eipStatus = (EipStatus) observable;
}
+ }
- switch (action) {
- case EIP_ACTION_START:
- boolean earlyRoutes = intent.getBooleanExtra(EIP_EARLY_ROUTES, true);
- startEIP(earlyRoutes);
- break;
- case EIP_ACTION_START_ALWAYS_ON_VPN:
- startEIPAlwaysOnVpn();
- break;
- case EIP_ACTION_STOP:
- stopEIP();
- break;
- case EIP_ACTION_IS_RUNNING:
- isRunning();
- break;
- case EIP_ACTION_CHECK_CERT_VALIDITY:
- checkVPNCertificateValidity();
- break;
+ /**
+ * register new process with processCounter and start it
+ * @param intent the intent that started this EIP call
+ */
+ @Override
+ public int onStartCommand(final Intent intent, int flags, int startId) {
+ Log.d(TAG, "new process counter: " + processCounter.incrementAndGet());
+ final String action = intent.getAction();
+ if (action != null) {
+ ResultReceiver resultReceiver = intent.getParcelableExtra(EIP_RECEIVER);
+ new EipThread(this, action, intent, resultReceiver).start();
+ } else {
+ processCounter.decrementAndGet();
}
+ return START_STICKY;
}
/**
- * Initiates an EIP connection by selecting a gateway and preparing and sending an
- * Intent to {@link de.blinkt.openvpn.LaunchVPN}.
- * It also sets up early routes.
+ * Thread to handle the requests to this service
*/
- private void startEIP(boolean earlyRoutes) {
- if (!EipStatus.getInstance().isBlockingVpnEstablished() && earlyRoutes) {
- earlyRoutes();
+ class EipThread extends Thread {
+ EipThread(EIP eipReference, String action, Intent startIntent, ResultReceiver resultReceiver) {
+ super(new EipRunnable(eipReference, action, startIntent, resultReceiver));
}
+ }
+
+ /**
+ * Runnable to be used in the EipThread class
+ */
+ class EipRunnable implements Runnable {
+ private String action;
+ private EIP eipReference;
+ private Intent intent;
- Bundle result = new Bundle();
+ private WeakReference<ResultReceiver> mReceiverRef = new WeakReference<>(null);
- if (!preferences.getBoolean(EIP_RESTART_ON_BOOT, false)){
- preferences.edit().putBoolean(EIP_RESTART_ON_BOOT, true).commit();
+
+ EipRunnable(EIP eipReference, String action, Intent startIntent, ResultReceiver resultReceiver) {
+ super();
+ this.action = action;
+ this.eipReference = eipReference;
+ this.intent = startIntent;
+ this.mReceiverRef = new WeakReference<ResultReceiver>(resultReceiver);
}
- GatewaysManager gatewaysManager = gatewaysFromPreferences();
- if (!isVPNCertificateValid()){
- setErrorResult(result, vpn_certificate_is_invalid, ERROR_INVALID_VPN_CERTIFICATE.toString());
- tellToReceiverOrBroadcast(EIP_ACTION_START, RESULT_CANCELED, result);
- return;
+ /**
+ * select correct function to call based upon transmitted action
+ * after completing check if no other thread is running
+ * if no other thread is running terminate the EIP service
+ */
+ @Override
+ public void run() {
+ Log.d(TAG, "new EIP thread started!");
+ switch (action) {
+ case EIP_ACTION_START:
+ boolean earlyRoutes = intent.getBooleanExtra(EIP_EARLY_ROUTES, true);
+ startEIP(earlyRoutes);
+ break;
+ case EIP_ACTION_START_ALWAYS_ON_VPN:
+ startEIPAlwaysOnVpn();
+ break;
+ case EIP_ACTION_STOP:
+ stopEIP();
+ break;
+ case EIP_ACTION_IS_RUNNING:
+ isRunning();
+ break;
+ case EIP_ACTION_CHECK_CERT_VALIDITY:
+ checkVPNCertificateValidity();
+ break;
+ }
+ if (processCounter.decrementAndGet() == 0) {
+ Log.d(TAG, "no more running EIP threads!");
+ eipReference.stopSelf();
+ }
}
- Gateway gateway = gatewaysManager.select();
- if (gateway != null && gateway.getProfile() != null) {
- launchActiveGateway(gateway);
- tellToReceiverOrBroadcast(EIP_ACTION_START, RESULT_OK);
- } else
- tellToReceiverOrBroadcast(EIP_ACTION_START, RESULT_CANCELED);
- }
+ /**
+ * Initiates an EIP connection by selecting a gateway and preparing and sending an
+ * Intent to {@link de.blinkt.openvpn.LaunchVPN}.
+ * It also sets up early routes.
+ */
+ @SuppressLint("ApplySharedPref")
+ private void startEIP(boolean earlyRoutes) {
+ if (!eipStatus.isBlockingVpnEstablished() && earlyRoutes) {
+ earlyRoutes();
+ }
- /**
- * Tries to start the last used vpn profile when the OS was rebooted and always-on-VPN is enabled.
- * The {@link OnBootReceiver} will care if there is no profile.
- */
- private void startEIPAlwaysOnVpn() {
- Log.d(TAG, "startEIPAlwaysOnVpn vpn");
+ Bundle result = new Bundle();
+ if (!preferences.getBoolean(EIP_RESTART_ON_BOOT, false)) {
+ preferences.edit().putBoolean(EIP_RESTART_ON_BOOT, true).commit();
+ }
- GatewaysManager gatewaysManager = gatewaysFromPreferences();
- Gateway gateway = gatewaysManager.select();
+ GatewaysManager gatewaysManager = gatewaysFromPreferences();
+ if (!isVPNCertificateValid()) {
+ setErrorResult(result, vpn_certificate_is_invalid, ERROR_INVALID_VPN_CERTIFICATE.toString());
+ tellToReceiverOrBroadcast(EIP_ACTION_START, RESULT_CANCELED, result);
+ return;
+ }
- if (gateway != null && gateway.getProfile() != null) {
- Log.d(TAG, "startEIPAlwaysOnVpn eip launch avtive gateway vpn");
- launchActiveGateway(gateway);
- } else {
- Log.d(TAG, "startEIPAlwaysOnVpn no active profile available!");
+ Gateway gateway = gatewaysManager.select();
+ if (gateway != null && gateway.getProfile() != null) {
+ launchActiveGateway(gateway);
+ tellToReceiverOrBroadcast(EIP_ACTION_START, RESULT_OK);
+ } else
+ tellToReceiverOrBroadcast(EIP_ACTION_START, RESULT_CANCELED);
}
- }
- /**
- * Early routes are routes that block traffic until a new
- * VpnService is started properly.
- */
- private void earlyRoutes() {
- Intent voidVpnLauncher = new Intent(getApplicationContext(), VoidVpnLauncher.class);
- voidVpnLauncher.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
- startActivity(voidVpnLauncher);
- }
+ /**
+ * Tries to start the last used vpn profile when the OS was rebooted and always-on-VPN is enabled.
+ * The {@link OnBootReceiver} will care if there is no profile.
+ */
+ private void startEIPAlwaysOnVpn() {
+ Log.d(TAG, "startEIPAlwaysOnVpn vpn");
+
+ GatewaysManager gatewaysManager = gatewaysFromPreferences();
+ Gateway gateway = gatewaysManager.select();
+
+ if (gateway != null && gateway.getProfile() != null) {
+ Log.d(TAG, "startEIPAlwaysOnVpn eip launch avtive gateway vpn");
+ launchActiveGateway(gateway);
+ } else {
+ Log.d(TAG, "startEIPAlwaysOnVpn no active profile available!");
+ }
+ }
- private void launchActiveGateway(Gateway gateway) {
- Intent intent = new Intent(this, LaunchVPN.class);
- intent.setAction(Intent.ACTION_MAIN);
- intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
- intent.putExtra(LaunchVPN.EXTRA_HIDELOG, true);
- intent.putExtra(LaunchVPN.EXTRA_TEMP_VPN_PROFILE, gateway.getProfile());
- startActivity(intent);
- }
+ /**
+ * Early routes are routes that block traffic until a new
+ * VpnService is started properly.
+ */
+ private void earlyRoutes() {
+ Intent voidVpnLauncher = new Intent(getApplicationContext(), VoidVpnLauncher.class);
+ voidVpnLauncher.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+ startActivity(voidVpnLauncher);
+ }
- private void stopEIP() {
- // TODO stop eip from here if possible...
- // TODO then refactor EipFragment.handleSwitchOff
- EipStatus eipStatus = EipStatus.getInstance();
- int resultCode = RESULT_CANCELED;
- if (eipStatus.isConnected() || eipStatus.isConnecting())
- resultCode = RESULT_OK;
+ /**
+ * starts the VPN and connects to the given gateway
+ *
+ * @param gateway to connect to
+ */
+ private void launchActiveGateway(Gateway gateway) {
+ Intent intent = new Intent(eipReference, LaunchVPN.class);
+ intent.setAction(Intent.ACTION_MAIN);
+ intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+ intent.putExtra(LaunchVPN.EXTRA_HIDELOG, true);
+ intent.putExtra(LaunchVPN.EXTRA_TEMP_VPN_PROFILE, gateway.getProfile());
+ startActivity(intent);
+ }
- tellToReceiverOrBroadcast(EIP_ACTION_STOP, resultCode);
- }
+ /**
+ * Stop VPN
+ * First checks if the OpenVpnConnection is open then
+ * terminates EIP if currently connected or connecting
+ */
+ private void stopEIP() {
+ int resultCode = stop() ? RESULT_OK : RESULT_CANCELED;
+ tellToReceiverOrBroadcast(EIP_ACTION_STOP, resultCode);
+ }
- /**
- * Checks the last stored status notified by ics-openvpn
- * Sends <code>Activity.RESULT_CANCELED</code> to the ResultReceiver that made the
- * request if it's not connected, <code>Activity.RESULT_OK</code> otherwise.
- */
- private void isRunning() {
- EipStatus eipStatus = EipStatus.getInstance();
- int resultCode = (eipStatus.isConnected()) ?
- RESULT_OK :
- RESULT_CANCELED;
- tellToReceiverOrBroadcast(EIP_ACTION_IS_RUNNING, resultCode);
- }
+ /**
+ * Checks the last stored status notified by ics-openvpn
+ * Sends <code>Activity.RESULT_CANCELED</code> to the ResultReceiver that made the
+ * request if it's not connected, <code>Activity.RESULT_OK</code> otherwise.
+ */
+ private void isRunning() {
+ int resultCode = (eipStatus.isConnected()) ?
+ RESULT_OK :
+ RESULT_CANCELED;
+ tellToReceiverOrBroadcast(EIP_ACTION_IS_RUNNING, resultCode);
+ }
- private JSONObject eipDefinitionFromPreferences() {
- JSONObject result = new JSONObject();
- try {
- String eipDefinitionString = preferences.getString(PROVIDER_EIP_DEFINITION, "");
- if (!eipDefinitionString.isEmpty()) {
- result = new JSONObject(eipDefinitionString);
+ /**
+ * read eipServiceJson from preferences and parse Gateways
+ *
+ * @return GatewaysManager
+ */
+ private GatewaysManager gatewaysFromPreferences() {
+ GatewaysManager gatewaysManager = new GatewaysManager(eipReference, preferences);
+ gatewaysManager.configureFromPreferences();
+ return gatewaysManager;
+ }
+
+ /**
+ * read VPN certificate from preferences and check it
+ * broadcast result
+ */
+ private void checkVPNCertificateValidity() {
+ int resultCode = isVPNCertificateValid() ?
+ RESULT_OK :
+ RESULT_CANCELED;
+ tellToReceiverOrBroadcast(EIP_ACTION_CHECK_CERT_VALIDITY, resultCode);
+ }
+
+ /**
+ * read VPN certificate from preferences and check it
+ *
+ * @return true if VPN certificate is valid false otherwise
+ */
+ private boolean isVPNCertificateValid() {
+ VpnCertificateValidator validator = new VpnCertificateValidator(preferences.getString(PROVIDER_VPN_CERTIFICATE, ""));
+ return validator.isValid();
+ }
+
+ /**
+ * send resultCode and resultData to receiver or
+ * broadcast the result if no receiver is defined
+ *
+ * @param action the action that has been performed
+ * @param resultCode RESULT_OK if action was successful RESULT_CANCELED otherwise
+ * @param resultData other data to broadcast or return to receiver
+ */
+ private void tellToReceiverOrBroadcast(String action, int resultCode, Bundle resultData) {
+ resultData.putString(EIP_REQUEST, action);
+ if (mReceiverRef.get() != null) {
+ mReceiverRef.get().send(resultCode, resultData);
+ } else {
+ broadcastEvent(resultCode, resultData);
}
- } catch (JSONException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
}
- return result;
- }
- private GatewaysManager gatewaysFromPreferences() {
- GatewaysManager gatewaysManager = new GatewaysManager(this, preferences);
- //TODO: THIS IS A QUICK FIX - it deletes all profiles in ProfileManager, thus it's possible
- // to add all gateways from prefs without duplicates, but this should be refactored.
- gatewaysManager.clearGatewaysAndProfiles();
- gatewaysManager.fromEipServiceJson(eipDefinitionFromPreferences());
- return gatewaysManager;
- }
+ /**
+ * send resultCode and resultData to receiver or
+ * broadcast the result if no receiver is defined
+ *
+ * @param action the action that has been performed
+ * @param resultCode RESULT_OK if action was successful RESULT_CANCELED otherwise
+ */
+ private void tellToReceiverOrBroadcast(String action, int resultCode) {
+ tellToReceiverOrBroadcast(action, resultCode, new Bundle());
+ }
- private void checkVPNCertificateValidity() {
- int resultCode = isVPNCertificateValid() ?
- RESULT_OK :
- RESULT_CANCELED;
- tellToReceiverOrBroadcast(EIP_ACTION_CHECK_CERT_VALIDITY, resultCode);
- }
+ /**
+ * broadcast result
+ *
+ * @param resultCode RESULT_OK if action was successful RESULT_CANCELED otherwise
+ * @param resultData other data to broadcast or return to receiver
+ */
+ private void broadcastEvent(int resultCode, Bundle resultData) {
+ Intent intentUpdate = new Intent(BROADCAST_EIP_EVENT);
+ intentUpdate.addCategory(CATEGORY_DEFAULT);
+ intentUpdate.putExtra(BROADCAST_RESULT_CODE, resultCode);
+ intentUpdate.putExtra(BROADCAST_RESULT_KEY, resultData);
+ Log.d(TAG, "sending broadcast");
+ LocalBroadcastManager.getInstance(eipReference).sendBroadcast(intentUpdate);
+ }
- private boolean isVPNCertificateValid() {
- VpnCertificateValidator validator = new VpnCertificateValidator(preferences.getString(PROVIDER_VPN_CERTIFICATE, ""));
- return validator.isValid();
- }
- private void tellToReceiverOrBroadcast(String action, int resultCode, Bundle resultData) {
- resultData.putString(EIP_REQUEST, action);
- if (mReceiverRef.get() != null) {
- mReceiverRef.get().send(resultCode, resultData);
- } else {
- broadcastEvent(resultCode, resultData);
+ /**
+ * helper function to add error to result bundle
+ *
+ * @param result - result of an action
+ * @param errorMessageId - id of string resource describing the error
+ * @param errorId - MainActivityErrorDialog DownloadError id
+ */
+ void setErrorResult(Bundle result, @StringRes int errorMessageId, String errorId) {
+ JSONObject errorJson = new JSONObject();
+ try {
+ errorJson.put(ERRORS, getResources().getString(errorMessageId));
+ errorJson.put(ERROR_ID, errorId);
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ result.putString(ERRORS, errorJson.toString());
+ result.putBoolean(BROADCAST_RESULT_KEY, false);
}
- }
- private void tellToReceiverOrBroadcast(String action, int resultCode) {
- tellToReceiverOrBroadcast(action, resultCode, new Bundle());
- }
- private void broadcastEvent(int resultCode , Bundle resultData) {
- Intent intentUpdate = new Intent(BROADCAST_EIP_EVENT);
- intentUpdate.addCategory(CATEGORY_DEFAULT);
- intentUpdate.putExtra(BROADCAST_RESULT_CODE, resultCode);
- intentUpdate.putExtra(BROADCAST_RESULT_KEY, resultData);
- Log.d(TAG, "sending broadcast");
- LocalBroadcastManager.getInstance(this).sendBroadcast(intentUpdate);
- }
+ /**
+ * disable Bitmask starting on after phone reboot
+ * then stop VPN
+ */
+ private boolean stop() {
+ preferences.edit().putBoolean(EIP_RESTART_ON_BOOT, false).apply();
+ if (eipStatus.isBlockingVpnEstablished()) {
+ stopBlockingVpn();
+ }
+ return disconnect();
+ }
- Bundle setErrorResult(Bundle result, int errorMessageId, String errorId) {
- JSONObject errorJson = new JSONObject();
- addErrorMessageToJson(errorJson, getResources().getString(errorMessageId), errorId);
- result.putString(ERRORS, errorJson.toString());
- result.putBoolean(BROADCAST_RESULT_KEY, false);
- return result;
+ /**
+ * stop void vpn from blocking internet
+ */
+ private void stopBlockingVpn() {
+ Log.d(TAG, "stop VoidVpn!");
+ Intent stopVoidVpnIntent = new Intent(eipReference, VoidVpnService.class);
+ stopVoidVpnIntent.setAction(EIP_ACTION_STOP_BLOCKING_VPN);
+ startService(stopVoidVpnIntent);
+ }
+
+
+ /**
+ * creates a OpenVpnServiceConnection if necessary
+ * then terminates OpenVPN
+ */
+ private boolean disconnect() {
+ try {
+ initOpenVpnServiceConnection();
+ } catch (InterruptedException | IllegalStateException e) {
+ return false;
+ }
+
+ ProfileManager.setConntectedVpnProfileDisconnected(eipReference);
+ try {
+ return openvpnServiceConnection.getService().stopVPN(false);
+ } catch (RemoteException e) {
+ VpnStatus.logException(e);
+ }
+ return false;
+ }
+
+ /**
+ * Assigns a new OpenvpnServiceConnection to EIP's member variable openvpnServiceConnection.
+ * Only one thread at a time can create the service connection, that will be shared between threads
+ *
+ * @throws InterruptedException thrown if thread gets interrupted
+ * @throws IllegalStateException thrown if this method was not called from a background thread
+ */
+ private void initOpenVpnServiceConnection() throws InterruptedException, IllegalStateException {
+ synchronized (lock) {
+ if (openvpnServiceConnection == null) {
+ Log.d(TAG, "serviceConnection is still null");
+ openvpnServiceConnection = new OpenvpnServiceConnection(eipReference);
+ }
+ }
+ }
}
- private void addErrorMessageToJson(JSONObject jsonObject, String errorMessage, String errorId) {
- try {
- jsonObject.put(ERRORS, errorMessage);
- jsonObject.put(ERROR_ID, errorId);
- } catch (JSONException e) {
- e.printStackTrace();
+ /**
+ * Creates a service connection to OpenVpnService.
+ * The constructor blocks until the service is bound to the given Context.
+ * Pattern stolen from android.security.KeyChain.java
+ */
+ @WorkerThread
+ public static class OpenvpnServiceConnection implements Closeable {
+ private final Context context;
+ private ServiceConnection serviceConnection;
+ private IOpenVPNServiceInternal service;
+
+ protected OpenvpnServiceConnection(Context context) throws InterruptedException, IllegalStateException {
+ this.context = context;
+ ensureNotOnMainThread(context);
+ Log.d(TAG, "initSynchronizedServiceConnection!");
+ initSynchronizedServiceConnection(context);
+ }
+
+ private void initSynchronizedServiceConnection(final Context context) throws InterruptedException {
+ final BlockingQueue<IOpenVPNServiceInternal> blockingQueue = new LinkedBlockingQueue<>(1);
+ this.serviceConnection = new ServiceConnection() {
+ volatile boolean mConnectedAtLeastOnce = false;
+ @Override public void onServiceConnected(ComponentName name, IBinder service) {
+ if (!mConnectedAtLeastOnce) {
+ mConnectedAtLeastOnce = true;
+ try {
+ Log.d(TAG, "serviceConnection connected! ProcessCounter: " + ((EIP) context).processCounter.get());
+ blockingQueue.put(IOpenVPNServiceInternal.Stub.asInterface(service));
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ @Override public void onServiceDisconnected(ComponentName name) {
+ Log.d(TAG, "serviceConnection disconnected! ProcessCounter: " + ((EIP) context).processCounter.get());
+ }
+ };
+
+ Intent intent = new Intent(context, OpenVPNService.class);
+ intent.setAction(OpenVPNService.START_SERVICE);
+ context.bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
+ service = blockingQueue.take();
+ }
+
+ @Override public void close() {
+ context.unbindService(serviceConnection);
+ }
+
+ public IOpenVPNServiceInternal getService() {
+ return service;
}
}
+
}
+
diff --git a/app/src/main/java/se/leap/bitmaskclient/eip/EipCommand.java b/app/src/main/java/se/leap/bitmaskclient/eip/EipCommand.java
index d2c8b4fc..5a6a98d8 100644
--- a/app/src/main/java/se/leap/bitmaskclient/eip/EipCommand.java
+++ b/app/src/main/java/se/leap/bitmaskclient/eip/EipCommand.java
@@ -5,6 +5,7 @@ import android.content.Context;
import android.content.Intent;
import android.os.ResultReceiver;
import android.support.annotation.NonNull;
+import android.support.annotation.VisibleForTesting;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -50,6 +51,7 @@ public class EipCommand {
execute(context, EIP_ACTION_START, null, baseIntent);
}
+ @VisibleForTesting
public static void startVPN(@NonNull Context context, ResultReceiver resultReceiver) {
execute(context, EIP_ACTION_START, resultReceiver, null);
}
@@ -58,6 +60,7 @@ public class EipCommand {
execute(context, EIP_ACTION_STOP);
}
+ @VisibleForTesting
public static void stopVPN(@NonNull Context context, ResultReceiver resultReceiver) {
execute(context, EIP_ACTION_STOP, resultReceiver, null);
}
@@ -66,6 +69,7 @@ public class EipCommand {
execute(context, EIP_ACTION_CHECK_CERT_VALIDITY);
}
+ @VisibleForTesting
public static void checkVpnCertificate(@NonNull Context context, ResultReceiver resultReceiver) {
execute(context, EIP_ACTION_CHECK_CERT_VALIDITY, resultReceiver, null);
}
diff --git a/app/src/main/java/se/leap/bitmaskclient/eip/GatewaysManager.java b/app/src/main/java/se/leap/bitmaskclient/eip/GatewaysManager.java
index 1bdb53ab..a04ede08 100644
--- a/app/src/main/java/se/leap/bitmaskclient/eip/GatewaysManager.java
+++ b/app/src/main/java/se/leap/bitmaskclient/eip/GatewaysManager.java
@@ -20,7 +20,6 @@ import android.content.Context;
import android.content.SharedPreferences;
import com.google.gson.Gson;
-import com.google.gson.JsonSyntaxException;
import com.google.gson.reflect.TypeToken;
import org.json.JSONArray;
@@ -36,6 +35,7 @@ import java.util.List;
import de.blinkt.openvpn.VpnProfile;
import de.blinkt.openvpn.core.Connection;
import de.blinkt.openvpn.core.ProfileManager;
+import se.leap.bitmaskclient.ConfigHelper;
import se.leap.bitmaskclient.Provider;
import static se.leap.bitmaskclient.Constants.PROVIDER_PRIVATE_KEY;
@@ -49,52 +49,49 @@ public class GatewaysManager {
private Context context;
private SharedPreferences preferences;
private List<Gateway> gateways = new ArrayList<>();
- private ProfileManager profile_manager;
- private Type list_type = new TypeToken<ArrayList<Gateway>>() {
- }.getType();
+ private ProfileManager profileManager;
+ private Type listType = new TypeToken<ArrayList<Gateway>>() {}.getType();
- public GatewaysManager() {
- }
-
- public GatewaysManager(Context context, SharedPreferences preferences) {
+ GatewaysManager(Context context, SharedPreferences preferences) {
this.context = context;
this.preferences = preferences;
- profile_manager = ProfileManager.getInstance(context);
+ profileManager = ProfileManager.getInstance(context);
}
+ /**
+ * select closest Gateway
+ * @return the closest Gateway
+ */
public Gateway select() {
- GatewaySelector gateway_selector = new GatewaySelector(gateways);
- return gateway_selector.select();
+ GatewaySelector gatewaySelector = new GatewaySelector(gateways);
+ return gatewaySelector.select();
}
+ /**
+ * check if there are no gateways defined
+ * @return true if no gateways defined else false
+ */
public boolean isEmpty() {
return gateways.isEmpty();
}
+ /**
+ * @return number of gateways defined in the GatewaysManager
+ */
public int size() {
return gateways.size();
}
- public void addFromString(String gateways) {
- List<Gateway> gateways_list = new ArrayList<>();
- try {
- gateways_list = new Gson().fromJson(gateways, list_type);
- } catch (JsonSyntaxException e) {
- gateways_list.add(new Gson().fromJson(gateways, Gateway.class));
- }
-
- if (gateways_list != null) {
- for (Gateway gateway : gateways_list)
- addGateway(gateway);
- }
- }
-
@Override
public String toString() {
- return new Gson().toJson(gateways, list_type);
+ return new Gson().toJson(gateways, listType);
}
- public void fromEipServiceJson(JSONObject eipDefinition) {
+ /**
+ * parse gateways from eipDefinition
+ * @param eipDefinition eipServiceJson
+ */
+ void fromEipServiceJson(JSONObject eipDefinition) {
try {
JSONArray gatewaysDefined = eipDefinition.getJSONArray("gateways");
for (int i = 0; i < gatewaysDefined.length(); i++) {
@@ -113,6 +110,11 @@ public class GatewaysManager {
}
}
+ /**
+ * check if a gateway is an OpenVpn gateway
+ * @param gateway to check
+ * @return true if gateway is an OpenVpn gateway otherwise false
+ */
private boolean isOpenVpnGateway(JSONObject gateway) {
try {
String transport = gateway.getJSONObject("capabilities").getJSONArray("transport").toString();
@@ -137,7 +139,7 @@ public class GatewaysManager {
private boolean containsProfileWithSecrets(VpnProfile profile) {
boolean result = false;
- Collection<VpnProfile> profiles = profile_manager.getProfiles();
+ Collection<VpnProfile> profiles = profileManager.getProfiles();
for (VpnProfile aux : profiles) {
result = result || sameConnections(profile.mConnections, aux.mConnections)
&& profile.mClientCertFilename.equalsIgnoreCase(aux.mClientCertFilename)
@@ -146,11 +148,11 @@ public class GatewaysManager {
return result;
}
- protected void clearGatewaysAndProfiles() {
+ void clearGatewaysAndProfiles() {
gateways.clear();
- ArrayList<VpnProfile> profiles = new ArrayList<>(profile_manager.getProfiles());
+ ArrayList<VpnProfile> profiles = new ArrayList<>(profileManager.getProfiles());
for (VpnProfile profile : profiles) {
- profile_manager.removeProfile(context, profile);
+ profileManager.removeProfile(context, profile);
}
}
@@ -159,42 +161,62 @@ public class GatewaysManager {
gateways.add(gateway);
VpnProfile profile = gateway.getProfile();
- profile_manager.addProfile(profile);
+ profileManager.addProfile(profile);
}
private void removeDuplicatedGateway(Gateway gateway) {
Iterator<Gateway> it = gateways.iterator();
- List<Gateway> gateways_to_remove = new ArrayList<>();
+ List<Gateway> gatewaysToRemove = new ArrayList<>();
while (it.hasNext()) {
Gateway aux = it.next();
if (sameConnections(aux.getProfile().mConnections, gateway.getProfile().mConnections)) {
- gateways_to_remove.add(aux);
+ gatewaysToRemove.add(aux);
}
}
- gateways.removeAll(gateways_to_remove);
+ gateways.removeAll(gatewaysToRemove);
removeDuplicatedProfiles(gateway.getProfile());
}
private void removeDuplicatedProfiles(VpnProfile original) {
- Collection<VpnProfile> profiles = profile_manager.getProfiles();
- List<VpnProfile> remove_list = new ArrayList<>();
+ Collection<VpnProfile> profiles = profileManager.getProfiles();
+ List<VpnProfile> removeList = new ArrayList<>();
for (VpnProfile aux : profiles) {
- if (sameConnections(original.mConnections, aux.mConnections))
- remove_list.add(aux);
+ if (sameConnections(original.mConnections, aux.mConnections)) {
+ removeList.add(aux);
+ }
+ }
+ for (VpnProfile profile : removeList) {
+ profileManager.removeProfile(context, profile);
}
- for (VpnProfile profile : remove_list)
- profile_manager.removeProfile(context, profile);
}
+ /**
+ * check if all connections in c1 are also in c2
+ * @param c1 array of connections
+ * @param c2 array of connections
+ * @return true if all connections of c1 exist in c2 and vice versa
+ */
private boolean sameConnections(Connection[] c1, Connection[] c2) {
- int same_connections = 0;
+ int sameConnections = 0;
for (Connection c1_aux : c1) {
for (Connection c2_aux : c2)
if (c2_aux.mServerName.equals(c1_aux.mServerName)) {
- same_connections++;
+ sameConnections++;
break;
}
}
- return c1.length == c2.length && c1.length == same_connections;
+ return c1.length == c2.length && c1.length == sameConnections;
+ }
+
+ /**
+ * read EipServiceJson from preferences and set gateways
+ */
+ void configureFromPreferences() {
+ //TODO: THIS IS A QUICK FIX - it deletes all profiles in ProfileManager, thus it's possible
+ // to add all gateways from prefs without duplicates, but this should be refactored.
+ clearGatewaysAndProfiles();
+ fromEipServiceJson(
+ ConfigHelper.getEipDefinitionFromPreferences(preferences)
+ );
}
}