Notify all VMs when proxy changes.

bug:2700664
Change-Id: I74cc6e0bd6e66847bf18f524ce851e3e9d2c4e87

1 files changed, 105 insertions, 37 deletions

diff --git a/core/java/android/net/ProxyProperties.java b/core/java/android/net/ProxyProperties.java
index 5fd0d89c72eb..cbe4445a3a2d 100644
--- a/core/java/android/net/ProxyProperties.java
+++ b/core/java/android/net/ProxyProperties.java
@@ -19,6 +19,8 @@ package android.net;
 
 import android.os.Parcel;
 import android.os.Parcelable;
+import android.text.TextUtils;
+import android.util.Log;
 
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
@@ -30,44 +32,108 @@ import java.net.UnknownHostException;
  */
 public class ProxyProperties implements Parcelable {
 
-    private InetSocketAddress mProxy;
+    private String mHost;
+    private int mPort;
     private String mExclusionList;
+    private String[] mParsedExclusionList;
 
-    public ProxyProperties() {
+    public ProxyProperties(String host, int port, String exclList) {
+        mHost = host;
+        mPort = port;
+        setExclusionList(exclList);
+    }
+
+    private ProxyProperties(String host, int port, String exclList, String[] parsedExclList) {
+        mHost = host;
+        mPort = port;
+        mExclusionList = exclList;
+        mParsedExclusionList = parsedExclList;
     }
 
     // copy constructor instead of clone
     public ProxyProperties(ProxyProperties source) {
         if (source != null) {
-            mProxy = source.getSocketAddress();
-            String exclusionList = source.getExclusionList();
-            if (exclusionList != null) {
-                mExclusionList = new String(exclusionList);
-            }
+            mHost = source.getHost();
+            mPort = source.getPort();
+            mExclusionList = source.getExclusionList();
+            mParsedExclusionList = source.mParsedExclusionList;
         }
     }
 
     public InetSocketAddress getSocketAddress() {
-        return mProxy;
+        InetSocketAddress inetSocketAddress = null;
+        try {
+            inetSocketAddress = new InetSocketAddress(mHost, mPort);
+        } catch (IllegalArgumentException e) { }
+        return inetSocketAddress;
     }
 
-    public void setSocketAddress(InetSocketAddress proxy) {
-        mProxy = proxy;
+    public String getHost() {
+        return mHost;
     }
 
+    public int getPort() {
+        return mPort;
+    }
+
+    // comma separated
     public String getExclusionList() {
         return mExclusionList;
     }
 
-    public void setExclusionList(String exclusionList) {
+    // comma separated
+    private void setExclusionList(String exclusionList) {
         mExclusionList = exclusionList;
+        if (mExclusionList == null) {
+            mParsedExclusionList = new String[0];
+        } else {
+            String splitExclusionList[] = exclusionList.toLowerCase().split(",");
+            mParsedExclusionList = new String[splitExclusionList.length * 2];
+            for (int i = 0; i < splitExclusionList.length; i++) {
+                String s = splitExclusionList[i].trim();
+                if (s.startsWith(".")) s = s.substring(1);
+                mParsedExclusionList[i*2] = s;
+                mParsedExclusionList[(i*2)+1] = "." + s;
+            }
+        }
+    }
+
+    public boolean isExcluded(String url) {
+        if (TextUtils.isEmpty(url) || mParsedExclusionList == null ||
+                mParsedExclusionList.length == 0) return false;
+
+        Uri u = Uri.parse(url);
+        String urlDomain = u.getHost();
+        if (urlDomain == null) return false;
+        for (int i = 0; i< mParsedExclusionList.length; i+=2) {
+            if (urlDomain.equals(mParsedExclusionList[i]) ||
+                    urlDomain.endsWith(mParsedExclusionList[i+1])) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public java.net.Proxy makeProxy() {
+        java.net.Proxy proxy = java.net.Proxy.NO_PROXY;
+        if (mHost != null) {
+            try {
+                InetSocketAddress inetSocketAddress = new InetSocketAddress(mHost, mPort);
+                proxy = new java.net.Proxy(java.net.Proxy.Type.HTTP, inetSocketAddress);
+            } catch (IllegalArgumentException e) {
+            }
+        }
+        return proxy;
     }
 
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
-        if (mProxy != null) {
-            sb.append(mProxy.toString());
+        if (mHost != null) {
+            sb.append("[");
+            sb.append(mHost);
+            sb.append("] ");
+            sb.append(Integer.toString(mPort));
             if (mExclusionList != null) {
                     sb.append(" xl=").append(mExclusionList);
             }
@@ -75,6 +141,20 @@ public class ProxyProperties implements Parcelable {
         return sb.toString();
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof ProxyProperties)) return false;
+        ProxyProperties p = (ProxyProperties)o;
+        if (mExclusionList != null && !mExclusionList.equals(p.getExclusionList())) return false;
+        if (mHost != null && p.getHost() != null && mHost.equals(p.getHost()) == false) {
+            return false;
+        }
+        if (mHost != null && p.mHost == null) return false;
+        if (mHost == null && p.mHost != null) return false;
+        if (mPort != p.mPort) return false;
+        return true;
+    }
+
     /**
      * Implement the Parcelable interface
      * @hide
@@ -88,27 +168,15 @@ public class ProxyProperties implements Parcelable {
      * @hide
      */
     public void writeToParcel(Parcel dest, int flags) {
-        String host = null;
-        if (mProxy != null) {
-            try {
-                InetAddress addr = mProxy.getAddress();
-                if (addr != null) {
-                    host = addr.getHostAddress();
-                } else {
-                    /* Does not resolve when addr is null */
-                    host = mProxy.getHostName();
-                }
-            } catch (Exception e) { }
-        }
-
-        if (host != null) {
+        if (mHost != null) {
             dest.writeByte((byte)1);
-            dest.writeString(host);
-            dest.writeInt(mProxy.getPort());
+            dest.writeString(mHost);
+            dest.writeInt(mPort);
         } else {
             dest.writeByte((byte)0);
         }
         dest.writeString(mExclusionList);
+        dest.writeStringArray(mParsedExclusionList);
     }
 
     /**
@@ -118,16 +186,16 @@ public class ProxyProperties implements Parcelable {
     public static final Creator<ProxyProperties> CREATOR =
         new Creator<ProxyProperties>() {
             public ProxyProperties createFromParcel(Parcel in) {
-                ProxyProperties proxyProperties = new ProxyProperties();
+                String host = null;
+                int port = 0;
                 if (in.readByte() == 1) {
-                    try {
-                        String host = in.readString();
-                        int port = in.readInt();
-                        proxyProperties.setSocketAddress(InetSocketAddress.createUnresolved(
-                                host, port));
-                    } catch (IllegalArgumentException e) { }
+                    host = in.readString();
+                    port = in.readInt();
                 }
-                proxyProperties.setExclusionList(in.readString());
+                String exclList = in.readString();
+                String[] parsedExclList = in.readStringArray();
+                ProxyProperties proxyProperties =
+                        new ProxyProperties(host, port, exclList, parsedExclList);
                 return proxyProperties;
             }