joy/android_packages_modules_Connectivity
Watch
1
Fork
You've already forked android_packages_modules_Connectivity
 0
Code Issues Pull requests Projects Releases Wiki Activity

Support bringing up restricted wifi am: 7cabd32bc5

Browse source 
Original change: https://android-review.googlesource.com/c/platform/packages/modules/Connectivity/+/2917645

Change-Id: Ic0a92e04759cb49e5eacd42cdbd1f18df7bd0412
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
This commit is contained in:
Ying Xu 2024-02-07 16:01:47 +00:00 • committed by Automerger Merge Worker
commit 0a53aec0b4
3 changed files with 382 additions and 31 deletions
Download patch file Download diff file Expand all files Collapse all files

143
tests/unit/java/com/android/server/ConnectivityServiceTest.java
View file

@ -172,6 +172,7 @@ import static com.android.server.ConnectivityService.makeNflogPrefix;
import static com.android.server.ConnectivityServiceTestUtils.transportToLegacyType;
import static com.android.server.NetworkAgentWrapper.CallbackType.OnQosCallbackRegister;
import static com.android.server.NetworkAgentWrapper.CallbackType.OnQosCallbackUnregister;
import static com.android.server.connectivity.CarrierPrivilegeAuthenticator.CarrierPrivilegesLostListener;
import static com.android.testutils.Cleanup.testAndCleanup;
import static com.android.testutils.ConcurrentUtils.await;
import static com.android.testutils.ConcurrentUtils.durationOf;
@ -2053,7 +2054,9 @@ public class ConnectivityServiceTest {
@Override
public CarrierPrivilegeAuthenticator makeCarrierPrivilegeAuthenticator(
@NonNull final Context context,
@NonNull final TelephonyManager tm) {
@NonNull final TelephonyManager tm,
final boolean requestRestrictedWifiEnabled,
CarrierPrivilegesLostListener listener) {
return mDeps.isAtLeastT() ? mCarrierPrivilegeAuthenticator : null;
}
@ -2147,6 +2150,8 @@ public class ConnectivityServiceTest {
case ConnectivityFlags.NO_REMATCH_ALL_REQUESTS_ON_REGISTER:
case ConnectivityFlags.CARRIER_SERVICE_CHANGED_USE_CALLBACK:
return true;
case ConnectivityFlags.REQUEST_RESTRICTED_WIFI:
return true;
case KEY_DESTROY_FROZEN_SOCKETS_VERSION:
return true;
case DELAY_DESTROY_FROZEN_SOCKETS_VERSION:
@ -17353,6 +17358,14 @@ public class ConnectivityServiceTest {
.build();
}
private NetworkRequest getRestrictedRequestForWifiWithSubIds() {
return new NetworkRequest.Builder()
.addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
.setSubscriptionIds(Collections.singleton(Process.myUid()))
.build();
}
@Test
public void testNetworkRequestWithSubIdsWithNetworkFactoryPermission() throws Exception {
mServiceContext.setPermission(NETWORK_FACTORY, PERMISSION_GRANTED);
@ -17385,6 +17398,134 @@ public class ConnectivityServiceTest {
() -> mCm.registerNetworkCallback(getRequestWithSubIds(), new NetworkCallback()));
}
@Test
@IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
public void testCarrierConfigAppSendNetworkRequestForRestrictedWifi() throws Exception {
mServiceContext.setPermission(CONNECTIVITY_USE_RESTRICTED_NETWORKS, PERMISSION_DENIED);
doReturn(true).when(mCarrierPrivilegeAuthenticator)
.isCarrierServiceUidForNetworkCapabilities(anyInt(), any());
final PendingIntent pendingIntent = PendingIntent.getBroadcast(
mContext, 0 /* requestCode */, new Intent("a"), FLAG_IMMUTABLE);
final NetworkCallback networkCallback1 = new NetworkCallback();
final NetworkCallback networkCallback2 = new NetworkCallback();
mCm.requestNetwork(getRestrictedRequestForWifiWithSubIds(), networkCallback1);
mCm.requestNetwork(getRestrictedRequestForWifiWithSubIds(), pendingIntent);
mCm.registerNetworkCallback(getRestrictedRequestForWifiWithSubIds(), networkCallback2);
mCm.unregisterNetworkCallback(networkCallback1);
mCm.releaseNetworkRequest(pendingIntent);
mCm.unregisterNetworkCallback(networkCallback2);
}
@Test
@IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
public void testRestrictedRequestRemovedDueToCarrierPrivilegesLost() throws Exception {
mServiceContext.setPermission(CONNECTIVITY_USE_RESTRICTED_NETWORKS, PERMISSION_DENIED);
NetworkCapabilities filter = getRestrictedRequestForWifiWithSubIds().networkCapabilities;
final HandlerThread handlerThread = new HandlerThread("testRestrictedFactoryRequests");
handlerThread.start();
final MockNetworkFactory testFactory = new MockNetworkFactory(handlerThread.getLooper(),
mServiceContext, "testFactory", filter, mCsHandlerThread);
testFactory.register();
testFactory.assertRequestCountEquals(0);
doReturn(true).when(mCarrierPrivilegeAuthenticator)
.isCarrierServiceUidForNetworkCapabilities(eq(Process.myUid()), any());
final TestNetworkCallback networkCallback1 = new TestNetworkCallback();
final NetworkRequest networkrequest1 = getRestrictedRequestForWifiWithSubIds();
mCm.requestNetwork(networkrequest1, networkCallback1);
testFactory.expectRequestAdd();
testFactory.assertRequestCountEquals(1);
NetworkCapabilities nc = new NetworkCapabilities.Builder(filter)
.setAllowedUids(Set.of(Process.myUid()))
.build();
mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(), nc);
mWiFiAgent.connect(true);
networkCallback1.expectAvailableThenValidatedCallbacks(mWiFiAgent);
final NetworkAgentInfo nai = mService.getNetworkAgentInfoForNetwork(
mWiFiAgent.getNetwork());
doReturn(false).when(mCarrierPrivilegeAuthenticator)
.isCarrierServiceUidForNetworkCapabilities(eq(Process.myUid()), any());
final CarrierPrivilegesLostListener carrierPrivilegesLostListener =
mService.getCarrierPrivilegesLostListener();
carrierPrivilegesLostListener.onCarrierPrivilegesLost(Process.myUid());
waitForIdle();
testFactory.expectRequestRemove();
testFactory.assertRequestCountEquals(0);
assertTrue(nai.networkCapabilities.getAllowedUidsNoCopy().isEmpty());
networkCallback1.expect(NETWORK_CAPS_UPDATED);
networkCallback1.expect(UNAVAILABLE);
handlerThread.quitSafely();
handlerThread.join();
}
@Test
@IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
public void testRequestNotRemoved_MismatchUid() throws Exception {
mServiceContext.setPermission(CONNECTIVITY_USE_RESTRICTED_NETWORKS, PERMISSION_DENIED);
NetworkCapabilities filter = getRestrictedRequestForWifiWithSubIds().networkCapabilities;
final HandlerThread handlerThread = new HandlerThread("testRestrictedFactoryRequests");
handlerThread.start();
final MockNetworkFactory testFactory = new MockNetworkFactory(handlerThread.getLooper(),
mServiceContext, "testFactory", filter, mCsHandlerThread);
testFactory.register();
doReturn(true).when(mCarrierPrivilegeAuthenticator)
.isCarrierServiceUidForNetworkCapabilities(anyInt(), any());
final TestNetworkCallback networkCallback1 = new TestNetworkCallback();
final NetworkRequest networkrequest1 = getRestrictedRequestForWifiWithSubIds();
mCm.requestNetwork(networkrequest1, networkCallback1);
testFactory.expectRequestAdd();
testFactory.assertRequestCountEquals(1);
doReturn(false).when(mCarrierPrivilegeAuthenticator)
.isCarrierServiceUidForNetworkCapabilities(eq(Process.myUid()), any());
final CarrierPrivilegesLostListener carrierPrivilegesLostListener =
mService.getCarrierPrivilegesLostListener();
carrierPrivilegesLostListener.onCarrierPrivilegesLost(Process.myUid() + 1);
expectNoRequestChanged(testFactory);
handlerThread.quitSafely();
handlerThread.join();
}
@Test
@IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
public void testRequestNotRemoved_HasRestrictedNetworkPermission() throws Exception {
mServiceContext.setPermission(CONNECTIVITY_USE_RESTRICTED_NETWORKS, PERMISSION_GRANTED);
NetworkCapabilities filter = getRestrictedRequestForWifiWithSubIds().networkCapabilities;
final HandlerThread handlerThread = new HandlerThread("testRestrictedFactoryRequests");
handlerThread.start();
final MockNetworkFactory testFactory = new MockNetworkFactory(handlerThread.getLooper(),
mServiceContext, "testFactory", filter, mCsHandlerThread);
testFactory.register();
doReturn(true).when(mCarrierPrivilegeAuthenticator)
.isCarrierServiceUidForNetworkCapabilities(anyInt(), any());
final TestNetworkCallback networkCallback1 = new TestNetworkCallback();
final NetworkRequest networkrequest1 = getRestrictedRequestForWifiWithSubIds();
mCm.requestNetwork(networkrequest1, networkCallback1);
testFactory.expectRequestAdd();
testFactory.assertRequestCountEquals(1);
doReturn(false).when(mCarrierPrivilegeAuthenticator)
.isCarrierServiceUidForNetworkCapabilities(eq(Process.myUid()), any());
final CarrierPrivilegesLostListener carrierPrivilegesLostListener =
mService.getCarrierPrivilegesLostListener();
carrierPrivilegesLostListener.onCarrierPrivilegesLost(Process.myUid());
expectNoRequestChanged(testFactory);
handlerThread.quitSafely();
handlerThread.join();
}
@Test
public void testAllowedUids() throws Exception {
final int preferenceOrder =

54
tests/unit/java/com/android/server/connectivity/CarrierPrivilegeAuthenticatorTest.java
View file

@ -20,6 +20,7 @@ import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
import static android.telephony.TelephonyManager.ACTION_MULTI_SIM_CONFIG_CHANGED;
import static com.android.server.connectivity.CarrierPrivilegeAuthenticator.CarrierPrivilegesLostListener;
import static com.android.server.connectivity.ConnectivityFlags.CARRIER_SERVICE_CHANGED_USE_CALLBACK;
import static org.junit.Assert.assertEquals;
@ -54,10 +55,12 @@ import com.android.networkstack.apishim.TelephonyManagerShimImpl;
import com.android.networkstack.apishim.common.TelephonyManagerShim.CarrierPrivilegesListenerShim;
import com.android.networkstack.apishim.common.UnsupportedApiLevelException;
import com.android.server.connectivity.CarrierPrivilegeAuthenticator.Dependencies;
import com.android.testutils.DevSdkIgnoreRule;
import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo;
import com.android.testutils.DevSdkIgnoreRunner;
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@ -67,6 +70,7 @@ import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
/**
* Tests for CarrierPrivilegeAuthenticatorTest.
@ -77,6 +81,9 @@ import java.util.Map;
@RunWith(DevSdkIgnoreRunner.class)
@IgnoreUpTo(Build.VERSION_CODES.S_V2)
public class CarrierPrivilegeAuthenticatorTest {
@Rule
public final DevSdkIgnoreRule ignoreRule = new DevSdkIgnoreRule();
private static final int SUBSCRIPTION_COUNT = 2;
private static final int TEST_SUBSCRIPTION_ID = 1;
@ -85,7 +92,9 @@ public class CarrierPrivilegeAuthenticatorTest {
@NonNull private final TelephonyManagerShimImpl mTelephonyManagerShim;
@NonNull private final PackageManager mPackageManager;
@NonNull private TestCarrierPrivilegeAuthenticator mCarrierPrivilegeAuthenticator;
@NonNull private final CarrierPrivilegesLostListener mListener;
private final int mCarrierConfigPkgUid = 12345;
private final boolean mUseCallbacks;
private final String mTestPkg = "com.android.server.connectivity.test";
private final BroadcastReceiver mMultiSimBroadcastReceiver;
@NonNull private final HandlerThread mHandlerThread;
@ -94,7 +103,8 @@ public class CarrierPrivilegeAuthenticatorTest {
TestCarrierPrivilegeAuthenticator(@NonNull final Context c,
@NonNull final Dependencies deps,
@NonNull final TelephonyManager t) {
super(c, deps, t, mTelephonyManagerShim);
super(c, deps, t, mTelephonyManagerShim, true /* requestRestrictedWifiEnabled */,
mListener);
}
@Override
protected int getSlotIndex(int subId) {
@ -119,7 +129,9 @@ public class CarrierPrivilegeAuthenticatorTest {
mTelephonyManager = mock(TelephonyManager.class);
mTelephonyManagerShim = mock(TelephonyManagerShimImpl.class);
mPackageManager = mock(PackageManager.class);
mListener = mock(CarrierPrivilegesLostListener.class);
mHandlerThread = new HandlerThread(CarrierPrivilegeAuthenticatorTest.class.getSimpleName());
mUseCallbacks = useCallbacks;
final Dependencies deps = mock(Dependencies.class);
doReturn(useCallbacks).when(deps).isFeatureEnabled(any() /* context */,
eq(CARRIER_SERVICE_CHANGED_USE_CALLBACK));
@ -219,6 +231,18 @@ public class CarrierPrivilegeAuthenticatorTest {
mCarrierConfigPkgUid + 1, nc));
}
@Test
@IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
public void testCarrierPrivilegesLostDueToCarrierServiceUpdate() throws Exception {
final CarrierPrivilegesListenerShim l = getCarrierPrivilegesListeners().get(0);
l.onCarrierServiceChanged(null, mCarrierConfigPkgUid);
l.onCarrierServiceChanged(null, mCarrierConfigPkgUid + 1);
if (mUseCallbacks) {
verify(mListener).onCarrierPrivilegesLost(eq(mCarrierConfigPkgUid));
}
}
@Test
public void testOnCarrierPrivilegesChanged() throws Exception {
final CarrierPrivilegesListenerShim listener = getCarrierPrivilegesListeners().get(0);
@ -264,4 +288,32 @@ public class CarrierPrivilegeAuthenticatorTest {
assertFalse(mCarrierPrivilegeAuthenticator.isCarrierServiceUidForNetworkCapabilities(
mCarrierConfigPkgUid, ncBuilder.build()));
}
@Test
@IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
public void testNetworkCapabilitiesContainOneSubId() throws Exception {
final CarrierPrivilegesListenerShim listener = getCarrierPrivilegesListeners().get(0);
listener.onCarrierServiceChanged(null, mCarrierConfigPkgUid);
final NetworkCapabilities.Builder ncBuilder = new NetworkCapabilities.Builder();
ncBuilder.addTransportType(TRANSPORT_WIFI);
ncBuilder.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED);
ncBuilder.setSubscriptionIds(Set.of(0));
assertTrue(mCarrierPrivilegeAuthenticator.isCarrierServiceUidForNetworkCapabilities(
mCarrierConfigPkgUid, ncBuilder.build()));
}
@Test
@IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
public void testNetworkCapabilitiesContainTwoSubIds() throws Exception {
final CarrierPrivilegesListenerShim listener = getCarrierPrivilegesListeners().get(0);
listener.onCarrierServiceChanged(null, mCarrierConfigPkgUid);
final NetworkCapabilities.Builder ncBuilder = new NetworkCapabilities.Builder();
ncBuilder.addTransportType(TRANSPORT_WIFI);
ncBuilder.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED);
ncBuilder.setSubscriptionIds(Set.of(0, 1));
assertFalse(mCarrierPrivilegeAuthenticator.isCarrierServiceUidForNetworkCapabilities(
mCarrierConfigPkgUid, ncBuilder.build()));
}
}

7
tests/unit/java/com/android/server/connectivityservice/base/CSTest.kt
View file

@ -59,6 +59,7 @@ import com.android.net.module.util.ArrayTrackRecord
import com.android.networkstack.apishim.common.UnsupportedApiLevelException
import com.android.server.connectivity.AutomaticOnOffKeepaliveTracker
import com.android.server.connectivity.CarrierPrivilegeAuthenticator
import com.android.server.connectivity.CarrierPrivilegeAuthenticator.CarrierPrivilegesLostListener
import com.android.server.connectivity.ClatCoordinator
import com.android.server.connectivity.ConnectivityFlags
import com.android.server.connectivity.MulticastRoutingCoordinatorService
@ -66,7 +67,6 @@ import com.android.server.connectivity.MultinetworkPolicyTracker
import com.android.server.connectivity.MultinetworkPolicyTrackerTestDependencies
import com.android.server.connectivity.NetworkRequestStateStatsMetrics
import com.android.server.connectivity.ProxyTracker
import com.android.server.connectivity.RoutingCoordinatorService
import com.android.testutils.visibleOnHandlerThread
import com.android.testutils.waitForIdle
import java.util.concurrent.Executors
@ -133,6 +133,7 @@ open class CSTest {
// permissions using static contexts.
val enabledFeatures = HashMap<String, Boolean>().also {
it[ConnectivityFlags.NO_REMATCH_ALL_REQUESTS_ON_REGISTER] = true
it[ConnectivityFlags.REQUEST_RESTRICTED_WIFI] = true
it[ConnectivityService.KEY_DESTROY_FROZEN_SOCKETS_VERSION] = true
it[ConnectivityService.DELAY_DESTROY_FROZEN_SOCKETS_VERSION] = true
it[ConnectivityService.ALLOW_SYSUI_CONNECTIVITY_REPORTS] = true
@ -200,7 +201,9 @@ open class CSTest {
override fun makeCarrierPrivilegeAuthenticator(
context: Context,
tm: TelephonyManager
tm: TelephonyManager,
requestRestrictedWifiEnabled: Boolean,
listener: CarrierPrivilegesLostListener
) = if (SdkLevel.isAtLeastT()) mock<CarrierPrivilegeAuthenticator>() else null
private inner class AOOKTDeps(c: Context) : AutomaticOnOffKeepaliveTracker.Dependencies(c) {