Merge changes I270ff43c,Ifc7eee24 into sc-dev
* changes:
Add enable and disable ip serving common functions
Allow to use ncm function for usb tethering
diff --git a/framework/src/android/net/NetworkCapabilities.java b/framework/src/android/net/NetworkCapabilities.java
index ed9df56..ec71d3d 100644
--- a/framework/src/android/net/NetworkCapabilities.java
+++ b/framework/src/android/net/NetworkCapabilities.java
@@ -1585,6 +1585,28 @@
}
/**
+ * Compare if the given NetworkCapabilities have the same UIDs.
+ *
+ * @hide
+ */
+ public static boolean hasSameUids(@Nullable NetworkCapabilities nc1,
+ @Nullable NetworkCapabilities nc2) {
+ final Set<UidRange> uids1 = (nc1 == null) ? null : nc1.mUids;
+ final Set<UidRange> uids2 = (nc2 == null) ? null : nc2.mUids;
+ if (null == uids1) return null == uids2;
+ if (null == uids2) return false;
+ // Make a copy so it can be mutated to check that all ranges in uids2 also are in uids.
+ final Set<UidRange> uids = new ArraySet<>(uids2);
+ for (UidRange range : uids1) {
+ if (!uids.contains(range)) {
+ return false;
+ }
+ uids.remove(range);
+ }
+ return uids.isEmpty();
+ }
+
+ /**
* Tests if the set of UIDs that this network applies to is the same as the passed network.
* <p>
* This test only checks whether equal range objects are in both sets. It will
@@ -1600,19 +1622,7 @@
*/
@VisibleForTesting
public boolean equalsUids(@NonNull NetworkCapabilities nc) {
- Set<UidRange> comparedUids = nc.mUids;
- if (null == comparedUids) return null == mUids;
- if (null == mUids) return false;
- // Make a copy so it can be mutated to check that all ranges in mUids
- // also are in uids.
- final Set<UidRange> uids = new ArraySet<>(mUids);
- for (UidRange range : comparedUids) {
- if (!uids.contains(range)) {
- return false;
- }
- uids.remove(range);
- }
- return uids.isEmpty();
+ return hasSameUids(nc, this);
}
/**
diff --git a/service/src/com/android/server/ConnectivityService.java b/service/src/com/android/server/ConnectivityService.java
index 58cd7cc..899286b 100644
--- a/service/src/com/android/server/ConnectivityService.java
+++ b/service/src/com/android/server/ConnectivityService.java
@@ -80,6 +80,8 @@
import static android.net.NetworkCapabilities.TRANSPORT_VPN;
import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
import static android.net.NetworkRequest.Type.LISTEN_FOR_BEST;
+import static android.net.OemNetworkPreferences.OEM_NETWORK_PREFERENCE_TEST;
+import static android.net.OemNetworkPreferences.OEM_NETWORK_PREFERENCE_TEST_ONLY;
import static android.net.shared.NetworkMonitorUtils.isPrivateDnsValidationRequired;
import static android.os.Process.INVALID_UID;
import static android.os.Process.VPN_UID;
@@ -2630,6 +2632,12 @@
"ConnectivityService");
}
+ private void enforceManageTestNetworksPermission() {
+ mContext.enforceCallingOrSelfPermission(
+ android.Manifest.permission.MANAGE_TEST_NETWORKS,
+ "ConnectivityService");
+ }
+
private boolean checkNetworkStackPermission() {
return checkAnyPermissionOf(
android.Manifest.permission.NETWORK_STACK,
@@ -7340,6 +7348,8 @@
mDnsManager.updateTransportsForNetwork(
nai.network.getNetId(), newNc.getTransportTypes());
}
+
+ maybeSendProxyBroadcast(nai, prevNc, newNc);
}
/** Convenience method to update the capabilities for a given network. */
@@ -7432,6 +7442,30 @@
maybeCloseSockets(nai, ranges, exemptUids);
}
+ private boolean isProxySetOnAnyDefaultNetwork() {
+ ensureRunningOnConnectivityServiceThread();
+ for (final NetworkRequestInfo nri : mDefaultNetworkRequests) {
+ final NetworkAgentInfo nai = nri.getSatisfier();
+ if (nai != null && nai.linkProperties.getHttpProxy() != null) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private void maybeSendProxyBroadcast(NetworkAgentInfo nai, NetworkCapabilities prevNc,
+ NetworkCapabilities newNc) {
+ // When the apps moved from/to a VPN, a proxy broadcast is needed to inform the apps that
+ // the proxy might be changed since the default network satisfied by the apps might also
+ // changed.
+ // TODO: Try to track the default network that apps use and only send a proxy broadcast when
+ // that happens to prevent false alarms.
+ if (nai.isVPN() && nai.everConnected && !NetworkCapabilities.hasSameUids(prevNc, newNc)
+ && (nai.linkProperties.getHttpProxy() != null || isProxySetOnAnyDefaultNetwork())) {
+ mProxyTracker.sendProxyBroadcast();
+ }
+ }
+
private void updateUids(NetworkAgentInfo nai, NetworkCapabilities prevNc,
NetworkCapabilities newNc) {
Set<UidRange> prevRanges = null == prevNc ? null : prevNc.getUidRanges();
@@ -9926,8 +9960,15 @@
@NonNull final OemNetworkPreferences preference,
@Nullable final IOnCompleteListener listener) {
- enforceAutomotiveDevice();
- enforceOemNetworkPreferencesPermission();
+ Objects.requireNonNull(preference, "OemNetworkPreferences must be non-null");
+ // Only bypass the permission/device checks if this is a valid test request.
+ if (isValidTestOemNetworkPreference(preference)) {
+ enforceManageTestNetworksPermission();
+ } else {
+ enforceAutomotiveDevice();
+ enforceOemNetworkPreferencesPermission();
+ validateOemNetworkPreferences(preference);
+ }
// TODO: Have a priority for each preference.
if (!mProfileNetworkPreferences.isEmpty() || !mMobileDataPreferredUids.isEmpty()) {
@@ -9939,18 +9980,41 @@
throwConcurrentPreferenceException();
}
- Objects.requireNonNull(preference, "OemNetworkPreferences must be non-null");
- validateOemNetworkPreferences(preference);
mHandler.sendMessage(mHandler.obtainMessage(EVENT_SET_OEM_NETWORK_PREFERENCE,
new Pair<>(preference, listener)));
}
+ /**
+ * Check the validity of an OEM network preference to be used for testing purposes.
+ * @param preference the preference to validate
+ * @return true if this is a valid OEM network preference test request.
+ */
+ private boolean isValidTestOemNetworkPreference(
+ @NonNull final OemNetworkPreferences preference) {
+ // Allow for clearing of an existing OemNetworkPreference used for testing.
+ // This isn't called on the handler thread so it is possible that mOemNetworkPreferences
+ // changes after this check is complete. This is an unlikely scenario as calling of this API
+ // is controlled by the OEM therefore the added complexity is not worth adding given those
+ // circumstances. That said, it is an edge case to be aware of hence this comment.
+ final boolean isValidTestClearPref = preference.getNetworkPreferences().size() == 0
+ && isTestOemNetworkPreference(mOemNetworkPreferences);
+ return isTestOemNetworkPreference(preference) || isValidTestClearPref;
+ }
+
+ private boolean isTestOemNetworkPreference(@NonNull final OemNetworkPreferences preference) {
+ final Map<String, Integer> prefMap = preference.getNetworkPreferences();
+ return prefMap.size() == 1
+ && (prefMap.containsValue(OEM_NETWORK_PREFERENCE_TEST)
+ || prefMap.containsValue(OEM_NETWORK_PREFERENCE_TEST_ONLY));
+ }
+
private void validateOemNetworkPreferences(@NonNull OemNetworkPreferences preference) {
for (@OemNetworkPreferences.OemNetworkPreference final int pref
: preference.getNetworkPreferences().values()) {
- if (OemNetworkPreferences.OEM_NETWORK_PREFERENCE_UNINITIALIZED == pref) {
- final String msg = "OEM_NETWORK_PREFERENCE_UNINITIALIZED is an invalid value.";
- throw new IllegalArgumentException(msg);
+ if (pref <= 0 || OemNetworkPreferences.OEM_NETWORK_PREFERENCE_MAX < pref) {
+ throw new IllegalArgumentException(
+ OemNetworkPreferences.oemNetworkPreferenceToString(pref)
+ + " is an invalid value.");
}
}
}
@@ -10174,13 +10238,21 @@
case OemNetworkPreferences.OEM_NETWORK_PREFERENCE_OEM_PRIVATE_ONLY:
requests.add(createOemPrivateNetworkRequest());
break;
+ case OEM_NETWORK_PREFERENCE_TEST:
+ requests.add(createUnmeteredNetworkRequest());
+ requests.add(createTestNetworkRequest());
+ requests.add(createDefaultRequest());
+ break;
+ case OEM_NETWORK_PREFERENCE_TEST_ONLY:
+ requests.add(createTestNetworkRequest());
+ break;
default:
// This should never happen.
throw new IllegalArgumentException("createNriFromOemNetworkPreferences()"
+ " called with invalid preference of " + preference);
}
- final ArraySet ranges = new ArraySet<Integer>();
+ final ArraySet<UidRange> ranges = new ArraySet<>();
for (final int uid : uids) {
ranges.add(new UidRange(uid, uid));
}
@@ -10213,10 +10285,17 @@
}
private NetworkCapabilities createDefaultPerAppNetCap() {
- final NetworkCapabilities netCap = new NetworkCapabilities();
- netCap.addCapability(NET_CAPABILITY_INTERNET);
- netCap.setRequestorUidAndPackageName(Process.myUid(), mContext.getPackageName());
- return netCap;
+ final NetworkCapabilities netcap = new NetworkCapabilities();
+ netcap.addCapability(NET_CAPABILITY_INTERNET);
+ netcap.setRequestorUidAndPackageName(Process.myUid(), mContext.getPackageName());
+ return netcap;
+ }
+
+ private NetworkRequest createTestNetworkRequest() {
+ final NetworkCapabilities netcap = new NetworkCapabilities();
+ netcap.clearAll();
+ netcap.addTransportType(TRANSPORT_TEST);
+ return createNetworkRequest(NetworkRequest.Type.REQUEST, netcap);
}
}
}
diff --git a/tests/common/java/android/net/NetworkAgentConfigTest.kt b/tests/common/java/android/net/NetworkAgentConfigTest.kt
index 2b45b3d..afaae1c 100644
--- a/tests/common/java/android/net/NetworkAgentConfigTest.kt
+++ b/tests/common/java/android/net/NetworkAgentConfigTest.kt
@@ -59,6 +59,7 @@
@Test @IgnoreUpTo(Build.VERSION_CODES.Q)
fun testBuilder() {
+ val testExtraInfo = "mylegacyExtraInfo"
val config = NetworkAgentConfig.Builder().apply {
setExplicitlySelected(true)
setLegacyType(ConnectivityManager.TYPE_ETHERNET)
@@ -67,6 +68,7 @@
setUnvalidatedConnectivityAcceptable(true)
setLegacyTypeName("TEST_NETWORK")
if (isAtLeastS()) {
+ setLegacyExtraInfo(testExtraInfo)
setNat64DetectionEnabled(false)
setProvisioningNotificationEnabled(false)
setBypassableVpn(true)
@@ -80,6 +82,7 @@
assertTrue(config.isUnvalidatedConnectivityAcceptable())
assertEquals("TEST_NETWORK", config.getLegacyTypeName())
if (isAtLeastS()) {
+ assertEquals(testExtraInfo, config.getLegacyExtraInfo())
assertFalse(config.isNat64DetectionEnabled())
assertFalse(config.isProvisioningNotificationEnabled())
assertTrue(config.isBypassableVpn())
diff --git a/tests/common/java/android/net/NetworkProviderTest.kt b/tests/common/java/android/net/NetworkProviderTest.kt
index 7424157..8cea12e 100644
--- a/tests/common/java/android/net/NetworkProviderTest.kt
+++ b/tests/common/java/android/net/NetworkProviderTest.kt
@@ -18,31 +18,43 @@
import android.app.Instrumentation
import android.content.Context
+import android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED
+import android.net.NetworkCapabilities.NET_CAPABILITY_TRUSTED
import android.net.NetworkCapabilities.TRANSPORT_TEST
import android.net.NetworkProviderTest.TestNetworkCallback.CallbackEntry.OnUnavailable
import android.net.NetworkProviderTest.TestNetworkProvider.CallbackEntry.OnNetworkRequestWithdrawn
import android.net.NetworkProviderTest.TestNetworkProvider.CallbackEntry.OnNetworkRequested
import android.os.Build
+import android.os.Handler
import android.os.HandlerThread
import android.os.Looper
+import android.util.Log
import androidx.test.InstrumentationRegistry
import com.android.net.module.util.ArrayTrackRecord
import com.android.testutils.CompatUtil
+import com.android.testutils.DevSdkIgnoreRule
+import com.android.testutils.DevSdkIgnoreRule.IgnoreAfter
import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo
import com.android.testutils.DevSdkIgnoreRunner
+import com.android.testutils.TestableNetworkOfferCallback
import com.android.testutils.isDevSdkInRange
import org.junit.After
import org.junit.Before
+import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
import org.mockito.Mockito.doReturn
import org.mockito.Mockito.mock
import org.mockito.Mockito.verifyNoMoreInteractions
import java.util.UUID
+import java.util.concurrent.Executor
+import java.util.concurrent.RejectedExecutionException
import kotlin.test.assertEquals
import kotlin.test.assertNotEquals
+import kotlin.test.fail
private const val DEFAULT_TIMEOUT_MS = 5000L
+private const val DEFAULT_NO_CALLBACK_TIMEOUT_MS = 200L
private val instrumentation: Instrumentation
get() = InstrumentationRegistry.getInstrumentation()
private val context: Context get() = InstrumentationRegistry.getContext()
@@ -51,6 +63,8 @@
@RunWith(DevSdkIgnoreRunner::class)
@IgnoreUpTo(Build.VERSION_CODES.Q)
class NetworkProviderTest {
+ @Rule @JvmField
+ val mIgnoreRule = DevSdkIgnoreRule()
private val mCm = context.getSystemService(ConnectivityManager::class.java)
private val mHandlerThread = HandlerThread("${javaClass.simpleName} handler thread")
@@ -68,6 +82,7 @@
private class TestNetworkProvider(context: Context, looper: Looper) :
NetworkProvider(context, looper, PROVIDER_NAME) {
+ private val TAG = this::class.simpleName
private val seenEvents = ArrayTrackRecord<CallbackEntry>().newReadHead()
sealed class CallbackEntry {
@@ -80,38 +95,57 @@
}
override fun onNetworkRequested(request: NetworkRequest, score: Int, id: Int) {
+ Log.d(TAG, "onNetworkRequested $request, $score, $id")
seenEvents.add(OnNetworkRequested(request, score, id))
}
override fun onNetworkRequestWithdrawn(request: NetworkRequest) {
+ Log.d(TAG, "onNetworkRequestWithdrawn $request")
seenEvents.add(OnNetworkRequestWithdrawn(request))
}
- inline fun <reified T : CallbackEntry> expectCallback(
+ inline fun <reified T : CallbackEntry> eventuallyExpectCallbackThat(
crossinline predicate: (T) -> Boolean
) = seenEvents.poll(DEFAULT_TIMEOUT_MS) { it is T && predicate(it) }
+ ?: fail("Did not receive callback after ${DEFAULT_TIMEOUT_MS}ms")
+
+ fun assertNoCallback() {
+ val cb = seenEvents.poll(DEFAULT_NO_CALLBACK_TIMEOUT_MS)
+ if (null != cb) fail("Expected no callback but got $cb")
+ }
}
private fun createNetworkProvider(ctx: Context = context): TestNetworkProvider {
return TestNetworkProvider(ctx, mHandlerThread.looper)
}
+ private fun createAndRegisterNetworkProvider(ctx: Context = context) =
+ createNetworkProvider(ctx).also {
+ assertEquals(it.getProviderId(), NetworkProvider.ID_NONE)
+ mCm.registerNetworkProvider(it)
+ assertNotEquals(it.getProviderId(), NetworkProvider.ID_NONE)
+ }
+
+ // In S+ framework, do not run this test, since the provider will no longer receive
+ // onNetworkRequested for every request. Instead, provider needs to
+ // call {@code registerNetworkOffer} with the description of networks they
+ // might have ability to setup, and expects {@link NetworkOfferCallback#onNetworkNeeded}.
+ @IgnoreAfter(Build.VERSION_CODES.R)
@Test
fun testOnNetworkRequested() {
- val provider = createNetworkProvider()
- assertEquals(provider.getProviderId(), NetworkProvider.ID_NONE)
- mCm.registerNetworkProvider(provider)
- assertNotEquals(provider.getProviderId(), NetworkProvider.ID_NONE)
+ val provider = createAndRegisterNetworkProvider()
val specifier = CompatUtil.makeTestNetworkSpecifier(
UUID.randomUUID().toString())
+ // Test network is not allowed to be trusted.
val nr: NetworkRequest = NetworkRequest.Builder()
.addTransportType(TRANSPORT_TEST)
+ .removeCapability(NET_CAPABILITY_TRUSTED)
.setNetworkSpecifier(specifier)
.build()
val cb = ConnectivityManager.NetworkCallback()
mCm.requestNetwork(nr, cb)
- provider.expectCallback<OnNetworkRequested>() { callback ->
+ provider.eventuallyExpectCallbackThat<OnNetworkRequested>() { callback ->
callback.request.getNetworkSpecifier() == specifier &&
callback.request.hasTransport(TRANSPORT_TEST)
}
@@ -131,22 +165,24 @@
val config = NetworkAgentConfig.Builder().build()
val agent = object : NetworkAgent(context, mHandlerThread.looper, "TestAgent", nc, lp,
initialScore, config, provider) {}
+ agent.register()
+ agent.markConnected()
- provider.expectCallback<OnNetworkRequested>() { callback ->
+ provider.eventuallyExpectCallbackThat<OnNetworkRequested>() { callback ->
callback.request.getNetworkSpecifier() == specifier &&
callback.score == initialScore &&
callback.id == agent.providerId
}
agent.sendNetworkScore(updatedScore)
- provider.expectCallback<OnNetworkRequested>() { callback ->
+ provider.eventuallyExpectCallbackThat<OnNetworkRequested>() { callback ->
callback.request.getNetworkSpecifier() == specifier &&
callback.score == updatedScore &&
callback.id == agent.providerId
}
mCm.unregisterNetworkCallback(cb)
- provider.expectCallback<OnNetworkRequestWithdrawn>() { callback ->
+ provider.eventuallyExpectCallbackThat<OnNetworkRequestWithdrawn>() { callback ->
callback.request.getNetworkSpecifier() == specifier &&
callback.request.hasTransport(TRANSPORT_TEST)
}
@@ -158,6 +194,167 @@
mCm.unregisterNetworkProvider(provider)
}
+ // Mainline module can't use internal HandlerExecutor, so add an identical executor here.
+ // TODO: Refactor with the one in MultiNetworkPolicyTracker.
+ private class HandlerExecutor(private val handler: Handler) : Executor {
+ public override fun execute(command: Runnable) {
+ if (!handler.post(command)) {
+ throw RejectedExecutionException(handler.toString() + " is shutting down")
+ }
+ }
+ }
+
+ @IgnoreUpTo(Build.VERSION_CODES.R)
+ @Test
+ fun testRegisterNetworkOffer() {
+ val provider = createAndRegisterNetworkProvider()
+ val provider2 = createAndRegisterNetworkProvider()
+
+ // Prepare the materials which will be used to create different offers.
+ val specifier1 = CompatUtil.makeTestNetworkSpecifier("TEST-SPECIFIER-1")
+ val specifier2 = CompatUtil.makeTestNetworkSpecifier("TEST-SPECIFIER-2")
+ val scoreWeaker = NetworkScore.Builder().build()
+ val scoreStronger = NetworkScore.Builder().setTransportPrimary(true).build()
+ val ncFilter1 = NetworkCapabilities.Builder().addTransportType(TRANSPORT_TEST)
+ .setNetworkSpecifier(specifier1).build()
+ val ncFilter2 = NetworkCapabilities.Builder().addTransportType(TRANSPORT_TEST)
+ .addCapability(NET_CAPABILITY_NOT_VCN_MANAGED)
+ .setNetworkSpecifier(specifier1).build()
+ val ncFilter3 = NetworkCapabilities.Builder().addTransportType(TRANSPORT_TEST)
+ .setNetworkSpecifier(specifier2).build()
+ val ncFilter4 = NetworkCapabilities.Builder().addTransportType(TRANSPORT_TEST)
+ .setNetworkSpecifier(specifier2).build()
+
+ // Make 4 offers, where 1 doesn't have NOT_VCN, 2 has NOT_VCN, 3 is similar to 1 but with
+ // different specifier, and 4 is also similar to 1 but with different provider.
+ val offerCallback1 = TestableNetworkOfferCallback(
+ DEFAULT_TIMEOUT_MS, DEFAULT_NO_CALLBACK_TIMEOUT_MS)
+ val offerCallback2 = TestableNetworkOfferCallback(
+ DEFAULT_TIMEOUT_MS, DEFAULT_NO_CALLBACK_TIMEOUT_MS)
+ val offerCallback3 = TestableNetworkOfferCallback(
+ DEFAULT_TIMEOUT_MS, DEFAULT_NO_CALLBACK_TIMEOUT_MS)
+ val offerCallback4 = TestableNetworkOfferCallback(
+ DEFAULT_TIMEOUT_MS, DEFAULT_NO_CALLBACK_TIMEOUT_MS)
+ provider.registerNetworkOffer(scoreWeaker, ncFilter1,
+ HandlerExecutor(mHandlerThread.threadHandler), offerCallback1)
+ provider.registerNetworkOffer(scoreStronger, ncFilter2,
+ HandlerExecutor(mHandlerThread.threadHandler), offerCallback2)
+ provider.registerNetworkOffer(scoreWeaker, ncFilter3,
+ HandlerExecutor(mHandlerThread.threadHandler), offerCallback3)
+ provider2.registerNetworkOffer(scoreWeaker, ncFilter4,
+ HandlerExecutor(mHandlerThread.threadHandler), offerCallback4)
+ // Unlike Android R, Android S+ provider will only receive interested requests via offer
+ // callback. Verify that the callbacks do not see any existing request such as default
+ // requests.
+ offerCallback1.assertNoCallback()
+ offerCallback2.assertNoCallback()
+ offerCallback3.assertNoCallback()
+ offerCallback4.assertNoCallback()
+
+ // File a request with specifier but without NOT_VCN, verify network is needed for callback
+ // with the same specifier.
+ val nrNoNotVcn: NetworkRequest = NetworkRequest.Builder()
+ .addTransportType(TRANSPORT_TEST)
+ // Test network is not allowed to be trusted.
+ .removeCapability(NET_CAPABILITY_TRUSTED)
+ .setNetworkSpecifier(specifier1)
+ .build()
+ val cb1 = ConnectivityManager.NetworkCallback()
+ mCm.requestNetwork(nrNoNotVcn, cb1)
+ offerCallback1.expectOnNetworkNeeded(ncFilter1)
+ offerCallback2.expectOnNetworkNeeded(ncFilter2)
+ offerCallback3.assertNoCallback()
+ offerCallback4.assertNoCallback()
+
+ mCm.unregisterNetworkCallback(cb1)
+ offerCallback1.expectOnNetworkUnneeded(ncFilter1)
+ offerCallback2.expectOnNetworkUnneeded(ncFilter2)
+ offerCallback3.assertNoCallback()
+ offerCallback4.assertNoCallback()
+
+ // File a request without specifier but with NOT_VCN, verify network is needed for offer
+ // with NOT_VCN.
+ val nrNotVcn: NetworkRequest = NetworkRequest.Builder()
+ .addTransportType(TRANSPORT_TEST)
+ .addCapability(NET_CAPABILITY_NOT_VCN_MANAGED)
+ // Test network is not allowed to be trusted.
+ .removeCapability(NET_CAPABILITY_TRUSTED)
+ .build()
+ val cb2 = ConnectivityManager.NetworkCallback()
+ mCm.requestNetwork(nrNotVcn, cb2)
+ offerCallback1.assertNoCallback()
+ offerCallback2.expectOnNetworkNeeded(ncFilter2)
+ offerCallback3.assertNoCallback()
+ offerCallback4.assertNoCallback()
+
+ // Upgrade offer 3 & 4 to satisfy previous request and then verify they are also needed.
+ ncFilter3.addCapability(NET_CAPABILITY_NOT_VCN_MANAGED)
+ provider.registerNetworkOffer(scoreWeaker, ncFilter3,
+ HandlerExecutor(mHandlerThread.threadHandler), offerCallback3)
+ ncFilter4.addCapability(NET_CAPABILITY_NOT_VCN_MANAGED)
+ provider2.registerNetworkOffer(scoreWeaker, ncFilter4,
+ HandlerExecutor(mHandlerThread.threadHandler), offerCallback4)
+ offerCallback1.assertNoCallback()
+ offerCallback2.assertNoCallback()
+ offerCallback3.expectOnNetworkNeeded(ncFilter3)
+ offerCallback4.expectOnNetworkNeeded(ncFilter4)
+
+ // Connect an agent to fulfill the request, verify offer 4 is not needed since it is not
+ // from currently serving provider nor can beat the current satisfier.
+ val nc = NetworkCapabilities().apply {
+ addTransportType(NetworkCapabilities.TRANSPORT_TEST)
+ removeCapability(NetworkCapabilities.NET_CAPABILITY_TRUSTED)
+ addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED)
+ addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED)
+ addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING)
+ addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VPN)
+ setNetworkSpecifier(specifier1)
+ }
+ val config = NetworkAgentConfig.Builder().build()
+ val agent = object : NetworkAgent(context, mHandlerThread.looper, "TestAgent", nc,
+ LinkProperties(), scoreWeaker, config, provider) {}
+ agent.register()
+ agent.markConnected()
+ // TODO: The request is satisying by offer 2 instead of offer 1, thus it should not be
+ // considered as needed.
+ offerCallback1.expectOnNetworkNeeded(ncFilter2)
+ offerCallback2.assertNoCallback() // Still needed.
+ offerCallback3.assertNoCallback() // Still needed.
+ offerCallback4.expectOnNetworkUnneeded(ncFilter4)
+
+ // Upgrade the agent, verify no change since the framework will treat the offer as needed
+ // if a request is currently satisfied by the network provided by the same provider.
+ // TODO: Consider offers with weaker score are unneeded.
+ agent.sendNetworkScore(scoreStronger)
+ offerCallback1.assertNoCallback()
+ offerCallback2.assertNoCallback() // Still needed.
+ offerCallback3.assertNoCallback() // Still needed.
+ offerCallback4.assertNoCallback() // Still unneeded.
+
+ // Verify that offer callbacks cannot receive any event if offer is unregistered.
+ provider2.unregisterNetworkOffer(offerCallback4)
+ agent.unregister()
+ offerCallback1.assertNoCallback() // Still needed.
+ offerCallback2.assertNoCallback() // Still needed.
+ offerCallback3.assertNoCallback() // Still needed.
+ // Since the agent is unregistered, and the offer has chance to satisfy the request,
+ // this callback should receive needed if it is not unregistered.
+ offerCallback4.assertNoCallback()
+
+ // Verify that offer callbacks cannot receive any event if provider is unregistered.
+ mCm.unregisterNetworkProvider(provider)
+ mCm.unregisterNetworkCallback(cb2)
+ offerCallback1.assertNoCallback() // Should be unneeded if not unregistered.
+ offerCallback2.assertNoCallback() // Should be unneeded if not unregistered.
+ offerCallback3.assertNoCallback() // Should be unneeded if not unregistered.
+ offerCallback4.assertNoCallback() // Already unregistered.
+
+ // Clean up and Verify providers did not receive any callback during the entire test.
+ mCm.unregisterNetworkProvider(provider2)
+ provider.assertNoCallback()
+ provider2.assertNoCallback()
+ }
+
private class TestNetworkCallback : ConnectivityManager.NetworkCallback() {
private val seenEvents = ArrayTrackRecord<CallbackEntry>().newReadHead()
sealed class CallbackEntry {
diff --git a/tests/cts/hostside/app/src/com/android/cts/net/hostside/AbstractRestrictBackgroundNetworkTestCase.java b/tests/cts/hostside/app/src/com/android/cts/net/hostside/AbstractRestrictBackgroundNetworkTestCase.java
index f9454ad..5b95eea 100644
--- a/tests/cts/hostside/app/src/com/android/cts/net/hostside/AbstractRestrictBackgroundNetworkTestCase.java
+++ b/tests/cts/hostside/app/src/com/android/cts/net/hostside/AbstractRestrictBackgroundNetworkTestCase.java
@@ -126,6 +126,8 @@
private static final String KEY_NETWORK_STATE_OBSERVER = TEST_PKG + ".observer";
private static final String KEY_SKIP_VALIDATION_CHECKS = TEST_PKG + ".skip_validation_checks";
+ private static final String EMPTY_STRING = "";
+
protected static final int TYPE_COMPONENT_ACTIVTIY = 0;
protected static final int TYPE_COMPONENT_FOREGROUND_SERVICE = 1;
protected static final int TYPE_EXPEDITED_JOB = 2;
@@ -229,6 +231,8 @@
final String resultData = getResultData();
if (resultData == null) {
Log.e(TAG, "Received null data from ordered intent");
+ // Offer an empty string so that the code waiting for the result can return.
+ result.offer(EMPTY_STRING);
return;
}
result.offer(resultData);
diff --git a/tests/cts/hostside/app/src/com/android/cts/net/hostside/VpnTest.java b/tests/cts/hostside/app/src/com/android/cts/net/hostside/VpnTest.java
index 532fd86..8485263 100755
--- a/tests/cts/hostside/app/src/com/android/cts/net/hostside/VpnTest.java
+++ b/tests/cts/hostside/app/src/com/android/cts/net/hostside/VpnTest.java
@@ -17,6 +17,7 @@
package com.android.cts.net.hostside;
import static android.Manifest.permission.NETWORK_SETTINGS;
+import static android.net.ConnectivityManager.TYPE_VPN;
import static android.net.NetworkCapabilities.TRANSPORT_VPN;
import static android.os.Process.INVALID_UID;
import static android.system.OsConstants.AF_INET;
@@ -759,6 +760,7 @@
assertEquals(vpnNetwork, mCM.getActiveNetwork());
assertNotEqual(defaultNetwork, vpnNetwork);
maybeExpectVpnTransportInfo(vpnNetwork);
+ assertTrue(mCM.getNetworkInfo(vpnNetwork).getType() == TYPE_VPN);
if (SdkLevel.isAtLeastS()) {
// Check that system default network callback has not seen any network changes, even
diff --git a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
index fe313b9..34f3cc9 100644
--- a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
+++ b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
@@ -28,6 +28,7 @@
import static android.content.pm.PackageManager.FEATURE_WIFI_DIRECT;
import static android.content.pm.PackageManager.GET_PERMISSIONS;
import static android.content.pm.PackageManager.PERMISSION_GRANTED;
+import static android.net.ConnectivityManager.PROFILE_NETWORK_PREFERENCE_ENTERPRISE;
import static android.net.ConnectivityManager.TYPE_BLUETOOTH;
import static android.net.ConnectivityManager.TYPE_ETHERNET;
import static android.net.ConnectivityManager.TYPE_MOBILE_CBS;
@@ -152,6 +153,7 @@
import com.android.networkstack.apishim.common.ConnectivityManagerShim;
import com.android.testutils.CompatUtil;
import com.android.testutils.DevSdkIgnoreRule;
+import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo;
import com.android.testutils.DevSdkIgnoreRuleKt;
import com.android.testutils.RecorderCallback.CallbackEntry;
import com.android.testutils.SkipPresubmit;
@@ -650,6 +652,18 @@
mCm.getBackgroundDataSetting();
}
+ private NetworkRequest makeDefaultRequest() {
+ // Make a request that is similar to the way framework tracks the system
+ // default network.
+ return new NetworkRequest.Builder()
+ .clearCapabilities()
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_TRUSTED)
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VPN)
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+ .build();
+ }
+
private NetworkRequest makeWifiNetworkRequest() {
return new NetworkRequest.Builder()
.addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
@@ -662,6 +676,31 @@
.build();
}
+ @Test @IgnoreUpTo(Build.VERSION_CODES.Q)
+ public void testIsPrivateDnsBroken() throws InterruptedException {
+ final String invalidPrivateDnsServer = "invalidhostname.example.com";
+ final String goodPrivateDnsServer = "dns.google";
+ mCtsNetUtils.storePrivateDnsSetting();
+ final TestableNetworkCallback cb = new TestableNetworkCallback();
+ mCm.registerNetworkCallback(makeWifiNetworkRequest(), cb);
+ try {
+ // Verifying the good private DNS sever
+ mCtsNetUtils.setPrivateDnsStrictMode(goodPrivateDnsServer);
+ final Network networkForPrivateDns = mCtsNetUtils.ensureWifiConnected();
+ cb.eventuallyExpect(CallbackEntry.NETWORK_CAPS_UPDATED, NETWORK_CALLBACK_TIMEOUT_MS,
+ entry -> (!((CallbackEntry.CapabilitiesChanged) entry).getCaps()
+ .isPrivateDnsBroken()) && networkForPrivateDns.equals(entry.getNetwork()));
+
+ // Verifying the broken private DNS sever
+ mCtsNetUtils.setPrivateDnsStrictMode(invalidPrivateDnsServer);
+ cb.eventuallyExpect(CallbackEntry.NETWORK_CAPS_UPDATED, NETWORK_CALLBACK_TIMEOUT_MS,
+ entry -> (((CallbackEntry.CapabilitiesChanged) entry).getCaps()
+ .isPrivateDnsBroken()) && networkForPrivateDns.equals(entry.getNetwork()));
+ } finally {
+ mCtsNetUtils.restorePrivateDnsSetting();
+ }
+ }
+
/**
* Exercises both registerNetworkCallback and unregisterNetworkCallback. This checks to
* see if we get a callback for the TRANSPORT_WIFI transport type being available.
@@ -688,12 +727,14 @@
final TestNetworkCallback systemDefaultCallback = new TestNetworkCallback();
final TestNetworkCallback perUidCallback = new TestNetworkCallback();
+ final TestNetworkCallback bestMatchingCallback = new TestNetworkCallback();
final Handler h = new Handler(Looper.getMainLooper());
if (TestUtils.shouldTestSApis()) {
runWithShellPermissionIdentity(() -> {
mCmShim.registerSystemDefaultNetworkCallback(systemDefaultCallback, h);
mCmShim.registerDefaultNetworkCallbackForUid(Process.myUid(), perUidCallback, h);
}, NETWORK_SETTINGS);
+ mCm.registerBestMatchingNetworkCallback(makeDefaultRequest(), bestMatchingCallback, h);
}
Network wifiNetwork = null;
@@ -719,6 +760,10 @@
assertNotNull("Did not receive onAvailable on per-UID default network callback",
perUidNetwork);
assertEquals(defaultNetwork, perUidNetwork);
+ final Network bestMatchingNetwork = bestMatchingCallback.waitForAvailable();
+ assertNotNull("Did not receive onAvailable on best matching network callback",
+ bestMatchingNetwork);
+ assertEquals(defaultNetwork, bestMatchingNetwork);
}
} catch (InterruptedException e) {
@@ -729,6 +774,7 @@
if (TestUtils.shouldTestSApis()) {
mCm.unregisterNetworkCallback(systemDefaultCallback);
mCm.unregisterNetworkCallback(perUidCallback);
+ mCm.unregisterNetworkCallback(bestMatchingCallback);
}
}
}
@@ -2059,6 +2105,20 @@
}
}
+ /**
+ * Verify that {@link ConnectivityManager#setProfileNetworkPreference} cannot be called
+ * without required NETWORK_STACK permissions.
+ */
+ @Test
+ public void testSetProfileNetworkPreference_NoPermission() {
+ // Cannot use @IgnoreUpTo(Build.VERSION_CODES.R) because this test also requires API 31
+ // shims, and @IgnoreUpTo does not check that.
+ assumeTrue(TestUtils.shouldTestSApis());
+ assertThrows(SecurityException.class, () -> mCm.setProfileNetworkPreference(
+ UserHandle.of(0), PROFILE_NETWORK_PREFERENCE_ENTERPRISE, null /* executor */,
+ null /* listener */));
+ }
+
private void verifySettings(int expectedAirplaneMode, int expectedPrivateDnsMode,
int expectedAvoidBadWifi) throws Exception {
assertEquals(expectedAirplaneMode, Settings.Global.getInt(
diff --git a/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt b/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt
index 8e2b310..c505cef 100644
--- a/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt
+++ b/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt
@@ -66,10 +66,12 @@
import android.net.cts.NetworkAgentTest.TestableNetworkAgent.CallbackEntry.OnStopSocketKeepalive
import android.net.cts.NetworkAgentTest.TestableNetworkAgent.CallbackEntry.OnValidationStatus
import android.os.Build
+import android.os.Handler
import android.os.HandlerThread
import android.os.Looper
import android.os.Message
import android.os.SystemClock
+import android.telephony.TelephonyManager
import android.util.DebugUtils.valueToString
import androidx.test.InstrumentationRegistry
import com.android.compatibility.common.util.SystemUtil.runWithShellPermissionIdentity
@@ -268,10 +270,9 @@
history.add(OnSignalStrengthThresholdsUpdated(thresholds))
}
- fun expectEmptySignalStrengths() {
+ fun expectSignalStrengths(thresholds: IntArray? = intArrayOf()) {
expectCallback<OnSignalStrengthThresholdsUpdated>().let {
- // intArrayOf() without arguments makes an empty array
- assertArrayEquals(intArrayOf(), it.thresholds)
+ assertArrayEquals(thresholds, it.thresholds)
}
}
@@ -291,7 +292,7 @@
// a NetworkAgent whose network does not require validation (which test networks do
// not, since they lack the INTERNET capability). It always contains the default argument
// for the URI.
- fun expectNoInternetValidationStatus() = expectCallback<OnValidationStatus>().let {
+ fun expectValidationBypassedStatus() = expectCallback<OnValidationStatus>().let {
assertEquals(it.status, VALID_NETWORK)
// The returned Uri is parsed from the empty string, which means it's an
// instance of the (private) Uri.StringUri. There are no real good ways
@@ -331,9 +332,30 @@
callbacksToCleanUp.add(callback)
}
+ private fun registerBestMatchingNetworkCallback(
+ request: NetworkRequest,
+ callback: TestableNetworkCallback,
+ handler: Handler
+ ) {
+ mCM!!.registerBestMatchingNetworkCallback(request, callback, handler)
+ callbacksToCleanUp.add(callback)
+ }
+
+ private fun makeTestNetworkRequest(specifier: String? = null): NetworkRequest {
+ return NetworkRequest.Builder()
+ .clearCapabilities()
+ .addTransportType(TRANSPORT_TEST)
+ .also {
+ if (specifier != null) {
+ it.setNetworkSpecifier(CompatUtil.makeEthernetNetworkSpecifier(specifier))
+ }
+ }
+ .build()
+ }
+
private fun createNetworkAgent(
context: Context = realContext,
- name: String? = null,
+ specifier: String? = null,
initialNc: NetworkCapabilities? = null,
initialLp: LinkProperties? = null,
initialConfig: NetworkAgentConfig? = null
@@ -348,8 +370,8 @@
if (SdkLevel.isAtLeastS()) {
addCapability(NET_CAPABILITY_NOT_VCN_MANAGED)
}
- if (null != name) {
- setNetworkSpecifier(CompatUtil.makeEthernetNetworkSpecifier(name))
+ if (null != specifier) {
+ setNetworkSpecifier(CompatUtil.makeEthernetNetworkSpecifier(specifier))
}
}
val lp = initialLp ?: LinkProperties().apply {
@@ -362,19 +384,24 @@
}
}
- private fun createConnectedNetworkAgent(context: Context = realContext, name: String? = null):
- Pair<TestableNetworkAgent, TestableNetworkCallback> {
- val request: NetworkRequest = NetworkRequest.Builder()
- .clearCapabilities()
- .addTransportType(TRANSPORT_TEST)
- .build()
+ private fun createConnectedNetworkAgent(
+ context: Context = realContext,
+ specifier: String? = UUID.randomUUID().toString(),
+ initialConfig: NetworkAgentConfig? = null,
+ expectedInitSignalStrengthThresholds: IntArray? = intArrayOf()
+ ): Pair<TestableNetworkAgent, TestableNetworkCallback> {
val callback = TestableNetworkCallback(timeoutMs = DEFAULT_TIMEOUT_MS)
- requestNetwork(request, callback)
- val agent = createNetworkAgent(context, name)
+ // Ensure this NetworkAgent is never unneeded by filing a request with its specifier.
+ requestNetwork(makeTestNetworkRequest(specifier = specifier), callback)
+ val agent = createNetworkAgent(context, specifier, initialConfig = initialConfig)
agent.setTeardownDelayMillis(0)
+ // Connect the agent and verify initial status callbacks.
agent.register()
agent.markConnected()
agent.expectCallback<OnNetworkCreated>()
+ agent.expectSignalStrengths(expectedInitSignalStrengthThresholds)
+ agent.expectValidationBypassedStatus()
+ callback.expectAvailableThenValidatedCallbacks(agent.network!!)
return agent to callback
}
@@ -383,14 +410,52 @@
}
@Test
+ fun testSetSubtypeNameAndExtraInfoByAgentConfig() {
+ val subtypeLTE = TelephonyManager.NETWORK_TYPE_LTE
+ val subtypeNameLTE = "LTE"
+ val legacyExtraInfo = "mylegacyExtraInfo"
+ val config = NetworkAgentConfig.Builder()
+ .setLegacySubType(subtypeLTE)
+ .setLegacySubTypeName(subtypeNameLTE)
+ .setLegacyExtraInfo(legacyExtraInfo).build()
+ val (agent, callback) = createConnectedNetworkAgent(initialConfig = config)
+ val networkInfo = mCM.getNetworkInfo(agent.network)
+ assertEquals(subtypeLTE, networkInfo.getSubtype())
+ assertEquals(subtypeNameLTE, networkInfo.getSubtypeName())
+ assertEquals(legacyExtraInfo, config.getLegacyExtraInfo())
+ }
+
+ @Test
+ fun testSetLegacySubtypeInNetworkAgent() {
+ val subtypeLTE = TelephonyManager.NETWORK_TYPE_LTE
+ val subtypeUMTS = TelephonyManager.NETWORK_TYPE_UMTS
+ val subtypeNameLTE = "LTE"
+ val subtypeNameUMTS = "UMTS"
+ val config = NetworkAgentConfig.Builder()
+ .setLegacySubType(subtypeLTE)
+ .setLegacySubTypeName(subtypeNameLTE).build()
+ val (agent, callback) = createConnectedNetworkAgent(initialConfig = config)
+ agent.setLegacySubtype(subtypeUMTS, subtypeNameUMTS)
+
+ // There is no callback when networkInfo changes,
+ // so use the NetworkCapabilities callback to ensure
+ // that networkInfo is ready for verification.
+ val nc = NetworkCapabilities(agent.nc)
+ nc.addCapability(NET_CAPABILITY_NOT_METERED)
+ agent.sendNetworkCapabilities(nc)
+ callback.expectCapabilitiesThat(agent.network) {
+ it.hasCapability(NET_CAPABILITY_NOT_METERED)
+ }
+ val networkInfo = mCM.getNetworkInfo(agent.network)
+ assertEquals(subtypeUMTS, networkInfo.getSubtype())
+ assertEquals(subtypeNameUMTS, networkInfo.getSubtypeName())
+ }
+
+ @Test
fun testConnectAndUnregister() {
val (agent, callback) = createConnectedNetworkAgent()
- callback.expectAvailableThenValidatedCallbacks(agent.network)
- agent.expectEmptySignalStrengths()
- agent.expectNoInternetValidationStatus()
-
unregister(agent)
- callback.expectCallback<Lost>(agent.network)
+ callback.expectCallback<Lost>(agent.network!!)
assertFailsWith<IllegalStateException>("Must not be able to register an agent twice") {
agent.register()
}
@@ -398,11 +463,8 @@
@Test
fun testOnBandwidthUpdateRequested() {
- val (agent, callback) = createConnectedNetworkAgent()
- callback.expectAvailableThenValidatedCallbacks(agent.network)
- agent.expectEmptySignalStrengths()
- agent.expectNoInternetValidationStatus()
- mCM.requestBandwidthUpdate(agent.network)
+ val (agent, _) = createConnectedNetworkAgent()
+ mCM.requestBandwidthUpdate(agent.network!!)
agent.expectCallback<OnBandwidthUpdateRequested>()
unregister(agent)
}
@@ -420,13 +482,8 @@
registerNetworkCallback(request, it)
}
}
- createConnectedNetworkAgent().let { (agent, callback) ->
- callback.expectAvailableThenValidatedCallbacks(agent.network)
- agent.expectCallback<OnSignalStrengthThresholdsUpdated>().let {
- assertArrayEquals(it.thresholds, thresholds)
- }
- agent.expectNoInternetValidationStatus()
-
+ createConnectedNetworkAgent(expectedInitSignalStrengthThresholds = thresholds).let {
+ (agent, callback) ->
// Send signal strength and check that the callbacks are called appropriately.
val nc = NetworkCapabilities(agent.nc)
nc.setSignalStrength(20)
@@ -435,21 +492,21 @@
nc.setSignalStrength(40)
agent.sendNetworkCapabilities(nc)
- callbacks[0].expectAvailableCallbacks(agent.network)
+ callbacks[0].expectAvailableCallbacks(agent.network!!)
callbacks[1].assertNoCallback(NO_CALLBACK_TIMEOUT)
callbacks[2].assertNoCallback(NO_CALLBACK_TIMEOUT)
nc.setSignalStrength(80)
agent.sendNetworkCapabilities(nc)
- callbacks[0].expectCapabilitiesThat(agent.network) { it.signalStrength == 80 }
- callbacks[1].expectAvailableCallbacks(agent.network)
- callbacks[2].expectAvailableCallbacks(agent.network)
+ callbacks[0].expectCapabilitiesThat(agent.network!!) { it.signalStrength == 80 }
+ callbacks[1].expectAvailableCallbacks(agent.network!!)
+ callbacks[2].expectAvailableCallbacks(agent.network!!)
nc.setSignalStrength(55)
agent.sendNetworkCapabilities(nc)
- callbacks[0].expectCapabilitiesThat(agent.network) { it.signalStrength == 55 }
- callbacks[1].expectCapabilitiesThat(agent.network) { it.signalStrength == 55 }
- callbacks[2].expectCallback<Lost>(agent.network)
+ callbacks[0].expectCapabilitiesThat(agent.network!!) { it.signalStrength == 55 }
+ callbacks[1].expectCapabilitiesThat(agent.network!!) { it.signalStrength == 55 }
+ callbacks[2].expectCallback<Lost>(agent.network!!)
}
callbacks.forEach {
mCM.unregisterNetworkCallback(it)
@@ -498,20 +555,17 @@
@Test
fun testSendUpdates(): Unit = createConnectedNetworkAgent().let { (agent, callback) ->
- callback.expectAvailableThenValidatedCallbacks(agent.network)
- agent.expectEmptySignalStrengths()
- agent.expectNoInternetValidationStatus()
val ifaceName = "adhocIface"
val lp = LinkProperties(agent.lp)
lp.setInterfaceName(ifaceName)
agent.sendLinkProperties(lp)
- callback.expectLinkPropertiesThat(agent.network) {
+ callback.expectLinkPropertiesThat(agent.network!!) {
it.getInterfaceName() == ifaceName
}
val nc = NetworkCapabilities(agent.nc)
nc.addCapability(NET_CAPABILITY_NOT_METERED)
agent.sendNetworkCapabilities(nc)
- callback.expectCapabilitiesThat(agent.network) {
+ callback.expectCapabilitiesThat(agent.network!!) {
it.hasCapability(NET_CAPABILITY_NOT_METERED)
}
}
@@ -520,56 +574,32 @@
fun testSendScore() {
// This test will create two networks and check that the one with the stronger
// score wins out for a request that matches them both.
- // First create requests to make sure both networks are kept up, using the
- // specifier so they are specific to each network
- val name1 = UUID.randomUUID().toString()
- val name2 = UUID.randomUUID().toString()
- val request1 = NetworkRequest.Builder()
- .clearCapabilities()
- .addTransportType(TRANSPORT_TEST)
- .setNetworkSpecifier(CompatUtil.makeEthernetNetworkSpecifier(name1))
- .build()
- val request2 = NetworkRequest.Builder()
- .clearCapabilities()
- .addTransportType(TRANSPORT_TEST)
- .setNetworkSpecifier(CompatUtil.makeEthernetNetworkSpecifier(name2))
- .build()
- val callback1 = TestableNetworkCallback(timeoutMs = DEFAULT_TIMEOUT_MS)
- val callback2 = TestableNetworkCallback(timeoutMs = DEFAULT_TIMEOUT_MS)
- requestNetwork(request1, callback1)
- requestNetwork(request2, callback2)
- // Then file the interesting request
- val request = NetworkRequest.Builder()
- .clearCapabilities()
- .addTransportType(TRANSPORT_TEST)
- .build()
+ // File the interesting request
val callback = TestableNetworkCallback(timeoutMs = DEFAULT_TIMEOUT_MS)
- requestNetwork(request, callback)
+ requestNetwork(makeTestNetworkRequest(), callback)
- // Connect the first Network
- createConnectedNetworkAgent(name = name1).let { (agent1, _) ->
- callback.expectAvailableThenValidatedCallbacks(agent1.network)
- // If using the int ranking, agent1 must be upgraded to a better score so that there is
- // no ambiguity when agent2 connects that agent1 is still better. If using policy
- // ranking, this is not necessary.
- agent1.sendNetworkScore(NetworkScore.Builder().setLegacyInt(BETTER_NETWORK_SCORE)
- .build())
- // Connect the second agent
- createConnectedNetworkAgent(name = name2).let { (agent2, _) ->
- agent2.markConnected()
- // The callback should not see anything yet. With int ranking, agent1 was upgraded
- // to a stronger score beforehand. With policy ranking, agent1 is preferred by
- // virtue of already satisfying the request.
- callback.assertNoCallback(NO_CALLBACK_TIMEOUT)
- // Now downgrade the score and expect the callback now prefers agent2
- agent1.sendNetworkScore(NetworkScore.Builder()
- .setLegacyInt(WORSE_NETWORK_SCORE)
- .setExiting(true)
- .build())
- callback.expectCallback<Available>(agent2.network)
- }
- }
+ // Connect the first Network, with an unused callback that kept the network up.
+ val (agent1, _) = createConnectedNetworkAgent()
+ callback.expectAvailableThenValidatedCallbacks(agent1.network!!)
+ // If using the int ranking, agent1 must be upgraded to a better score so that there is
+ // no ambiguity when agent2 connects that agent1 is still better. If using policy
+ // ranking, this is not necessary.
+ agent1.sendNetworkScore(NetworkScore.Builder().setLegacyInt(BETTER_NETWORK_SCORE)
+ .build())
+
+ // Connect the second agent.
+ val (agent2, _) = createConnectedNetworkAgent()
+ // The callback should not see anything yet. With int ranking, agent1 was upgraded
+ // to a stronger score beforehand. With policy ranking, agent1 is preferred by
+ // virtue of already satisfying the request.
+ callback.assertNoCallback(NO_CALLBACK_TIMEOUT)
+ // Now downgrade the score and expect the callback now prefers agent2
+ agent1.sendNetworkScore(NetworkScore.Builder()
+ .setLegacyInt(WORSE_NETWORK_SCORE)
+ .setExiting(true)
+ .build())
+ callback.expectCallback<Available>(agent2.network!!)
// tearDown() will unregister the requests and agents
}
@@ -610,7 +640,7 @@
callback.expectAvailableThenValidatedCallbacks(agent.network!!)
// Check that the default network's transport is propagated to the VPN.
- var vpnNc = mCM.getNetworkCapabilities(agent.network)
+ var vpnNc = mCM.getNetworkCapabilities(agent.network!!)
assertNotNull(vpnNc)
assertEquals(VpnManager.TYPE_VPN_SERVICE,
(vpnNc.transportInfo as VpnTransportInfo).type)
@@ -642,7 +672,7 @@
// This is not very accurate because the test does not control the capabilities of the
// underlying networks, and because not congested, not roaming, and not suspended are the
// default anyway. It's still useful as an extra check though.
- vpnNc = mCM.getNetworkCapabilities(agent.network)
+ vpnNc = mCM.getNetworkCapabilities(agent.network!!)
for (cap in listOf(NET_CAPABILITY_NOT_CONGESTED,
NET_CAPABILITY_NOT_ROAMING,
NET_CAPABILITY_NOT_SUSPENDED)) {
@@ -653,7 +683,7 @@
}
unregister(agent)
- callback.expectCallback<Lost>(agent.network)
+ callback.expectCallback<Lost>(agent.network!!)
}
private fun unregister(agent: TestableNetworkAgent) {
@@ -741,43 +771,24 @@
fun testTemporarilyUnmeteredCapability() {
// This test will create a networks with/without NET_CAPABILITY_TEMPORARILY_NOT_METERED
// and check that the callback reflects the capability changes.
- // First create a request to make sure the network is kept up
- val request1 = NetworkRequest.Builder()
- .clearCapabilities()
- .addTransportType(TRANSPORT_TEST)
- .build()
- val callback1 = TestableNetworkCallback(timeoutMs = DEFAULT_TIMEOUT_MS).also {
- registerNetworkCallback(request1, it)
- }
- requestNetwork(request1, callback1)
-
- // Then file the interesting request
- val request = NetworkRequest.Builder()
- .clearCapabilities()
- .addTransportType(TRANSPORT_TEST)
- .build()
- val callback = TestableNetworkCallback(timeoutMs = DEFAULT_TIMEOUT_MS)
- requestNetwork(request, callback)
// Connect the network
- createConnectedNetworkAgent().let { (agent, _) ->
- callback.expectAvailableThenValidatedCallbacks(agent.network)
+ val (agent, callback) = createConnectedNetworkAgent()
- // Send TEMP_NOT_METERED and check that the callback is called appropriately.
- val nc1 = NetworkCapabilities(agent.nc)
- .addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED)
- agent.sendNetworkCapabilities(nc1)
- callback.expectCapabilitiesThat(agent.network) {
- it.hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED)
- }
+ // Send TEMP_NOT_METERED and check that the callback is called appropriately.
+ val nc1 = NetworkCapabilities(agent.nc)
+ .addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED)
+ agent.sendNetworkCapabilities(nc1)
+ callback.expectCapabilitiesThat(agent.network!!) {
+ it.hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED)
+ }
- // Remove TEMP_NOT_METERED and check that the callback is called appropriately.
- val nc2 = NetworkCapabilities(agent.nc)
- .removeCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED)
- agent.sendNetworkCapabilities(nc2)
- callback.expectCapabilitiesThat(agent.network) {
- !it.hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED)
- }
+ // Remove TEMP_NOT_METERED and check that the callback is called appropriately.
+ val nc2 = NetworkCapabilities(agent.nc)
+ .removeCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED)
+ agent.sendNetworkCapabilities(nc2)
+ callback.expectCapabilitiesThat(agent.network!!) {
+ !it.hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED)
}
// tearDown() will unregister the requests and agents
@@ -790,88 +801,137 @@
// score wins out for a request that matches them both. And the weaker agent will
// be disconnected after customized linger duration.
- // Connect the first Network
- val name1 = UUID.randomUUID().toString()
- val name2 = UUID.randomUUID().toString()
- val (agent1, callback) = createConnectedNetworkAgent(name = name1)
- callback.expectAvailableThenValidatedCallbacks(agent1.network!!)
- // Downgrade agent1 to a worse score so that there is no ambiguity when
- // agent2 connects.
- agent1.sendNetworkScore(NetworkScore.Builder().setLegacyInt(WORSE_NETWORK_SCORE)
+ // Request the first Network, with a request that could moved to agentStronger in order to
+ // make agentWeaker linger later.
+ val specifierWeaker = UUID.randomUUID().toString()
+ val specifierStronger = UUID.randomUUID().toString()
+ val commonCallback = TestableNetworkCallback(timeoutMs = DEFAULT_TIMEOUT_MS)
+ requestNetwork(makeTestNetworkRequest(), commonCallback)
+ val agentWeaker = createNetworkAgent(specifier = specifierWeaker)
+ agentWeaker.register()
+ agentWeaker.markConnected()
+ commonCallback.expectAvailableThenValidatedCallbacks(agentWeaker.network!!)
+ // Downgrade agentWeaker to a worse score so that there is no ambiguity when
+ // agentStronger connects.
+ agentWeaker.sendNetworkScore(NetworkScore.Builder().setLegacyInt(WORSE_NETWORK_SCORE)
.setExiting(true).build())
// Verify invalid linger duration cannot be set.
assertFailsWith<IllegalArgumentException> {
- agent1.setLingerDuration(Duration.ofMillis(-1))
+ agentWeaker.setLingerDuration(Duration.ofMillis(-1))
}
- assertFailsWith<IllegalArgumentException> { agent1.setLingerDuration(Duration.ZERO) }
+ assertFailsWith<IllegalArgumentException> { agentWeaker.setLingerDuration(Duration.ZERO) }
assertFailsWith<IllegalArgumentException> {
- agent1.setLingerDuration(Duration.ofMillis(Integer.MIN_VALUE.toLong()))
+ agentWeaker.setLingerDuration(Duration.ofMillis(Integer.MIN_VALUE.toLong()))
}
assertFailsWith<IllegalArgumentException> {
- agent1.setLingerDuration(Duration.ofMillis(Integer.MAX_VALUE.toLong() + 1))
+ agentWeaker.setLingerDuration(Duration.ofMillis(Integer.MAX_VALUE.toLong() + 1))
}
assertFailsWith<IllegalArgumentException> {
- agent1.setLingerDuration(Duration.ofMillis(
+ agentWeaker.setLingerDuration(Duration.ofMillis(
NetworkAgent.MIN_LINGER_TIMER_MS.toLong() - 1))
}
// Verify valid linger timer can be set, but it should not take effect since the network
// is still needed.
- agent1.setLingerDuration(Duration.ofMillis(Integer.MAX_VALUE.toLong()))
- callback.assertNoCallback(NO_CALLBACK_TIMEOUT)
+ agentWeaker.setLingerDuration(Duration.ofMillis(Integer.MAX_VALUE.toLong()))
+ commonCallback.assertNoCallback(NO_CALLBACK_TIMEOUT)
// Set to the value we want to verify the functionality.
- agent1.setLingerDuration(Duration.ofMillis(NetworkAgent.MIN_LINGER_TIMER_MS.toLong()))
- // Make a listener which can observe agent1 lost later.
+ agentWeaker.setLingerDuration(Duration.ofMillis(NetworkAgent.MIN_LINGER_TIMER_MS.toLong()))
+ // Make a listener which can observe agentWeaker lost later.
val callbackWeaker = TestableNetworkCallback(timeoutMs = DEFAULT_TIMEOUT_MS)
registerNetworkCallback(NetworkRequest.Builder()
.clearCapabilities()
.addTransportType(TRANSPORT_TEST)
- .setNetworkSpecifier(CompatUtil.makeEthernetNetworkSpecifier(name1))
+ .setNetworkSpecifier(CompatUtil.makeEthernetNetworkSpecifier(specifierWeaker))
.build(), callbackWeaker)
- callbackWeaker.expectAvailableCallbacks(agent1.network!!)
+ callbackWeaker.expectAvailableCallbacks(agentWeaker.network!!)
- // Connect the second agent with a score better than agent1. Verify the callback for
- // agent1 sees the linger expiry while the callback for both sees the winner.
+ // Connect the agentStronger with a score better than agentWeaker. Verify the callback for
+ // agentWeaker sees the linger expiry while the callback for both sees the winner.
// Record linger start timestamp prior to send score to prevent possible race, the actual
// timestamp should be slightly late than this since the service handles update
// network score asynchronously.
val lingerStart = SystemClock.elapsedRealtime()
- val agent2 = createNetworkAgent(name = name2)
- agent2.register()
- agent2.markConnected()
- callback.expectAvailableCallbacks(agent2.network!!)
- callbackWeaker.expectCallback<Losing>(agent1.network!!)
+ val agentStronger = createNetworkAgent(specifier = specifierStronger)
+ agentStronger.register()
+ agentStronger.markConnected()
+ commonCallback.expectAvailableCallbacks(agentStronger.network!!)
+ callbackWeaker.expectCallback<Losing>(agentWeaker.network!!)
val expectedRemainingLingerDuration = lingerStart +
NetworkAgent.MIN_LINGER_TIMER_MS.toLong() - SystemClock.elapsedRealtime()
// If the available callback is too late. The remaining duration will be reduced.
assertTrue(expectedRemainingLingerDuration > 0,
"expected remaining linger duration is $expectedRemainingLingerDuration")
callbackWeaker.assertNoCallback(expectedRemainingLingerDuration)
- callbackWeaker.expectCallback<Lost>(agent1.network!!)
+ callbackWeaker.expectCallback<Lost>(agentWeaker.network!!)
}
@Test
@IgnoreUpTo(Build.VERSION_CODES.R)
fun testSetSubscriberId() {
- val name = "TEST-AGENT"
val imsi = UUID.randomUUID().toString()
val config = NetworkAgentConfig.Builder().setSubscriberId(imsi).build()
- val request: NetworkRequest = NetworkRequest.Builder()
- .clearCapabilities()
- .addTransportType(TRANSPORT_TEST)
- .setNetworkSpecifier(CompatUtil.makeEthernetNetworkSpecifier(name))
- .build()
- val callback = TestableNetworkCallback(timeoutMs = DEFAULT_TIMEOUT_MS)
- requestNetwork(request, callback)
-
- val agent = createNetworkAgent(name = name, initialConfig = config)
- agent.register()
- agent.markConnected()
- callback.expectAvailableThenValidatedCallbacks(agent.network!!)
+ val (agent, _) = createConnectedNetworkAgent(initialConfig = config)
val snapshots = runWithShellPermissionIdentity(ThrowingSupplier {
mCM!!.allNetworkStateSnapshots }, NETWORK_SETTINGS)
val testNetworkSnapshot = snapshots.findLast { it.network == agent.network }
assertEquals(imsi, testNetworkSnapshot!!.subscriberId)
}
+
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.R)
+ // TODO: Refactor helper functions to util class and move this test case to
+ // {@link android.net.cts.ConnectivityManagerTest}.
+ fun testRegisterBestMatchingNetworkCallback() {
+ // Register best matching network callback with additional condition that will be
+ // exercised later. This assumes the test network agent has NOT_VCN_MANAGED in it and
+ // does not have NET_CAPABILITY_TEMPORARILY_NOT_METERED.
+ val bestMatchingCb = TestableNetworkCallback(timeoutMs = DEFAULT_TIMEOUT_MS)
+ registerBestMatchingNetworkCallback(NetworkRequest.Builder()
+ .clearCapabilities()
+ .addTransportType(TRANSPORT_TEST)
+ .addCapability(NET_CAPABILITY_NOT_VCN_MANAGED)
+ .build(), bestMatchingCb, mHandlerThread.threadHandler)
+
+ val (agent1, _) = createConnectedNetworkAgent(specifier = "AGENT-1")
+ bestMatchingCb.expectAvailableThenValidatedCallbacks(agent1.network!!)
+ // Make agent1 worse so when agent2 shows up, the callback will see that.
+ agent1.sendNetworkScore(NetworkScore.Builder().setExiting(true).build())
+ bestMatchingCb.assertNoCallback(NO_CALLBACK_TIMEOUT)
+
+ val (agent2, _) = createConnectedNetworkAgent(specifier = "AGENT-2")
+ bestMatchingCb.expectAvailableDoubleValidatedCallbacks(agent2.network!!)
+
+ // Change something on agent1 to trigger capabilities changed, since the callback
+ // only cares about the best network, verify it received nothing from agent1.
+ val ncAgent1 = agent1.nc
+ ncAgent1.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED)
+ agent1.sendNetworkCapabilities(ncAgent1)
+ bestMatchingCb.assertNoCallback(NO_CALLBACK_TIMEOUT)
+
+ // Make agent1 the best network again, verify the callback now tracks agent1.
+ agent1.sendNetworkScore(NetworkScore.Builder()
+ .setExiting(false).setTransportPrimary(true).build())
+ bestMatchingCb.expectAvailableCallbacks(agent1.network!!)
+
+ // Make agent1 temporary vcn managed, which will not satisfying the request.
+ // Verify the callback switch from/to the other network accordingly.
+ ncAgent1.removeCapability(NET_CAPABILITY_NOT_VCN_MANAGED)
+ agent1.sendNetworkCapabilities(ncAgent1)
+ bestMatchingCb.expectAvailableCallbacks(agent2.network!!)
+ ncAgent1.addCapability(NET_CAPABILITY_NOT_VCN_MANAGED)
+ agent1.sendNetworkCapabilities(ncAgent1)
+ bestMatchingCb.expectAvailableDoubleValidatedCallbacks(agent1.network!!)
+
+ // Verify the callback doesn't care about agent2 disconnect.
+ agent2.unregister()
+ agentsToCleanUp.remove(agent2)
+ bestMatchingCb.assertNoCallback()
+ agent1.unregister()
+ agentsToCleanUp.remove(agent1)
+ bestMatchingCb.expectCallback<Lost>(agent1.network!!)
+
+ // tearDown() will unregister the requests and agents
+ }
}
diff --git a/tests/cts/net/src/android/net/cts/NetworkRequestTest.java b/tests/cts/net/src/android/net/cts/NetworkRequestTest.java
index bca4456..637ed26 100644
--- a/tests/cts/net/src/android/net/cts/NetworkRequestTest.java
+++ b/tests/cts/net/src/android/net/cts/NetworkRequestTest.java
@@ -30,6 +30,7 @@
import static junit.framework.Assert.fail;
+import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
@@ -456,6 +457,21 @@
}
}
+ @Test @IgnoreUpTo(Build.VERSION_CODES.R)
+ public void testGetCapabilities() {
+ final int[] netCapabilities = new int[] {
+ NET_CAPABILITY_INTERNET,
+ NET_CAPABILITY_NOT_ROAMING };
+ final NetworkCapabilities.Builder builder = NetworkCapabilities.Builder
+ .withoutDefaultCapabilities();
+ for (int capability : netCapabilities) builder.addCapability(capability);
+ final NetworkRequest nr = new NetworkRequest.Builder()
+ .clearCapabilities()
+ .setCapabilities(builder.build())
+ .build();
+ assertArrayEquals(netCapabilities, nr.getCapabilities());
+ }
+
@Test
public void testBuildRequestFromExistingRequestWithBuilder() {
assumeTrue(TestUtils.shouldTestSApis());
diff --git a/tests/unit/java/com/android/server/ConnectivityServiceTest.java b/tests/unit/java/com/android/server/ConnectivityServiceTest.java
index 308b038..be7239d 100644
--- a/tests/unit/java/com/android/server/ConnectivityServiceTest.java
+++ b/tests/unit/java/com/android/server/ConnectivityServiceTest.java
@@ -109,6 +109,8 @@
import static android.net.OemNetworkPreferences.OEM_NETWORK_PREFERENCE_OEM_PAID_NO_FALLBACK;
import static android.net.OemNetworkPreferences.OEM_NETWORK_PREFERENCE_OEM_PAID_ONLY;
import static android.net.OemNetworkPreferences.OEM_NETWORK_PREFERENCE_OEM_PRIVATE_ONLY;
+import static android.net.OemNetworkPreferences.OEM_NETWORK_PREFERENCE_TEST;
+import static android.net.OemNetworkPreferences.OEM_NETWORK_PREFERENCE_TEST_ONLY;
import static android.net.OemNetworkPreferences.OEM_NETWORK_PREFERENCE_UNINITIALIZED;
import static android.net.RouteInfo.RTN_UNREACHABLE;
import static android.net.resolv.aidl.IDnsResolverUnsolicitedEventListener.PREFIX_OPERATION_ADDED;
@@ -484,6 +486,7 @@
@Mock VpnProfileStore mVpnProfileStore;
@Mock SystemConfigManager mSystemConfigManager;
@Mock Resources mResources;
+ @Mock ProxyTracker mProxyTracker;
private ArgumentCaptor<ResolverParamsParcel> mResolverParamsParcelCaptor =
ArgumentCaptor.forClass(ResolverParamsParcel.class);
@@ -1278,10 +1281,14 @@
return mMockNetworkAgent;
}
- public void establish(LinkProperties lp, int uid, Set<UidRange> ranges, boolean validated,
- boolean hasInternet, boolean isStrictMode) throws Exception {
+ private void setOwnerAndAdminUid(int uid) throws Exception {
mNetworkCapabilities.setOwnerUid(uid);
mNetworkCapabilities.setAdministratorUids(new int[]{uid});
+ }
+
+ public void establish(LinkProperties lp, int uid, Set<UidRange> ranges, boolean validated,
+ boolean hasInternet, boolean isStrictMode) throws Exception {
+ setOwnerAndAdminUid(uid);
registerAgent(false, ranges, lp);
connect(validated, hasInternet, isStrictMode);
waitForIdle();
@@ -1636,7 +1643,7 @@
doReturn(mNetIdManager).when(deps).makeNetIdManager();
doReturn(mNetworkStack).when(deps).getNetworkStack();
doReturn(mSystemProperties).when(deps).getSystemProperties();
- doReturn(mock(ProxyTracker.class)).when(deps).makeProxyTracker(any(), any());
+ doReturn(mProxyTracker).when(deps).makeProxyTracker(any(), any());
doReturn(true).when(deps).queryUserAccess(anyInt(), any(), any());
doAnswer(inv -> {
mPolicyTracker = new WrappedMultinetworkPolicyTracker(
@@ -10380,16 +10387,23 @@
@Test
public void testVpnUidRangesUpdate() throws Exception {
- LinkProperties lp = new LinkProperties();
+ // Set up a WiFi network without proxy.
+ mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiNetworkAgent.connect(true);
+ assertNull(mService.getProxyForNetwork(null));
+ assertNull(mCm.getDefaultProxy());
+
+ final LinkProperties lp = new LinkProperties();
lp.setInterfaceName("tun0");
lp.addRoute(new RouteInfo(new IpPrefix(Inet4Address.ANY, 0), null));
lp.addRoute(new RouteInfo(new IpPrefix(Inet6Address.ANY, 0), null));
final UidRange vpnRange = PRIMARY_UIDRANGE;
- Set<UidRange> vpnRanges = Collections.singleton(vpnRange);
+ final Set<UidRange> vpnRanges = Collections.singleton(vpnRange);
mMockVpn.establish(lp, VPN_UID, vpnRanges);
assertVpnUidRangesUpdated(true, vpnRanges, VPN_UID);
+ // VPN is connected but proxy is not set, so there is no need to send proxy broadcast.
+ verify(mProxyTracker, never()).sendProxyBroadcast();
- reset(mMockNetd);
// Update to new range which is old range minus APP1, i.e. only APP2
final Set<UidRange> newRanges = new HashSet<>(Arrays.asList(
new UidRange(vpnRange.start, APP1_UID - 1),
@@ -10399,6 +10413,101 @@
assertVpnUidRangesUpdated(true, newRanges, VPN_UID);
assertVpnUidRangesUpdated(false, vpnRanges, VPN_UID);
+
+ // Uid has changed but proxy is not set, so there is no need to send proxy broadcast.
+ verify(mProxyTracker, never()).sendProxyBroadcast();
+
+ final ProxyInfo testProxyInfo = ProxyInfo.buildDirectProxy("test", 8888);
+ lp.setHttpProxy(testProxyInfo);
+ mMockVpn.sendLinkProperties(lp);
+ waitForIdle();
+ // Proxy is set, so send a proxy broadcast.
+ verify(mProxyTracker, times(1)).sendProxyBroadcast();
+ reset(mProxyTracker);
+
+ mMockVpn.setUids(vpnRanges);
+ waitForIdle();
+ // Uid has changed and proxy is already set, so send a proxy broadcast.
+ verify(mProxyTracker, times(1)).sendProxyBroadcast();
+ reset(mProxyTracker);
+
+ // Proxy is removed, send a proxy broadcast.
+ lp.setHttpProxy(null);
+ mMockVpn.sendLinkProperties(lp);
+ waitForIdle();
+ verify(mProxyTracker, times(1)).sendProxyBroadcast();
+ reset(mProxyTracker);
+
+ // Proxy is added in WiFi(default network), setDefaultProxy will be called.
+ final LinkProperties wifiLp = mCm.getLinkProperties(mWiFiNetworkAgent.getNetwork());
+ assertNotNull(wifiLp);
+ wifiLp.setHttpProxy(testProxyInfo);
+ mWiFiNetworkAgent.sendLinkProperties(wifiLp);
+ waitForIdle();
+ verify(mProxyTracker, times(1)).setDefaultProxy(eq(testProxyInfo));
+ reset(mProxyTracker);
+ }
+
+ @Test
+ public void testProxyBroadcastWillBeSentWhenVpnHasProxyAndConnects() throws Exception {
+ // Set up a WiFi network without proxy.
+ mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiNetworkAgent.connect(true);
+ assertNull(mService.getProxyForNetwork(null));
+ assertNull(mCm.getDefaultProxy());
+
+ final LinkProperties lp = new LinkProperties();
+ lp.setInterfaceName("tun0");
+ lp.addRoute(new RouteInfo(new IpPrefix(Inet4Address.ANY, 0), null));
+ lp.addRoute(new RouteInfo(new IpPrefix(Inet6Address.ANY, 0), null));
+ final ProxyInfo testProxyInfo = ProxyInfo.buildDirectProxy("test", 8888);
+ lp.setHttpProxy(testProxyInfo);
+ final UidRange vpnRange = PRIMARY_UIDRANGE;
+ final Set<UidRange> vpnRanges = Collections.singleton(vpnRange);
+ mMockVpn.setOwnerAndAdminUid(VPN_UID);
+ mMockVpn.registerAgent(false, vpnRanges, lp);
+ // In any case, the proxy broadcast won't be sent before VPN goes into CONNECTED state.
+ // Otherwise, the app that calls ConnectivityManager#getDefaultProxy() when it receives the
+ // proxy broadcast will get null.
+ verify(mProxyTracker, never()).sendProxyBroadcast();
+ mMockVpn.connect(true /* validated */, true /* hasInternet */, false /* isStrictMode */);
+ waitForIdle();
+ assertVpnUidRangesUpdated(true, vpnRanges, VPN_UID);
+ // Vpn is connected with proxy, so the proxy broadcast will be sent to inform the apps to
+ // update their proxy data.
+ verify(mProxyTracker, times(1)).sendProxyBroadcast();
+ }
+
+ @Test
+ public void testProxyBroadcastWillBeSentWhenTheProxyOfNonDefaultNetworkHasChanged()
+ throws Exception {
+ // Set up a CELLULAR network without proxy.
+ mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellNetworkAgent.connect(true);
+ assertNull(mService.getProxyForNetwork(null));
+ assertNull(mCm.getDefaultProxy());
+ // CELLULAR network should be the default network.
+ assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+
+ // Set up a WiFi network without proxy.
+ mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiNetworkAgent.connect(true);
+ assertNull(mService.getProxyForNetwork(null));
+ assertNull(mCm.getDefaultProxy());
+ // WiFi network should be the default network.
+ assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ // CELLULAR network is not the default network.
+ assertNotEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+
+ // CELLULAR network is not the system default network, but it might be a per-app default
+ // network. The proxy broadcast should be sent once its proxy has changed.
+ final LinkProperties cellularLp = new LinkProperties();
+ cellularLp.setInterfaceName(MOBILE_IFNAME);
+ final ProxyInfo testProxyInfo = ProxyInfo.buildDirectProxy("test", 8888);
+ cellularLp.setHttpProxy(testProxyInfo);
+ mCellNetworkAgent.sendLinkProperties(cellularLp);
+ waitForIdle();
+ verify(mProxyTracker, times(1)).sendProxyBroadcast();
}
@Test
@@ -10715,8 +10824,7 @@
}
@Test
- public void testOemNetworkRequestFactoryPreferenceUninitializedThrowsError()
- throws PackageManager.NameNotFoundException {
+ public void testOemNetworkRequestFactoryPreferenceUninitializedThrowsError() {
@OemNetworkPreferences.OemNetworkPreference final int prefToTest =
OEM_NETWORK_PREFERENCE_UNINITIALIZED;
@@ -10983,7 +11091,48 @@
assertThrows(UnsupportedOperationException.class,
() -> mService.setOemNetworkPreference(
createDefaultOemNetworkPreferences(networkPref),
- new TestOemListenerCallback()));
+ null));
+ }
+
+ @Test
+ public void testSetOemNetworkPreferenceFailsForTestRequestWithoutPermission() {
+ // Calling setOemNetworkPreference() with a test pref requires the permission
+ // MANAGE_TEST_NETWORKS.
+ mockHasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE, false);
+ @OemNetworkPreferences.OemNetworkPreference final int networkPref =
+ OEM_NETWORK_PREFERENCE_TEST;
+
+ // Act on ConnectivityService.setOemNetworkPreference()
+ assertThrows(SecurityException.class,
+ () -> mService.setOemNetworkPreference(
+ createDefaultOemNetworkPreferences(networkPref),
+ null));
+ }
+
+ @Test
+ public void testSetOemNetworkPreferenceFailsForInvalidTestRequest() {
+ assertSetOemNetworkPreferenceFailsForInvalidTestRequest(OEM_NETWORK_PREFERENCE_TEST);
+ }
+
+ @Test
+ public void testSetOemNetworkPreferenceFailsForInvalidTestOnlyRequest() {
+ assertSetOemNetworkPreferenceFailsForInvalidTestRequest(OEM_NETWORK_PREFERENCE_TEST_ONLY);
+ }
+
+ private void assertSetOemNetworkPreferenceFailsForInvalidTestRequest(
+ @OemNetworkPreferences.OemNetworkPreference final int oemNetworkPreferenceForTest) {
+ mockHasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE, true);
+ final String secondPackage = "does.not.matter";
+
+ // A valid test request would only have a single mapping.
+ final OemNetworkPreferences pref = new OemNetworkPreferences.Builder()
+ .addNetworkPreference(TEST_PACKAGE_NAME, oemNetworkPreferenceForTest)
+ .addNetworkPreference(secondPackage, oemNetworkPreferenceForTest)
+ .build();
+
+ // Act on ConnectivityService.setOemNetworkPreference()
+ assertThrows(IllegalArgumentException.class,
+ () -> mService.setOemNetworkPreference(pref, null));
}
private void setOemNetworkPreferenceAgentConnected(final int transportType,
@@ -11160,8 +11309,18 @@
private void setupSetOemNetworkPreferenceForPreferenceTest(
@OemNetworkPreferences.OemNetworkPreference final int networkPrefToSetup,
@NonNull final UidRangeParcel[] uidRanges,
- @NonNull final String testPackageName)
- throws Exception {
+ @NonNull final String testPackageName) throws Exception {
+ setupSetOemNetworkPreferenceForPreferenceTest(
+ networkPrefToSetup, uidRanges, testPackageName, true);
+ }
+
+ private void setupSetOemNetworkPreferenceForPreferenceTest(
+ @OemNetworkPreferences.OemNetworkPreference final int networkPrefToSetup,
+ @NonNull final UidRangeParcel[] uidRanges,
+ @NonNull final String testPackageName,
+ final boolean hasAutomotiveFeature) throws Exception {
+ mockHasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE, hasAutomotiveFeature);
+
// These tests work off a single UID therefore using 'start' is valid.
mockGetApplicationInfo(testPackageName, uidRanges[0].start);
@@ -11466,6 +11625,55 @@
}
/**
+ * Test the tracked default requests allows test requests without standard setup.
+ */
+ @Test
+ public void testSetOemNetworkPreferenceAllowsValidTestRequestWithoutChecks() throws Exception {
+ @OemNetworkPreferences.OemNetworkPreference int networkPref =
+ OEM_NETWORK_PREFERENCE_TEST;
+ validateSetOemNetworkPreferenceAllowsValidTestPrefRequest(networkPref);
+ }
+
+ /**
+ * Test the tracked default requests allows test only requests without standard setup.
+ */
+ @Test
+ public void testSetOemNetworkPreferenceAllowsValidTestOnlyRequestWithoutChecks()
+ throws Exception {
+ @OemNetworkPreferences.OemNetworkPreference int networkPref =
+ OEM_NETWORK_PREFERENCE_TEST_ONLY;
+ validateSetOemNetworkPreferenceAllowsValidTestPrefRequest(networkPref);
+ }
+
+ private void validateSetOemNetworkPreferenceAllowsValidTestPrefRequest(int networkPref)
+ throws Exception {
+ // The caller must have the MANAGE_TEST_NETWORKS permission.
+ final int testPackageUid = 123;
+ final String validTestPackageName = "does.not.matter";
+ final UidRangeParcel[] uidRanges =
+ toUidRangeStableParcels(uidRangesForUids(testPackageUid));
+ mServiceContext.setPermission(
+ Manifest.permission.MANAGE_TEST_NETWORKS, PERMISSION_GRANTED);
+
+ // Put the system into a state in which setOemNetworkPreference() would normally fail. This
+ // will confirm that a valid test request can bypass these checks.
+ mockHasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE, false);
+ mServiceContext.setPermission(
+ Manifest.permission.CONTROL_OEM_PAID_NETWORK_PREFERENCE, PERMISSION_DENIED);
+
+ // Validate the starting requests only includes the system default request.
+ assertEquals(1, mService.mDefaultNetworkRequests.size());
+
+ // Add an OEM default network request to track.
+ setupSetOemNetworkPreferenceForPreferenceTest(
+ networkPref, uidRanges, validTestPackageName,
+ false /* hasAutomotiveFeature */);
+
+ // Two requests should now exist; the system default and the test request.
+ assertEquals(2, mService.mDefaultNetworkRequests.size());
+ }
+
+ /**
* Test the tracked default requests clear previous OEM requests on setOemNetworkPreference().
*/
@Test
@@ -11477,7 +11685,7 @@
final UidRangeParcel[] uidRanges =
toUidRangeStableParcels(uidRangesForUids(testPackageUid));
- // Validate the starting requests only includes the fallback request.
+ // Validate the starting requests only includes the system default request.
assertEquals(1, mService.mDefaultNetworkRequests.size());
// Add an OEM default network request to track.