summaryrefslogtreecommitdiffstats
path: root/core/java
diff options
context:
space:
mode:
Diffstat (limited to 'core/java')
-rw-r--r--core/java/android/net/INetworkManagementEventObserver.aidl16
-rw-r--r--core/java/android/net/LinkAddress.java158
-rw-r--r--core/java/android/net/LinkProperties.java48
-rw-r--r--core/java/com/android/server/net/BaseNetworkObserver.java4
4 files changed, 190 insertions, 36 deletions
diff --git a/core/java/android/net/INetworkManagementEventObserver.aidl b/core/java/android/net/INetworkManagementEventObserver.aidl
index 405a897..5b16f8b 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 570b6fe..22543e3 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 b4d07a1..4dfd3d9 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 1e80a21..5502a17 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
}
generated by cgit v1.1 at 2025-11-29 23:53:21 +0000