ABP/Android proxy service

src/org/adblockplus/android/ProxyService.java

 package org.adblockplus.android;
 
 import java.io.File;
+import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.lang.reflect.Method;
 import java.net.InetAddress;
 import java.net.ServerSocket;
 import java.util.List;
 import java.util.Properties;
 import java.util.concurrent.TimeoutException;
 
 import sunlabs.brazil.server.Server;
 import sunlabs.brazil.util.Base64;
@@ skipping 17 matching lines @@
 import android.preference.PreferenceManager;
 import android.util.Log;
 import android.widget.Toast;
 
 import com.stericson.RootTools.RootTools;
 import com.stericson.RootTools.RootToolsException;
 
 public class ProxyService extends Service implements OnSharedPreferenceChangeListener
 {
   private static final String LOCALHOST = "127.0.0.1";
+  /**
+   * Indicates that system supports native proxy configuration.
+   */
+  public static boolean hasNativeProxy = Build.VERSION.SDK_INT >= 12; // Honeycomb 3.1
 
   static
   {
     RootTools.debugMode = false;
   }
 
   private static final String TAG = "ProxyService";
-  private static final boolean logRequests = true;
+  private static final boolean logRequests = false;
 
   private final static int DEFAULT_TIMEOUT = 3000;
   private final static int NO_TRAFFIC_TIMEOUT = 5 * 60 * 1000; // 5 minutes
 
   final static int ONGOING_NOTIFICATION_ID = R.string.app_name;
   private final static int NOTRAFFIC_NOTIFICATION_ID = R.string.app_name + 3;
 
   /**
    * Broadcasted when service starts or stops.
    */
@@ skipping 44 matching lines @@
       port = getResources().getInteger(R.integer.def_port);
     }
 
     // Try to read user proxy settings
     String proxyHost = null;
     String proxyPort = null;
     String proxyExcl = null;
     String proxyUser = null;
     String proxyPass = null;
 
-    if (Build.VERSION.SDK_INT >= 12) // Honeycomb 3.1
+    if (hasNativeProxy)
     {
       // Read system settings
       proxyHost = System.getProperty("http.proxyHost");
       proxyPort = System.getProperty("http.proxyPort");
       proxyExcl = System.getProperty("http.nonProxyHosts");
 
       Log.d(TAG, "PRX: " + proxyHost + ":" + proxyPort + "(" + proxyExcl + ")");
       String[] px = ProxySettings.getUserProxy(getApplicationContext()); // not used but left for future reference
       if (px != null)
         Log.d(TAG, "PRX: " + px[0] + ":" + px[1] + "(" + px[2] + ")");
     }
     else
     {
       // Read application settings
       proxyHost = prefs.getString(getString(R.string.pref_proxyhost), null);
       proxyPort = prefs.getString(getString(R.string.pref_proxyport), null);
       proxyUser = prefs.getString(getString(R.string.pref_proxyuser), null);
       proxyPass = prefs.getString(getString(R.string.pref_proxypass), null);
     }
 
     // Check for root privileges and try to install transparent proxy
     if (RootTools.isAccessGiven())
     {
       try
       {
-        iptables = getIptables();
-        if (iptables != null)
-        {
-          StringBuffer cmd = new StringBuffer();
-          int uid = getPackageManager().getPackageInfo(getPackageName(), 0).applicationInfo.uid;
-          cmd.append(iptables);
-          cmd.append(IPTABLES_RETURN.replace("{{UID}}", String.valueOf(uid)));
-          cmd.append(iptables);
-          cmd.append(IPTABLES_ADD_HTTP.replace("{{PORT}}", String.valueOf(port)));
-          String rules = cmd.toString();
-          RootTools.sendShell(rules, DEFAULT_TIMEOUT);
-          transparent = true;
-        }
-        else
-        {
-          Log.w(TAG, "Have root access, but no iptables found");
-        }
+        initIptables();
+
+        StringBuffer cmd = new StringBuffer();
+        int uid = getPackageManager().getPackageInfo(getPackageName(), 0).applicationInfo.uid;
+        cmd.append(iptables);
+        cmd.append(IPTABLES_RETURN.replace("{{UID}}", String.valueOf(uid)));
+        cmd.append(iptables);
+        cmd.append(IPTABLES_ADD_HTTP.replace("{{PORT}}", String.valueOf(port)));
+        String rules = cmd.toString();
+        RootTools.sendShell(rules, DEFAULT_TIMEOUT);
+        transparent = true;
+      }
+      catch (FileNotFoundException e)
+      {
+        // ignore - this is "normal" case
       }
       catch (NameNotFoundException e)
       {
         Log.e(TAG, "Failed to initialize iptables", e);
       }
       catch (IOException e)
       {
         Log.e(TAG, "Failed to initialize iptables", e);
       }
       catch (RootToolsException e)
@@ skipping 236 matching lines @@
     }
     catch (ClassCastException e)
     {
       // ignore - default handler in use
     }
   }
 
   @Override
   public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key)
   {
-    if (Build.VERSION.SDK_INT < 12) // Honeycomb 3.1
+    if (hasNativeProxy)
     {
       String ketHost = getString(R.string.pref_proxyhost);
       String keyPort = getString(R.string.pref_proxyport);
       String keyUser = getString(R.string.pref_proxyuser);
       String keyPass = getString(R.string.pref_proxypass);
       if (key.equals(ketHost) || key.equals(keyPort) || key.equals(keyUser) || key.equals(keyPass))
       {
         String proxyHost = sharedPreferences.getString(ketHost, null);
         String proxyPort = sharedPreferences.getString(keyPort, null);
         String proxyUser = sharedPreferences.getString(keyUser, null);
@@ skipping 42 matching lines @@
         return true;
     }
     catch (Exception e)
     {
       Log.w(TAG, null, e);
     }
     return false;
   }
 
   /**
-   * Returns path to iptables executable.
-   */
-  public String getIptables() throws IOException, RootToolsException, TimeoutException
+   * Initializes iptables executable.
+   * 
+   * @throws FileNotFoundException If iptables initialization failed due to provided reasons.
+   */
+  private void initIptables() throws IOException, RootToolsException, TimeoutException, FileNotFoundException
   {
     if (!RootTools.isAccessGiven())
-      return null;
+      throw new FileNotFoundException("No root access");
 
     File ipt = getFileStreamPath("iptables");
 
     if (!ipt.exists())
     {
       Log.e(TAG, "No iptables excutable found");
-      return null;
+      throw new FileNotFoundException("No iptables executable");
     }
     
     String path = ipt.getAbsolutePath();
 
     RootTools.sendShell("chmod 700 " + path, DEFAULT_TIMEOUT);
 
     boolean compatible = false;
     boolean version = false;
 
     String command = path + " --version\n" + path + " -L -t nat -n\n";
 
     List<String> result = RootTools.sendShell(command, DEFAULT_TIMEOUT);
     for (String line : result)
     {
       if (line.contains("OUTPUT"))
         compatible = true;
       if (line.contains("v1.4."))
         version = true;
     }
 
     if (!compatible || !version)
     {
       Log.e(TAG, "Incompatible iptables excutable");
-      return null;
-    }
-
-    return path;
+      throw new FileNotFoundException("Incompatible iptables excutable");
+    }
+
+    iptables = path;
   }
   
   public List<String> getIptablesOutput()
   {
     if (iptables == null)
       return null;
 
     String command = iptables + " -L -t nat -n\n";
     try
     {
@@ skipping 151 matching lines @@
     public void close()
     {
       try
       {
         listen.close();
         this.interrupt();
         this.join();
       }
       catch (Exception e)
       {
+        // ignore - it always happens
       }
       log(LOG_WARNING, null, "server stopped");
     }
 
     @Override
     public void log(int level, Object obj, String message)
     {
       if (level <= logLevel)
       {
         Log.println(7 - level, obj != null ? obj.toString() : TAG, message);
       }
     }
   }
 }