allow selecting routes

tool/src/main/java/io/netbird/client/tool/EngineRunner.java

@@ -1,10 +1,11 @@
 package io.netbird.client.tool;
 
-
-import android.content.Context;
 import android.os.Build;
 import android.util.Log;
 
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
 import java.util.HashSet;
 import java.util.Set;
 
@@ -13,59 +14,55 @@
 import io.netbird.gomobile.android.ConnectionListener;
 import io.netbird.gomobile.android.DNSList;
 import io.netbird.gomobile.android.NetworkArray;
+import io.netbird.gomobile.android.NetworkChangeListener;
 import io.netbird.gomobile.android.PeerInfoArray;
+import io.netbird.gomobile.android.TunAdapter;
 import io.netbird.gomobile.android.URLOpener;
 
 class EngineRunner {
 
     private static final String LOGTAG = "EngineRunner";
-    private final Context context;
     private boolean engineIsRunning = false;
     Set<ServiceStateListener> serviceStateListeners = new HashSet<>();
     private final Client goClient;
 
-    public EngineRunner(VPNService vpnService) {
-        context = vpnService;
-        NetworkChangeNotifier notifier = new NetworkChangeNotifier(vpnService);
-        IFace iFace = new IFace(vpnService);
+    public EngineRunner(String configurationFilePath, NetworkChangeListener networkChangeListener, TunAdapter tunAdapter, IFaceDiscover iFaceDiscover, String versionName, boolean isTraceLogEnabled, boolean isDebuggable) {
         goClient = Android.newClient(
-                Preferences.configFile(vpnService),
+                configurationFilePath,
                 androidSDKVersion(),
                 DeviceName.getDeviceName(),
-                Version.getVersionName(vpnService),
-                iFace,
-                new IFaceDiscover(),
-                notifier);
+                versionName,
+                tunAdapter,
+                iFaceDiscover,
+                networkChangeListener);
 
-        updateLogLevel();
+        updateLogLevel(isTraceLogEnabled, isDebuggable);
     }
 
-    public void run(URLOpener urlOpener) {
-        runClient(urlOpener);
+    public void run(@NotNull DNSWatch dnsWatch, @NotNull Preferences preferences, boolean isDebuggable, @NotNull URLOpener urlOpener) {
+        runClient(dnsWatch, preferences, isDebuggable, urlOpener);
     }
 
-    public void runWithoutAuth() {
-        runClient(null);
+    public void runWithoutAuth(@NotNull DNSWatch dnsWatch, @NotNull Preferences preferences, boolean isDebuggable) {
+        runClient(dnsWatch, preferences, isDebuggable, null);
     }
 
-    private synchronized void runClient(URLOpener urlOpener) {
+    private synchronized void runClient(@NotNull DNSWatch dnsWatch, @NotNull Preferences preferences, boolean isDebuggable, @Nullable URLOpener urlOpener) {
         Log.d(LOGTAG, "run engine");
         if (engineIsRunning) {
             Log.e(LOGTAG, "engine already running");
             return;
         }
 
-        updateLogLevel();
+        updateLogLevel(preferences.isTraceLogEnabled(), isDebuggable);
 
         engineIsRunning = true;
         Runnable r = () -> {
-            DNSWatch dnsWatch = new DNSWatch(context);
-            Preferences preferences = new Preferences(context);
             var envList = EnvVarPackager.getEnvironmentVariables(preferences);
 
             try {
                 notifyServiceStateListeners(true);
-                if(urlOpener == null) {
+                if (urlOpener == null) {
                     goClient.runWithoutLogin(dnsWatch.dnsServers(), () -> dnsWatch.setDNSChangeListener(this::changed), envList);
                 } else {
                     goClient.run(urlOpener, dnsWatch.dnsServers(), () -> dnsWatch.setDNSChangeListener(this::changed), envList);
@@ -87,6 +84,7 @@ private synchronized void runClient(URLOpener urlOpener) {
     private void changed(DNSList dnsServers) throws Exception {
         goClient.onUpdatedHostDNS(dnsServers);
     }
+
     public synchronized boolean isRunning() {
         return engineIsRunning;
     }
@@ -145,16 +143,20 @@ private synchronized void notifyServiceStateListeners(boolean engineIsRunning) {
         }
     }
 
-    private void updateLogLevel() {
-        Preferences pref = new Preferences(context);
-        if (Version.isDebuggable(context) || pref.isTraceLogEnabled()) {
+    private void updateLogLevel(boolean isTraceLogEnabled, boolean isDebuggable) {
+        if (isDebuggable || isTraceLogEnabled) {
             goClient.setTraceLogLevel();
         } else {
             goClient.setInfoLogLevel();
         }
     }
 
     private int androidSDKVersion() {
-       return Build.VERSION.SDK_INT ;
+        return Build.VERSION.SDK_INT;
+    }
+
+    public void renewTUN(int fd) {
+        Log.d(LOGTAG, String.format("renewing TUN fd: %d", fd));
+        // goClient.sendFd(fd);
     }
 }

tool/src/main/java/io/netbird/client/tool/IFace.java

@@ -33,12 +33,20 @@ public long configureInterface(String address, long mtu, String dns, String sear
         LinkedList<Route> routes = toRoutes(routesString);
 
         InetNetwork addr = InetNetwork.parse(address);
+        long fd = -1;
+
         try {
-            return createTun(addr.getAddress().getHostAddress(), addr.getMask(), (int) mtu, dns, searchDomains, routes);
-        }catch (Exception e) {
+            fd = createTun(addr.getAddress().getHostAddress(), addr.getMask(), (int) mtu, dns, searchDomains, routes);
+        } catch (Exception e) {
             Log.e(LOGTAG, "failed to create tunnel", e);
-            throw e;
         }
+
+        // only set the currently used TUN parameters if createTun didn't throw exceptions
+        if (fd != -1) {
+            this.vpnService.setCurrentTUNParameters(new TUNParameters(address, mtu, dns, searchDomainsString, routesString));
+        }
+
+        return fd;
     }
 
     @Override

tool/src/main/java/io/netbird/client/tool/NetworkChangeNotifier.java

@@ -13,23 +13,38 @@ public class NetworkChangeNotifier implements NetworkChangeListener {
 
     private final Context context;
 
+    private RouteChangeListener routeChangeListener;
+
     NetworkChangeNotifier(Context context) {
         this.context = context;
     }
 
     @Override
     public void onNetworkChanged(String routes) {
-        sendBroadcast();
+        if (routes != null) {
+            routes = routes.replace(",", ";");
+        }
+
+        if (this.routeChangeListener != null) {
+            this.routeChangeListener.onRouteChanged(routes);
+        }
+
+        sendBroadcast(routes);
     }
 
     @Override
     public void setInterfaceIP(String ip) {
 
     }
 
-    private void sendBroadcast() {
+    public void setRouteChangeListener(RouteChangeListener routeChangeListener) {
+        this.routeChangeListener = routeChangeListener;
+    }
+
+    private void sendBroadcast(String routes) {
         Intent intent = new Intent(action);
         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        intent.putExtra("routes", routes);
         LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
     }
 }

tool/src/main/java/io/netbird/client/tool/RouteChangeListener.java

@@ -0,0 +1,5 @@
+package io.netbird.client.tool;
+
+public interface RouteChangeListener {
+    void onRouteChanged(String routes);
+}

tool/src/main/java/io/netbird/client/tool/TUNCreatorLooperThread.java

@@ -0,0 +1,54 @@
+package io.netbird.client.tool;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.core.util.Consumer;
+
+import java.util.Objects;
+
+public class TUNCreatorLooperThread extends Thread {
+    private static final String TAG = TUNCreatorLooperThread.class.getSimpleName();
+    private Handler handler;
+
+    private final Consumer<String> tunCreator;
+
+    public TUNCreatorLooperThread(Consumer<String> tunCreator) {
+        this.tunCreator = tunCreator;
+    }
+
+    public void run() {
+        Looper.prepare();
+
+        synchronized (this) {
+            handler = new Handler(Objects.requireNonNull(Looper.myLooper())) {
+                @Override
+                public void handleMessage(@NonNull Message msg) {
+                    if (msg.what == 1) {
+                        Log.d(TAG, "handleMessage: renewing TUN!");
+                        String routes = msg.obj.toString();
+                        tunCreator.accept(routes);
+                    }
+                }
+            };
+            notifyAll();
+        }
+
+        Looper.loop();
+    }
+
+    public synchronized Handler getHandler() {
+        while (handler == null) {
+            try {
+                wait();
+            } catch (InterruptedException e) {
+                Log.d(TAG, "getHandler: ", e);
+            }
+        }
+
+        return handler;
+    }
+}

tool/src/main/java/io/netbird/client/tool/TUNParameters.java

@@ -0,0 +1,25 @@
+package io.netbird.client.tool;
+
+public class TUNParameters {
+    String address;
+    long mtu;
+    String dns;
+    String searchDomainsString;
+    String routesString;
+
+    public TUNParameters(String address, long mtu, String dns, String searchDomainsString, String routesString) {
+        this.address = address;
+        this.mtu = mtu;
+        this.dns = dns;
+        this.searchDomainsString = searchDomainsString;
+        this.routesString = routesString;
+    }
+
+    public boolean didRoutesChange(String routesString) {
+        if (this.routesString != null) {
+            return !this.routesString.equals(routesString);
+        } else {
+            return routesString != null;
+        }
+    }
+}