diff options
11 files changed, 388 insertions, 82 deletions
diff --git a/core/java/android/net/INetworkManagementEventObserver.aidl b/core/java/android/net/INetworkManagementEventObserver.aidl index 405a897a9004..5b16f8b3e581 100644 --- a/core/java/android/net/INetworkManagementEventObserver.aidl +++ b/core/java/android/net/INetworkManagementEventObserver.aidl @@ -57,24 +57,20 @@ interface INetworkManagementEventObserver { /** - * An interface address has been added or updated + * An interface address has been added or updated. * - * @param address The address. * @param iface The interface. - * @param flags The address flags. - * @param scope The address scope. + * @param address The address. */ - void addressUpdated(in LinkAddress address, String iface, int flags, int scope); + void addressUpdated(String iface, in LinkAddress address); /** - * An interface address has been removed + * An interface address has been removed. * - * @param address The address. * @param iface The interface. - * @param flags The address flags. - * @param scope The address scope. + * @param address The address. */ - void addressRemoved(in LinkAddress address, String iface, int flags, int scope); + void addressRemoved(String iface, in LinkAddress address); /** * A networking quota limit has been reached. The quota might not diff --git a/core/java/android/net/LinkAddress.java b/core/java/android/net/LinkAddress.java index 570b6fe5be0e..22543e3ef156 100644 --- a/core/java/android/net/LinkAddress.java +++ b/core/java/android/net/LinkAddress.java @@ -24,8 +24,32 @@ import java.net.InetAddress; 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 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 { @@ -39,8 +63,46 @@ public class LinkAddress implements Parcelable { */ 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,32 +110,59 @@ public class LinkAddress implements Parcelable { } 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 { @@ -90,18 +179,22 @@ public class LinkAddress implements Parcelable { throw new IllegalArgumentException("Bad LinkAddress params " + address); } - init(inetAddress, prefixLength); + init(inetAddress, prefixLength, flags, scope); } + /** + * 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 the specified address - * in {@code obj}. Two addresses are equal if their InetAddress and prefixLength - * are equal. + * 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. @@ -113,7 +206,9 @@ public class LinkAddress implements Parcelable { } LinkAddress linkAddress = (LinkAddress) obj; return this.address.equals(linkAddress.address) && - this.prefixLength == linkAddress.prefixLength; + this.prefixLength == linkAddress.prefixLength && + this.flags == linkAddress.flags && + this.scope == linkAddress.scope; } /** @@ -121,7 +216,20 @@ public class LinkAddress implements Parcelable { */ @Override public int hashCode() { - return address.hashCode() + 11 * prefixLength; + 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; } /** @@ -139,6 +247,28 @@ public class LinkAddress implements Parcelable { } /** + * 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 */ @@ -153,6 +283,8 @@ public class LinkAddress implements Parcelable { public void writeToParcel(Parcel dest, int flags) { dest.writeByteArray(address.getAddress()); dest.writeInt(prefixLength); + dest.writeInt(this.flags); + dest.writeInt(scope); } /** @@ -171,7 +303,9 @@ public class LinkAddress implements Parcelable { // InetAddress. } int prefixLength = in.readInt(); - return new LinkAddress(address, prefixLength); + 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 b4d07a1ec23c..4dfd3d9586fd 100644 --- a/core/java/android/net/LinkProperties.java +++ b/core/java/android/net/LinkProperties.java @@ -61,10 +61,10 @@ import java.util.Hashtable; 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 @@ public class LinkProperties implements Parcelable { return addresses; } + private int findLinkAddressIndex(LinkAddress address) { + for (int i = 0; i < mLinkAddresses.size(); i++) { + if (mLinkAddresses.get(i).isSameAddressAs(address)) { + return i; + } + } + return -1; + } + /** - * Adds a link address if it does not exist, or update it if it does. + * 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 the address was added, false if it already existed. + * @return true if {@code address} was added or updated, false otherwise. */ 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)) { + 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; } - return false; } /** - * Removes a link address. - * @param address The {@code LinkAddress} to remove. + * 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/java/com/android/server/net/BaseNetworkObserver.java b/core/java/com/android/server/net/BaseNetworkObserver.java index 1e80a218c577..5502a178649f 100644 --- a/core/java/com/android/server/net/BaseNetworkObserver.java +++ b/core/java/com/android/server/net/BaseNetworkObserver.java @@ -37,12 +37,12 @@ public class BaseNetworkObserver extends INetworkManagementEventObserver.Stub { } @Override - public void addressUpdated(LinkAddress address, String iface, int flags, int scope) { + public void addressUpdated(String iface, LinkAddress address) { // default no-op } @Override - public void addressRemoved(LinkAddress address, String iface, int flags, int scope) { + public void addressRemoved(String iface, LinkAddress address) { // default no-op } diff --git a/core/res/res/values-de/strings.xml b/core/res/res/values-de/strings.xml index e30d8795947a..9a086cff3178 100644 --- a/core/res/res/values-de/strings.xml +++ b/core/res/res/values-de/strings.xml @@ -456,9 +456,9 @@ <string name="permlab_writeCallLog" msgid="8552045664743499354">"Anrufliste bearbeiten"</string> <string name="permdesc_writeCallLog" product="tablet" msgid="6661806062274119245">"Ermöglicht der App, die Anrufliste Ihres Tablets zu ändern, einschließlich der Daten über ein- und ausgehende Anrufe. Schädliche Apps können so Ihre Anrufliste löschen oder ändern."</string> <string name="permdesc_writeCallLog" product="default" msgid="683941736352787842">"Ermöglicht der App, die Anrufliste Ihres Telefons zu ändern, einschließlich der Daten über ein- und ausgehende Anrufe. Schädliche Apps können so Ihre Anrufliste löschen oder ändern."</string> - <string name="permlab_readProfile" msgid="4701889852612716678">"Meine Kontaktkarten lesen"</string> + <string name="permlab_readProfile" msgid="4701889852612716678">"Ihre Kontaktkarten lesen"</string> <string name="permdesc_readProfile" product="default" msgid="5462475151849888848">"Ermöglicht der App, auf Ihrem Gerät gespeicherte personenbezogene Profildaten zu lesen, einschließlich Ihres Namens und Ihrer Kontaktdaten. Die App kann Sie somit identifizieren und Ihre Profildaten an andere senden."</string> - <string name="permlab_writeProfile" msgid="907793628777397643">"Meine Kontaktkarten ändern"</string> + <string name="permlab_writeProfile" msgid="907793628777397643">"Ihre Kontaktkarten ändern"</string> <string name="permdesc_writeProfile" product="default" msgid="5552084294598465899">"Ermöglicht der App, auf Ihrem Gerät gespeicherte personenbezogene Profildaten zu ändern, einschließlich Ihres Namens und Ihrer Kontaktdaten, sowie Daten hinzuzufügen. Die App kann Sie so identifizieren und Ihre Profildaten an andere senden."</string> <string name="permlab_readSocialStream" product="default" msgid="1268920956152419170">"In sozialem Stream lesen"</string> <string name="permdesc_readSocialStream" product="default" msgid="4255706027172050872">"Ermöglicht der App, auf Updates aus sozialen Netzwerken von Ihnen und Ihren Freunden zuzugreifen und diese zu synchronisieren. Seien Sie vorsichtig, wenn Sie Informationen teilen: Der App wird erlaubt, die Kommunikation zwischen Ihnen und Ihren Freunden in sozialen Netzwerken zu lesen, unabhängig von der Vertraulichkeit der kommunizierten Informationen. Hinweis: Diese Berechtigung kann möglicherweise nicht in allen sozialen Netzwerken erzwungen werden."</string> diff --git a/core/tests/coretests/src/android/net/LinkAddressTest.java b/core/tests/coretests/src/android/net/LinkAddressTest.java index 389ff4dead93..17423be65feb 100644 --- a/core/tests/coretests/src/android/net/LinkAddressTest.java +++ b/core/tests/coretests/src/android/net/LinkAddressTest.java @@ -22,6 +22,7 @@ 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; @@ -31,6 +32,14 @@ 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}. */ @@ -48,18 +57,27 @@ public class LinkAddressTest extends AndroidTestCase { 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()); - address = new LinkAddress(V6 + "/64"); + // 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"); + 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(); @@ -88,7 +106,7 @@ public class LinkAddressTest extends AndroidTestCase { } catch(IllegalArgumentException expected) {} try { - address = new LinkAddress((String) null); + address = new LinkAddress((String) null, IFA_F_PERMANENT, RT_SCOPE_UNIVERSE); fail("Null string should cause IllegalArgumentException"); } catch(IllegalArgumentException expected) {} @@ -99,24 +117,77 @@ public class LinkAddressTest extends AndroidTestCase { // Invalid prefix lengths are rejected. try { - address = new LinkAddress(V4 + "/-1"); + address = new LinkAddress(V4_ADDRESS, -1); fail("Negative IPv4 prefix length should cause IllegalArgumentException"); } catch(IllegalArgumentException expected) {} try { - address = new LinkAddress(V6 + "/-1"); + address = new LinkAddress(V6_ADDRESS, -1); fail("Negative IPv6 prefix length should cause IllegalArgumentException"); } catch(IllegalArgumentException expected) {} try { - address = new LinkAddress(V4 + "/33"); - fail("/35 IPv4 prefix length should cause IllegalArgumentException"); + 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 + "/129"); + 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) { @@ -130,33 +201,73 @@ public class LinkAddressTest extends AndroidTestCase { assertFalse(l2 + " unexpectedly equal to " + l1, l2.equals(l1)); } - public void testEquals() { - LinkAddress l1, l2; + 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); - // Addresses with the same start or end bytes aren't equal between families. - l1 = new LinkAddress("255.255.255.255/24"); - l2 = new LinkAddress("ffff:ffff::/24"); + + // 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); - l2 = new LinkAddress("::ffff:ffff/24"); + 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. @@ -164,6 +275,7 @@ public class LinkAddressTest extends AndroidTestCase { l1 = new LinkAddress(addressString); l2 = new LinkAddress("::ffff:" + addressString); assertLinkAddressesEqual(l1, l2); + assertIsSameAddressAs(l1, l2); } public void testHashCode() { @@ -172,6 +284,9 @@ public class LinkAddressTest extends AndroidTestCase { 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()); @@ -180,6 +295,9 @@ public class LinkAddressTest extends AndroidTestCase { 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) { @@ -204,10 +322,10 @@ public class LinkAddressTest extends AndroidTestCase { public void testParceling() { LinkAddress l; - l = new LinkAddress(V6_ADDRESS, 64); + l = new LinkAddress(V6_ADDRESS, 64, 123, 456); assertParcelingIsLossless(l); - l = new LinkAddress(V4 + "/28"); + 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 e63f6b08f6e3..a602e07d9b04 100644 --- a/core/tests/coretests/src/android/net/LinkPropertiesTest.java +++ b/core/tests/coretests/src/android/net/LinkPropertiesTest.java @@ -24,6 +24,8 @@ import junit.framework.TestCase; 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 @@ public class LinkPropertiesTest extends TestCase { 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 @@ public class LinkPropertiesTest extends TestCase { // 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/policy/src/com/android/internal/policy/impl/ImmersiveModeConfirmation.java b/policy/src/com/android/internal/policy/impl/ImmersiveModeConfirmation.java index 3e57a77807c4..b734c41c9a11 100644 --- a/policy/src/com/android/internal/policy/impl/ImmersiveModeConfirmation.java +++ b/policy/src/com/android/internal/policy/impl/ImmersiveModeConfirmation.java @@ -178,6 +178,7 @@ public class ImmersiveModeConfirmation { | WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED , PixelFormat.TRANSLUCENT); + lp.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS; lp.setTitle("ImmersiveModeConfirmation"); lp.windowAnimations = com.android.internal.R.style.Animation_RecentApplications; lp.gravity = Gravity.FILL; diff --git a/services/java/com/android/server/NetworkManagementService.java b/services/java/com/android/server/NetworkManagementService.java index 40ea49e45adc..ad7ec99775a3 100644 --- a/services/java/com/android/server/NetworkManagementService.java +++ b/services/java/com/android/server/NetworkManagementService.java @@ -405,11 +405,11 @@ public class NetworkManagementService extends INetworkManagementService.Stub /** * Notify our observers of a new or updated interface address. */ - private void notifyAddressUpdated(LinkAddress address, String iface, int flags, int scope) { + private void notifyAddressUpdated(String iface, LinkAddress address) { final int length = mObservers.beginBroadcast(); for (int i = 0; i < length; i++) { try { - mObservers.getBroadcastItem(i).addressUpdated(address, iface, flags, scope); + mObservers.getBroadcastItem(i).addressUpdated(iface, address); } catch (RemoteException e) { } catch (RuntimeException e) { } @@ -420,11 +420,11 @@ public class NetworkManagementService extends INetworkManagementService.Stub /** * Notify our observers of a deleted interface address. */ - private void notifyAddressRemoved(LinkAddress address, String iface, int flags, int scope) { + private void notifyAddressRemoved(String iface, LinkAddress address) { final int length = mObservers.beginBroadcast(); for (int i = 0; i < length; i++) { try { - mObservers.getBroadcastItem(i).addressRemoved(address, iface, flags, scope); + mObservers.getBroadcastItem(i).addressRemoved(iface, address); } catch (RemoteException e) { } catch (RuntimeException e) { } @@ -535,23 +535,22 @@ public class NetworkManagementService extends INetworkManagementService.Stub throw new IllegalStateException(errorMessage); } - int flags; - int scope; + String iface = cooked[4]; LinkAddress address; try { - flags = Integer.parseInt(cooked[5]); - scope = Integer.parseInt(cooked[6]); - address = new LinkAddress(cooked[3]); + int flags = Integer.parseInt(cooked[5]); + int scope = Integer.parseInt(cooked[6]); + address = new LinkAddress(cooked[3], flags, scope); } catch(NumberFormatException e) { // Non-numeric lifetime or scope. throw new IllegalStateException(errorMessage, e); - } catch(IllegalArgumentException e) { // Malformed IP address. + } catch(IllegalArgumentException e) { // Malformed/invalid IP address. throw new IllegalStateException(errorMessage, e); } if (cooked[2].equals("updated")) { - notifyAddressUpdated(address, cooked[4], flags, scope); + notifyAddressUpdated(iface, address); } else { - notifyAddressRemoved(address, cooked[4], flags, scope); + notifyAddressRemoved(iface, address); } return true; // break; diff --git a/services/tests/servicestests/src/com/android/server/NetworkManagementServiceTest.java b/services/tests/servicestests/src/com/android/server/NetworkManagementServiceTest.java index a78e7b6d519b..7a30d31daab7 100644 --- a/services/tests/servicestests/src/com/android/server/NetworkManagementServiceTest.java +++ b/services/tests/servicestests/src/com/android/server/NetworkManagementServiceTest.java @@ -158,17 +158,14 @@ public class NetworkManagementServiceTest extends AndroidTestCase { * IP address changes. */ sendMessage("614 Address updated fe80::1/64 wlan0 128 253"); - expectSoon(observer).addressUpdated( - new LinkAddress("fe80::1/64"), "wlan0", 128, 253); + expectSoon(observer).addressUpdated("wlan0", new LinkAddress("fe80::1/64", 128, 253)); // There is no "added", so we take this as "removed". sendMessage("614 Address added fe80::1/64 wlan0 128 253"); - expectSoon(observer).addressRemoved( - new LinkAddress("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( - new LinkAddress("2001:db8::1/64"), "wlan0", 1, 0); + expectSoon(observer).addressRemoved("wlan0", new LinkAddress("2001:db8::1/64", 1, 0)); sendMessage("614 Address removed 2001:db8::1/64 wlan0 1"); // Not enough arguments. diff --git a/wifi/java/android/net/wifi/WifiStateMachine.java b/wifi/java/android/net/wifi/WifiStateMachine.java index 49fc75d2c772..149f08dddff8 100644 --- a/wifi/java/android/net/wifi/WifiStateMachine.java +++ b/wifi/java/android/net/wifi/WifiStateMachine.java @@ -237,24 +237,25 @@ public class WifiStateMachine extends StateMachine { mWifiStateMachine = wifiStateMachine; } + private void maybeLog(String operation, String iface, LinkAddress address) { + if (DBG) { + log(operation + ": " + address + " on " + iface + + " flags " + address.getFlags() + " scope " + address.getScope()); + } + } + @Override - public void addressUpdated(LinkAddress address, String iface, int flags, int scope) { + public void addressUpdated(String iface, LinkAddress address) { if (mWifiStateMachine.mInterfaceName.equals(iface)) { - if (DBG) { - log("addressUpdated: " + address + " on " + iface + - " flags " + flags + " scope " + scope); - } + maybeLog("addressUpdated", iface, address); mWifiStateMachine.sendMessage(CMD_IP_ADDRESS_UPDATED, address); } } @Override - public void addressRemoved(LinkAddress address, String iface, int flags, int scope) { + public void addressRemoved(String iface, LinkAddress address) { if (mWifiStateMachine.mInterfaceName.equals(iface)) { - if (DBG) { - log("addressRemoved: " + address + " on " + iface + - " flags " + flags + " scope " + scope); - } + maybeLog("addressRemoved", iface, address); mWifiStateMachine.sendMessage(CMD_IP_ADDRESS_REMOVED, address); } } |