am c3f5d718: Merge "Fix null handling in proxies." into lmp-dev
automerge: e34455e
* commit 'e34455e4b44a125147d025f3310630600dbdab6d':
Fix null handling in proxies.
diff --git a/core/java/android/net/ConnectivityManager.java b/core/java/android/net/ConnectivityManager.java
index 9194ca8..ec24ded 100644
--- a/core/java/android/net/ConnectivityManager.java
+++ b/core/java/android/net/ConnectivityManager.java
@@ -1012,60 +1012,57 @@
return null;
}
+ /**
+ * Guess what the network request was trying to say so that the resulting
+ * network is accessible via the legacy (deprecated) API such as
+ * requestRouteToHost.
+ * This means we should try to be fairly preceise about transport and
+ * capability but ignore things such as networkSpecifier.
+ * If the request has more than one transport or capability it doesn't
+ * match the old legacy requests (they selected only single transport/capability)
+ * so this function cannot map the request to a single legacy type and
+ * the resulting network will not be available to the legacy APIs.
+ *
+ * TODO - This should be removed when the legacy APIs are removed.
+ */
private int inferLegacyTypeForNetworkCapabilities(NetworkCapabilities netCap) {
if (netCap == null) {
return TYPE_NONE;
}
+
if (!netCap.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
return TYPE_NONE;
}
+
+ String type = null;
+ int result = TYPE_NONE;
+
if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_CBS)) {
- if (netCap.equals(networkCapabilitiesForFeature(TYPE_MOBILE, "enableCBS"))) {
- return TYPE_MOBILE_CBS;
- } else {
- return TYPE_NONE;
- }
+ type = "enableCBS";
+ result = TYPE_MOBILE_CBS;
+ } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_IMS)) {
+ type = "enableIMS";
+ result = TYPE_MOBILE_IMS;
+ } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_FOTA)) {
+ type = "enableFOTA";
+ result = TYPE_MOBILE_FOTA;
+ } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_DUN)) {
+ type = "enableDUN";
+ result = TYPE_MOBILE_DUN;
+ } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL)) {
+ type = "enableSUPL";
+ result = TYPE_MOBILE_SUPL;
+ } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_MMS)) {
+ type = "enableMMS";
+ result = TYPE_MOBILE_MMS;
+ } else if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)) {
+ type = "enableHIPRI";
+ result = TYPE_MOBILE_HIPRI;
}
- if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_IMS)) {
- if (netCap.equals(networkCapabilitiesForFeature(TYPE_MOBILE, "enableIMS"))) {
- return TYPE_MOBILE_IMS;
- } else {
- return TYPE_NONE;
- }
- }
- if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_FOTA)) {
- if (netCap.equals(networkCapabilitiesForFeature(TYPE_MOBILE, "enableFOTA"))) {
- return TYPE_MOBILE_FOTA;
- } else {
- return TYPE_NONE;
- }
- }
- if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_DUN)) {
- if (netCap.equals(networkCapabilitiesForFeature(TYPE_MOBILE, "enableDUN"))) {
- return TYPE_MOBILE_DUN;
- } else {
- return TYPE_NONE;
- }
- }
- if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL)) {
- if (netCap.equals(networkCapabilitiesForFeature(TYPE_MOBILE, "enableSUPL"))) {
- return TYPE_MOBILE_SUPL;
- } else {
- return TYPE_NONE;
- }
- }
- if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_MMS)) {
- if (netCap.equals(networkCapabilitiesForFeature(TYPE_MOBILE, "enableMMS"))) {
- return TYPE_MOBILE_MMS;
- } else {
- return TYPE_NONE;
- }
- }
- if (netCap.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)) {
- if (netCap.equals(networkCapabilitiesForFeature(TYPE_MOBILE, "enableHIPRI"))) {
- return TYPE_MOBILE_HIPRI;
- } else {
- return TYPE_NONE;
+ if (type != null) {
+ NetworkCapabilities testCap = networkCapabilitiesForFeature(TYPE_MOBILE, type);
+ if (testCap.equalsNetCapabilities(netCap) && testCap.equalsTransportTypes(netCap)) {
+ return result;
}
}
return TYPE_NONE;
@@ -2381,26 +2378,23 @@
/**
* The lookup key for a {@link Network} object included with the intent after
- * succesfully finding a network for the applications request. Retrieve it with
+ * successfully finding a network for the applications request. Retrieve it with
* {@link android.content.Intent#getParcelableExtra(String)}.
- * @hide
*/
- public static final String EXTRA_NETWORK_REQUEST_NETWORK = "networkRequestNetwork";
+ public static final String EXTRA_NETWORK = "android.net.extra.NETWORK";
/**
* The lookup key for a {@link NetworkRequest} object included with the intent after
- * succesfully finding a network for the applications request. Retrieve it with
+ * successfully finding a network for the applications request. Retrieve it with
* {@link android.content.Intent#getParcelableExtra(String)}.
- * @hide
*/
- public static final String EXTRA_NETWORK_REQUEST_NETWORK_REQUEST =
- "networkRequestNetworkRequest";
+ public static final String EXTRA_NETWORK_REQUEST = "android.net.extra.NETWORK_REQUEST";
/**
* Request a network to satisfy a set of {@link NetworkCapabilities}.
*
- * This function behavies identically to the version that takes a NetworkCallback, but instead
+ * This function behaves identically to the version that takes a NetworkCallback, but instead
* of {@link NetworkCallback} a {@link PendingIntent} is used. This means
* the request may outlive the calling application and get called back when a suitable
* network is found.
@@ -2410,8 +2404,8 @@
* <receiver> tag in an AndroidManifest.xml file
* <p>
* The operation Intent is delivered with two extras, a {@link Network} typed
- * extra called {@link #EXTRA_NETWORK_REQUEST_NETWORK} and a {@link NetworkRequest}
- * typed extra called {@link #EXTRA_NETWORK_REQUEST_NETWORK_REQUEST} containing
+ * extra called {@link #EXTRA_NETWORK} and a {@link NetworkRequest}
+ * typed extra called {@link #EXTRA_NETWORK_REQUEST} containing
* the original requests parameters. It is important to create a new,
* {@link NetworkCallback} based request before completing the processing of the
* Intent to reserve the network or it will be released shortly after the Intent
@@ -2421,21 +2415,46 @@
* two Intents defined by {@link Intent#filterEquals}), then it will be removed and
* replaced by this one, effectively releasing the previous {@link NetworkRequest}.
* <p>
- * The request may be released normally by calling {@link #unregisterNetworkCallback}.
+ * The request may be released normally by calling
+ * {@link #releaseNetworkRequest(android.app.PendingIntent)}.
*
* @param request {@link NetworkRequest} describing this request.
* @param operation Action to perform when the network is available (corresponds
* to the {@link NetworkCallback#onAvailable} call. Typically
- * comes from {@link PendingIntent#getBroadcast}.
- * @hide
+ * comes from {@link PendingIntent#getBroadcast}. Cannot be null.
*/
public void requestNetwork(NetworkRequest request, PendingIntent operation) {
+ checkPendingIntent(operation);
try {
mService.pendingRequestForNetwork(request.networkCapabilities, operation);
} catch (RemoteException e) {}
}
/**
+ * Removes a request made via {@link #requestNetwork(NetworkRequest, android.app.PendingIntent)}
+ * <p>
+ * This method has the same behavior as {@link #unregisterNetworkCallback} with respect to
+ * releasing network resources and disconnecting.
+ *
+ * @param operation A PendingIntent equal (as defined by {@link Intent#filterEquals}) to the
+ * PendingIntent passed to
+ * {@link #requestNetwork(NetworkRequest, android.app.PendingIntent)} with the
+ * corresponding NetworkRequest you'd like to remove. Cannot be null.
+ */
+ public void releaseNetworkRequest(PendingIntent operation) {
+ checkPendingIntent(operation);
+ try {
+ mService.releasePendingNetworkRequest(operation);
+ } catch (RemoteException e) {}
+ }
+
+ private void checkPendingIntent(PendingIntent intent) {
+ if (intent == null) {
+ throw new IllegalArgumentException("PendingIntent cannot be null.");
+ }
+ }
+
+ /**
* Registers to receive notifications about all networks which satisfy the given
* {@link NetworkRequest}. The callbacks will continue to be called until
* either the application exits or {@link #unregisterNetworkCallback} is called
@@ -2451,7 +2470,7 @@
/**
* Unregisters callbacks about and possibly releases networks originating from
* {@link #requestNetwork} and {@link #registerNetworkCallback} calls. If the
- * given {@code NetworkCallback} had previosuly been used with {@code #requestNetwork},
+ * given {@code NetworkCallback} had previously been used with {@code #requestNetwork},
* any networks that had been connected to only to satisfy that request will be
* disconnected.
*
diff --git a/core/java/android/net/IConnectivityManager.aidl b/core/java/android/net/IConnectivityManager.aidl
index a983d88..a7bbc53 100644
--- a/core/java/android/net/IConnectivityManager.aidl
+++ b/core/java/android/net/IConnectivityManager.aidl
@@ -156,6 +156,8 @@
NetworkRequest pendingRequestForNetwork(in NetworkCapabilities networkCapabilities,
in PendingIntent operation);
+ void releasePendingNetworkRequest(in PendingIntent operation);
+
NetworkRequest listenForNetwork(in NetworkCapabilities networkCapabilities,
in Messenger messenger, in IBinder binder);
diff --git a/core/java/android/net/LinkAddress.java b/core/java/android/net/LinkAddress.java
index c387055..384ab1c 100644
--- a/core/java/android/net/LinkAddress.java
+++ b/core/java/android/net/LinkAddress.java
@@ -21,12 +21,14 @@
import android.util.Pair;
import java.net.Inet4Address;
+import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.InterfaceAddress;
import java.net.UnknownHostException;
import static android.system.OsConstants.IFA_F_DADFAILED;
import static android.system.OsConstants.IFA_F_DEPRECATED;
+import static android.system.OsConstants.IFA_F_OPTIMISTIC;
import static android.system.OsConstants.IFA_F_TENTATIVE;
import static android.system.OsConstants.RT_SCOPE_HOST;
import static android.system.OsConstants.RT_SCOPE_LINK;
@@ -93,6 +95,20 @@
}
/**
+ * Utility function to check if |address| is a Unique Local IPv6 Unicast Address
+ * (a.k.a. "ULA"; RFC 4193).
+ *
+ * Per RFC 4193 section 8, fc00::/7 identifies these addresses.
+ */
+ private boolean isIPv6ULA() {
+ if (address != null && address instanceof Inet6Address) {
+ byte[] bytes = address.getAddress();
+ return ((bytes[0] & (byte)0xfc) == (byte)0xfc);
+ }
+ return false;
+ }
+
+ /**
* Utility function for the constructors.
*/
private void init(InetAddress address, int prefixLength, int flags, int scope) {
@@ -268,8 +284,16 @@
* @hide
*/
public boolean isGlobalPreferred() {
+ /**
+ * Note that addresses flagged as IFA_F_OPTIMISTIC are
+ * simultaneously flagged as IFA_F_TENTATIVE (when the tentative
+ * state has cleared either DAD has succeeded or failed, and both
+ * flags are cleared regardless).
+ */
return (scope == RT_SCOPE_UNIVERSE &&
- (flags & (IFA_F_DADFAILED | IFA_F_DEPRECATED | IFA_F_TENTATIVE)) == 0L);
+ !isIPv6ULA() &&
+ (flags & (IFA_F_DADFAILED | IFA_F_DEPRECATED)) == 0L &&
+ ((flags & IFA_F_TENTATIVE) == 0L || (flags & IFA_F_OPTIMISTIC) != 0L));
}
/**
diff --git a/core/java/android/net/LinkProperties.java b/core/java/android/net/LinkProperties.java
index 662c576..8b0dfc9 100644
--- a/core/java/android/net/LinkProperties.java
+++ b/core/java/android/net/LinkProperties.java
@@ -493,16 +493,16 @@
/**
* Removes a stacked link.
*
- * If there a stacked link with the same interfacename as link, it is
+ * If there is a stacked link with the given interface name, it is
* removed. Otherwise, nothing changes.
*
- * @param link The link to remove.
+ * @param iface The interface name of the link to remove.
* @return true if the link was removed, false otherwise.
* @hide
*/
- public boolean removeStackedLink(LinkProperties link) {
- if (link != null && link.getInterfaceName() != null) {
- LinkProperties removed = mStackedLinks.remove(link.getInterfaceName());
+ public boolean removeStackedLink(String iface) {
+ if (iface != null) {
+ LinkProperties removed = mStackedLinks.remove(iface);
return removed != null;
}
return false;
@@ -675,17 +675,38 @@
}
/**
- * Returns true if this link is provisioned for global connectivity. For IPv6, this requires an
- * IP address, default route, and DNS server. For IPv4, this requires only an IPv4 address,
- * because WifiStateMachine accepts static configurations that only specify an address but not
- * DNS servers or a default route.
+ * Returns true if this link is provisioned for global IPv4 connectivity.
+ * This requires an IP address, default route, and DNS server.
+ *
+ * @return {@code true} if the link is provisioned, {@code false} otherwise.
+ */
+ private boolean hasIPv4() {
+ return (hasIPv4Address() &&
+ hasIPv4DefaultRoute() &&
+ hasIPv4DnsServer());
+ }
+
+ /**
+ * Returns true if this link is provisioned for global IPv6 connectivity.
+ * This requires an IP address, default route, and DNS server.
+ *
+ * @return {@code true} if the link is provisioned, {@code false} otherwise.
+ */
+ private boolean hasIPv6() {
+ return (hasGlobalIPv6Address() &&
+ hasIPv6DefaultRoute() &&
+ hasIPv6DnsServer());
+ }
+
+ /**
+ * Returns true if this link is provisioned for global connectivity,
+ * for at least one Internet Protocol family.
*
* @return {@code true} if the link is provisioned, {@code false} otherwise.
* @hide
*/
public boolean isProvisioned() {
- return (hasIPv4Address() ||
- (hasGlobalIPv6Address() && hasIPv6DefaultRoute() && hasIPv6DnsServer()));
+ return (hasIPv4() || hasIPv6());
}
/**
diff --git a/core/java/android/net/Network.java b/core/java/android/net/Network.java
index 58f0fc0..4fa0593 100644
--- a/core/java/android/net/Network.java
+++ b/core/java/android/net/Network.java
@@ -21,7 +21,9 @@
import android.os.Parcel;
import android.system.ErrnoException;
+import java.io.FileDescriptor;
import java.io.IOException;
+import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.MalformedURLException;
@@ -264,18 +266,40 @@
}
/**
+ * Binds the specified {@link DatagramSocket} to this {@code Network}. All data traffic on the
+ * socket will be sent on this {@code Network}, irrespective of any process-wide network binding
+ * set by {@link ConnectivityManager#setProcessDefaultNetwork}. The socket must not be
+ * connected.
+ */
+ public void bindSocket(DatagramSocket socket) throws IOException {
+ // Apparently, the kernel doesn't update a connected UDP socket's routing upon mark changes.
+ if (socket.isConnected()) {
+ throw new SocketException("Socket is connected");
+ }
+ // Query a property of the underlying socket to ensure that the socket's file descriptor
+ // exists, is available to bind to a network and is not closed.
+ socket.getReuseAddress();
+ bindSocketFd(socket.getFileDescriptor$());
+ }
+
+ /**
* Binds the specified {@link Socket} to this {@code Network}. All data traffic on the socket
* will be sent on this {@code Network}, irrespective of any process-wide network binding set by
* {@link ConnectivityManager#setProcessDefaultNetwork}. The socket must not be connected.
*/
public void bindSocket(Socket socket) throws IOException {
+ // Apparently, the kernel doesn't update a connected TCP socket's routing upon mark changes.
if (socket.isConnected()) {
throw new SocketException("Socket is connected");
}
- // Query a property of the underlying socket to ensure the underlying
- // socket exists so a file descriptor is available to bind to a network.
+ // Query a property of the underlying socket to ensure that the socket's file descriptor
+ // exists, is available to bind to a network and is not closed.
socket.getReuseAddress();
- int err = NetworkUtils.bindSocketToNetwork(socket.getFileDescriptor$().getInt$(), netId);
+ bindSocketFd(socket.getFileDescriptor$());
+ }
+
+ private void bindSocketFd(FileDescriptor fd) throws IOException {
+ int err = NetworkUtils.bindSocketToNetwork(fd.getInt$(), netId);
if (err != 0) {
// bindSocketToNetwork returns negative errno.
throw new ErrnoException("Binding socket to network " + netId, -err)
diff --git a/core/java/android/net/NetworkCapabilities.java b/core/java/android/net/NetworkCapabilities.java
index 1efe478..ce7ad65 100644
--- a/core/java/android/net/NetworkCapabilities.java
+++ b/core/java/android/net/NetworkCapabilities.java
@@ -235,7 +235,8 @@
return ((nc.mNetworkCapabilities & this.mNetworkCapabilities) == this.mNetworkCapabilities);
}
- private boolean equalsNetCapabilities(NetworkCapabilities nc) {
+ /** @hide */
+ public boolean equalsNetCapabilities(NetworkCapabilities nc) {
return (nc.mNetworkCapabilities == this.mNetworkCapabilities);
}
@@ -344,7 +345,8 @@
return ((this.mTransportTypes == 0) ||
((this.mTransportTypes & nc.mTransportTypes) != 0));
}
- private boolean equalsTransportTypes(NetworkCapabilities nc) {
+ /** @hide */
+ public boolean equalsTransportTypes(NetworkCapabilities nc) {
return (nc.mTransportTypes == this.mTransportTypes);
}
diff --git a/core/java/android/net/ProxyInfo.java b/core/java/android/net/ProxyInfo.java
index 1534e2c..7694420 100644
--- a/core/java/android/net/ProxyInfo.java
+++ b/core/java/android/net/ProxyInfo.java
@@ -36,7 +36,13 @@
*
* Other HTTP stacks will need to obtain the proxy info from
* {@link Proxy#PROXY_CHANGE_ACTION} broadcast as the extra {@link Proxy#EXTRA_PROXY_INFO}.
+ *
+ * @deprecated Please use {@link java.net.URL#openConnection}, {@link java.net.Proxy} and
+ * friends. The Apache HTTP client is no longer maintained and may be removed in a future
+ * release. Please visit <a href="http://android-developers.blogspot.com/2011/09/androids-http-clients.html">this webpage</a>
+ * for further details.
*/
+@Deprecated
public class ProxyInfo implements Parcelable {
private String mHost;
diff --git a/core/java/android/net/StaticIpConfiguration.java b/core/java/android/net/StaticIpConfiguration.java
index 5a273cf..598a503 100644
--- a/core/java/android/net/StaticIpConfiguration.java
+++ b/core/java/android/net/StaticIpConfiguration.java
@@ -107,6 +107,7 @@
for (InetAddress dns : dnsServers) {
lp.addDnsServer(dns);
}
+ lp.setDomains(domains);
return lp;
}
diff --git a/core/tests/coretests/src/android/net/LinkAddressTest.java b/core/tests/coretests/src/android/net/LinkAddressTest.java
index 7bc3974..adf8d95 100644
--- a/core/tests/coretests/src/android/net/LinkAddressTest.java
+++ b/core/tests/coretests/src/android/net/LinkAddressTest.java
@@ -33,8 +33,11 @@
import static android.test.MoreAsserts.assertNotEqual;
import android.test.suitebuilder.annotation.SmallTest;
+import static android.system.OsConstants.IFA_F_DADFAILED;
import static android.system.OsConstants.IFA_F_DEPRECATED;
+import static android.system.OsConstants.IFA_F_OPTIMISTIC;
import static android.system.OsConstants.IFA_F_PERMANENT;
+import static android.system.OsConstants.IFA_F_TEMPORARY;
import static android.system.OsConstants.IFA_F_TENTATIVE;
import static android.system.OsConstants.RT_SCOPE_HOST;
import static android.system.OsConstants.RT_SCOPE_LINK;
@@ -340,4 +343,73 @@
l = new LinkAddress(V4 + "/28", IFA_F_PERMANENT, RT_SCOPE_LINK);
assertParcelingIsLossless(l);
}
+
+ private void assertGlobalPreferred(LinkAddress l, String msg) {
+ assertTrue(msg, l.isGlobalPreferred());
+ }
+
+ private void assertNotGlobalPreferred(LinkAddress l, String msg) {
+ assertFalse(msg, l.isGlobalPreferred());
+ }
+
+ public void testIsGlobalPreferred() {
+ LinkAddress l;
+
+ l = new LinkAddress(V4_ADDRESS, 32, 0, RT_SCOPE_UNIVERSE);
+ assertGlobalPreferred(l, "v4,global,noflags");
+
+ l = new LinkAddress("10.10.1.7/23", 0, RT_SCOPE_UNIVERSE);
+ assertGlobalPreferred(l, "v4-rfc1918,global,noflags");
+
+ l = new LinkAddress("10.10.1.7/23", 0, RT_SCOPE_SITE);
+ assertNotGlobalPreferred(l, "v4-rfc1918,site-local,noflags");
+
+ l = new LinkAddress("127.0.0.7/8", 0, RT_SCOPE_HOST);
+ assertNotGlobalPreferred(l, "v4-localhost,node-local,noflags");
+
+ l = new LinkAddress(V6_ADDRESS, 64, 0, RT_SCOPE_UNIVERSE);
+ assertGlobalPreferred(l, "v6,global,noflags");
+
+ l = new LinkAddress(V6_ADDRESS, 64, IFA_F_PERMANENT, RT_SCOPE_UNIVERSE);
+ assertGlobalPreferred(l, "v6,global,permanent");
+
+ // IPv6 ULAs are not acceptable "global preferred" addresses.
+ l = new LinkAddress("fc12::1/64", 0, RT_SCOPE_UNIVERSE);
+ assertNotGlobalPreferred(l, "v6,ula1,noflags");
+
+ l = new LinkAddress("fd34::1/64", 0, RT_SCOPE_UNIVERSE);
+ assertNotGlobalPreferred(l, "v6,ula2,noflags");
+
+ l = new LinkAddress(V6_ADDRESS, 64, IFA_F_TEMPORARY, RT_SCOPE_UNIVERSE);
+ assertGlobalPreferred(l, "v6,global,tempaddr");
+
+ l = new LinkAddress(V6_ADDRESS, 64, (IFA_F_TEMPORARY|IFA_F_DADFAILED),
+ RT_SCOPE_UNIVERSE);
+ assertNotGlobalPreferred(l, "v6,global,tempaddr+dadfailed");
+
+ l = new LinkAddress(V6_ADDRESS, 64, (IFA_F_TEMPORARY|IFA_F_DEPRECATED),
+ RT_SCOPE_UNIVERSE);
+ assertNotGlobalPreferred(l, "v6,global,tempaddr+deprecated");
+
+ l = new LinkAddress(V6_ADDRESS, 64, IFA_F_TEMPORARY, RT_SCOPE_SITE);
+ assertNotGlobalPreferred(l, "v6,site-local,tempaddr");
+
+ l = new LinkAddress(V6_ADDRESS, 64, IFA_F_TEMPORARY, RT_SCOPE_LINK);
+ assertNotGlobalPreferred(l, "v6,link-local,tempaddr");
+
+ l = new LinkAddress(V6_ADDRESS, 64, IFA_F_TEMPORARY, RT_SCOPE_HOST);
+ assertNotGlobalPreferred(l, "v6,node-local,tempaddr");
+
+ l = new LinkAddress("::1/128", IFA_F_PERMANENT, RT_SCOPE_HOST);
+ assertNotGlobalPreferred(l, "v6-localhost,node-local,permanent");
+
+ l = new LinkAddress(V6_ADDRESS, 64, (IFA_F_TEMPORARY|IFA_F_TENTATIVE),
+ RT_SCOPE_UNIVERSE);
+ assertNotGlobalPreferred(l, "v6,global,tempaddr+tentative");
+
+ l = new LinkAddress(V6_ADDRESS, 64,
+ (IFA_F_TEMPORARY|IFA_F_TENTATIVE|IFA_F_OPTIMISTIC),
+ RT_SCOPE_UNIVERSE);
+ assertGlobalPreferred(l, "v6,global,tempaddr+optimistic");
+ }
}
diff --git a/core/tests/coretests/src/android/net/LinkPropertiesTest.java b/core/tests/coretests/src/android/net/LinkPropertiesTest.java
index 4015b3d..abfed6e 100644
--- a/core/tests/coretests/src/android/net/LinkPropertiesTest.java
+++ b/core/tests/coretests/src/android/net/LinkPropertiesTest.java
@@ -31,8 +31,10 @@
"2001:0db8:85a3:0000:0000:8a2e:0370:7334");
private static InetAddress DNS1 = NetworkUtils.numericToInetAddress("75.208.7.1");
private static InetAddress DNS2 = NetworkUtils.numericToInetAddress("69.78.7.1");
+ private static InetAddress DNS6 = NetworkUtils.numericToInetAddress("2001:4860:4860::8888");
private static InetAddress GATEWAY1 = NetworkUtils.numericToInetAddress("75.208.8.1");
private static InetAddress GATEWAY2 = NetworkUtils.numericToInetAddress("69.78.8.1");
+ private static InetAddress GATEWAY6 = NetworkUtils.numericToInetAddress("fe80::6:0000:613");
private static String NAME = "qmi0";
private static int MTU = 1500;
@@ -338,14 +340,14 @@
assertFalse("newname".equals(link.getInterfaceName()));
}
- assertTrue(rmnet0.removeStackedLink(clat4));
+ assertTrue(rmnet0.removeStackedLink("clat4"));
assertEquals(0, rmnet0.getStackedLinks().size());
assertEquals(1, rmnet0.getAddresses().size());
assertEquals(1, rmnet0.getLinkAddresses().size());
assertEquals(1, rmnet0.getAllAddresses().size());
assertEquals(1, rmnet0.getAllLinkAddresses().size());
- assertFalse(rmnet0.removeStackedLink(clat4));
+ assertFalse(rmnet0.removeStackedLink("clat4"));
}
private LinkAddress getFirstLinkAddress(LinkProperties lp) {
@@ -370,7 +372,7 @@
assertTrue(stacked.hasGlobalIPv6Address());
assertFalse(lp.hasIPv4Address());
assertFalse(lp.hasGlobalIPv6Address());
- lp.removeStackedLink(stacked);
+ lp.removeStackedLink("stacked");
assertFalse(lp.hasIPv4Address());
assertFalse(lp.hasGlobalIPv6Address());
@@ -453,4 +455,47 @@
lp2.setLinkAddresses(lp.getLinkAddresses());
assertTrue(lp.equals(lp));
}
+
+ @SmallTest
+ public void testIsProvisioned() {
+ LinkProperties lp4 = new LinkProperties();
+ assertFalse("v4only:empty", lp4.isProvisioned());
+ lp4.addLinkAddress(LINKADDRV4);
+ assertFalse("v4only:addr-only", lp4.isProvisioned());
+ lp4.addDnsServer(DNS1);
+ assertFalse("v4only:addr+dns", lp4.isProvisioned());
+ lp4.addRoute(new RouteInfo(GATEWAY1));
+ assertTrue("v4only:addr+dns+route", lp4.isProvisioned());
+
+ LinkProperties lp6 = new LinkProperties();
+ assertFalse("v6only:empty", lp6.isProvisioned());
+ lp6.addLinkAddress(LINKADDRV6LINKLOCAL);
+ assertFalse("v6only:fe80-only", lp6.isProvisioned());
+ lp6.addDnsServer(DNS6);
+ assertFalse("v6only:fe80+dns", lp6.isProvisioned());
+ lp6.addRoute(new RouteInfo(GATEWAY6));
+ assertFalse("v6only:fe80+dns+route", lp6.isProvisioned());
+ lp6.addLinkAddress(LINKADDRV6);
+ assertTrue("v6only:fe80+global+dns+route", lp6.isProvisioned());
+ lp6.removeLinkAddress(LINKADDRV6LINKLOCAL);
+ assertTrue("v6only:global+dns+route", lp6.isProvisioned());
+
+ LinkProperties lp46 = new LinkProperties();
+ lp46.addLinkAddress(LINKADDRV4);
+ lp46.addLinkAddress(LINKADDRV6);
+ lp46.addDnsServer(DNS1);
+ lp46.addDnsServer(DNS6);
+ assertFalse("dualstack:missing-routes", lp46.isProvisioned());
+ lp46.addRoute(new RouteInfo(GATEWAY1));
+ assertTrue("dualstack:v4-provisioned", lp46.isProvisioned());
+ lp6.addRoute(new RouteInfo(GATEWAY6));
+ assertTrue("dualstack:both-provisioned", lp46.isProvisioned());
+
+ // A link with an IPv6 address and default route, but IPv4 DNS server.
+ LinkProperties mixed = new LinkProperties();
+ mixed.addLinkAddress(LINKADDRV6);
+ mixed.addDnsServer(DNS1);
+ mixed.addRoute(new RouteInfo(GATEWAY6));
+ assertFalse("mixed:addr6+route6+dns4", mixed.isProvisioned());
+ }
}
diff --git a/services/core/java/com/android/server/ConnectivityService.java b/services/core/java/com/android/server/ConnectivityService.java
index b4a248f..3281387 100644
--- a/services/core/java/com/android/server/ConnectivityService.java
+++ b/services/core/java/com/android/server/ConnectivityService.java
@@ -23,18 +23,19 @@
import static android.net.ConnectivityManager.TYPE_BLUETOOTH;
import static android.net.ConnectivityManager.TYPE_DUMMY;
import static android.net.ConnectivityManager.TYPE_MOBILE;
-import static android.net.ConnectivityManager.TYPE_MOBILE_MMS;
-import static android.net.ConnectivityManager.TYPE_MOBILE_SUPL;
+import static android.net.ConnectivityManager.TYPE_MOBILE_CBS;
import static android.net.ConnectivityManager.TYPE_MOBILE_DUN;
import static android.net.ConnectivityManager.TYPE_MOBILE_FOTA;
-import static android.net.ConnectivityManager.TYPE_MOBILE_IMS;
-import static android.net.ConnectivityManager.TYPE_MOBILE_CBS;
-import static android.net.ConnectivityManager.TYPE_MOBILE_IA;
import static android.net.ConnectivityManager.TYPE_MOBILE_HIPRI;
+import static android.net.ConnectivityManager.TYPE_MOBILE_IA;
+import static android.net.ConnectivityManager.TYPE_MOBILE_IMS;
+import static android.net.ConnectivityManager.TYPE_MOBILE_MMS;
+import static android.net.ConnectivityManager.TYPE_MOBILE_SUPL;
import static android.net.ConnectivityManager.TYPE_NONE;
+import static android.net.ConnectivityManager.TYPE_PROXY;
+import static android.net.ConnectivityManager.TYPE_VPN;
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;
@@ -184,7 +185,8 @@
/**
* @hide
*/
-public class ConnectivityService extends IConnectivityManager.Stub {
+public class ConnectivityService extends IConnectivityManager.Stub
+ implements PendingIntent.OnFinished {
private static final String TAG = "ConnectivityService";
private static final boolean DBG = true;
@@ -238,8 +240,6 @@
private boolean mLockdownEnabled;
private LockdownVpnTracker mLockdownTracker;
- private Nat464Xlat mClat;
-
/** Lock around {@link #mUidRules} and {@link #mMeteredIfaces}. */
private Object mRulesLock = new Object();
/** Currently active network rules by UID. */
@@ -384,6 +384,19 @@
*/
private static final int EVENT_SYSTEM_READY = 25;
+ /**
+ * used to add a network request with a pending intent
+ * includes a NetworkRequestInfo
+ */
+ private static final int EVENT_REGISTER_NETWORK_REQUEST_WITH_INTENT = 26;
+
+ /**
+ * used to remove a pending intent and its associated network request.
+ * arg1 = UID of caller
+ * obj = PendingIntent
+ */
+ private static final int EVENT_RELEASE_NETWORK_REQUEST_WITH_INTENT = 27;
+
/** Handler used for internal events. */
final private InternalHandler mHandler;
@@ -397,6 +410,7 @@
private String mNetTransitionWakeLockCausedBy = "";
private int mNetTransitionWakeLockSerialNumber;
private int mNetTransitionWakeLockTimeout;
+ private final PowerManager.WakeLock mPendingIntentWakeLock;
private InetAddress mDefaultDns;
@@ -651,6 +665,7 @@
mNetTransitionWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
mNetTransitionWakeLockTimeout = mContext.getResources().getInteger(
com.android.internal.R.integer.config_networkTransitionTimeout);
+ mPendingIntentWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
mNetTrackers = new NetworkStateTracker[
ConnectivityManager.MAX_NETWORK_TYPE+1];
@@ -689,6 +704,15 @@
// ignore it - leave the entry null
}
}
+
+ // Forcibly add TYPE_VPN as a supported type, if it has not already been added via config.
+ if (mNetConfigs[TYPE_VPN] == null) {
+ // mNetConfigs is used only for "restore time", which isn't applicable to VPNs, so we
+ // don't need to add TYPE_VPN to mNetConfigs.
+ mLegacyTypeTracker.addSupportedType(TYPE_VPN);
+ mNetworksDefined++; // used only in the log() statement below.
+ }
+
if (VDBG) log("mNetworksDefined=" + mNetworksDefined);
mProtectedNetworks = new ArrayList<Integer>();
@@ -715,12 +739,10 @@
intentFilter.addAction(Intent.ACTION_USER_STOPPING);
mContext.registerReceiverAsUser(
mUserIntentReceiver, UserHandle.ALL, intentFilter, null, null);
- mClat = new Nat464Xlat(mContext, mNetd, this, mTrackerHandler);
try {
mNetd.registerObserver(mTethering);
mNetd.registerObserver(mDataActivityObserver);
- mNetd.registerObserver(mClat);
} catch (RemoteException e) {
loge("Error registering observer :" + e);
}
@@ -2135,11 +2157,40 @@
}
}
+ // If this method proves to be too slow then we can maintain a separate
+ // pendingIntent => NetworkRequestInfo map.
+ // This method assumes that every non-null PendingIntent maps to exactly 1 NetworkRequestInfo.
+ private NetworkRequestInfo findExistingNetworkRequestInfo(PendingIntent pendingIntent) {
+ Intent intent = pendingIntent.getIntent();
+ for (Map.Entry<NetworkRequest, NetworkRequestInfo> entry : mNetworkRequests.entrySet()) {
+ PendingIntent existingPendingIntent = entry.getValue().mPendingIntent;
+ if (existingPendingIntent != null &&
+ existingPendingIntent.getIntent().filterEquals(intent)) {
+ return entry.getValue();
+ }
+ }
+ return null;
+ }
+
+ private void handleRegisterNetworkRequestWithIntent(Message msg) {
+ final NetworkRequestInfo nri = (NetworkRequestInfo) (msg.obj);
+
+ NetworkRequestInfo existingRequest = findExistingNetworkRequestInfo(nri.mPendingIntent);
+ if (existingRequest != null) { // remove the existing request.
+ if (DBG) log("Replacing " + existingRequest.request + " with "
+ + nri.request + " because their intents matched.");
+ handleReleaseNetworkRequest(existingRequest.request, getCallingUid());
+ }
+ handleRegisterNetworkRequest(msg);
+ }
+
private void handleRegisterNetworkRequest(Message msg) {
final NetworkRequestInfo nri = (NetworkRequestInfo) (msg.obj);
final NetworkCapabilities newCap = nri.request.networkCapabilities;
int score = 0;
+ mNetworkRequests.put(nri.request, nri);
+
// Check for the best currently alive network that satisfies this request
NetworkAgentInfo bestNetwork = null;
for (NetworkAgentInfo network : mNetworkAgentInfos.values()) {
@@ -2177,7 +2228,7 @@
mLegacyTypeTracker.add(nri.request.legacyType, bestNetwork);
}
}
- mNetworkRequests.put(nri.request, nri);
+
if (nri.isRequest) {
if (DBG) log("sending new NetworkRequest to factories");
for (NetworkFactoryInfo nfi : mNetworkFactoryInfos.values()) {
@@ -2187,6 +2238,14 @@
}
}
+ private void handleReleaseNetworkRequestWithIntent(PendingIntent pendingIntent,
+ int callingUid) {
+ NetworkRequestInfo nri = findExistingNetworkRequestInfo(pendingIntent);
+ if (nri != null) {
+ handleReleaseNetworkRequest(nri.request, callingUid);
+ }
+ }
+
private void handleReleaseNetworkRequest(NetworkRequest request, int callingUid) {
NetworkRequestInfo nri = mNetworkRequests.get(request);
if (nri != null) {
@@ -2222,11 +2281,11 @@
}
}
- // Maintain the illusion. When this request arrived, we might have preteneded
+ // Maintain the illusion. When this request arrived, we might have pretended
// that a network connected to serve it, even though the network was already
// connected. Now that this request has gone away, we might have to pretend
// that the network disconnected. LegacyTypeTracker will generate that
- // phatom disconnect for this type.
+ // phantom disconnect for this type.
NetworkAgentInfo nai = mNetworkForRequestId.get(nri.request.requestId);
if (nai != null) {
mNetworkForRequestId.remove(nri.request.requestId);
@@ -2257,7 +2316,6 @@
@Override
public void handleMessage(Message msg) {
- NetworkInfo info;
switch (msg.what) {
case EVENT_EXPIRE_NET_TRANSITION_WAKELOCK:
case EVENT_CLEAR_NET_TRANSITION_WAKELOCK: {
@@ -2338,6 +2396,14 @@
handleRegisterNetworkRequest(msg);
break;
}
+ case EVENT_REGISTER_NETWORK_REQUEST_WITH_INTENT: {
+ handleRegisterNetworkRequestWithIntent(msg);
+ break;
+ }
+ case EVENT_RELEASE_NETWORK_REQUEST_WITH_INTENT: {
+ handleReleaseNetworkRequestWithIntent((PendingIntent) msg.obj, msg.arg1);
+ break;
+ }
case EVENT_RELEASE_NETWORK_REQUEST: {
handleReleaseNetworkRequest((NetworkRequest) msg.obj, msg.arg1);
break;
@@ -2748,9 +2814,8 @@
}
/**
- * Prepare for a VPN application. This method is used by VpnDialogs
- * and not available in ConnectivityManager. Permissions are checked
- * in Vpn class.
+ * Prepare for a VPN application. This method is used by system-privileged apps.
+ * Permissions are checked in Vpn class.
* @hide
*/
@Override
@@ -2764,8 +2829,8 @@
/**
* Set whether the current VPN package has the ability to launch VPNs without
- * user intervention. This method is used by system UIs and not available
- * in ConnectivityManager. Permissions are checked in Vpn class.
+ * user intervention. This method is used by system-privileged apps.
+ * Permissions are checked in Vpn class.
* @hide
*/
@Override
@@ -3182,7 +3247,7 @@
Settings.Global.putInt(cr, Settings.Global.AIRPLANE_MODE_ON, enable ? 1 : 0);
Intent intent = new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED);
intent.putExtra("state", enable);
- mContext.sendBroadcast(intent);
+ mContext.sendBroadcastAsUser(intent, UserHandle.ALL);
} finally {
Binder.restoreCallingIdentity(ident);
}
@@ -3352,12 +3417,23 @@
static final boolean LISTEN = false;
final NetworkRequest request;
- IBinder mBinder;
+ final PendingIntent mPendingIntent;
+ private final IBinder mBinder;
final int mPid;
final int mUid;
final Messenger messenger;
final boolean isRequest;
+ NetworkRequestInfo(NetworkRequest r, PendingIntent pi, boolean isRequest) {
+ request = r;
+ mPendingIntent = pi;
+ messenger = null;
+ mBinder = null;
+ mPid = getCallingPid();
+ mUid = getCallingUid();
+ this.isRequest = isRequest;
+ }
+
NetworkRequestInfo(Messenger m, NetworkRequest r, IBinder binder, boolean isRequest) {
super();
messenger = m;
@@ -3366,6 +3442,7 @@
mPid = getCallingPid();
mUid = getCallingUid();
this.isRequest = isRequest;
+ mPendingIntent = null;
try {
mBinder.linkToDeath(this, 0);
@@ -3375,7 +3452,9 @@
}
void unlinkDeathRecipient() {
- mBinder.unlinkToDeath(this, 0);
+ if (mBinder != null) {
+ mBinder.unlinkToDeath(this, 0);
+ }
}
public void binderDied() {
@@ -3386,40 +3465,22 @@
public String toString() {
return (isRequest ? "Request" : "Listen") + " from uid/pid:" + mUid + "/" +
- mPid + " for " + request;
+ mPid + " for " + request +
+ (mPendingIntent == null ? "" : " to trigger " + mPendingIntent);
}
}
@Override
public NetworkRequest requestNetwork(NetworkCapabilities networkCapabilities,
Messenger messenger, int timeoutMs, IBinder binder, int legacyType) {
- if (networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
- == false) {
- enforceConnectivityInternalPermission();
- } else {
- enforceChangePermission();
- }
-
networkCapabilities = new NetworkCapabilities(networkCapabilities);
-
- // if UID is restricted, don't allow them to bring up metered APNs
- if (networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)
- == false) {
- final int uidRules;
- final int uid = Binder.getCallingUid();
- synchronized(mRulesLock) {
- uidRules = mUidRules.get(uid, RULE_ALLOW_ALL);
- }
- if ((uidRules & RULE_REJECT_METERED) != 0) {
- // we could silently fail or we can filter the available nets to only give
- // them those they have access to. Chose the more useful
- networkCapabilities.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
- }
- }
+ enforceNetworkRequestPermissions(networkCapabilities);
+ enforceMeteredApnPolicy(networkCapabilities);
if (timeoutMs < 0 || timeoutMs > ConnectivityManager.MAX_NETWORK_REQUEST_TIMEOUT_MS) {
throw new IllegalArgumentException("Bad timeout specified");
}
+
NetworkRequest networkRequest = new NetworkRequest(networkCapabilities, legacyType,
nextNetworkRequestId());
if (DBG) log("requestNetwork for " + networkRequest);
@@ -3434,11 +3495,54 @@
return networkRequest;
}
+ private void enforceNetworkRequestPermissions(NetworkCapabilities networkCapabilities) {
+ if (networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
+ == false) {
+ enforceConnectivityInternalPermission();
+ } else {
+ enforceChangePermission();
+ }
+ }
+
+ private void enforceMeteredApnPolicy(NetworkCapabilities networkCapabilities) {
+ // if UID is restricted, don't allow them to bring up metered APNs
+ if (networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)
+ == false) {
+ final int uidRules;
+ final int uid = Binder.getCallingUid();
+ synchronized(mRulesLock) {
+ uidRules = mUidRules.get(uid, RULE_ALLOW_ALL);
+ }
+ if ((uidRules & RULE_REJECT_METERED) != 0) {
+ // we could silently fail or we can filter the available nets to only give
+ // them those they have access to. Chose the more useful
+ networkCapabilities.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
+ }
+ }
+ }
+
@Override
public NetworkRequest pendingRequestForNetwork(NetworkCapabilities networkCapabilities,
PendingIntent operation) {
- // TODO
- return null;
+ checkNotNull(operation, "PendingIntent cannot be null.");
+ networkCapabilities = new NetworkCapabilities(networkCapabilities);
+ enforceNetworkRequestPermissions(networkCapabilities);
+ enforceMeteredApnPolicy(networkCapabilities);
+
+ NetworkRequest networkRequest = new NetworkRequest(networkCapabilities, TYPE_NONE,
+ nextNetworkRequestId());
+ if (DBG) log("pendingRequest for " + networkRequest + " to trigger " + operation);
+ NetworkRequestInfo nri = new NetworkRequestInfo(networkRequest, operation,
+ NetworkRequestInfo.REQUEST);
+ mHandler.sendMessage(mHandler.obtainMessage(EVENT_REGISTER_NETWORK_REQUEST_WITH_INTENT,
+ nri));
+ return networkRequest;
+ }
+
+ @Override
+ public void releasePendingNetworkRequest(PendingIntent operation) {
+ mHandler.sendMessage(mHandler.obtainMessage(EVENT_RELEASE_NETWORK_REQUEST_WITH_INTENT,
+ getCallingUid(), 0, operation));
}
@Override
@@ -3550,7 +3654,9 @@
// The NetworkAgentInfo does not know whether clatd is running on its network or not. Before
// we do anything else, make sure its LinkProperties are accurate.
- mClat.fixupLinkProperties(networkAgent, oldLp);
+ if (networkAgent.clatd != null) {
+ networkAgent.clatd.fixupLinkProperties(oldLp);
+ }
updateInterfaces(newLp, oldLp, netId);
updateMtu(newLp, oldLp);
@@ -3569,15 +3675,15 @@
}
}
- private void updateClat(LinkProperties newLp, LinkProperties oldLp, NetworkAgentInfo na) {
- final boolean wasRunningClat = mClat.isRunningClat(na);
- final boolean shouldRunClat = Nat464Xlat.requiresClat(na);
+ private void updateClat(LinkProperties newLp, LinkProperties oldLp, NetworkAgentInfo nai) {
+ final boolean wasRunningClat = nai.clatd != null && nai.clatd.isStarted();
+ final boolean shouldRunClat = Nat464Xlat.requiresClat(nai);
if (!wasRunningClat && shouldRunClat) {
- // Start clatd. If it's already been started but is not running yet, this is a no-op.
- mClat.startClat(na);
+ nai.clatd = new Nat464Xlat(mContext, mNetd, mTrackerHandler, nai);
+ nai.clatd.start();
} else if (wasRunningClat && !shouldRunClat) {
- mClat.stopClat();
+ nai.clatd.stop();
}
}
@@ -3704,12 +3810,11 @@
private void updateCapabilities(NetworkAgentInfo networkAgent,
NetworkCapabilities networkCapabilities) {
- // TODO - turn this on in MR1 when we have more dogfooding time.
- // rematchAllNetworksAndRequests();
if (!Objects.equals(networkAgent.networkCapabilities, networkCapabilities)) {
synchronized (networkAgent) {
networkAgent.networkCapabilities = networkCapabilities;
}
+ rematchAllNetworksAndRequests(networkAgent, networkAgent.getCurrentScore());
notifyNetworkCallbacks(networkAgent, ConnectivityManager.CALLBACK_CAP_CHANGED);
}
}
@@ -3731,6 +3836,38 @@
}
}
+ private void sendPendingIntentForRequest(NetworkRequestInfo nri, NetworkAgentInfo networkAgent,
+ int notificationType) {
+ if (notificationType == ConnectivityManager.CALLBACK_AVAILABLE) {
+ Intent intent = new Intent();
+ intent.putExtra(ConnectivityManager.EXTRA_NETWORK, nri.request);
+ intent.putExtra(ConnectivityManager.EXTRA_NETWORK_REQUEST, networkAgent.network);
+ sendIntent(nri.mPendingIntent, intent);
+ }
+ // else not handled
+ }
+
+ private void sendIntent(PendingIntent pendingIntent, Intent intent) {
+ mPendingIntentWakeLock.acquire();
+ try {
+ if (DBG) log("Sending " + pendingIntent);
+ pendingIntent.send(mContext, 0, intent, this /* onFinished */, null /* Handler */);
+ } catch (PendingIntent.CanceledException e) {
+ if (DBG) log(pendingIntent + " was not sent, it had been canceled.");
+ mPendingIntentWakeLock.release();
+ releasePendingNetworkRequest(pendingIntent);
+ }
+ // ...otherwise, mPendingIntentWakeLock.release() gets called by onSendFinished()
+ }
+
+ @Override
+ public void onSendFinished(PendingIntent pendingIntent, Intent intent, int resultCode,
+ String resultData, Bundle resultExtras) {
+ if (DBG) log("Finished sending " + pendingIntent);
+ mPendingIntentWakeLock.release();
+ releasePendingNetworkRequest(pendingIntent);
+ }
+
private void callCallbackForRequest(NetworkRequestInfo nri,
NetworkAgentInfo networkAgent, int notificationType) {
if (nri.messenger == null) return; // Default request has no msgr
@@ -3983,6 +4120,14 @@
}
notifyNetworkCallbacks(newNetwork, ConnectivityManager.CALLBACK_AVAILABLE);
+
+ // A VPN generally won't get added to the legacy tracker in the "for (nri)" loop above,
+ // because usually there are no NetworkRequests it satisfies (e.g., mDefaultRequest
+ // wants the NOT_VPN capability, so it will never be satisfied by a VPN). So, add the
+ // newNetwork to the tracker explicitly (it's a no-op if it has already been added).
+ if (newNetwork.isVPN()) {
+ mLegacyTypeTracker.add(TYPE_VPN, newNetwork);
+ }
} else if (nascent) {
// Only tear down newly validated networks here. Leave unvalidated to either become
// validated (and get evaluated against peers, one losing here) or
@@ -4141,7 +4286,11 @@
// } else if (nai.networkMonitor.isEvaluating()) {
// notifyType = NetworkCallbacks.callCallbackForRequest(request, nai, notifyType);
// }
- callCallbackForRequest(nri, nai, notifyType);
+ if (nri.mPendingIntent == null) {
+ callCallbackForRequest(nri, nai, notifyType);
+ } else {
+ sendPendingIntentForRequest(nri, nai, notifyType);
+ }
}
private void sendLegacyNetworkBroadcast(NetworkAgentInfo nai, boolean connected, int type) {
@@ -4200,7 +4349,11 @@
NetworkRequest nr = networkAgent.networkRequests.valueAt(i);
NetworkRequestInfo nri = mNetworkRequests.get(nr);
if (VDBG) log(" sending notification for " + nr);
- callCallbackForRequest(nri, networkAgent, notifyType);
+ if (nri.mPendingIntent == null) {
+ callCallbackForRequest(nri, networkAgent, notifyType);
+ } else {
+ sendPendingIntentForRequest(nri, networkAgent, notifyType);
+ }
}
}
diff --git a/services/core/java/com/android/server/connectivity/Nat464Xlat.java b/services/core/java/com/android/server/connectivity/Nat464Xlat.java
index c382be0..3fa21d0 100644
--- a/services/core/java/com/android/server/connectivity/Nat464Xlat.java
+++ b/services/core/java/com/android/server/connectivity/Nat464Xlat.java
@@ -17,6 +17,7 @@
package com.android.server.connectivity;
import static android.net.ConnectivityManager.TYPE_MOBILE;
+import static android.net.ConnectivityManager.TYPE_WIFI;
import java.net.Inet4Address;
@@ -43,45 +44,41 @@
* Class to manage a 464xlat CLAT daemon.
*/
public class Nat464Xlat extends BaseNetworkObserver {
- private Context mContext;
- private INetworkManagementService mNMService;
- private IConnectivityManager mConnService;
- // Whether we started clatd and expect it to be running.
- private boolean mIsStarted;
- // Whether the clatd interface exists (i.e., clatd is running).
- private boolean mIsRunning;
- // The LinkProperties of the clat interface.
- private LinkProperties mLP;
- // Current LinkProperties of the network. Includes mLP as a stacked link when clat is active.
- private LinkProperties mBaseLP;
- // ConnectivityService Handler for LinkProperties updates.
- private Handler mHandler;
- // Marker to connote which network we're augmenting.
- private Messenger mNetworkMessenger;
-
- // This must match the interface name in clatd.conf.
- private static final String CLAT_INTERFACE_NAME = "clat4";
-
private static final String TAG = "Nat464Xlat";
- public Nat464Xlat(Context context, INetworkManagementService nmService,
- IConnectivityManager connService, Handler handler) {
- mContext = context;
+ // This must match the interface prefix in clatd.c.
+ private static final String CLAT_PREFIX = "v4-";
+
+ private final INetworkManagementService mNMService;
+
+ // ConnectivityService Handler for LinkProperties updates.
+ private final Handler mHandler;
+
+ // The network we're running on, and its type.
+ private final NetworkAgentInfo mNetwork;
+
+ // Internal state variables.
+ //
+ // The possible states are:
+ // - Idle: start() not called. Everything is null.
+ // - Starting: start() called. Interfaces are non-null. isStarted() returns true.
+ // mIsRunning is false.
+ // - Running: start() called, and interfaceLinkStateChanged() told us that mIface is up.
+ // mIsRunning is true.
+ //
+ // Once mIface is non-null and isStarted() is true, methods called by ConnectivityService on
+ // its handler thread must not modify any internal state variables; they are only updated by the
+ // interface observers, called on the notification threads.
+ private String mBaseIface;
+ private String mIface;
+ private boolean mIsRunning;
+
+ public Nat464Xlat(
+ Context context, INetworkManagementService nmService,
+ Handler handler, NetworkAgentInfo nai) {
mNMService = nmService;
- mConnService = connService;
mHandler = handler;
-
- mIsStarted = false;
- mIsRunning = false;
- mLP = new LinkProperties();
-
- // If this is a runtime restart, it's possible that clatd is already
- // running, but we don't know about it. If so, stop it.
- try {
- if (mNMService.isClatdStarted()) {
- mNMService.stopClatd();
- }
- } catch(RemoteException e) {} // Well, we tried.
+ mNetwork = nai;
}
/**
@@ -94,137 +91,196 @@
final boolean connected = nai.networkInfo.isConnected();
final boolean hasIPv4Address =
(nai.linkProperties != null) ? nai.linkProperties.hasIPv4Address() : false;
- Slog.d(TAG, "requiresClat: netType=" + netType +
- ", connected=" + connected +
- ", hasIPv4Address=" + hasIPv4Address);
- // Only support clat on mobile for now.
- return netType == TYPE_MOBILE && connected && !hasIPv4Address;
- }
-
- public boolean isRunningClat(NetworkAgentInfo network) {
- return mNetworkMessenger == network.messenger;
+ // Only support clat on mobile and wifi for now, because these are the only IPv6-only
+ // networks we can connect to.
+ return connected && !hasIPv4Address && (netType == TYPE_MOBILE || netType == TYPE_WIFI);
}
/**
- * Starts the clat daemon.
- * @param lp The link properties of the interface to start clatd on.
+ * Determines whether clatd is started. Always true, except a) if start has not yet been called,
+ * or b) if our interface was removed.
*/
- public void startClat(NetworkAgentInfo network) {
- if (mNetworkMessenger != null && mNetworkMessenger != network.messenger) {
- Slog.e(TAG, "startClat: too many networks requesting clat");
- return;
- }
- mNetworkMessenger = network.messenger;
- LinkProperties lp = network.linkProperties;
- mBaseLP = new LinkProperties(lp);
- if (mIsStarted) {
+ public boolean isStarted() {
+ return mIface != null;
+ }
+
+ /**
+ * Clears internal state. Must not be called by ConnectivityService.
+ */
+ private void clear() {
+ mIface = null;
+ mBaseIface = null;
+ mIsRunning = false;
+ }
+
+ /**
+ * Starts the clat daemon. Called by ConnectivityService on the handler thread.
+ */
+ public void start() {
+ if (isStarted()) {
Slog.e(TAG, "startClat: already started");
return;
}
- String iface = lp.getInterfaceName();
- Slog.i(TAG, "Starting clatd on " + iface + ", lp=" + lp);
- try {
- mNMService.startClatd(iface);
- } catch(RemoteException e) {
- Slog.e(TAG, "Error starting clat daemon: " + e);
+
+ if (mNetwork.linkProperties == null) {
+ Slog.e(TAG, "startClat: Can't start clat with null LinkProperties");
+ return;
}
- mIsStarted = true;
+
+ try {
+ mNMService.registerObserver(this);
+ } catch(RemoteException e) {
+ Slog.e(TAG, "startClat: Can't register interface observer for clat on " + mNetwork);
+ return;
+ }
+
+ mBaseIface = mNetwork.linkProperties.getInterfaceName();
+ if (mBaseIface == null) {
+ Slog.e(TAG, "startClat: Can't start clat on null interface");
+ return;
+ }
+ mIface = CLAT_PREFIX + mBaseIface;
+ // From now on, isStarted() will return true.
+
+ Slog.i(TAG, "Starting clatd on " + mBaseIface);
+ try {
+ mNMService.startClatd(mBaseIface);
+ } catch(RemoteException|IllegalStateException e) {
+ Slog.e(TAG, "Error starting clatd: " + e);
+ }
}
/**
- * Stops the clat daemon.
+ * Stops the clat daemon. Called by ConnectivityService on the handler thread.
*/
- public void stopClat() {
- if (mIsStarted) {
+ public void stop() {
+ if (isStarted()) {
Slog.i(TAG, "Stopping clatd");
try {
- mNMService.stopClatd();
- } catch(RemoteException e) {
- Slog.e(TAG, "Error stopping clat daemon: " + e);
+ mNMService.stopClatd(mBaseIface);
+ } catch(RemoteException|IllegalStateException e) {
+ Slog.e(TAG, "Error stopping clatd: " + e);
}
- mIsStarted = false;
- mIsRunning = false;
- mNetworkMessenger = null;
- mBaseLP = null;
- mLP.clear();
+ // When clatd stops and its interface is deleted, interfaceRemoved() will notify
+ // ConnectivityService and call clear().
} else {
- Slog.e(TAG, "stopClat: already stopped");
+ Slog.e(TAG, "clatd: already stopped");
}
}
- private void updateConnectivityService() {
- Message msg = mHandler.obtainMessage(
- NetworkAgent.EVENT_NETWORK_PROPERTIES_CHANGED, mBaseLP);
- msg.replyTo = mNetworkMessenger;
+ private void updateConnectivityService(LinkProperties lp) {
+ Message msg = mHandler.obtainMessage(NetworkAgent.EVENT_NETWORK_PROPERTIES_CHANGED, lp);
+ msg.replyTo = mNetwork.messenger;
Slog.i(TAG, "sending message to ConnectivityService: " + msg);
msg.sendToTarget();
}
- // Copies the stacked clat link in oldLp, if any, to the LinkProperties in nai.
- public void fixupLinkProperties(NetworkAgentInfo nai, LinkProperties oldLp) {
- if (isRunningClat(nai) &&
- nai.linkProperties != null &&
- !nai.linkProperties.getAllInterfaceNames().contains(CLAT_INTERFACE_NAME)) {
- Slog.d(TAG, "clatd running, updating NAI for " + nai.linkProperties.getInterfaceName());
+ /**
+ * Copies the stacked clat link in oldLp, if any, to the LinkProperties in mNetwork.
+ * This is necessary because the LinkProperties in mNetwork come from the transport layer, which
+ * has no idea that 464xlat is running on top of it.
+ */
+ public void fixupLinkProperties(LinkProperties oldLp) {
+ if (mNetwork.clatd != null &&
+ mIsRunning &&
+ mNetwork.linkProperties != null &&
+ !mNetwork.linkProperties.getAllInterfaceNames().contains(mIface)) {
+ Slog.d(TAG, "clatd running, updating NAI for " + mIface);
for (LinkProperties stacked: oldLp.getStackedLinks()) {
- if (CLAT_INTERFACE_NAME.equals(stacked.getInterfaceName())) {
- nai.linkProperties.addStackedLink(stacked);
+ if (mIface.equals(stacked.getInterfaceName())) {
+ mNetwork.linkProperties.addStackedLink(stacked);
break;
}
}
}
}
+ private LinkProperties makeLinkProperties(LinkAddress clatAddress) {
+ LinkProperties stacked = new LinkProperties();
+ stacked.setInterfaceName(mIface);
+
+ // Although the clat interface is a point-to-point tunnel, we don't
+ // point the route directly at the interface because some apps don't
+ // understand routes without gateways (see, e.g., http://b/9597256
+ // http://b/9597516). Instead, set the next hop of the route to the
+ // clat IPv4 address itself (for those apps, it doesn't matter what
+ // the IP of the gateway is, only that there is one).
+ RouteInfo ipv4Default = new RouteInfo(
+ new LinkAddress(Inet4Address.ANY, 0),
+ clatAddress.getAddress(), mIface);
+ stacked.addRoute(ipv4Default);
+ stacked.addLinkAddress(clatAddress);
+ return stacked;
+ }
+
+ private LinkAddress getLinkAddress(String iface) {
+ try {
+ InterfaceConfiguration config = mNMService.getInterfaceConfig(iface);
+ return config.getLinkAddress();
+ } catch(RemoteException|IllegalStateException e) {
+ Slog.e(TAG, "Error getting link properties: " + e);
+ return null;
+ }
+ }
+
+ private void maybeSetIpv6NdOffload(String iface, boolean on) {
+ if (mNetwork.networkInfo.getType() != TYPE_WIFI) {
+ return;
+ }
+ try {
+ Slog.d(TAG, (on ? "En" : "Dis") + "abling ND offload on " + iface);
+ mNMService.setInterfaceIpv6NdOffload(iface, on);
+ } catch(RemoteException|IllegalStateException e) {
+ Slog.w(TAG, "Changing IPv6 ND offload on " + iface + "failed: " + e);
+ }
+ }
+
@Override
- public void interfaceAdded(String iface) {
- if (iface.equals(CLAT_INTERFACE_NAME)) {
- Slog.i(TAG, "interface " + CLAT_INTERFACE_NAME +
- " added, mIsRunning = " + mIsRunning + " -> true");
- mIsRunning = true;
+ public void interfaceLinkStateChanged(String iface, boolean up) {
+ // Called by the InterfaceObserver on its own thread, so can race with stop().
+ if (isStarted() && up && mIface.equals(iface)) {
+ Slog.i(TAG, "interface " + iface + " is up, mIsRunning " + mIsRunning + "->true");
- // Create the LinkProperties for the clat interface by fetching the
- // IPv4 address for the interface and adding an IPv4 default route,
- // then stack the LinkProperties on top of the link it's running on.
- try {
- InterfaceConfiguration config = mNMService.getInterfaceConfig(iface);
- LinkAddress clatAddress = config.getLinkAddress();
- mLP.clear();
- mLP.setInterfaceName(iface);
-
- // Although the clat interface is a point-to-point tunnel, we don't
- // point the route directly at the interface because some apps don't
- // understand routes without gateways (see, e.g., http://b/9597256
- // http://b/9597516). Instead, set the next hop of the route to the
- // clat IPv4 address itself (for those apps, it doesn't matter what
- // the IP of the gateway is, only that there is one).
- RouteInfo ipv4Default = new RouteInfo(new LinkAddress(Inet4Address.ANY, 0),
- clatAddress.getAddress(), iface);
- mLP.addRoute(ipv4Default);
- mLP.addLinkAddress(clatAddress);
- mBaseLP.addStackedLink(mLP);
- Slog.i(TAG, "Adding stacked link. tracker LP: " + mBaseLP);
- updateConnectivityService();
- } catch(RemoteException e) {
- Slog.e(TAG, "Error getting link properties: " + e);
+ if (!mIsRunning) {
+ LinkAddress clatAddress = getLinkAddress(iface);
+ if (clatAddress == null) {
+ return;
+ }
+ mIsRunning = true;
+ maybeSetIpv6NdOffload(mBaseIface, false);
+ LinkProperties lp = new LinkProperties(mNetwork.linkProperties);
+ lp.addStackedLink(makeLinkProperties(clatAddress));
+ Slog.i(TAG, "Adding stacked link " + mIface + " on top of " + mBaseIface);
+ updateConnectivityService(lp);
}
}
}
@Override
public void interfaceRemoved(String iface) {
- if (iface == CLAT_INTERFACE_NAME) {
+ if (isStarted() && mIface.equals(iface)) {
+ Slog.i(TAG, "interface " + iface + " removed, mIsRunning " + mIsRunning + "->false");
+
if (mIsRunning) {
- NetworkUtils.resetConnections(
- CLAT_INTERFACE_NAME,
- NetworkUtils.RESET_IPV4_ADDRESSES);
- mBaseLP.removeStackedLink(mLP);
- updateConnectivityService();
+ // The interface going away likely means clatd has crashed. Ask netd to stop it,
+ // because otherwise when we try to start it again on the same base interface netd
+ // will complain that it's already started.
+ //
+ // Note that this method can be called by the interface observer at the same time
+ // that ConnectivityService calls stop(). In this case, the second call to
+ // stopClatd() will just throw IllegalStateException, which we'll ignore.
+ try {
+ mNMService.unregisterObserver(this);
+ mNMService.stopClatd(mBaseIface);
+ } catch (RemoteException|IllegalStateException e) {
+ // Well, we tried.
+ }
+ maybeSetIpv6NdOffload(mBaseIface, true);
+ LinkProperties lp = new LinkProperties(mNetwork.linkProperties);
+ lp.removeStackedLink(mIface);
+ clear();
+ updateConnectivityService(lp);
}
- Slog.i(TAG, "interface " + CLAT_INTERFACE_NAME +
- " removed, mIsRunning = " + mIsRunning + " -> false");
- mIsRunning = false;
- mLP.clear();
- Slog.i(TAG, "mLP = " + mLP);
}
}
-};
+}
diff --git a/services/core/java/com/android/server/connectivity/NetworkAgentInfo.java b/services/core/java/com/android/server/connectivity/NetworkAgentInfo.java
index 15ffc0d..4cf2a4a 100644
--- a/services/core/java/com/android/server/connectivity/NetworkAgentInfo.java
+++ b/services/core/java/com/android/server/connectivity/NetworkAgentInfo.java
@@ -63,6 +63,9 @@
public final Messenger messenger;
public final AsyncChannel asyncChannel;
+ // Used by ConnectivityService to keep track of 464xlat.
+ public Nat464Xlat clatd;
+
public NetworkAgentInfo(Messenger messenger, AsyncChannel ac, NetworkInfo info,
LinkProperties lp, NetworkCapabilities nc, int score, Context context, Handler handler,
NetworkMisc misc) {
diff --git a/services/core/java/com/android/server/connectivity/PermissionMonitor.java b/services/core/java/com/android/server/connectivity/PermissionMonitor.java
index 238402f..debda14 100644
--- a/services/core/java/com/android/server/connectivity/PermissionMonitor.java
+++ b/services/core/java/com/android/server/connectivity/PermissionMonitor.java
@@ -191,8 +191,8 @@
}
try {
if (add) {
- mNetd.setPermission(CHANGE_NETWORK_STATE, toIntArray(network));
- mNetd.setPermission(CONNECTIVITY_INTERNAL, toIntArray(system));
+ mNetd.setPermission("NETWORK", toIntArray(network));
+ mNetd.setPermission("SYSTEM", toIntArray(system));
} else {
mNetd.clearPermission(toIntArray(network));
mNetd.clearPermission(toIntArray(system));
diff --git a/services/tests/servicestests/src/com/android/server/NetworkStatsServiceTest.java b/services/tests/servicestests/src/com/android/server/NetworkStatsServiceTest.java
index c3d4ed9..c115339 100644
--- a/services/tests/servicestests/src/com/android/server/NetworkStatsServiceTest.java
+++ b/services/tests/servicestests/src/com/android/server/NetworkStatsServiceTest.java
@@ -932,7 +932,6 @@
expect(mSettings.getPollInterval()).andReturn(HOUR_IN_MILLIS).anyTimes();
expect(mSettings.getTimeCacheMaxAge()).andReturn(DAY_IN_MILLIS).anyTimes();
expect(mSettings.getSampleEnabled()).andReturn(true).anyTimes();
- expect(mSettings.getReportXtOverDev()).andReturn(true).anyTimes();
final Config config = new Config(bucketDuration, deleteAge, deleteAge);
expect(mSettings.getDevConfig()).andReturn(config).anyTimes();