Enable restart behavior on start API (#8)

Author: alberto lalama

README.md

@@ -15,6 +15,7 @@ This plugin targets Android devices running Marshmellow (API 23), or higher. Thi
 `start(socksServerAddress:string) : Promise<string>;`
 
 Starts the VPN service, and tunnels all the traffic to the SOCKS5 server at `socksServerAddress`.
+Restarts tunneling while preserving the VPN connection if called when the plugin is already running.
 
 `stop(): Promise<string>;`
 

src/android/org/uproxy/tun2socks/DnsResolverService.java

@@ -56,6 +56,10 @@ public int onStartCommand(Intent intent, int flags, int startId) {
       Log.e(LOG_TAG, "Failed to receive socks server address.");
       return START_NOT_STICKY;
     }
+
+    if (m_dnsResolver != null) {
+      m_dnsResolver.interrupt();  // Stop resolver to handle reconnect.
+    }
     m_dnsResolver = new DnsUdpToSocksResolver(DnsResolverService.this);
     m_dnsResolver.start();
 
@@ -169,6 +173,7 @@ public void run() {
             e.printStackTrace();
             continue;
           }
+
           if (!writeUdpPacketToStream(dnsOutputStream, udpPacket)) {
             continue;
           }

src/android/org/uproxy/tun2socks/Tun2Socks.java

@@ -140,6 +140,10 @@ protected void startTunnelService(Context context) {
     Log.i(LOG_TAG, "starting tunnel service");
     if (isServiceRunning()) {
       Log.w(LOG_TAG, "already running service");
+      TunnelManager tunnelManager = TunnelState.getTunnelState().getTunnelManager();
+      if (tunnelManager != null) {
+        tunnelManager.restartTunnel(m_socksServerAddress);
+      }
       return;
     }
     Intent startTunnelVpn = new Intent(context, TunnelVpnService.class);

src/android/org/uproxy/tun2socks/Tun2SocksJni.java

@@ -15,8 +15,8 @@ public class Tun2SocksJni {
   // udpgw server.
   //
   // The tun device file descriptor should be set to non-blocking mode.
-  // tun2Socks takes ownership of the tun device file descriptor and will close
-  // it when tun2socks is stopped.
+  // tun2Socks does *not* take ownership of the tun device file descriptor; the
+  // caller is responsible for closing it after tun2socks terminates.
   //
   // runTun2Socks blocks until tun2socks is stopped by calling terminateTun2Socks.
   // It's safe to call terminateTun2Socks from a different thread.

src/android/org/uproxy/tun2socks/Tunnel.java

@@ -107,6 +107,12 @@ public synchronized boolean startTunneling(String socksServerAddress, String dns
     return routeThroughTunnel(socksServerAddress, dnsServerAddress);
   }
 
+  // Stops routing traffic through the tunnel by stopping tun2socks.
+  // The VPN is unaffected by this method.
+  public synchronized void stopTunneling() {
+    stopRoutingThroughTunnel();
+  }
+
   // Note: to avoid deadlock, do not call directly from a HostService callback;
   // instead post to a Handler if necessary to trigger from a HostService callback.
   public synchronized void stop() {
@@ -174,7 +180,7 @@ private boolean routeThroughTunnel(String socksServerAddress, String dnsServerAd
     if (!mRoutingThroughTunnel.compareAndSet(false, true)) {
       return false;
     }
-    ParcelFileDescriptor tunFd = mTunFd.getAndSet(null);
+    ParcelFileDescriptor tunFd = mTunFd.get();
     if (tunFd == null) {
       return false;
     }
@@ -196,6 +202,10 @@ private boolean routeThroughTunnel(String socksServerAddress, String dnsServerAd
     return true;
   }
 
+  private void stopRoutingThroughTunnel() {
+    stopTun2Socks();
+  }
+
   @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
   public void protectSocket(long fileDescriptor) {
     if (!((VpnService) mHostService.getVpnService()).protect((int) fileDescriptor)) {
@@ -208,11 +218,11 @@ private void stopVpn() {
     ParcelFileDescriptor tunFd = mTunFd.getAndSet(null);
     if (tunFd != null) {
       try {
+        mHostService.onDiagnosticMessage("closing VPN interface");
         tunFd.close();
       } catch (IOException e) {
       }
     }
-    mRoutingThroughTunnel.set(false);
   }
 
   //----------------------------------------------------------------------------
@@ -237,7 +247,7 @@ private void startTun2Socks(
               @Override
               public void run() {
                 Tun2SocksJni.runTun2Socks(
-                    vpnInterfaceFileDescriptor.detachFd(),
+                    vpnInterfaceFileDescriptor.getFd(),
                     vpnInterfaceMTU,
                     vpnIpAddress,
                     vpnNetMask,
@@ -259,6 +269,7 @@ private void stopTun2Socks() {
         Thread.currentThread().interrupt();
       }
       mTun2SocksThread = null;
+      mRoutingThroughTunnel.set(false);
       mHostService.onDiagnosticMessage("tun2socks stopped");
     }
   }

src/android/org/uproxy/tun2socks/TunnelManager.java

@@ -41,17 +41,17 @@ public class TunnelManager implements Tunnel.HostService {
   public static final String SOCKS_SERVER_ADDRESS_EXTRA = "socksServerAddress";
 
   private Service m_parentService = null;
-  private boolean m_firstStart = true;
-  private boolean m_signalledStop = false;
   private CountDownLatch m_tunnelThreadStopSignal;
   private Thread m_tunnelThread;
   private AtomicBoolean m_isStopping;
   private Tunnel m_tunnel = null;
   private String m_socksServerAddress;
+  private AtomicBoolean m_isReconnecting;
 
   public TunnelManager(Service parentService) {
     m_parentService = parentService;
     m_isStopping = new AtomicBoolean(false);
+    m_isReconnecting = new AtomicBoolean(false);
     m_tunnel = Tunnel.newTunnel(this);
   }
 
@@ -108,30 +108,40 @@ public void onDestroy() {
   // 1. VpnService doesn't respond to stopService calls
   // 2. The UI will not block while waiting for stopService to return
   public void signalStopService() {
-    m_signalledStop = true;
     if (m_tunnelThreadStopSignal != null) {
       m_tunnelThreadStopSignal.countDown();
     }
   }
 
-  public boolean signalledStop() {
-    return m_signalledStop;
+  // Stops the tunnel thread and restarts it with |socksServerAddress|.
+  public void restartTunnel(final String socksServerAddress) {
+    Log.i(LOG_TAG, "Restarting tunnel.");
+    if (socksServerAddress == null ||
+        socksServerAddress.equals(m_socksServerAddress)) {
+      // Don't reconnect if the socks server address hasn't changed.
+      return;
+    }
+    m_socksServerAddress = socksServerAddress;
+    m_isReconnecting.set(true);
+
+    // Signaling stop to the tunnel thread with the reconnect flag set causes
+    // the thread to stop the tunnel (but not the VPN or the service) and send
+    // the new SOCKS server address to the DNS resolver before exiting itself.
+    // When the DNS broadcasts its local address, the tunnel will restart.
+    signalStopService();
   }
 
   private void startTunnel(final String dnsResolverAddress) {
-    if (m_firstStart) {
-      m_firstStart = false;
-      m_tunnelThreadStopSignal = new CountDownLatch(1);
-      m_tunnelThread =
-          new Thread(
-              new Runnable() {
-                @Override
-                public void run() {
-                  runTunnel(m_socksServerAddress, dnsResolverAddress);
-                }
-              });
-      m_tunnelThread.start();
-    }
+    m_tunnelThreadStopSignal = new CountDownLatch(1);
+    m_tunnelThread =
+        new Thread(
+            new Runnable() {
+              @Override
+              public void run() {
+                runTunnel(m_socksServerAddress, dnsResolverAddress);
+              }
+            });
+    m_tunnelThread.start();
   }
 
   private void runTunnel(String socksServerAddress, String dnsResolverAddress) {
@@ -154,12 +164,20 @@ private void runTunnel(String socksServerAddress, String dnsResolverAddress) {
     } catch (Tunnel.Exception e) {
       Log.e(LOG_TAG, String.format("Start tunnel failed: %s", e.getMessage()));
     } finally {
-      Log.i(LOG_TAG, "Stopping tunnel...");
-      m_tunnel.stop();
-
-      // Stop service
-      m_parentService.stopForeground(true);
-      m_parentService.stopSelf();
+      if (m_isReconnecting.get()) {
+        // Stop tunneling only, not VPN, if reconnecting.
+        Log.i(LOG_TAG, "Stopping tunnel.");
+        m_tunnel.stopTunneling();
+        // Start the DNS resolver service with the new SOCKS server address.
+        startDnsResolverService();
+      } else {
+        // Stop VPN tunnel and service only if not reconnecting.
+        Log.i(LOG_TAG, "Stopping VPN and tunnel.");
+        m_tunnel.stop();
+        m_parentService.stopForeground(true);
+        m_parentService.stopSelf();
+      }
+      m_isReconnecting.set(false);
     }
   }
 
@@ -201,6 +219,10 @@ public void onTunnelConnected() {
   @TargetApi(Build.VERSION_CODES.M)
   public void onVpnEstablished() {
     Log.i(LOG_TAG, "VPN established.");
+    startDnsResolverService();
+  }
+
+  private void startDnsResolverService() {
     Intent dnsResolverStart = new Intent(m_parentService, DnsResolverService.class);
     dnsResolverStart.putExtra(SOCKS_SERVER_ADDRESS_EXTRA, m_socksServerAddress);
     m_parentService.startService(dnsResolverStart);

src/android/org/uproxy/tun2socks/TunnelVpnService.java

@@ -68,6 +68,7 @@ public void onCreate() {
 
   @Override
   public void onDestroy() {
+    Log.d(LOG_TAG, "on destroy");
     TunnelState.getTunnelState().setTunnelManager(null);
     m_tunnelManager.onDestroy();
   }

src/badvpn/tun2socks/tun2socks.c

@@ -298,7 +298,7 @@ static void udp_fd_handler(UdpPcb* udp_pcb, int event) {
     dns_get_header_id_str(dns_id_str, udp_pcb->udp_recv_buffer);
     const char* local_addr_str = BStringMap_Get(&udp_pcb->map, dns_id_str);
     if (!local_addr_str) {
-        BLog(BLOG_ERROR, "udp_fd_handler: no address for dns reqeust id %s",
+        BLog(BLOG_ERROR, "udp_fd_handler: no address for DNS request id %s",
              dns_id_str);
         return;
     }

src/badvpn/tuntap/BTap.c

@@ -488,7 +488,10 @@ int BTap_InitWithFD (BTap *o, BReactor *reactor, int fd, int mtu, BTap_handler_e
     o->handler_error_user = handler_error_user;
     o->frame_mtu = mtu;
     o->fd = fd;
-    o->close_fd = 1;
+    // ===== UPROXY =====
+    // Do not take ownership or close the TUN file descriptor
+    o->close_fd = 0;
+    // ===== /UPROXY =====
 
     // TODO: use BTap_Init2? Still some different behavior (we don't want the fcntl block; we do want close to be called)