refine #171

Conflicts:
	src/main/scala/com/github/shadowsocks/ShadowsocksNatService.scala

build.sbt

@@ -20,9 +20,9 @@ resolvers += "madeye private releases" at "http://madeye-maven-repository.google
 
 libraryDependencies ++= Seq(
   "dnsjava" % "dnsjava" % "2.1.5",
-  "org.scalaj" %% "scalaj-http" % "0.3.10",
+  "com.github.kevinsawicki" % "http-request" % "5.6",
   "commons-net" % "commons-net" % "3.3",
-  "com.google.zxing" % "android-integration" % "2.2"
+  "com.google.zxing" % "android-integration" % "3.1.0"
 )
 
 libraryDependencies ++= Seq(

src/main/AndroidManifest.xml

@@ -1,7 +1,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.github.shadowsocks"
-    android:versionCode="86"
-    android:versionName="2.4.6">
+    android:versionCode="91"
+    android:versionName="2.5.3">
 
   <uses-permission android:name="android.permission.INTERNET"/>
   <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
@@ -74,11 +74,13 @@
 
     <service
         android:name=".ShadowsocksNatService"
+        android:process=":nat"
         android:exported="false">
     </service>
 
     <service
         android:name=".ShadowsocksVpnService"
+        android:process=":vpn"
         android:label="@string/app_name"
         android:permission="android.permission.BIND_VPN_SERVICE"
         android:exported="false">

src/main/res/values-zh/strings.xml

@@ -46,6 +46,7 @@
   <string name="forward_stop">后台服务已停止。</string>
   <string name="service_failed">无法连接远程服务器</string>
   <string name="stop">停止服务</string>
+  <string name="stopping">正在关闭...</string>
   <string name="vpn_error">后台服务启动失败：\"%s\"。</string>
   <string name="ok_iknow">确定</string>
   <string name="port_alert">端口号应大于1024</string>
@@ -68,6 +69,9 @@
   <string name="flushing">刷新中...</string>
   <string name="add_profile">添加配置文件</string>
 
+  <string name="enable_nat">启用 NAT 模式.</string>
+  <string name="disable_nat">禁用 NAT 模式.</string>
+
   <string name="udp_dns">UDP 转发</string>
   <string name="udp_dns_summary">由远程服务器转发 UDP 协议的数据包</string>
 

src/main/res/values/strings.xml

@@ -57,7 +57,10 @@
   <string name="forward_stop">Shadowsocks stopped.</string>
   <string name="service_failed">Failed to connect the remote server</string>
   <string name="stop">Stop the service</string>
+  <string name="stopping">Shutting down...</string>
   <string name="vpn_error">Error: \"%s\".</string>
+  <string name="enable_nat">Turn on NAT mode.</string>
+  <string name="disable_nat">Turn off NAT mode.</string>
 
   <!-- alert category -->
   <string name="ok_iknow">OK</string>

src/main/scala/com/github/shadowsocks/AppManager.scala

@@ -46,7 +46,6 @@ import android.content.pm.PackageManager
 import android.graphics.{Bitmap, PixelFormat}
 import android.os.Bundle
 import android.os.Handler
-import android.os.Message
 import android.preference.PreferenceManager
 import android.view.View
 import android.view.View.OnClickListener
@@ -62,7 +61,10 @@ import com.nostra13.universalimageloader.core.{DisplayImageOptions, ImageLoader,
 import com.nostra13.universalimageloader.core.display.FadeInBitmapDisplayer
 import com.github.shadowsocks.utils.{Utils, Scheme, Key}
 
-case class ProxiedApp(uid: Int, name: String, var proxied: Boolean)
+import scala.concurrent.ops._
+import scala.language.implicitConversions
+
+case class ProxiedApp(uid: Int, name: String, packageName: String, var proxied: Boolean)
 
 class ObjectArrayTools[T <: AnyRef](a: Array[T]) {
   def binarySearch(key: T) = {
@@ -74,7 +76,7 @@ case class ListEntry(box: CheckBox, text: TextView, icon: ImageView)
 
 object AppManager {
 
-  implicit def anyrefarray_tools[T <: AnyRef](a: Array[T]) = new ObjectArrayTools(a)
+  implicit def anyrefarray_tools[T <: AnyRef](a: Array[T]): ObjectArrayTools[T] = new ObjectArrayTools(a)
 
   def getProxiedApps(context: Context, proxiedAppString: String): Array[ProxiedApp] = {
 
@@ -86,13 +88,13 @@ object AppManager {
     val appList = packageManager.getInstalledApplications(0)
 
     appList.filter(_.uid >= 10000).map {
-      case a => {
+      case a =>
         val uid = a.uid
         val userName = uid.toString
+        val name = packageManager.getApplicationLabel(a).toString
         val packageName = a.packageName
         val proxied = proxiedApps.binarySearch(userName) >= 0
-        new ProxiedApp(uid, packageName, proxied)
-      }
+        new ProxiedApp(uid, name, packageName, proxied)
     }.toArray
   }
 }
@@ -103,7 +105,7 @@ class AppManager extends Activity with OnCheckedChangeListener with OnClickListe
   val MSG_LOAD_FINISH = 2
   val STUB = android.R.drawable.sym_def_app_icon
 
-  implicit def anyrefarray_tools[T <: AnyRef](a: Array[T]) = new ObjectArrayTools(a)
+  implicit def anyrefarray_tools[T <: AnyRef](a: Array[T]): ObjectArrayTools[T] = new ObjectArrayTools(a)
 
   var apps: Array[ProxiedApp] = null
   var appListView: ListView = null
@@ -129,8 +131,9 @@ class AppManager extends Activity with OnCheckedChangeListener with OnClickListe
         val uid = a.uid
         val userName = uid.toString
         val name = packageManager.getApplicationLabel(a).toString
+        val packageName = a.packageName
         val proxied = (proxiedApps binarySearch userName) >= 0
-        new ProxiedApp(uid, name, proxied)
+        new ProxiedApp(uid, name, packageName, proxied)
     }.toArray
   }
 
@@ -175,7 +178,7 @@ class AppManager extends Activity with OnCheckedChangeListener with OnClickListe
             .cacheOnDisc()
             .displayer(new FadeInBitmapDisplayer(300))
             .build()
-        ImageLoader.getInstance().displayImage(Scheme.APP + app.uid, entry.icon, options)
+        ImageLoader.getInstance().displayImage(Scheme.APP + app.packageName, entry.icon, options)
 
         entry.text.setText(app.name)
         val box: CheckBox = entry.box
@@ -243,18 +246,17 @@ class AppManager extends Activity with OnCheckedChangeListener with OnClickListe
       }
     })
     bypassSwitch.setChecked(prefs.getBoolean(Key.isBypassApps, false))
+
+    appListView = findViewById(R.id.applistview).asInstanceOf[ListView]
   }
 
   protected override def onResume() {
     super.onResume()
-    new Thread {
-      override def run() {
-        handler.post(loadStartRunnable)
-        appListView = findViewById(R.id.applistview).asInstanceOf[ListView]
-        if (!appsLoaded) loadApps()
-        handler.post(loadFinishRunnable)
-      }
-    }.start()
+    spawn {
+      handler.post(loadStartRunnable)
+      if (!appsLoaded) loadApps()
+      handler.post(loadFinishRunnable)
+    }
   }
 
   def saveAppSettings(context: Context) {
@@ -319,8 +321,8 @@ class AppManager extends Activity with OnCheckedChangeListener with OnClickListe
     }
 
     override def getStreamFromOtherSource(imageUri: String, extra: AnyRef): InputStream = {
-      val uid = imageUri.substring(Scheme.APP.length).toInt
-      val drawable = Utils.getAppIcon(getBaseContext, uid)
+      val packageName = imageUri.substring(Scheme.APP.length)
+      val drawable = Utils.getAppIcon(getBaseContext, packageName)
       val bitmap = Utils.drawableToBitmap(drawable)
 
       val os = new ByteArrayOutputStream()

src/main/scala/com/github/shadowsocks/BaseService.scala

@@ -81,11 +81,15 @@ trait BaseService {
     }
 
     override def stop() {
-      stopRunner()
+      if (state != State.CONNECTING && state != State.STOPPING) {
+        stopRunner()
+      }
     }
 
     override def start(config: Config) {
-      startRunner(config)
+      if (state != State.CONNECTING && state != State.STOPPING) {
+        startRunner(config)
+      }
     }
   }
 

src/main/scala/com/github/shadowsocks/Shadowsocks.scala

@@ -40,6 +40,7 @@ package com.github.shadowsocks
 
 import java.util
 import java.io.{OutputStream, InputStream, ByteArrayInputStream, ByteArrayOutputStream, IOException, FileOutputStream}
+import java.util.Locale
 
 import android.app.backup.BackupManager
 import android.app.{Activity, AlertDialog, ProgressDialog}
@@ -51,6 +52,7 @@ import android.net.{Uri, VpnService}
 import android.os._
 import android.preference._
 import android.util.{DisplayMetrics, Log}
+import android.view.View.OnLongClickListener
 import android.view._
 import android.webkit.{WebView, WebViewClient}
 import android.widget._
@@ -67,7 +69,6 @@ import net.simonvt.menudrawer.MenuDrawer
 
 import scala.collection.mutable.{ArrayBuffer, ListBuffer}
 import scala.concurrent.ops._
-import scala.ref.WeakReference
 
 class ProfileIconDownloader(context: Context, connectTimeout: Int, readTimeout: Int)
   extends BaseImageDownloader(context, connectTimeout, readTimeout) {
@@ -322,35 +323,34 @@ class Shadowsocks
   }
 
   private def crash_recovery() {
-    val ab = new ArrayBuffer[String]
+    val cmd = new ArrayBuffer[String]()
 
-    ab.append("kill -9 `cat /data/data/com.github.shadowsocks/ss-local.pid`")
-    ab.append("kill -9 `cat /data/data/com.github.shadowsocks/ss-tunnel.pid`")
-    ab.append("kill -9 `cat /data/data/com.github.shadowsocks/tun2socks.pid`")
-
-    ab.append("kill -9 `cat /data/data/com.github.shadowsocks/pdnsd.pid`")
-    ab.append("rm /data/data/com.github.shadowsocks/pdnsd.pid")
-    ab.append("rm /data/data/com.github.shadowsocks/pdnsd.conf")
-    ab.append("rm /data/data/com.github.shadowsocks/pdnsd.cache")
-
-    Console.runCommand(ab.toArray)
-
-    if (!Utils.isLollipopOrAbove) {
-      ab.clear()
-
-      ab.append("kill -9 `cat /data/data/com.github.shadowsocks/redsocks.pid`")
-      ab.append("rm /data/data/com.github.shadowsocks/redsocks.conf")
-      ab.append("rm /data/data/com.github.shadowsocks/redsocks.pid")
-
-      ab.append("kill -9 `cat /data/data/com.github.shadowsocks/pdnsd.pid`")
-      ab.append("rm /data/data/com.github.shadowsocks/pdnsd.pid")
-      ab.append("rm /data/data/com.github.shadowsocks/pdnsd.conf")
-      ab.append("rm /data/data/com.github.shadowsocks/pdnsd.cache")
-
-      ab.append(Utils.getIptables + " -t nat -F OUTPUT")
-
-      Console.runRootCommand(ab.toArray)
+    for (task <- Array("ss-local", "ss-tunnel", "pdnsd", "redsocks", "tun2socks")) {
+      cmd.append("chmod 666 %s%s-nat.pid".formatLocal(Locale.ENGLISH, Path.BASE, task))
+      cmd.append("chmod 666 %s%s-vpn.pid".formatLocal(Locale.ENGLISH, Path.BASE, task))
     }
+    Console.runRootCommand(cmd.toArray)
+    cmd.clear()
+
+    for (task <- Array("ss-local", "ss-tunnel", "pdnsd", "redsocks", "tun2socks")) {
+      try {
+        val pid_nat = scala.io.Source.fromFile(Path.BASE + task + "-nat.pid").mkString.trim.toInt
+        val pid_vpn = scala.io.Source.fromFile(Path.BASE + task + "-vpn.pid").mkString.trim.toInt
+        cmd.append("kill -9 %d".formatLocal(Locale.ENGLISH, pid_nat))
+        cmd.append("kill -9 %d".formatLocal(Locale.ENGLISH, pid_vpn))
+        Process.killProcess(pid_nat)
+        Process.killProcess(pid_vpn)
+      } catch {
+        case e: Throwable => Log.e(Shadowsocks.TAG, "unable to kill " + task)
+      }
+      cmd.append("rm -f %s%s-nat.pid".formatLocal(Locale.ENGLISH, Path.BASE, task))
+      cmd.append("rm -f %s%s-nat.conf".formatLocal(Locale.ENGLISH, Path.BASE, task))
+      cmd.append("rm -f %s%s-vpn.pid".formatLocal(Locale.ENGLISH, Path.BASE, task))
+      cmd.append("rm -f %s%s-vpn.conf".formatLocal(Locale.ENGLISH, Path.BASE, task))
+    }
+    Console.runCommand(cmd.toArray)
+    Console.runRootCommand(cmd.toArray)
+    Console.runRootCommand(Utils.getIptables + " -t nat -F OUTPUT")
   }
 
   private def getVersionName: String = {
@@ -500,13 +500,30 @@ class Shadowsocks
     getActionBar.setDisplayShowTitleEnabled(false)
     getActionBar.setDisplayShowCustomEnabled(true)
     getActionBar.setIcon(R.drawable.ic_stat_shadowsocks)
+    title.setOnLongClickListener(new OnLongClickListener {
+      override def onLongClick(v: View): Boolean = {
+        if (Utils.isLollipopOrAbove && bgService != null
+          && (bgService.getState == State.INIT || bgService.getState == State.STOPPED)) {
+          val natEnabled = status.getBoolean(Key.isNAT, false)
+          status.edit().putBoolean(Key.isNAT, !natEnabled).commit()
+          if (!natEnabled) {
+            Toast.makeText(getBaseContext, R.string.enable_nat, Toast.LENGTH_LONG).show()
+          } else {
+            Toast.makeText(getBaseContext, R.string.disable_nat, Toast.LENGTH_LONG).show()
+          }
+          true
+        } else {
+          false
+        }
+      }
+    })
 
     // Register broadcast receiver
     registerReceiver(preferenceReceiver, new IntentFilter(Action.UPDATE_PREFS))
 
     // Bind to the service
     spawn {
-      val isRoot = !Utils.isLollipopOrAbove && Console.isRoot
+      val isRoot = (!Utils.isLollipopOrAbove || status.getBoolean(Key.isNAT, false)) && Console.isRoot
       handler.post(new Runnable {
         override def run() {
           status.edit.putBoolean(Key.isRoot, isRoot).commit()
@@ -576,6 +593,9 @@ class Shadowsocks
             h.postDelayed(new Runnable() {
               def run() {
                 val integrator = new IntentIntegrator(Shadowsocks.this)
+                val list = new java.util.ArrayList(IntentIntegrator.TARGET_ALL_KNOWN)
+                list.add("tw.com.quickmark")
+                integrator.setTargetApplications(list)
                 integrator.initiateScan()
                 h.sendEmptyMessage(0)
               }
@@ -653,7 +673,7 @@ class Shadowsocks
     if (!profile.isDefined) return false
 
     new AlertDialog.Builder(this)
-      .setMessage(String.format(getString(R.string.remove_profile), profile.get.name))
+      .setMessage(String.format(Locale.ENGLISH, getString(R.string.remove_profile), profile.get.name))
       .setCancelable(false)
       .setNegativeButton(R.string.no, new DialogInterface.OnClickListener() {
       override def onClick(dialog: DialogInterface, i: Int) = dialog.cancel()
@@ -821,7 +841,7 @@ class Shadowsocks
     val ab = new ArrayBuffer[String]
     ab.append("mount -o rw,remount -t yaffs2 /dev/block/mtdblock3 /system")
     for (executable <- Shadowsocks.EXECUTABLES) {
-      ab.append("cp %s%s /system/bin/".format(Path.BASE, executable))
+      ab.append("cp %s%s /system/bin/".formatLocal(Locale.ENGLISH, Path.BASE, executable))
       ab.append("chmod 755 /system/bin/" + executable)
       ab.append("chown root:shell /system/bin/" + executable)
     }
@@ -957,7 +977,7 @@ class Shadowsocks
     }
 
     new AlertDialog.Builder(this)
-      .setTitle(getString(R.string.about_title).format(versionName))
+      .setTitle(getString(R.string.about_title).formatLocal(Locale.ENGLISH, versionName))
       .setCancelable(false)
       .setNegativeButton(getString(R.string.ok_iknow), new DialogInterface.OnClickListener() {
       override def onClick(dialog: DialogInterface, id: Int) {
@@ -1002,11 +1022,16 @@ class Shadowsocks
                   .setDuration(Configuration.DURATION_LONG)
                   .build()
                 Crouton
-                  .makeText(Shadowsocks.this, getString(R.string.vpn_error).format(m), style)
+                  .makeText(Shadowsocks.this, getString(R.string.vpn_error).formatLocal(Locale.ENGLISH, m), style)
                   .setConfiguration(config)
                   .show()
               }
               setPreferenceEnabled(enabled = true)
+            case State.STOPPING =>
+              if (progressDialog == null) {
+                progressDialog = ProgressDialog
+                  .show(Shadowsocks.this, "", getString(R.string.stopping), true, true)
+              }
           }
         }
       }

src/main/scala/com/github/shadowsocks/ShadowsocksNatService.scala

@@ -41,14 +41,16 @@ package com.github.shadowsocks
 
 import java.io.File
 import java.lang.reflect.{InvocationTargetException, Method}
-import java.util.{Timer, TimerTask}
+import java.util.Locale
 
 import android.app.{Notification, NotificationManager, PendingIntent, Service}
 import android.content._
 import android.content.pm.{PackageInfo, PackageManager}
+import android.net.{Network, ConnectivityManager}
 import android.os._
 import android.support.v4.app.NotificationCompat
-import android.util.Log
+import android.util.{SparseArray, Log}
+import android.widget.Toast
 import com.github.shadowsocks.aidl.Config
 import com.github.shadowsocks.utils._
 import com.google.android.gms.analytics.HitBuilders
@@ -70,8 +72,12 @@ class ShadowsocksNatService extends Service with BaseService {
   private val mStartForegroundSignature = Array[Class[_]](classOf[Int], classOf[Notification])
   private val mStopForegroundSignature = Array[Class[_]](classOf[Boolean])
   private val mSetForegroundSignature = Array[Class[_]](classOf[Boolean])
+  private val mSetForegroundArgs = new Array[AnyRef](1)
+  private val mStartForegroundArgs = new Array[AnyRef](2)
+  private val mStopForegroundArgs = new Array[AnyRef](1)
 
-  var receiver: BroadcastReceiver = null
+  var closeReceiver: BroadcastReceiver = null
+  var connReceiver: BroadcastReceiver = null
   var notificationManager: NotificationManager = null
   var config: Config = null
   var apps: Array[ProxiedApp] = null
@@ -80,17 +86,100 @@ class ShadowsocksNatService extends Service with BaseService {
   private var mSetForeground: Method = null
   private var mStartForeground: Method = null
   private var mStopForeground: Method = null
-  private var mSetForegroundArgs = new Array[AnyRef](1)
-  private var mStartForegroundArgs = new Array[AnyRef](2)
-  private var mStopForegroundArgs = new Array[AnyRef](1)
-
-  private var lastTxRate = 0
-  private var lastRxRate = 0
-  private var timer: Timer = null
-  private val TIMER_INTERVAL = 2
 
   private lazy val application = getApplication.asInstanceOf[ShadowsocksApplication]
 
+  private val dnsAddressCache = new SparseArray[String]
+
+  def getNetId(network: Network): Int = {
+    network.getClass.getDeclaredField("netId").get(network).asInstanceOf[Int]
+  }
+
+  def restoreDnsForAllNetwork() {
+    val manager = getSystemService(Context.CONNECTIVITY_SERVICE).asInstanceOf[ConnectivityManager]
+    val networks = manager.getAllNetworks
+    val cmdBuf = new ArrayBuffer[String]()
+    networks.foreach(network => {
+      val netId = getNetId(network)
+      val oldDns = dnsAddressCache.get(netId)
+      if (oldDns != null) {
+        cmdBuf.append("ndc resolver setnetdns %d \"\" %s".formatLocal(Locale.ENGLISH, netId, oldDns))
+        dnsAddressCache.remove(netId)
+      }
+    })
+    if (cmdBuf.nonEmpty) Console.runRootCommand(cmdBuf.toArray)
+  }
+
+  def setDnsForAllNetwork(dns: String) {
+    val manager = getSystemService(Context.CONNECTIVITY_SERVICE).asInstanceOf[ConnectivityManager]
+    val networks = manager.getAllNetworks
+    if (networks == null) return
+
+    val cmdBuf = new ArrayBuffer[String]()
+    networks.foreach(network => {
+      val networkInfo = manager.getNetworkInfo(network)
+      if (networkInfo == null) return
+      if (networkInfo.isConnected) {
+        val netId = getNetId(network)
+        val curDnsList = manager.getLinkProperties(network).getDnsServers
+        if (curDnsList != null) {
+          import scala.collection.JavaConverters._
+          val curDns = curDnsList.asScala.map(ip => ip.getHostAddress).mkString(" ")
+          if (curDns != dns) {
+            dnsAddressCache.put(netId, curDns)
+            cmdBuf.append("ndc resolver setnetdns %d \"\" %s".formatLocal(Locale.ENGLISH, netId, dns))
+          }
+        }
+      }
+    })
+    if (cmdBuf.nonEmpty) Console.runRootCommand(cmdBuf.toArray)
+  }
+
+  def setupDns() {
+    setDnsForAllNetwork("127.0.0.1")
+  }
+
+  def resetDns() = {
+    restoreDnsForAllNetwork()
+  }
+
+  def flushDns() {
+    if (Utils.isLollipopOrAbove) {
+      val manager = getSystemService(Context.CONNECTIVITY_SERVICE).asInstanceOf[ConnectivityManager]
+      val networks = manager.getAllNetworks
+      val cmdBuf = new ArrayBuffer[String]()
+      networks.foreach(network => {
+        val networkInfo = manager.getNetworkInfo(network)
+        if (networkInfo.isAvailable) {
+          val netId = network.getClass.getDeclaredField("netId").get(network).asInstanceOf[Int]
+          cmdBuf.append("ndc resolver flushnet %d".formatLocal(Locale.ENGLISH, netId))
+        }
+      })
+      Console.runRootCommand(cmdBuf.toArray)
+    } else {
+      Console.runRootCommand(Array("ndc resolver flushdefaultif", "ndc resolver flushif wlan0"))
+    }
+  }
+
+
+  def destroyConnectionReceiver() {
+    if (connReceiver != null) {
+      unregisterReceiver(connReceiver)
+      connReceiver = null
+    }
+    resetDns()
+  }
+
+  def initConnectionReceiver() {
+    val filter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)
+    connReceiver = new BroadcastReceiver {
+      override def onReceive(context: Context, intent: Intent) = {
+        setupDns()
+      }
+    }
+    registerReceiver(connReceiver, filter)
+  }
+
   def startShadowsocksDaemon() {
     if (config.route != Route.ALL) {
       val acl: Array[String] = config.route match {
@@ -103,17 +192,17 @@ class ShadowsocksNatService extends Service with BaseService {
     }
 
     val conf = ConfigUtils
-      .SHADOWSOCKS.format(config.proxy, config.remotePort, config.localPort,
+      .SHADOWSOCKS.formatLocal(Locale.ENGLISH, config.proxy, config.remotePort, config.localPort,
         config.sitekey, config.encMethod, 10)
-    ConfigUtils.printToFile(new File(Path.BASE + "ss-local.json"))(p => {
+    ConfigUtils.printToFile(new File(Path.BASE + "ss-local-nat.conf"))(p => {
       p.println(conf)
     })
 
     val cmd = new ArrayBuffer[String]
     cmd += (Path.BASE + "ss-local"
           , "-b" , "127.0.0.1"
-          , "-c" , Path.BASE + "ss-local.json"
-          , "-f" , Path.BASE + "ss-local.pid")
+          , "-c" , Path.BASE + "ss-local-nat.conf"
+          , "-f" , Path.BASE + "ss-local-nat.pid")
 
     if (config.route != Route.ALL) {
       cmd += "--acl"
@@ -127,26 +216,37 @@ class ShadowsocksNatService extends Service with BaseService {
   def startTunnel() {
     if (config.isUdpDns) {
       val conf = ConfigUtils
-        .SHADOWSOCKS.format(config.proxy, config.remotePort, 8153,
+        .SHADOWSOCKS.formatLocal(Locale.ENGLISH, config.proxy, config.remotePort, 8153,
           config.sitekey, config.encMethod, 10)
-      ConfigUtils.printToFile(new File(Path.BASE + "ss-tunnel.json"))(p => {
+      ConfigUtils.printToFile(new File(Path.BASE + "ss-tunnel-nat.conf"))(p => {
         p.println(conf)
       })
       val cmd = new ArrayBuffer[String]
       cmd += (Path.BASE + "ss-tunnel" , "-u"
             , "-b" , "127.0.0.1"
-            , "-l" , "8153" 
             , "-L" , "8.8.8.8:53"
-            , "-c" , Path.BASE + "ss-tunnel.json"
-            , "-f" , Path.BASE + "ss-tunnel.pid")
+            , "-c" , Path.BASE + "ss-tunnel-nat.conf"
+            , "-f" , Path.BASE + "ss-tunnel-nat.pid")
+
+      if (Utils.isLollipopOrAbove) {
+        cmd += ("-l" , "53")
+      } else {
+        cmd += ("-l" , "8153")
+      }
 
       if (BuildConfig.DEBUG) Log.d(TAG, cmd.mkString(" "))
-      Console.runCommand(cmd.mkString(" "))
+
+      if (Utils.isLollipopOrAbove) {
+        Console.runRootCommand(cmd.mkString(" "))
+      } else {
+        Console.runCommand(cmd.mkString(" "))
+      }
+
     } else {
       val conf = ConfigUtils
-        .SHADOWSOCKS.format(config.proxy, config.remotePort, 8163,
+        .SHADOWSOCKS.formatLocal(Locale.ENGLISH, config.proxy, config.remotePort, 8163,
           config.sitekey, config.encMethod, 10)
-      ConfigUtils.printToFile(new File(Path.BASE + "ss-tunnel.json"))(p => {
+      ConfigUtils.printToFile(new File(Path.BASE + "ss-tunnel-nat.conf"))(p => {
         p.println(conf)
       })
       val cmdBuf = new ArrayBuffer[String]
@@ -154,8 +254,8 @@ class ShadowsocksNatService extends Service with BaseService {
         , "-b" , "127.0.0.1"
         , "-l" , "8163"
         , "-L" , "8.8.8.8:53"
-        , "-c" , Path.BASE + "ss-tunnel.json"
-        , "-f" , Path.BASE + "ss-tunnel.pid")
+        , "-c" , Path.BASE + "ss-tunnel-nat.conf"
+        , "-f" , Path.BASE + "ss-tunnel-nat.pid")
 
       if (BuildConfig.DEBUG) Log.d(TAG, cmdBuf.mkString(" "))
       Console.runCommand(cmdBuf.mkString(" "))
@@ -163,15 +263,26 @@ class ShadowsocksNatService extends Service with BaseService {
   }
 
   def startDnsDaemon() {
-    val conf = ConfigUtils
-      .PDNSD_BYPASS.format("127.0.0.1", getString(R.string.exclude), 8163)
-    ConfigUtils.printToFile(new File(Path.BASE + "pdnsd.conf"))(p => {
+    val conf = if (Utils.isLollipopOrAbove) {
+      ConfigUtils
+        .PDNSD_BYPASS.formatLocal(Locale.ENGLISH, "127.0.0.1", 53, Path.BASE + "pdnsd-nat.pid", getString(R.string.exclude), 8163)
+    } else {
+      ConfigUtils
+        .PDNSD_BYPASS.formatLocal(Locale.ENGLISH, "127.0.0.1", 8153, Path.BASE + "pdnsd-nat.pid", getString(R.string.exclude), 8163)
+    }
+    ConfigUtils.printToFile(new File(Path.BASE + "pdnsd-nat.conf"))(p => {
        p.println(conf)
     })
-    val cmd = Path.BASE + "pdnsd -c " + Path.BASE + "pdnsd.conf"
+    val cmd = Path.BASE + "pdnsd -c " + Path.BASE + "pdnsd-nat.conf"
 
     if (BuildConfig.DEBUG) Log.d(TAG, cmd)
-    Console.runCommand(cmd)
+
+    if (Utils.isLollipopOrAbove) {
+      Console.runRootCommand(cmd)
+    } else {
+      Console.runCommand(cmd)
+    }
+
   }
 
   def getVersionName: String = {
@@ -187,15 +298,15 @@ class ShadowsocksNatService extends Service with BaseService {
   }
 
   def startRedsocksDaemon() {
-    val conf = ConfigUtils.REDSOCKS.format(config.localPort)
-    val cmd = Path.BASE + "redsocks -p %sredsocks.pid -c %sredsocks.conf"
-      .format(Path.BASE, Path.BASE)
-    ConfigUtils.printToFile(new File(Path.BASE + "redsocks.conf"))(p => {
+    val conf = ConfigUtils.REDSOCKS.formatLocal(Locale.ENGLISH, config.localPort)
+    val cmd = Path.BASE + "redsocks -p %sredsocks-nat.pid -c %sredsocks-nat.conf"
+      .formatLocal(Locale.ENGLISH, Path.BASE, Path.BASE)
+    ConfigUtils.printToFile(new File(Path.BASE + "redsocks-nat.conf"))(p => {
       p.println(conf)
     })
 
     if (BuildConfig.DEBUG) Log.d(TAG, cmd)
-    Console.runCommand(cmd);
+    Console.runCommand(cmd)
   }
 
   /** Called when the activity is first created. */
@@ -206,7 +317,6 @@ class ShadowsocksNatService extends Service with BaseService {
     startRedsocksDaemon()
     startShadowsocksDaemon()
     setupIptables()
-    flushDNS()
 
     true
   }
@@ -280,20 +390,28 @@ class ShadowsocksNatService extends Service with BaseService {
   }
 
   def killProcesses() {
+    val cmd = new ArrayBuffer[String]()
+
+    for (task <- Array("ss-local", "ss-tunnel", "pdnsd", "redsocks")) {
+      cmd.append("chmod 666 %s%s-nat.pid".formatLocal(Locale.ENGLISH, Path.BASE, task))
+    }
+    Console.runRootCommand(cmd.toArray)
+    cmd.clear()
+
     for (task <- Array("ss-local", "ss-tunnel", "pdnsd", "redsocks")) {
       try {
-        val pid = scala.io.Source.fromFile(Path.BASE + task + ".pid").mkString.trim.toInt
+        val pid = scala.io.Source.fromFile(Path.BASE + task + "-nat.pid").mkString.trim.toInt
+        cmd.append("kill -9 %d".formatLocal(Locale.ENGLISH, pid))
         Process.killProcess(pid)
-        Log.d(TAG, "kill pid: " + pid)
       } catch {
-        case e: Throwable => Log.e(TAG, "unable to kill " + task, e)
+        case e: Throwable => Log.e(TAG, "unable to kill " + task)
       }
+      cmd.append("rm -f %s%s-nat.pid".formatLocal(Locale.ENGLISH, Path.BASE, task))
+      cmd.append("rm -f %s%s-nat.conf".formatLocal(Locale.ENGLISH, Path.BASE, task))
     }
-    Console.runRootCommand(Utils.getIptables + " -t nat -F OUTPUT")
-  }
 
-  def flushDNS() {
-    Console.runRootCommand(Array("ndc resolver flushdefaultif", "ndc resolver flushif wlan0"))
+    Console.runRootCommand(cmd.toArray)
+    Console.runRootCommand(Utils.getIptables + " -t nat -F OUTPUT")
   }
 
   def setupIptables() = {
@@ -308,9 +426,13 @@ class ShadowsocksNatService extends Service with BaseService {
     }
     init_sb.append(cmd_bypass.replace("0.0.0.0", "127.0.0.1"))
     init_sb.append(cmd_bypass.replace("-d 0.0.0.0", "-m owner --uid-owner " + myUid))
+    init_sb.append(cmd_bypass.replace("-d 0.0.0.0", "--dport 53"))
+
+    if (!Utils.isLollipopOrAbove) {
+      init_sb.append(Utils.getIptables
+        + " -t nat -A OUTPUT -p udp --dport 53 -j DNAT --to-destination 127.0.0.1:" + DNS_PORT)
+    }
 
-    init_sb.append(Utils.getIptables
-      + " -t nat -A OUTPUT -p udp --dport 53 -j DNAT --to-destination 127.0.0.1:" + DNS_PORT)
     if (config.isGlobalProxy || config.isBypassApps) {
       http_sb.append(Utils.getIptables + CMD_IPTABLES_DNAT_ADD_SOCKS)
     }
@@ -378,17 +500,20 @@ class ShadowsocksNatService extends Service with BaseService {
 
     config = c
 
+    // register connection receiver
+    if (Utils.isLollipopOrAbove) initConnectionReceiver()
+
     // register close receiver
     val filter = new IntentFilter()
     filter.addAction(Intent.ACTION_SHUTDOWN)
     filter.addAction(Action.CLOSE)
-    receiver = new BroadcastReceiver() {
+    closeReceiver = new BroadcastReceiver() {
       def onReceive(p1: Context, p2: Intent) {
+        Toast.makeText(p1, R.string.stopping, Toast.LENGTH_SHORT).show()
         stopRunner()
       }
     }
-    registerReceiver(receiver, filter)
-
+    registerReceiver(closeReceiver, filter)
 
     // send event
     application.tracker.send(new HitBuilders.EventBuilder()
@@ -415,6 +540,7 @@ class ShadowsocksNatService extends Service with BaseService {
 
       if (config != null) {
 
+        // Clean up
         killProcesses()
 
         var resolved: Boolean = false
@@ -431,8 +557,13 @@ class ShadowsocksNatService extends Service with BaseService {
         }
 
         if (resolved && handleConnection) {
+
+          // Set DNS
+          if (Utils.isLollipopOrAbove) setupDns()
+          flushDns()
+
           notifyForegroundAlert(getString(R.string.forward_success),
-            getString(R.string.service_running).format(config.profileName))
+            getString(R.string.service_running).formatLocal(Locale.ENGLISH, config.profileName))
           changeState(State.CONNECTED)
         } else {
           changeState(State.STOPPED, getString(R.string.service_failed))
@@ -444,8 +575,17 @@ class ShadowsocksNatService extends Service with BaseService {
 
   override def stopRunner() {
 
-    // change the state
-    changeState(State.STOPPED)
+    // channge the state
+    changeState(State.STOPPING)
+
+    // clean up recevier
+    if (closeReceiver != null) {
+      unregisterReceiver(closeReceiver)
+      closeReceiver = null
+    }
+    if (Utils.isLollipopOrAbove) {
+      destroyConnectionReceiver()
+    }
 
     // send event
     application.tracker.send(new HitBuilders.EventBuilder()
@@ -454,12 +594,6 @@ class ShadowsocksNatService extends Service with BaseService {
       .setLabel(getVersionName)
       .build())
 
-    // reset timer
-    if (timer != null) {
-      timer.cancel()
-      timer = null
-    }
-
     // reset NAT
     killProcesses()
 
@@ -468,17 +602,14 @@ class ShadowsocksNatService extends Service with BaseService {
       stopSelf()
     }
 
-    // clean up context
-    if (receiver != null) {
-      unregisterReceiver(receiver)
-      receiver = null
-    }
-
     stopForegroundCompat(1)
+
+    // change the state
+    changeState(State.STOPPED)
   }
 
   override def stopBackgroundService() {
-    stopRunner()
+    stopSelf()
   }
 
   override def getTag = TAG

src/main/scala/com/github/shadowsocks/ShadowsocksRunnerActivity.scala

@@ -50,7 +50,8 @@ import com.github.shadowsocks.aidl.IShadowsocksService
 
 class ShadowsocksRunnerActivity extends Activity {
 
-  lazy val settings = PreferenceManager.getDefaultSharedPreferences(this)
+  private lazy val settings = PreferenceManager.getDefaultSharedPreferences(this)
+  private lazy val status = getSharedPreferences(Key.status, Context.MODE_PRIVATE)
 
   val handler = new Handler()
   val connection = new ServiceConnection {
@@ -72,10 +73,10 @@ class ShadowsocksRunnerActivity extends Activity {
 
   def isVpnEnabled: Boolean = {
     if (vpnEnabled < 0) {
-      vpnEnabled = if (Utils.isLollipopOrAbove || !Console.isRoot) {
-        1
-      } else {
+      vpnEnabled = if ((!Utils.isLollipopOrAbove || status.getBoolean(Key.isNAT, false)) && Console.isRoot) {
         0
+      } else {
+        1
       }
     }
     if (vpnEnabled == 1) true else false

src/main/scala/com/github/shadowsocks/ShadowsocksVpnService.scala

@@ -40,15 +40,15 @@
 package com.github.shadowsocks
 
 import java.io.File
-import java.net.InetAddress
+import java.util.Locale
 
 import android.app._
 import android.content._
 import android.content.pm.{PackageInfo, PackageManager}
-import android.net.{LocalServerSocket, VpnService, LocalSocket, LocalSocketAddress}
+import android.net.VpnService
 import android.os._
-import android.support.v4.app.NotificationCompat
 import android.util.Log
+import android.widget.Toast
 import com.github.shadowsocks.aidl.Config
 import com.github.shadowsocks.utils._
 import com.google.android.gms.analytics.HitBuilders
@@ -108,17 +108,17 @@ class ShadowsocksVpnService extends VpnService with BaseService {
     }
 
     val conf = ConfigUtils
-      .SHADOWSOCKS.format(config.proxy, config.remotePort, config.localPort,
+      .SHADOWSOCKS.formatLocal(Locale.ENGLISH, config.proxy, config.remotePort, config.localPort,
         config.sitekey, config.encMethod, 10)
-    ConfigUtils.printToFile(new File(Path.BASE + "ss-local.json"))(p => {
+    ConfigUtils.printToFile(new File(Path.BASE + "ss-local-vpn.conf"))(p => {
       p.println(conf)
     })
 
     val cmd = new ArrayBuffer[String]
     cmd +=(Path.BASE + "ss-local", "-u"
       , "-b", "127.0.0.1"
-      , "-c", Path.BASE + "ss-local.json"
-      , "-f", Path.BASE + "ss-local.pid")
+      , "-c", Path.BASE + "ss-local-vpn.conf"
+      , "-f", Path.BASE + "ss-local-vpn.pid")
 
     if (Utils.isLollipopOrAbove && config.route != Route.ALL) {
       cmd += "--acl"
@@ -131,9 +131,9 @@ class ShadowsocksVpnService extends VpnService with BaseService {
 
   def startDnsTunnel() = {
     val conf = ConfigUtils
-      .SHADOWSOCKS.format(config.proxy, config.remotePort, 8163,
+      .SHADOWSOCKS.formatLocal(Locale.ENGLISH, config.proxy, config.remotePort, 8163,
         config.sitekey, config.encMethod, 10)
-    ConfigUtils.printToFile(new File(Path.BASE + "ss-tunnel.json"))(p => {
+    ConfigUtils.printToFile(new File(Path.BASE + "ss-tunnel-vpn.conf"))(p => {
       p.println(conf)
     })
     val cmd = new ArrayBuffer[String]
@@ -141,8 +141,8 @@ class ShadowsocksVpnService extends VpnService with BaseService {
       , "-b", "127.0.0.1"
       , "-l", "8163"
       , "-L", "8.8.8.8:53"
-      , "-c", Path.BASE + "ss-tunnel.json"
-      , "-f", Path.BASE + "ss-tunnel.pid")
+      , "-c", Path.BASE + "ss-tunnel-vpn.conf"
+      , "-f", Path.BASE + "ss-tunnel-vpn.pid")
 
     if (BuildConfig.DEBUG) Log.d(TAG, cmd.mkString(" "))
     Console.runCommand(cmd.mkString(" "))
@@ -151,15 +151,15 @@ class ShadowsocksVpnService extends VpnService with BaseService {
   def startDnsDaemon() {
     val conf = {
       if (Utils.isLollipopOrAbove) {
-        ConfigUtils.PDNSD_BYPASS.format("0.0.0.0", getString(R.string.exclude), 8163)
+        ConfigUtils.PDNSD_BYPASS.formatLocal(Locale.ENGLISH, "0.0.0.0", 8153, Path.BASE + "pdnsd-vpn.pid", getString(R.string.exclude), 8163)
       } else {
-        ConfigUtils.PDNSD_LOCAL.format("0.0.0.0", 8163)
+        ConfigUtils.PDNSD_LOCAL.formatLocal(Locale.ENGLISH, "0.0.0.0", 8163)
       }
     }
-    ConfigUtils.printToFile(new File(Path.BASE + "pdnsd.conf"))(p => {
+    ConfigUtils.printToFile(new File(Path.BASE + "pdnsd-vpn.conf"))(p => {
       p.println(conf)
     })
-    val cmd = Path.BASE + "pdnsd -c " + Path.BASE + "pdnsd.conf"
+    val cmd = Path.BASE + "pdnsd -c " + Path.BASE + "pdnsd-vpn.conf"
 
     if (BuildConfig.DEBUG) Log.d(TAG, cmd)
     Console.runCommand(cmd)
@@ -183,7 +183,7 @@ class ShadowsocksVpnService extends VpnService with BaseService {
     builder
       .setSession(config.profileName)
       .setMtu(VPN_MTU)
-      .addAddress(PRIVATE_VLAN.format("1"), 24)
+      .addAddress(PRIVATE_VLAN.formatLocal(Locale.ENGLISH, "1"), 24)
       .addDnsServer("8.8.8.8")
 
     if (Utils.isLollipopOrAbove) {
@@ -192,7 +192,7 @@ class ShadowsocksVpnService extends VpnService with BaseService {
         val pkgSet: mutable.HashSet[String] = new mutable.HashSet[String]
         for (app <- apps) {
           if (app.proxied) {
-            pkgSet.add(app.name)
+            pkgSet.add(app.packageName)
           }
         }
         for (pkg <- pkgSet) {
@@ -252,7 +252,7 @@ class ShadowsocksVpnService extends VpnService with BaseService {
                 builder.addRoute(addr(0), addr(1).toInt)
               }
             })
-          case _ =>
+          case Route.ALL =>
             for (i <- 1 to 223) {
               if (i != 26 && i != 127) {
                 val addr = i.toString + ".0.0.0"
@@ -312,21 +312,21 @@ class ShadowsocksVpnService extends VpnService with BaseService {
       + "--tunfd %d "
       + "--tunmtu %d "
       + "--loglevel 3 "
-      + "--pid %stun2socks.pid")
-      .format(PRIVATE_VLAN.format("2"), config.localPort, fd, VPN_MTU, Path.BASE)
+      + "--pid %stun2socks-vpn.pid")
+      .formatLocal(Locale.ENGLISH, PRIVATE_VLAN.formatLocal(Locale.ENGLISH, "2"), config.localPort, fd, VPN_MTU, Path.BASE)
 
     if (config.isUdpDns)
       cmd += " --enable-udprelay"
     else
-      cmd += " --dnsgw %s:8153".format(PRIVATE_VLAN.format("1"))
+      cmd += " --dnsgw %s:8153".formatLocal(Locale.ENGLISH, PRIVATE_VLAN.formatLocal(Locale.ENGLISH, "1"))
 
     if (Utils.isLollipopOrAbove) {
-      cmd += " --fake-proc";
+      cmd += " --fake-proc"
     }
 
     if (BuildConfig.DEBUG) Log.d(TAG, cmd)
 
-    System.exec(cmd);
+    System.exec(cmd)
   }
 
   /** Called when the activity is first created. */
@@ -366,11 +366,10 @@ class ShadowsocksVpnService extends VpnService with BaseService {
   def killProcesses() {
     for (task <- Array("ss-local", "ss-tunnel", "pdnsd", "tun2socks")) {
       try {
-        val pid = scala.io.Source.fromFile(Path.BASE + task + ".pid").mkString.trim.toInt
+        val pid = scala.io.Source.fromFile(Path.BASE + task + "-vpn.pid").mkString.trim.toInt
         Process.killProcess(pid)
-        Log.d(TAG, "kill pid: " + pid)
       } catch {
-        case e: Throwable => Log.e(TAG, "unable to kill " + task, e)
+        case e: Throwable => Log.e(TAG, "unable to kill " + task)
       }
     }
   }
@@ -399,6 +398,7 @@ class ShadowsocksVpnService extends VpnService with BaseService {
     filter.addAction(Intent.ACTION_SHUTDOWN)
     receiver = new BroadcastReceiver {
       def onReceive(p1: Context, p2: Intent) {
+        Toast.makeText(p1, R.string.stopping, Toast.LENGTH_SHORT)
         stopRunner()
       }
     }
@@ -451,7 +451,7 @@ class ShadowsocksVpnService extends VpnService with BaseService {
   override def stopRunner() {
 
     // channge the state
-    changeState(State.STOPPED)
+    changeState(State.STOPPING)
 
     // send event
     application.tracker.send(new HitBuilders.EventBuilder()
@@ -479,10 +479,13 @@ class ShadowsocksVpnService extends VpnService with BaseService {
       unregisterReceiver(receiver)
       receiver = null
     }
+
+    // channge the state
+    changeState(State.STOPPED)
   }
 
   override def stopBackgroundService() {
-    stopRunner()
+    stopSelf()
   }
 
   override def getTag = TAG

src/main/scala/com/github/shadowsocks/utils/ConfigUtils.scala

@@ -42,7 +42,7 @@ package com.github.shadowsocks.utils
 import android.content.{SharedPreferences, Context}
 import com.github.shadowsocks.ShadowsocksApplication
 import com.google.android.gms.tagmanager.Container
-import scalaj.http.{HttpOptions, Http}
+import com.github.kevinsawicki.http.HttpRequest
 import com.github.shadowsocks.aidl.Config
 
 object ConfigUtils {
@@ -130,14 +130,14 @@ object ConfigUtils {
       | perm_cache = 2048;
       | cache_dir = "/data/data/com.github.shadowsocks";
       | server_ip = %s;
-      | server_port = 8153;
+      | server_port = %d;
       | query_method = tcp_only;
       | run_ipv4 = on;
       | min_ttl = 15m;
       | max_ttl = 1w;
       | timeout = 10;
       | daemon = on;
-      | pid_file = "/data/data/com.github.shadowsocks/pdnsd.pid";
+      | pid_file = "%s";
       |}
       |
       |server {
@@ -183,12 +183,12 @@ object ConfigUtils {
   def getPublicConfig(context: Context, container: Container, config: Config): Config = {
     val url = container.getString("proxy_url")
     val sig = Utils.getSignature(context)
-    val list = Http
+    val list = HttpRequest
       .post(url)
-      .params("sig" -> sig)
-      .option(HttpOptions.connTimeout(1000))
-      .option(HttpOptions.readTimeout(5000))
-      .asString
+      .connectTimeout(2000)
+      .readTimeout(2000)
+      .send("sig="+sig)
+      .body
     val proxies = util.Random.shuffle(list.split('|').toSeq).toSeq
     val proxy = proxies(0).split(':')
 

src/main/scala/com/github/shadowsocks/utils/Console.scala

@@ -45,36 +45,21 @@ import java.util
 
 object Console {
 
-  private var shell: Shell.Interactive = null
-  private var rootShell: Shell.Interactive = null
-
-  private def openShell() {
-    if (shell == null) {
-      val builder = new Builder()
-      shell = builder
-        .useSH()
-        .setWatchdogTimeout(10)
-        .open(new OnCommandResultListener {
-        override def onCommandResult(commandCode: Int, exitCode: Int,
-          output: util.List[String]) {
-          if (exitCode < 0) {
-            shell.close()
-            shell = null
-          }
-        }
-      })
-    }
+  private def openShell(): Shell.Interactive = {
+    val builder = new Builder()
+    builder
+      .useSH()
+      .setWatchdogTimeout(10)
+      .open()
   }
 
-  private def openRootShell() {
-    if (rootShell == null) {
-      val builder = new Builder()
-      rootShell = builder
-        .setShell(SU.shell(0, "u:r:untrusted_app:s0"))
-        .setWantSTDERR(true)
-        .setWatchdogTimeout(10)
-        .open()
-    }
+  private def openRootShell(context: String): Shell.Interactive = {
+    val builder = new Builder()
+    builder
+      .setShell(SU.shell(0, context))
+      .setWantSTDERR(true)
+      .setWatchdogTimeout(10)
+      .open()
   }
 
   def runCommand(command: String) {
@@ -82,39 +67,48 @@ object Console {
   }
 
   def runCommand(commands: Array[String]) {
-    if (shell == null) {
-      openShell()
-    }
-    val ts = shell
-    ts.addCommand(commands)
-    ts.waitForIdle()
+    val shell = openShell()
+    shell.addCommand(commands, 0, new OnCommandResultListener {
+      override def onCommandResult(commandCode: Int, exitCode: Int,
+                                   output: util.List[String]) {
+        if (exitCode < 0) {
+          shell.close()
+        }
+      }
+    })
+    shell.waitForIdle()
+    shell.close()
   }
 
   def runRootCommand(command: String): String = runRootCommand(Array(command))
+  def runRootCommand(command: String, context: String): String = runRootCommand(Array(command), context)
+  def runRootCommand(commands: Array[String]): String = runRootCommand(commands, "u:r:init_shell:s0")
 
-  def runRootCommand(commands: Array[String]): String = {
+  def runRootCommand(commands: Array[String], context: String): String = {
     if (!isRoot) {
       return null
     }
-    if (rootShell == null) {
-      openRootShell()
-    }
-    val ts = rootShell
+    val shell = openRootShell(context)
     val sb = new StringBuilder
-    ts.addCommand(commands, 0, new OnCommandResultListener {
+    shell.addCommand(commands, 0, new OnCommandResultListener {
       override def onCommandResult(commandCode: Int, exitCode: Int,
         output: util.List[String]) {
         if (exitCode < 0) {
-          rootShell.close()
-          rootShell = null
+          shell.close()
         } else {
           import scala.collection.JavaConversions._
           output.foreach(line => sb.append(line).append('\n'))
         }
       }
     })
-    if (ts.waitForIdle()) sb.toString()
-    else null
+    if (shell.waitForIdle()) {
+      shell.close()
+      sb.toString()
+    }
+    else {
+      shell.close()
+      null
+    }
   }
 
   def isRoot: Boolean = SU.available()

src/main/scala/com/github/shadowsocks/utils/Constants.scala

@@ -65,6 +65,7 @@ object Key {
 
   val proxied = "Proxyed"
 
+  val isNAT = "isNAT"
   val isRoot = "isRoot"
   val status = "status"
   val proxyedApps = "proxyedApps"
@@ -101,7 +102,8 @@ object State {
   val INIT = 0
   val CONNECTING = 1
   val CONNECTED = 2
-  val STOPPED = 3
+  val STOPPING = 3
+  val STOPPED = 4
   def isAvailable(state: Int): Boolean = state != CONNECTED && state != CONNECTING
 }
 

src/main/scala/com/github/shadowsocks/utils/Utils.scala

@@ -69,7 +69,7 @@ object Utils {
   val DEFAULT_ROOT: String = "/system/bin/su"
   val ALTERNATIVE_ROOT: String = "/system/xbin/su"
   val DEFAULT_IPTABLES: String = "/system/bin/iptables"
-  val ALTERNATIVE_IPTABLES: String = "/data/data/com.github.shadowsocks/iptables"
+  val ALTERNATIVE_IPTABLES: String = "iptables"
   val TIME_OUT: Int = -99
   var initialized: Boolean = false
   var hasRedirectSupport: Int = -1
@@ -181,20 +181,24 @@ object Utils {
   }
 
   def resolve(host: String, addrType: Int): Option[String] = {
-    val lookup = new Lookup(host, addrType)
-    val resolver = new SimpleResolver("114.114.114.114")
-    resolver.setTimeout(5)
-    lookup.setResolver(resolver)
-    val result = lookup.run()
-    if (result == null) return None
-    val records = scala.util.Random.shuffle(result.toList)
-    for (r <- records) {
-      addrType match {
-        case Type.A =>
-          return Some(r.asInstanceOf[ARecord].getAddress.getHostAddress)
-        case Type.AAAA =>
-          return Some(r.asInstanceOf[AAAARecord].getAddress.getHostAddress)
+    try {
+      val lookup = new Lookup(host, addrType)
+      val resolver = new SimpleResolver("114.114.114.114")
+      resolver.setTimeout(5)
+      lookup.setResolver(resolver)
+      val result = lookup.run()
+      if (result == null) return None
+      val records = scala.util.Random.shuffle(result.toList)
+      for (r <- records) {
+        addrType match {
+          case Type.A =>
+            return Some(r.asInstanceOf[ARecord].getAddress.getHostAddress)
+          case Type.AAAA =>
+            return Some(r.asInstanceOf[AAAARecord].getAddress.getHostAddress)
+        }
       }
+    } catch {
+      case e: Exception => None
     }
     None
   }
@@ -332,6 +336,16 @@ object Utils {
     bitmap
   }
 
+  def getAppIcon(c: Context, packageName: String): Drawable = {
+    val pm: PackageManager = c.getPackageManager
+    val icon: Drawable = c.getResources.getDrawable(android.R.drawable.sym_def_app_icon)
+    try {
+      pm.getApplicationIcon(packageName)
+    } catch {
+      case e: PackageManager.NameNotFoundException => icon
+    }
+  }
+
   def getAppIcon(c: Context, uid: Int): Drawable = {
     val pm: PackageManager = c.getPackageManager
     val icon: Drawable = c.getResources.getDrawable(android.R.drawable.sym_def_app_icon)