drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

am 30253d7a: am 2daa0c93: Merge "Add address flags and scope to LinkAddress."

Browse Source 
* commit '30253d7a649bd4fc6a436ae880a70e1142c1e58f':
  Add address flags and scope to LinkAddress.
This commit is contained in:
Lorenzo Colitti
2013-12-09 18:31:25 +00:00
committed by Android Git Automerger
parent 0126e98034 30253d7a64
commit 263c4788dc
9 changed files with 391 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
core/java/android/net/INetworkManagementEventObserver.aidl
View File

@ -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

158
core/java/android/net/LinkAddress.java
View File

@ -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;
}
/**
@ -138,6 +246,28 @@ public class LinkAddress implements Parcelable {
return prefixLength;
}
/**
* 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) {

60
core/java/android/net/LinkProperties.java
View File

@ -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;
}
/**
* 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;
}
/**

4
core/java/com/android/server/net/BaseNetworkObserver.java
View File

@ -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
}

150
core/tests/coretests/src/android/net/LinkAddressTest.java
View File

@ -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(V6 + "/129");
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) {
@ -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);
// 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("255.255.255.255/24");
l2 = new LinkAddress("ffff:ffff::/24");
assertLinkAddressesNotEqual(l1, l2);
l2 = new LinkAddress("::ffff:ffff/24");
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);
}
}

36
core/tests/coretests/src/android/net/LinkPropertiesTest.java
View File

@ -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

23
services/java/com/android/server/NetworkManagementService.java
View File

@ -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;

9
services/tests/servicestests/src/com/android/server/NetworkManagementServiceTest.java
View File

@ -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.

21
wifi/java/android/net/wifi/WifiStateMachine.java
View File

@ -241,24 +241,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);
}
}