am bd84f01c: am cb58a2fc: Merge "Handle provisioning APN by turning off/on data." into klp-dev
* commit 'bd84f01c6ce122ab58fc7c5b687dc8bfb0fb03e6':
Handle provisioning APN by turning off/on data.
diff --git a/core/java/android/net/ConnectivityManager.java b/core/java/android/net/ConnectivityManager.java
index 70c8750..4eecfa9 100644
--- a/core/java/android/net/ConnectivityManager.java
+++ b/core/java/android/net/ConnectivityManager.java
@@ -361,11 +361,17 @@
*/
public static final int TYPE_MOBILE_IA = 14;
- /** {@hide} */
- public static final int MAX_RADIO_TYPE = TYPE_MOBILE_IA;
+ /**
+ * The network that uses proxy to achieve connectivity.
+ * {@hide}
+ */
+ public static final int TYPE_PROXY = 16;
/** {@hide} */
- public static final int MAX_NETWORK_TYPE = TYPE_MOBILE_IA;
+ public static final int MAX_RADIO_TYPE = TYPE_PROXY;
+
+ /** {@hide} */
+ public static final int MAX_NETWORK_TYPE = TYPE_PROXY;
/**
* If you want to set the default network preference,you can directly
@@ -446,6 +452,8 @@
return "WIFI_P2P";
case TYPE_MOBILE_IA:
return "MOBILE_IA";
+ case TYPE_PROXY:
+ return "PROXY";
default:
return Integer.toString(type);
}
diff --git a/core/java/android/net/LinkAddress.java b/core/java/android/net/LinkAddress.java
index a390add..22543e3 100644
--- a/core/java/android/net/LinkAddress.java
+++ b/core/java/android/net/LinkAddress.java
@@ -24,8 +24,32 @@
import java.net.InterfaceAddress;
import java.net.UnknownHostException;
+import static libcore.io.OsConstants.IFA_F_DADFAILED;
+import static libcore.io.OsConstants.IFA_F_DEPRECATED;
+import static libcore.io.OsConstants.IFA_F_TENTATIVE;
+import static libcore.io.OsConstants.RT_SCOPE_HOST;
+import static libcore.io.OsConstants.RT_SCOPE_LINK;
+import static libcore.io.OsConstants.RT_SCOPE_SITE;
+import static libcore.io.OsConstants.RT_SCOPE_UNIVERSE;
+
/**
- * Identifies an address of a network link
+ * Identifies an IP address on a network link.
+ *
+ * A {@code LinkAddress} consists of:
+ * <ul>
+ * <li>An IP address and prefix length (e.g., {@code 2001:db8::1/64} or {@code 192.0.2.1/24}).
+ * The address must be unicast, as multicast addresses cannot be assigned to interfaces.
+ * <li>Address flags: A bitmask of {@code IFA_F_*} values representing properties of the address.
+ * <li>Address scope: An integer defining the scope in which the address is unique (e.g.,
+ * {@code RT_SCOPE_LINK} or {@code RT_SCOPE_SITE}).
+ * <ul>
+ *<p>
+ * When constructing a {@code LinkAddress}, the IP address and prefix are required. The flags and
+ * scope are optional. If they are not specified, the flags are set to zero, and the scope will be
+ * determined based on the IP address (e.g., link-local addresses will be created with a scope of
+ * {@code RT_SCOPE_LINK}, global addresses with {@code RT_SCOPE_UNIVERSE}, etc.) If they are
+ * specified, they are not checked for validity.
+ *
* @hide
*/
public class LinkAddress implements Parcelable {
@@ -35,12 +59,50 @@
private InetAddress address;
/**
- * Network prefix length
+ * Prefix length.
*/
private int prefixLength;
- private void init(InetAddress address, int prefixLength) {
- if (address == null || prefixLength < 0 ||
+ /**
+ * Address flags. A bitmask of IFA_F_* values.
+ */
+ private int flags;
+
+ /**
+ * Address scope. One of the RT_SCOPE_* constants.
+ */
+ private int scope;
+
+ /**
+ * Utility function to determines the scope of a unicast address. Per RFC 4291 section 2.5 and
+ * RFC 6724 section 3.2.
+ * @hide
+ */
+ static int scopeForUnicastAddress(InetAddress addr) {
+ if (addr.isAnyLocalAddress()) {
+ return RT_SCOPE_HOST;
+ }
+
+ if (addr.isLoopbackAddress() || addr.isLinkLocalAddress()) {
+ return RT_SCOPE_LINK;
+ }
+
+ // isSiteLocalAddress() returns true for private IPv4 addresses, but RFC 6724 section 3.2
+ // says that they are assigned global scope.
+ if (!(addr instanceof Inet4Address) && addr.isSiteLocalAddress()) {
+ return RT_SCOPE_SITE;
+ }
+
+ return RT_SCOPE_UNIVERSE;
+ }
+
+ /**
+ * Utility function for the constructors.
+ */
+ private void init(InetAddress address, int prefixLength, int flags, int scope) {
+ if (address == null ||
+ address.isMulticastAddress() ||
+ prefixLength < 0 ||
((address instanceof Inet4Address) && prefixLength > 32) ||
(prefixLength > 128)) {
throw new IllegalArgumentException("Bad LinkAddress params " + address +
@@ -48,23 +110,59 @@
}
this.address = address;
this.prefixLength = prefixLength;
+ this.flags = flags;
+ this.scope = scope;
}
+ /**
+ * Constructs a new {@code LinkAddress} from an {@code InetAddress} and prefix length, with
+ * the specified flags and scope. Flags and scope are not checked for validity.
+ * @param address The IP address.
+ * @param prefixLength The prefix length.
+ */
+ public LinkAddress(InetAddress address, int prefixLength, int flags, int scope) {
+ init(address, prefixLength, flags, scope);
+ }
+
+ /**
+ * Constructs a new {@code LinkAddress} from an {@code InetAddress} and a prefix length.
+ * The flags are set to zero and the scope is determined from the address.
+ * @param address The IP address.
+ * @param prefixLength The prefix length.
+ */
public LinkAddress(InetAddress address, int prefixLength) {
- init(address, prefixLength);
+ this(address, prefixLength, 0, 0);
+ this.scope = scopeForUnicastAddress(address);
}
+ /**
+ * Constructs a new {@code LinkAddress} from an {@code InterfaceAddress}.
+ * The flags are set to zero and the scope is determined from the address.
+ * @param interfaceAddress The interface address.
+ */
public LinkAddress(InterfaceAddress interfaceAddress) {
- init(interfaceAddress.getAddress(),
+ this(interfaceAddress.getAddress(),
interfaceAddress.getNetworkPrefixLength());
}
/**
* Constructs a new {@code LinkAddress} from a string such as "192.0.2.5/24" or
- * "2001:db8::1/64".
+ * "2001:db8::1/64". The flags are set to zero and the scope is determined from the address.
* @param string The string to parse.
*/
public LinkAddress(String address) {
+ this(address, 0, 0);
+ this.scope = scopeForUnicastAddress(this.address);
+ }
+
+ /**
+ * Constructs a new {@code LinkAddress} from a string such as "192.0.2.5/24" or
+ * "2001:db8::1/64", with the specified flags and scope.
+ * @param string The string to parse.
+ * @param flags The address flags.
+ * @param scope The address scope.
+ */
+ public LinkAddress(String address, int flags, int scope) {
InetAddress inetAddress = null;
int prefixLength = -1;
try {
@@ -81,18 +179,22 @@
throw new IllegalArgumentException("Bad LinkAddress params " + address);
}
- init(inetAddress, prefixLength);
- }
-
- @Override
- public String toString() {
- return (address == null ? "" : (address.getHostAddress() + "/" + prefixLength));
+ init(inetAddress, prefixLength, flags, scope);
}
/**
- * Compares this {@code LinkAddress} instance against the specified address
- * in {@code obj}. Two addresses are equal if their InetAddress and prefixLength
- * are equal
+ * Returns a string representation of this address, such as "192.0.2.1/24" or "2001:db8::1/64".
+ * The string representation does not contain the flags and scope, just the address and prefix
+ * length.
+ */
+ @Override
+ public String toString() {
+ return address.getHostAddress() + "/" + prefixLength;
+ }
+
+ /**
+ * Compares this {@code LinkAddress} instance against {@code obj}. Two addresses are equal if
+ * their address, prefix length, flags and scope are equal.
*
* @param obj the object to be tested for equality.
* @return {@code true} if both objects are equal, {@code false} otherwise.
@@ -104,33 +206,70 @@
}
LinkAddress linkAddress = (LinkAddress) obj;
return this.address.equals(linkAddress.address) &&
- this.prefixLength == linkAddress.prefixLength;
- }
-
- @Override
- /*
- * generate hashcode based on significant fields
- */
- public int hashCode() {
- return ((null == address) ? 0 : address.hashCode()) + prefixLength;
+ this.prefixLength == linkAddress.prefixLength &&
+ this.flags == linkAddress.flags &&
+ this.scope == linkAddress.scope;
}
/**
- * Returns the InetAddress for this address.
+ * Returns a hashcode for this address.
+ */
+ @Override
+ public int hashCode() {
+ return address.hashCode() + 11 * prefixLength + 19 * flags + 43 * scope;
+ }
+
+ /**
+ * Determines whether this {@code LinkAddress} and the provided {@code LinkAddress} represent
+ * the same address. Two LinkAddresses represent the same address if they have the same IP
+ * address and prefix length, even if their properties are different.
+ *
+ * @param other the {@code LinkAddress} to compare to.
+ * @return {@code true} if both objects have the same address and prefix length, {@code false}
+ * otherwise.
+ */
+ public boolean isSameAddressAs(LinkAddress other) {
+ return address.equals(other.address) && prefixLength == other.prefixLength;
+ }
+
+ /**
+ * Returns the InetAddress of this address.
*/
public InetAddress getAddress() {
return address;
}
/**
- * Get network prefix length
+ * Returns the prefix length of this address.
*/
public int getNetworkPrefixLength() {
return prefixLength;
}
/**
- * Implement the Parcelable interface
+ * Returns the flags of this address.
+ */
+ public int getFlags() {
+ return flags;
+ }
+
+ /**
+ * Returns the scope of this address.
+ */
+ public int getScope() {
+ return scope;
+ }
+
+ /**
+ * Returns true if this {@code LinkAddress} is global scope and preferred.
+ */
+ public boolean isGlobalPreferred() {
+ return (scope == RT_SCOPE_UNIVERSE &&
+ (flags & (IFA_F_DADFAILED | IFA_F_DEPRECATED | IFA_F_TENTATIVE)) == 0L);
+ }
+
+ /**
+ * Implement the Parcelable interface.
* @hide
*/
public int describeContents() {
@@ -142,13 +281,10 @@
* @hide
*/
public void writeToParcel(Parcel dest, int flags) {
- if (address != null) {
- dest.writeByte((byte)1);
- dest.writeByteArray(address.getAddress());
- dest.writeInt(prefixLength);
- } else {
- dest.writeByte((byte)0);
- }
+ dest.writeByteArray(address.getAddress());
+ dest.writeInt(prefixLength);
+ dest.writeInt(this.flags);
+ dest.writeInt(scope);
}
/**
@@ -159,14 +295,17 @@
new Creator<LinkAddress>() {
public LinkAddress createFromParcel(Parcel in) {
InetAddress address = null;
- int prefixLength = 0;
- if (in.readByte() == 1) {
- try {
- address = InetAddress.getByAddress(in.createByteArray());
- prefixLength = in.readInt();
- } catch (UnknownHostException e) { }
+ try {
+ address = InetAddress.getByAddress(in.createByteArray());
+ } catch (UnknownHostException e) {
+ // Nothing we can do here. When we call the constructor, we'll throw an
+ // IllegalArgumentException, because a LinkAddress can't have a null
+ // InetAddress.
}
- return new LinkAddress(address, prefixLength);
+ int prefixLength = in.readInt();
+ int flags = in.readInt();
+ int scope = in.readInt();
+ return new LinkAddress(address, prefixLength, flags, scope);
}
public LinkAddress[] newArray(int size) {
diff --git a/core/java/android/net/LinkProperties.java b/core/java/android/net/LinkProperties.java
index b4d07a1..4dfd3d9 100644
--- a/core/java/android/net/LinkProperties.java
+++ b/core/java/android/net/LinkProperties.java
@@ -61,10 +61,10 @@
public class LinkProperties implements Parcelable {
// The interface described by the network link.
private String mIfaceName;
- private Collection<LinkAddress> mLinkAddresses = new ArrayList<LinkAddress>();
- private Collection<InetAddress> mDnses = new ArrayList<InetAddress>();
+ private ArrayList<LinkAddress> mLinkAddresses = new ArrayList<LinkAddress>();
+ private ArrayList<InetAddress> mDnses = new ArrayList<InetAddress>();
private String mDomains;
- private Collection<RouteInfo> mRoutes = new ArrayList<RouteInfo>();
+ private ArrayList<RouteInfo> mRoutes = new ArrayList<RouteInfo>();
private ProxyProperties mHttpProxy;
private int mMtu;
@@ -156,28 +156,52 @@
return addresses;
}
- /**
- * Adds a link address if it does not exist, or update it if it does.
- * @param address The {@code LinkAddress} to add.
- * @return true if the address was added, false if it already existed.
- */
- public boolean addLinkAddress(LinkAddress address) {
- // TODO: when the LinkAddress has other attributes beyond the
- // address and the prefix length, update them here.
- if (address != null && !mLinkAddresses.contains(address)) {
- mLinkAddresses.add(address);
- return true;
+ private int findLinkAddressIndex(LinkAddress address) {
+ for (int i = 0; i < mLinkAddresses.size(); i++) {
+ if (mLinkAddresses.get(i).isSameAddressAs(address)) {
+ return i;
+ }
}
- return false;
+ return -1;
}
/**
- * Removes a link address.
- * @param address The {@code LinkAddress} to remove.
+ * Adds a link address if it does not exist, or updates it if it does.
+ * @param address The {@code LinkAddress} to add.
+ * @return true if {@code address} was added or updated, false otherwise.
+ */
+ public boolean addLinkAddress(LinkAddress address) {
+ if (address == null) {
+ return false;
+ }
+ int i = findLinkAddressIndex(address);
+ if (i < 0) {
+ // Address was not present. Add it.
+ mLinkAddresses.add(address);
+ return true;
+ } else if (mLinkAddresses.get(i).equals(address)) {
+ // Address was present and has same properties. Do nothing.
+ return false;
+ } else {
+ // Address was present and has different properties. Update it.
+ mLinkAddresses.set(i, address);
+ return true;
+ }
+ }
+
+ /**
+ * Removes a link address. Specifically, removes the link address, if any, for which
+ * {@code isSameAddressAs(toRemove)} returns true.
+ * @param address A {@code LinkAddress} specifying the address to remove.
* @return true if the address was removed, false if it did not exist.
*/
public boolean removeLinkAddress(LinkAddress toRemove) {
- return mLinkAddresses.remove(toRemove);
+ int i = findLinkAddressIndex(toRemove);
+ if (i >= 0) {
+ mLinkAddresses.remove(i);
+ return true;
+ }
+ return false;
}
/**
diff --git a/core/tests/coretests/src/android/net/LinkAddressTest.java b/core/tests/coretests/src/android/net/LinkAddressTest.java
new file mode 100644
index 0000000..17423be
--- /dev/null
+++ b/core/tests/coretests/src/android/net/LinkAddressTest.java
@@ -0,0 +1,331 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.net;
+
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.net.InterfaceAddress;
+import java.net.NetworkInterface;
+import java.net.SocketException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import android.net.LinkAddress;
+import android.os.Parcel;
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import static libcore.io.OsConstants.IFA_F_DEPRECATED;
+import static libcore.io.OsConstants.IFA_F_PERMANENT;
+import static libcore.io.OsConstants.IFA_F_TENTATIVE;
+import static libcore.io.OsConstants.RT_SCOPE_HOST;
+import static libcore.io.OsConstants.RT_SCOPE_LINK;
+import static libcore.io.OsConstants.RT_SCOPE_SITE;
+import static libcore.io.OsConstants.RT_SCOPE_UNIVERSE;
+
+/**
+ * Tests for {@link LinkAddress}.
+ */
+public class LinkAddressTest extends AndroidTestCase {
+
+ private static final String V4 = "192.0.2.1";
+ private static final String V6 = "2001:db8::1";
+ private static final InetAddress V4_ADDRESS = NetworkUtils.numericToInetAddress(V4);
+ private static final InetAddress V6_ADDRESS = NetworkUtils.numericToInetAddress(V6);
+
+ public void testConstructors() throws SocketException {
+ LinkAddress address;
+
+ // Valid addresses work as expected.
+ address = new LinkAddress(V4_ADDRESS, 25);
+ assertEquals(V4_ADDRESS, address.getAddress());
+ assertEquals(25, address.getNetworkPrefixLength());
+ assertEquals(0, address.getFlags());
+ assertEquals(RT_SCOPE_UNIVERSE, address.getScope());
+
+ address = new LinkAddress(V6_ADDRESS, 127);
+ assertEquals(V6_ADDRESS, address.getAddress());
+ assertEquals(127, address.getNetworkPrefixLength());
+ assertEquals(0, address.getFlags());
+ assertEquals(RT_SCOPE_UNIVERSE, address.getScope());
+
+ // Nonsensical flags/scopes or combinations thereof are acceptable.
+ address = new LinkAddress(V6 + "/64", IFA_F_DEPRECATED | IFA_F_PERMANENT, RT_SCOPE_LINK);
+ assertEquals(V6_ADDRESS, address.getAddress());
+ assertEquals(64, address.getNetworkPrefixLength());
+ assertEquals(IFA_F_DEPRECATED | IFA_F_PERMANENT, address.getFlags());
+ assertEquals(RT_SCOPE_LINK, address.getScope());
+
+ address = new LinkAddress(V4 + "/23", 123, 456);
+ assertEquals(V4_ADDRESS, address.getAddress());
+ assertEquals(23, address.getNetworkPrefixLength());
+ assertEquals(123, address.getFlags());
+ assertEquals(456, address.getScope());
+
+ // InterfaceAddress doesn't have a constructor. Fetch some from an interface.
+ List<InterfaceAddress> addrs = NetworkInterface.getByName("lo").getInterfaceAddresses();
+
+ // We expect to find 127.0.0.1/8 and ::1/128, in any order.
+ LinkAddress ipv4Loopback, ipv6Loopback;
+ assertEquals(2, addrs.size());
+ if (addrs.get(0).getAddress() instanceof Inet4Address) {
+ ipv4Loopback = new LinkAddress(addrs.get(0));
+ ipv6Loopback = new LinkAddress(addrs.get(1));
+ } else {
+ ipv4Loopback = new LinkAddress(addrs.get(1));
+ ipv6Loopback = new LinkAddress(addrs.get(0));
+ }
+
+ assertEquals(NetworkUtils.numericToInetAddress("127.0.0.1"), ipv4Loopback.getAddress());
+ assertEquals(8, ipv4Loopback.getNetworkPrefixLength());
+
+ assertEquals(NetworkUtils.numericToInetAddress("::1"), ipv6Loopback.getAddress());
+ assertEquals(128, ipv6Loopback.getNetworkPrefixLength());
+
+ // Null addresses are rejected.
+ try {
+ address = new LinkAddress(null, 24);
+ fail("Null InetAddress should cause IllegalArgumentException");
+ } catch(IllegalArgumentException expected) {}
+
+ try {
+ address = new LinkAddress((String) null, IFA_F_PERMANENT, RT_SCOPE_UNIVERSE);
+ fail("Null string should cause IllegalArgumentException");
+ } catch(IllegalArgumentException expected) {}
+
+ try {
+ address = new LinkAddress((InterfaceAddress) null);
+ fail("Null string should cause NullPointerException");
+ } catch(NullPointerException expected) {}
+
+ // Invalid prefix lengths are rejected.
+ try {
+ address = new LinkAddress(V4_ADDRESS, -1);
+ fail("Negative IPv4 prefix length should cause IllegalArgumentException");
+ } catch(IllegalArgumentException expected) {}
+
+ try {
+ address = new LinkAddress(V6_ADDRESS, -1);
+ fail("Negative IPv6 prefix length should cause IllegalArgumentException");
+ } catch(IllegalArgumentException expected) {}
+
+ try {
+ address = new LinkAddress(V4_ADDRESS, 33);
+ fail("/33 IPv4 prefix length should cause IllegalArgumentException");
+ } catch(IllegalArgumentException expected) {}
+
+ try {
+ address = new LinkAddress(V4 + "/33", IFA_F_PERMANENT, RT_SCOPE_UNIVERSE);
+ fail("/33 IPv4 prefix length should cause IllegalArgumentException");
+ } catch(IllegalArgumentException expected) {}
+
+
+ try {
+ address = new LinkAddress(V6_ADDRESS, 129, IFA_F_PERMANENT, RT_SCOPE_UNIVERSE);
+ fail("/129 IPv6 prefix length should cause IllegalArgumentException");
+ } catch(IllegalArgumentException expected) {}
+
+ try {
+ address = new LinkAddress(V6 + "/129", IFA_F_PERMANENT, RT_SCOPE_UNIVERSE);
+ fail("/129 IPv6 prefix length should cause IllegalArgumentException");
+ } catch(IllegalArgumentException expected) {}
+
+ // Multicast addresses are rejected.
+ try {
+ address = new LinkAddress("224.0.0.2/32");
+ fail("IPv4 multicast address should cause IllegalArgumentException");
+ } catch(IllegalArgumentException expected) {}
+
+ try {
+ address = new LinkAddress("ff02::1/128");
+ fail("IPv6 multicast address should cause IllegalArgumentException");
+ } catch(IllegalArgumentException expected) {}
+ }
+
+ public void testAddressScopes() {
+ assertEquals(RT_SCOPE_HOST, new LinkAddress("::/128").getScope());
+ assertEquals(RT_SCOPE_HOST, new LinkAddress("0.0.0.0/32").getScope());
+
+ assertEquals(RT_SCOPE_LINK, new LinkAddress("::1/128").getScope());
+ assertEquals(RT_SCOPE_LINK, new LinkAddress("127.0.0.5/8").getScope());
+ assertEquals(RT_SCOPE_LINK, new LinkAddress("fe80::ace:d00d/64").getScope());
+ assertEquals(RT_SCOPE_LINK, new LinkAddress("169.254.5.12/16").getScope());
+
+ assertEquals(RT_SCOPE_SITE, new LinkAddress("fec0::dead/64").getScope());
+
+ assertEquals(RT_SCOPE_UNIVERSE, new LinkAddress("10.1.2.3/21").getScope());
+ assertEquals(RT_SCOPE_UNIVERSE, new LinkAddress("192.0.2.1/25").getScope());
+ assertEquals(RT_SCOPE_UNIVERSE, new LinkAddress("2001:db8::/64").getScope());
+ assertEquals(RT_SCOPE_UNIVERSE, new LinkAddress("5000::/127").getScope());
+ }
+
+ private void assertIsSameAddressAs(LinkAddress l1, LinkAddress l2) {
+ assertTrue(l1 + " unexpectedly does not have same address as " + l2,
+ l1.isSameAddressAs(l2));
+ assertTrue(l2 + " unexpectedly does not have same address as " + l1,
+ l2.isSameAddressAs(l1));
+ }
+
+ private void assertIsNotSameAddressAs(LinkAddress l1, LinkAddress l2) {
+ assertFalse(l1 + " unexpectedly has same address as " + l2,
+ l1.isSameAddressAs(l2));
+ assertFalse(l2 + " unexpectedly has same address as " + l1,
+ l1.isSameAddressAs(l2));
+ }
+
+ private void assertLinkAddressesEqual(LinkAddress l1, LinkAddress l2) {
+ assertTrue(l1 + " unexpectedly not equal to " + l2, l1.equals(l2));
+ assertTrue(l2 + " unexpectedly not equal to " + l1, l2.equals(l1));
+ assertEquals(l1.hashCode(), l2.hashCode());
+ }
+
+ private void assertLinkAddressesNotEqual(LinkAddress l1, LinkAddress l2) {
+ assertFalse(l1 + " unexpectedly equal to " + l2, l1.equals(l2));
+ assertFalse(l2 + " unexpectedly equal to " + l1, l2.equals(l1));
+ }
+
+ public void testEqualsAndSameAddressAs() {
+ LinkAddress l1, l2, l3;
+
+ l1 = new LinkAddress("2001:db8::1/64");
+ l2 = new LinkAddress("2001:db8::1/64");
+ assertLinkAddressesEqual(l1, l2);
+ assertIsSameAddressAs(l1, l2);
+
+ l2 = new LinkAddress("2001:db8::1/65");
+ assertLinkAddressesNotEqual(l1, l2);
+ assertIsNotSameAddressAs(l1, l2);
+
+ l2 = new LinkAddress("2001:db8::2/64");
+ assertLinkAddressesNotEqual(l1, l2);
+ assertIsNotSameAddressAs(l1, l2);
+
+
+ l1 = new LinkAddress("192.0.2.1/24");
+ l2 = new LinkAddress("192.0.2.1/24");
+ assertLinkAddressesEqual(l1, l2);
+ assertIsSameAddressAs(l1, l2);
+
+ l2 = new LinkAddress("192.0.2.1/23");
+ assertLinkAddressesNotEqual(l1, l2);
+ assertIsNotSameAddressAs(l1, l2);
+
+ l2 = new LinkAddress("192.0.2.2/24");
+ assertLinkAddressesNotEqual(l1, l2);
+ assertIsNotSameAddressAs(l1, l2);
+
+
+ // Check equals() and isSameAddressAs() on identical addresses with different flags.
+ l1 = new LinkAddress(V6_ADDRESS, 64);
+ l2 = new LinkAddress(V6_ADDRESS, 64, 0, RT_SCOPE_UNIVERSE);
+ assertLinkAddressesEqual(l1, l2);
+ assertIsSameAddressAs(l1, l2);
+
+ l2 = new LinkAddress(V6_ADDRESS, 64, IFA_F_DEPRECATED, RT_SCOPE_UNIVERSE);
+ assertLinkAddressesNotEqual(l1, l2);
+ assertIsSameAddressAs(l1, l2);
+
+ // Check equals() and isSameAddressAs() on identical addresses with different scope.
+ l1 = new LinkAddress(V4_ADDRESS, 24);
+ l2 = new LinkAddress(V4_ADDRESS, 24, 0, RT_SCOPE_UNIVERSE);
+ assertLinkAddressesEqual(l1, l2);
+ assertIsSameAddressAs(l1, l2);
+
+ l2 = new LinkAddress(V4_ADDRESS, 24, 0, RT_SCOPE_HOST);
+ assertLinkAddressesNotEqual(l1, l2);
+ assertIsSameAddressAs(l1, l2);
+
+ // Addresses with the same start or end bytes aren't equal between families.
+ l1 = new LinkAddress("32.1.13.184/24");
+ l2 = new LinkAddress("2001:db8::1/24");
+ l3 = new LinkAddress("::2001:db8/24");
+
+ byte[] ipv4Bytes = l1.getAddress().getAddress();
+ byte[] l2FirstIPv6Bytes = Arrays.copyOf(l2.getAddress().getAddress(), 4);
+ byte[] l3LastIPv6Bytes = Arrays.copyOfRange(l3.getAddress().getAddress(), 12, 16);
+ assertTrue(Arrays.equals(ipv4Bytes, l2FirstIPv6Bytes));
+ assertTrue(Arrays.equals(ipv4Bytes, l3LastIPv6Bytes));
+
+ assertLinkAddressesNotEqual(l1, l2);
+ assertIsNotSameAddressAs(l1, l2);
+
+ assertLinkAddressesNotEqual(l1, l3);
+ assertIsNotSameAddressAs(l1, l3);
+
+ // Because we use InetAddress, an IPv4 address is equal to its IPv4-mapped address.
+ // TODO: Investigate fixing this.
+ String addressString = V4 + "/24";
+ l1 = new LinkAddress(addressString);
+ l2 = new LinkAddress("::ffff:" + addressString);
+ assertLinkAddressesEqual(l1, l2);
+ assertIsSameAddressAs(l1, l2);
+ }
+
+ public void testHashCode() {
+ LinkAddress l;
+
+ l = new LinkAddress(V4_ADDRESS, 23);
+ assertEquals(-982787, l.hashCode());
+
+ l = new LinkAddress(V4_ADDRESS, 23, 0, RT_SCOPE_HOST);
+ assertEquals(-971865, l.hashCode());
+
+ l = new LinkAddress(V4_ADDRESS, 27);
+ assertEquals(-982743, l.hashCode());
+
+ l = new LinkAddress(V6_ADDRESS, 64);
+ assertEquals(1076522926, l.hashCode());
+
+ l = new LinkAddress(V6_ADDRESS, 128);
+ assertEquals(1076523630, l.hashCode());
+
+ l = new LinkAddress(V6_ADDRESS, 128, IFA_F_TENTATIVE, RT_SCOPE_UNIVERSE);
+ assertEquals(1076524846, l.hashCode());
+ }
+
+ private LinkAddress passThroughParcel(LinkAddress l) {
+ Parcel p = Parcel.obtain();
+ LinkAddress l2 = null;
+ try {
+ l.writeToParcel(p, 0);
+ p.setDataPosition(0);
+ l2 = LinkAddress.CREATOR.createFromParcel(p);
+ } finally {
+ p.recycle();
+ }
+ assertNotNull(l2);
+ return l2;
+ }
+
+ private void assertParcelingIsLossless(LinkAddress l) {
+ LinkAddress l2 = passThroughParcel(l);
+ assertEquals(l, l2);
+ }
+
+ public void testParceling() {
+ LinkAddress l;
+
+ l = new LinkAddress(V6_ADDRESS, 64, 123, 456);
+ assertParcelingIsLossless(l);
+
+ l = new LinkAddress(V4 + "/28", IFA_F_PERMANENT, RT_SCOPE_LINK);
+ assertParcelingIsLossless(l);
+ }
+}
diff --git a/core/tests/coretests/src/android/net/LinkPropertiesTest.java b/core/tests/coretests/src/android/net/LinkPropertiesTest.java
index e63f6b0..a602e07 100644
--- a/core/tests/coretests/src/android/net/LinkPropertiesTest.java
+++ b/core/tests/coretests/src/android/net/LinkPropertiesTest.java
@@ -24,6 +24,8 @@
import java.net.InetAddress;
import java.util.ArrayList;
+import libcore.io.OsConstants;
+
public class LinkPropertiesTest extends TestCase {
private static InetAddress ADDRV4 = NetworkUtils.numericToInetAddress("75.208.6.1");
private static InetAddress ADDRV6 = NetworkUtils.numericToInetAddress(
@@ -341,6 +343,10 @@
assertFalse(rmnet0.removeStackedLink(clat4));
}
+ private LinkAddress getFirstLinkAddress(LinkProperties lp) {
+ return lp.getLinkAddresses().iterator().next();
+ }
+
@SmallTest
public void testAddressMethods() {
LinkProperties lp = new LinkProperties();
@@ -366,26 +372,56 @@
// Addresses on the base link.
// Check the return values of hasIPvXAddress and ensure the add/remove methods return true
// iff something changes.
+ assertEquals(0, lp.getLinkAddresses().size());
assertTrue(lp.addLinkAddress(LINKADDRV6));
+ assertEquals(1, lp.getLinkAddresses().size());
assertFalse(lp.hasIPv4Address());
assertTrue(lp.hasIPv6Address());
assertTrue(lp.removeLinkAddress(LINKADDRV6));
+ assertEquals(0, lp.getLinkAddresses().size());
assertTrue(lp.addLinkAddress(LINKADDRV4));
+ assertEquals(1, lp.getLinkAddresses().size());
assertTrue(lp.hasIPv4Address());
assertFalse(lp.hasIPv6Address());
assertTrue(lp.addLinkAddress(LINKADDRV6));
+ assertEquals(2, lp.getLinkAddresses().size());
assertTrue(lp.hasIPv4Address());
assertTrue(lp.hasIPv6Address());
// Adding an address twice has no effect.
// Removing an address that's not present has no effect.
assertFalse(lp.addLinkAddress(LINKADDRV4));
+ assertEquals(2, lp.getLinkAddresses().size());
assertTrue(lp.hasIPv4Address());
assertTrue(lp.removeLinkAddress(LINKADDRV4));
+ assertEquals(1, lp.getLinkAddresses().size());
assertFalse(lp.hasIPv4Address());
assertFalse(lp.removeLinkAddress(LINKADDRV4));
+ assertEquals(1, lp.getLinkAddresses().size());
+
+ // Adding an address that's already present but with different properties causes the
+ // existing address to be updated and returns true.
+ // Start with only LINKADDRV6.
+ assertEquals(1, lp.getLinkAddresses().size());
+ assertEquals(LINKADDRV6, getFirstLinkAddress(lp));
+
+ // Create a LinkAddress object for the same address, but with different flags.
+ LinkAddress deprecated = new LinkAddress(ADDRV6, 128,
+ OsConstants.IFA_F_DEPRECATED, OsConstants.RT_SCOPE_UNIVERSE);
+ assertTrue(deprecated.isSameAddressAs(LINKADDRV6));
+ assertFalse(deprecated.equals(LINKADDRV6));
+
+ // Check that adding it updates the existing address instead of adding a new one.
+ assertTrue(lp.addLinkAddress(deprecated));
+ assertEquals(1, lp.getLinkAddresses().size());
+ assertEquals(deprecated, getFirstLinkAddress(lp));
+ assertFalse(LINKADDRV6.equals(getFirstLinkAddress(lp)));
+
+ // Removing LINKADDRV6 removes deprecated, because removing addresses ignores properties.
+ assertTrue(lp.removeLinkAddress(LINKADDRV6));
+ assertEquals(0, lp.getLinkAddresses().size());
}
@SmallTest
diff --git a/services/java/com/android/server/ConnectivityService.java b/services/core/java/com/android/server/ConnectivityService.java
similarity index 99%
rename from services/java/com/android/server/ConnectivityService.java
rename to services/core/java/com/android/server/ConnectivityService.java
index 3e22792..d5259f8 100644
--- a/services/java/com/android/server/ConnectivityService.java
+++ b/services/core/java/com/android/server/ConnectivityService.java
@@ -26,6 +26,7 @@
import static android.net.ConnectivityManager.TYPE_MOBILE;
import static android.net.ConnectivityManager.TYPE_WIFI;
import static android.net.ConnectivityManager.TYPE_WIMAX;
+import static android.net.ConnectivityManager.TYPE_PROXY;
import static android.net.ConnectivityManager.getNetworkTypeName;
import static android.net.ConnectivityManager.isNetworkTypeValid;
import static android.net.NetworkPolicyManager.RULE_ALLOW_ALL;
@@ -72,6 +73,7 @@
import android.net.NetworkStateTracker;
import android.net.NetworkUtils;
import android.net.Proxy;
+import android.net.ProxyDataTracker;
import android.net.ProxyProperties;
import android.net.RouteInfo;
import android.net.SamplingDataTracker;
@@ -736,6 +738,8 @@
return makeWimaxStateTracker(mContext, mTrackerHandler);
case TYPE_ETHERNET:
return EthernetDataTracker.getInstance();
+ case TYPE_PROXY:
+ return new ProxyDataTracker();
default:
throw new IllegalArgumentException(
"Trying to create a NetworkStateTracker for an unknown radio type: "
@@ -1637,9 +1641,12 @@
return false;
}
NetworkStateTracker tracker = mNetTrackers[networkType];
- DetailedState netState = tracker.getNetworkInfo().getDetailedState();
+ DetailedState netState = DetailedState.DISCONNECTED;
+ if (tracker != null) {
+ netState = tracker.getNetworkInfo().getDetailedState();
+ }
- if (tracker == null || (netState != DetailedState.CONNECTED &&
+ if ((netState != DetailedState.CONNECTED &&
netState != DetailedState.CAPTIVE_PORTAL_CHECK) ||
tracker.isTeardownRequested()) {
if (VDBG) {
diff --git a/services/java/com/android/server/connectivity/Nat464Xlat.java b/services/core/java/com/android/server/connectivity/Nat464Xlat.java
similarity index 100%
rename from services/java/com/android/server/connectivity/Nat464Xlat.java
rename to services/core/java/com/android/server/connectivity/Nat464Xlat.java
diff --git a/services/tests/servicestests/src/com/android/server/NetworkManagementServiceTest.java b/services/tests/servicestests/src/com/android/server/NetworkManagementServiceTest.java
index 56dd7c4..7a30d31 100644
--- a/services/tests/servicestests/src/com/android/server/NetworkManagementServiceTest.java
+++ b/services/tests/servicestests/src/com/android/server/NetworkManagementServiceTest.java
@@ -17,6 +17,7 @@
package com.android.server;
import android.content.Context;
+import android.net.LinkAddress;
import android.net.LocalSocket;
import android.net.LocalServerSocket;
import android.os.Binder;
@@ -157,18 +158,61 @@
* IP address changes.
*/
sendMessage("614 Address updated fe80::1/64 wlan0 128 253");
- expectSoon(observer).addressUpdated("fe80::1/64", "wlan0", 128, 253);
+ expectSoon(observer).addressUpdated("wlan0", new LinkAddress("fe80::1/64", 128, 253));
- // There is no "added".
+ // There is no "added", so we take this as "removed".
sendMessage("614 Address added fe80::1/64 wlan0 128 253");
- expectSoon(observer).addressRemoved("fe80::1/64", "wlan0", 128, 253);
+ expectSoon(observer).addressRemoved("wlan0", new LinkAddress("fe80::1/64", 128, 253));
sendMessage("614 Address removed 2001:db8::1/64 wlan0 1 0");
- expectSoon(observer).addressRemoved("2001:db8::1/64", "wlan0", 1, 0);
+ expectSoon(observer).addressRemoved("wlan0", new LinkAddress("2001:db8::1/64", 1, 0));
- sendMessage("666 Address added 2001:db8::1/64 wlan0 1 0");
+ sendMessage("614 Address removed 2001:db8::1/64 wlan0 1");
+ // Not enough arguments.
+
+ sendMessage("666 Address removed 2001:db8::1/64 wlan0 1 0");
// Invalid code.
+
+ /**
+ * DNS information broadcasts.
+ */
+ sendMessage("615 DnsInfo servers rmnet_usb0 3600 2001:db8::1");
+ expectSoon(observer).interfaceDnsServerInfo("rmnet_usb0", 3600,
+ new String[]{"2001:db8::1"});
+
+ sendMessage("615 DnsInfo servers wlan0 14400 2001:db8::1,2001:db8::2");
+ expectSoon(observer).interfaceDnsServerInfo("wlan0", 14400,
+ new String[]{"2001:db8::1", "2001:db8::2"});
+
+ // We don't check for negative lifetimes, only for parse errors.
+ sendMessage("615 DnsInfo servers wlan0 -3600 ::1");
+ expectSoon(observer).interfaceDnsServerInfo("wlan0", -3600,
+ new String[]{"::1"});
+
+ sendMessage("615 DnsInfo servers wlan0 SIXHUNDRED ::1");
+ // Non-numeric lifetime.
+
+ sendMessage("615 DnsInfo servers wlan0 2001:db8::1");
+ // Missing lifetime.
+
+ sendMessage("615 DnsInfo servers wlan0 3600");
+ // No servers.
+
+ sendMessage("615 DnsInfo servers 3600 wlan0 2001:db8::1,2001:db8::2");
+ // Non-numeric lifetime.
+
+ sendMessage("615 DnsInfo wlan0 7200 2001:db8::1,2001:db8::2");
+ // Invalid tokens.
+
+ sendMessage("666 DnsInfo servers wlan0 5400 2001:db8::1");
+ // Invalid code.
+
+ // No syntax checking on the addresses.
+ sendMessage("615 DnsInfo servers wlan0 600 ,::,,foo,::1,");
+ expectSoon(observer).interfaceDnsServerInfo("wlan0", 600,
+ new String[]{"", "::", "", "foo", "::1"});
+
// Make sure nothing else was called.
verifyNoMoreInteractions(observer);
}