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

Merge "Store the SubscriptionId together with the Carrier UID" into main am: 9a5aaaccf6

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

Change-Id: Ida00dc41b73a71b43f58e1746f3e10fb96b397c4
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
This commit is contained in:
Ying Xu 2024-02-20 22:17:30 +00:00 • committed by Automerger Merge Worker
commit 65ba2e69bd
3 changed files with 243 additions and 169 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -173,7 +173,6 @@ 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;
@ -488,6 +487,7 @@ import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;
@ -526,7 +526,7 @@ public class ConnectivityServiceTest {
// between a LOST callback that arrives immediately and a LOST callback that arrives after
// the linger/nascent timeout. For this, our assertions should run fast enough to leave
// less than (mService.mLingerDelayMs - TEST_CALLBACK_TIMEOUT_MS) between the time callbacks are
// supposedly fired, and the time we call expectCallback.
// supposedly fired, and the time we call expectCapChanged.
private static final int TEST_CALLBACK_TIMEOUT_MS = 250;
// Chosen to be less than TEST_CALLBACK_TIMEOUT_MS. This ensures that requests have time to
// complete before callbacks are verified.
@ -565,6 +565,7 @@ public class ConnectivityServiceTest {
private static final int TEST_PACKAGE_UID2 = 321;
private static final int TEST_PACKAGE_UID3 = 456;
private static final int NETWORK_ACTIVITY_NO_UID = -1;
private static final int TEST_SUBSCRIPTION_ID = 1;
private static final int PACKET_WAKEUP_MARK_MASK = 0x80000000;
@ -2059,7 +2060,7 @@ public class ConnectivityServiceTest {
@NonNull final Context context,
@NonNull final TelephonyManager tm,
final boolean requestRestrictedWifiEnabled,
CarrierPrivilegesLostListener listener) {
BiConsumer<Integer, Integer> listener) {
return mDeps.isAtLeastT() ? mCarrierPrivilegeAuthenticator : null;
}
@ -11486,7 +11487,7 @@ public class ConnectivityServiceTest {
doTestInterfaceClassActivityChanged(TRANSPORT_CELLULAR);
}
private void doTestOnNetworkActive_NewNetworkConnects(int transportType, boolean expectCallback)
private void doTestOnNetworkActive_NewNetworkConnects(int transportType, boolean expectCapChanged)
throws Exception {
final ConditionVariable onNetworkActiveCv = new ConditionVariable();
final ConnectivityManager.OnNetworkActiveListener listener = onNetworkActiveCv::open;
@ -11498,7 +11499,7 @@ public class ConnectivityServiceTest {
testAndCleanup(() -> {
mCm.addDefaultNetworkActiveListener(listener);
agent.connect(true);
if (expectCallback) {
if (expectCapChanged) {
assertTrue(onNetworkActiveCv.block(TEST_CALLBACK_TIMEOUT_MS));
} else {
assertFalse(onNetworkActiveCv.block(TEST_CALLBACK_TIMEOUT_MS));
@ -11513,7 +11514,7 @@ public class ConnectivityServiceTest {
@Test
public void testOnNetworkActive_NewCellConnects_CallbackCalled() throws Exception {
doTestOnNetworkActive_NewNetworkConnects(TRANSPORT_CELLULAR, true /* expectCallback */);
doTestOnNetworkActive_NewNetworkConnects(TRANSPORT_CELLULAR, true /* expectCapChanged */);
}
@Test
@ -11522,8 +11523,8 @@ public class ConnectivityServiceTest {
// networks that tracker adds the idle timer to. And the tracker does not set the idle timer
// for the ethernet network.
// So onNetworkActive is not called when the ethernet becomes the default network
final boolean expectCallback = mDeps.isAtLeastV();
doTestOnNetworkActive_NewNetworkConnects(TRANSPORT_ETHERNET, expectCallback);
final boolean expectCapChanged = mDeps.isAtLeastV();
doTestOnNetworkActive_NewNetworkConnects(TRANSPORT_ETHERNET, expectCapChanged);
}
@Test
@ -17375,7 +17376,7 @@ public class ConnectivityServiceTest {
return new NetworkRequest.Builder()
.addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
.setSubscriptionIds(Collections.singleton(Process.myUid()))
.setSubscriptionIds(Collections.singleton(TEST_SUBSCRIPTION_ID))
.build();
}
@ -17422,32 +17423,46 @@ public class ConnectivityServiceTest {
final NetworkCallback networkCallback1 = new NetworkCallback();
final NetworkCallback networkCallback2 = new NetworkCallback();
mCm.requestNetwork(getRestrictedRequestForWifiWithSubIds(), networkCallback1);
mCm.requestNetwork(getRestrictedRequestForWifiWithSubIds(), pendingIntent);
mCm.registerNetworkCallback(getRestrictedRequestForWifiWithSubIds(), networkCallback2);
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;
private void doTestNetworkRequestWithCarrierPrivilegesLost(
boolean shouldGrantRestrictedNetworkPermission,
int lostPrivilegeUid,
int lostPrivilegeSubId,
boolean expectUnavailable,
boolean expectCapChanged) throws Exception {
if (shouldGrantRestrictedNetworkPermission) {
mServiceContext.setPermission(CONNECTIVITY_USE_RESTRICTED_NETWORKS, PERMISSION_GRANTED);
} else {
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);
final TestNetworkCallback networkCallback = new TestNetworkCallback();
final NetworkRequest networkrequest =
getRestrictedRequestForWifiWithSubIds();
mCm.requestNetwork(networkrequest, networkCallback);
testFactory.expectRequestAdd();
testFactory.assertRequestCountEquals(1);
@ -17455,89 +17470,82 @@ public class ConnectivityServiceTest {
.setAllowedUids(Set.of(Process.myUid()))
.build();
mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(), nc);
mWiFiAgent.connect(true);
networkCallback1.expectAvailableThenValidatedCallbacks(mWiFiAgent);
mWiFiAgent.connect(false);
networkCallback.expectAvailableCallbacksUnvalidated(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());
doReturn(TEST_SUBSCRIPTION_ID).when(mCarrierPrivilegeAuthenticator)
.getSubIdFromNetworkCapabilities(any());
mService.onCarrierPrivilegesLost(lostPrivilegeUid, lostPrivilegeSubId);
waitForIdle();
testFactory.expectRequestRemove();
testFactory.assertRequestCountEquals(0);
assertTrue(nai.networkCapabilities.getAllowedUidsNoCopy().isEmpty());
networkCallback1.expect(NETWORK_CAPS_UPDATED);
networkCallback1.expect(UNAVAILABLE);
if (expectCapChanged) {
networkCallback.expect(NETWORK_CAPS_UPDATED);
}
if (expectUnavailable) {
networkCallback.expect(UNAVAILABLE);
}
if (!expectCapChanged && !expectUnavailable) {
networkCallback.assertNoCallback();
}
mWiFiAgent.disconnect();
waitForIdle();
if (expectUnavailable) {
testFactory.assertRequestCountEquals(0);
} else {
testFactory.assertRequestCountEquals(1);
}
handlerThread.quitSafely();
handlerThread.join();
}
@Test
@IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
public void testRestrictedRequestRemovedDueToCarrierPrivilegesLost() throws Exception {
doTestNetworkRequestWithCarrierPrivilegesLost(
false /* shouldGrantRestrictedNetworkPermission */,
Process.myUid(),
TEST_SUBSCRIPTION_ID,
true /* expectUnavailable */,
true /* expectCapChanged */);
}
@Test
@IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
public void testRequestNotRemoved_MismatchSubId() throws Exception {
doTestNetworkRequestWithCarrierPrivilegesLost(
false /* shouldGrantRestrictedNetworkPermission */,
Process.myUid(),
TEST_SUBSCRIPTION_ID + 1,
false /* expectUnavailable */,
false /* expectCapChanged */);
}
@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();
doTestNetworkRequestWithCarrierPrivilegesLost(
false /* shouldGrantRestrictedNetworkPermission */,
Process.myUid() + 1,
TEST_SUBSCRIPTION_ID,
false /* expectUnavailable */,
false /* expectCapChanged */);
}
@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();
doTestNetworkRequestWithCarrierPrivilegesLost(
true /* shouldGrantRestrictedNetworkPermission */,
Process.myUid(),
TEST_SUBSCRIPTION_ID,
false /* expectUnavailable */,
true /* expectCapChanged */);
}
@Test
public void testAllowedUids() throws Exception {

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

@ -20,7 +20,6 @@ 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;
@ -47,7 +46,6 @@ import android.net.NetworkCapabilities;
import android.net.TelephonyNetworkSpecifier;
import android.os.Build;
import android.os.HandlerThread;
import android.telephony.SubscriptionManager;
import android.telephony.TelephonyManager;
import com.android.net.module.util.CollectionUtils;
@ -71,6 +69,7 @@ import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
/**
* Tests for CarrierPrivilegeAuthenticatorTest.
@ -92,7 +91,7 @@ public class CarrierPrivilegeAuthenticatorTest {
@NonNull private final TelephonyManagerShimImpl mTelephonyManagerShim;
@NonNull private final PackageManager mPackageManager;
@NonNull private TestCarrierPrivilegeAuthenticator mCarrierPrivilegeAuthenticator;
@NonNull private final CarrierPrivilegesLostListener mListener;
@NonNull private final BiConsumer<Integer, Integer> mListener;
private final int mCarrierConfigPkgUid = 12345;
private final boolean mUseCallbacks;
private final String mTestPkg = "com.android.server.connectivity.test";
@ -107,9 +106,8 @@ public class CarrierPrivilegeAuthenticatorTest {
mListener);
}
@Override
protected int getSlotIndex(int subId) {
if (SubscriptionManager.DEFAULT_SUBSCRIPTION_ID == subId) return TEST_SUBSCRIPTION_ID;
return subId;
protected int getSubId(int slotIndex) {
return TEST_SUBSCRIPTION_ID;
}
}
@ -129,7 +127,7 @@ public class CarrierPrivilegeAuthenticatorTest {
mTelephonyManager = mock(TelephonyManager.class);
mTelephonyManagerShim = mock(TelephonyManagerShimImpl.class);
mPackageManager = mock(PackageManager.class);
mListener = mock(CarrierPrivilegesLostListener.class);
mListener = mock(BiConsumer.class);
mHandlerThread = new HandlerThread(CarrierPrivilegeAuthenticatorTest.class.getSimpleName());
mUseCallbacks = useCallbacks;
final Dependencies deps = mock(Dependencies.class);
@ -184,7 +182,7 @@ public class CarrierPrivilegeAuthenticatorTest {
final NetworkCapabilities.Builder ncBuilder = new NetworkCapabilities.Builder()
.addTransportType(TRANSPORT_CELLULAR)
.setNetworkSpecifier(new TelephonyNetworkSpecifier(0));
.setNetworkSpecifier(new TelephonyNetworkSpecifier(TEST_SUBSCRIPTION_ID));
assertTrue(mCarrierPrivilegeAuthenticator.isCarrierServiceUidForNetworkCapabilities(
mCarrierConfigPkgUid, ncBuilder.build()));
@ -220,7 +218,8 @@ public class CarrierPrivilegeAuthenticatorTest {
newListeners.get(0).onCarrierServiceChanged(null, mCarrierConfigPkgUid);
final TelephonyNetworkSpecifier specifier = new TelephonyNetworkSpecifier(0);
final TelephonyNetworkSpecifier specifier =
new TelephonyNetworkSpecifier(TEST_SUBSCRIPTION_ID);
final NetworkCapabilities nc = new NetworkCapabilities.Builder()
.addTransportType(TRANSPORT_CELLULAR)
.setNetworkSpecifier(specifier)
@ -239,7 +238,11 @@ public class CarrierPrivilegeAuthenticatorTest {
l.onCarrierServiceChanged(null, mCarrierConfigPkgUid);
l.onCarrierServiceChanged(null, mCarrierConfigPkgUid + 1);
if (mUseCallbacks) {
verify(mListener).onCarrierPrivilegesLost(eq(mCarrierConfigPkgUid));
verify(mListener).accept(eq(mCarrierConfigPkgUid), eq(TEST_SUBSCRIPTION_ID));
}
l.onCarrierServiceChanged(null, mCarrierConfigPkgUid + 2);
if (mUseCallbacks) {
verify(mListener).accept(eq(mCarrierConfigPkgUid + 1), eq(TEST_SUBSCRIPTION_ID));
}
}
@ -247,7 +250,8 @@ public class CarrierPrivilegeAuthenticatorTest {
public void testOnCarrierPrivilegesChanged() throws Exception {
final CarrierPrivilegesListenerShim listener = getCarrierPrivilegesListeners().get(0);
final TelephonyNetworkSpecifier specifier = new TelephonyNetworkSpecifier(0);
final TelephonyNetworkSpecifier specifier =
new TelephonyNetworkSpecifier(TEST_SUBSCRIPTION_ID);
final NetworkCapabilities nc = new NetworkCapabilities.Builder()
.addTransportType(TRANSPORT_CELLULAR)
.setNetworkSpecifier(specifier)
@ -275,7 +279,7 @@ public class CarrierPrivilegeAuthenticatorTest {
assertFalse(mCarrierPrivilegeAuthenticator.isCarrierServiceUidForNetworkCapabilities(
mCarrierConfigPkgUid, ncBuilder.build()));
ncBuilder.setNetworkSpecifier(new TelephonyNetworkSpecifier(0));
ncBuilder.setNetworkSpecifier(new TelephonyNetworkSpecifier(TEST_SUBSCRIPTION_ID));
assertTrue(mCarrierPrivilegeAuthenticator.isCarrierServiceUidForNetworkCapabilities(
mCarrierConfigPkgUid, ncBuilder.build()));
@ -284,7 +288,7 @@ public class CarrierPrivilegeAuthenticatorTest {
ncBuilder.setNetworkSpecifier(null);
ncBuilder.removeTransportType(TRANSPORT_CELLULAR);
ncBuilder.addTransportType(TRANSPORT_WIFI);
ncBuilder.setNetworkSpecifier(new TelephonyNetworkSpecifier(0));
ncBuilder.setNetworkSpecifier(new TelephonyNetworkSpecifier(TEST_SUBSCRIPTION_ID));
assertFalse(mCarrierPrivilegeAuthenticator.isCarrierServiceUidForNetworkCapabilities(
mCarrierConfigPkgUid, ncBuilder.build()));
}
@ -298,7 +302,7 @@ public class CarrierPrivilegeAuthenticatorTest {
final NetworkCapabilities.Builder ncBuilder = new NetworkCapabilities.Builder();
ncBuilder.addTransportType(TRANSPORT_WIFI);
ncBuilder.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED);
ncBuilder.setSubscriptionIds(Set.of(0));
ncBuilder.setSubscriptionIds(Set.of(TEST_SUBSCRIPTION_ID));
assertTrue(mCarrierPrivilegeAuthenticator.isCarrierServiceUidForNetworkCapabilities(
mCarrierConfigPkgUid, ncBuilder.build()));
}

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

@ -60,7 +60,6 @@ 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
@ -73,6 +72,7 @@ import com.android.testutils.visibleOnHandlerThread
import com.android.testutils.waitForIdle
import java.util.concurrent.Executors
import java.util.function.Consumer
import java.util.function.BiConsumer
import kotlin.test.assertNull
import kotlin.test.fail
import org.junit.After
@ -222,7 +222,7 @@ open class CSTest {
context: Context,
tm: TelephonyManager,
requestRestrictedWifiEnabled: Boolean,
listener: CarrierPrivilegesLostListener
listener: BiConsumer<Int, Int>
) = if (SdkLevel.isAtLeastT()) mock<CarrierPrivilegeAuthenticator>() else null
var satelliteNetworkFallbackUidUpdate: Consumer<Set<Int>>? = null