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 changes I7fae1964,Ic7cc9e1d into main am: d5743b9795

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

Change-Id: Ia6de0e7d6033918e5cdf6d0a9ab76638fc0e1487
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
This commit is contained in:
Treehugger Robot 2025-03-21 03:54:29 -07:00 • committed by Automerger Merge Worker
commit aa737d2a76
3 changed files with 419 additions and 132 deletions
Download patch file Download diff file Expand all files Collapse all files

20
Tethering/tests/unit/src/com/android/networkstack/tethering/MockTetheringService.java
View file

@ -37,6 +37,7 @@ public class MockTetheringService extends TetheringService {
private final ArrayMap<String, Integer> mMockedPermissions = new ArrayMap<>();
private final ArrayMap<String, Integer> mMockedPackageUids = new ArrayMap<>();
private final Set<String> mMockedDeviceOwnerPackages = new ArraySet<>();
private final Set<String> mMockedCarrierPrivilegedPackages = new ArraySet<>();
private int mMockCallingUid;
@Override
@ -83,6 +84,11 @@ public class MockTetheringService extends TetheringService {
return mMockedDeviceOwnerPackages.contains(callerPkg);
}
@Override
boolean isCarrierPrivileged(final String callerPkg) {
return mMockedCarrierPrivilegedPackages.contains(callerPkg);
}
public Tethering getTethering() {
return mTethering;
}
@ -141,5 +147,19 @@ public class MockTetheringService extends TetheringService {
public void removeDeviceOwnerPackage(final String packageName) {
mMockedDeviceOwnerPackages.remove(packageName);
}
/**
* Add a mocked carrier privileges package
*/
public void addCarrierPrivilegedPackage(final String packageName) {
mMockedCarrierPrivilegedPackages.add(packageName);
}
/**
* Remove a mocked carrier privileges package
*/
public void removeCarrierPrivilegedPackage(final String packageName) {
mMockedCarrierPrivilegedPackages.remove(packageName);
}
}
}

297
Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringServiceTest.java
View file

@ -90,6 +90,15 @@ public final class TetheringServiceTest {
private static final int TEST_CALLER_UID = 1234;
private static final String TEST_ATTRIBUTION_TAG = null;
private static final String TEST_WRONG_PACKAGE = "wrong.package";
private static final int NO_RESULT = -1;
private static final TetheringRequest USB_REQUEST =
new TetheringRequest.Builder(TETHERING_USB).build();
private static final TetheringRequest WIFI_REQUEST_NO_CONFIG =
new TetheringRequest.Builder(TETHERING_WIFI).build();
private static final TetheringRequest WIFI_REQUEST_WITH_CONFIG =
new TetheringRequest.Builder(TETHERING_WIFI)
.setSoftApConfiguration(new SoftApConfiguration.Builder().build())
.build();
@Mock private ITetheringEventCallback mITetheringEventCallback;
@Rule public ServiceTestRule mServiceTestRule;
private Tethering mTethering;
@ -100,7 +109,7 @@ public final class TetheringServiceTest {
@Mock private AppOpsManager mAppOps;
private class TestTetheringResult extends IIntResultListener.Stub {
private int mResult = -1; // Default value that does not match any result code.
private int mResult = NO_RESULT;
@Override
public void onResult(final int resultCode) {
mResult = resultCode;
@ -115,7 +124,7 @@ public final class TetheringServiceTest {
MyResultReceiver(Handler handler) {
super(handler);
}
private int mResult = -1; // Default value that does not match any result code.
private int mResult = NO_RESULT;
@Override
protected void onReceiveResult(int resultCode, Bundle resultData) {
mResult = resultCode;
@ -206,6 +215,21 @@ public final class TetheringServiceTest {
mMockConnector.removeDeviceOwnerPackage(TEST_CALLER_PKG);
}
private void runAsCarrierPrivileged(final TestTetheringCall test) throws Exception {
mMockConnector.addCarrierPrivilegedPackage(TEST_CALLER_PKG);
runTetheringCall(test, true /* isTetheringAllowed */,
true /* isTetheringWithSoftApConfigEnabled */, new String[0]);
mMockConnector.removeCarrierPrivilegedPackage(TEST_CALLER_PKG);
}
private void runAsCarrierPrivilegedWhenCarrierPrivilegeBypassNotEnabled(
final TestTetheringCall test) throws Exception {
mMockConnector.addCarrierPrivilegedPackage(TEST_CALLER_PKG);
runTetheringCall(test, true /* isTetheringAllowed */,
false /* isTetheringWithSoftApConfigEnabled */, new String[0]);
mMockConnector.removeCarrierPrivilegedPackage(TEST_CALLER_PKG);
}
private void runTetheringCall(final TestTetheringCall test, boolean isTetheringAllowed,
boolean isTetheringWithSoftApConfigEnabled, String... permissions) throws Exception {
// Allow the test to run even if ACCESS_NETWORK_STATE was granted at the APK level
@ -381,125 +405,114 @@ public final class TetheringServiceTest {
});
}
private void runStartTethering(final TestTetheringResult result,
final TetheringRequestParcel request) throws Exception {
mTetheringConnector.startTethering(request, TEST_CALLER_PKG, TEST_ATTRIBUTION_TAG,
result);
verify(mTethering, atLeastOnce()).isTetheringWithSoftApConfigEnabled();
verify(mTethering).isTetheringSupported();
verify(mTethering).isTetheringAllowed();
verify(mTethering).startTethering(
eq(new TetheringRequest(request)), eq(TEST_CALLER_PKG), eq(result));
private void verifyStartTetheringRequestSucceeds(final TetheringRequest request,
final TestTetheringResult result) throws Exception {
mTetheringConnector.startTethering(request.getParcel(), TEST_CALLER_PKG,
TEST_ATTRIBUTION_TAG, result);
verify(mTethering).startTethering(eq(request), eq(TEST_CALLER_PKG), eq(result));
reset(mTethering);
result.assertResult(NO_RESULT);
}
private void verifyStartTetheringRequestFails(final TetheringRequest request,
final TestTetheringResult result, final int resultCode) throws Exception {
mTetheringConnector.startTethering(request.getParcel(), TEST_CALLER_PKG,
TEST_ATTRIBUTION_TAG, result);
verify(mTethering, never()).startTethering(any(), any(), any());
reset(mTethering);
result.assertResult(resultCode);
}
private void verifyStartTetheringRequestWithWrongPackageFails(final TetheringRequest request,
final TestTetheringResult result) throws Exception {
mTetheringConnector.startTethering(request.getParcel(), TEST_WRONG_PACKAGE,
TEST_ATTRIBUTION_TAG, result);
verify(mTethering, never()).startTethering(any(), any(), any());
reset(mTethering);
result.assertResult(TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
}
@Test
public void testStartTethering() throws Exception {
final TetheringRequestParcel request = new TetheringRequestParcel();
request.tetheringType = TETHERING_WIFI;
runAsNoPermission((result) -> {
mTetheringConnector.startTethering(request, TEST_CALLER_PKG, TEST_ATTRIBUTION_TAG,
result);
verify(mTethering, atLeastOnce()).isTetheringWithSoftApConfigEnabled();
result.assertResult(TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
verifyNoMoreInteractionsForTethering();
});
// Not a Wifi request - Fail
runAsDeviceOwner((result) -> {
final TetheringRequestParcel notWifi = new TetheringRequestParcel();
notWifi.tetheringType = TETHERING_USB;
mTetheringConnector.startTethering(notWifi, TEST_CALLER_PKG, TEST_ATTRIBUTION_TAG,
result);
verify(mTethering, atLeastOnce()).isTetheringWithSoftApConfigEnabled();
result.assertResult(TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
verifyNoMoreInteractionsForTethering();
});
// Request has no SoftApConfiguration - Fail
runAsDeviceOwner((result) -> {
final TetheringRequestParcel noConfig = new TetheringRequestParcel();
noConfig.tetheringType = TETHERING_WIFI;
mTetheringConnector.startTethering(noConfig, TEST_CALLER_PKG, TEST_ATTRIBUTION_TAG,
result);
verify(mTethering, atLeastOnce()).isTetheringWithSoftApConfigEnabled();
result.assertResult(TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
verifyNoMoreInteractionsForTethering();
});
// Wifi request with SoftApConfiguration - Succeed
runAsDeviceOwner((result) -> {
final TetheringRequestParcel withConfig = new TetheringRequestParcel();
withConfig.tetheringType = TETHERING_WIFI;
withConfig.softApConfig = new SoftApConfiguration.Builder().build();
mTetheringConnector.startTethering(withConfig, TEST_CALLER_PKG, TEST_ATTRIBUTION_TAG,
result);
verify(mTethering, atLeastOnce()).isTetheringWithSoftApConfigEnabled();
verify(mTethering).isTetheringSupported();
verify(mTethering).isTetheringAllowed();
verify(mTethering).startTethering(any(), any(), any());
result.assertResult(-1); // No result
verifyNoMoreInteractionsForTethering();
});
runAsDeviceOwnerWhenDeviceOwnerBypassNotEnabled((result) -> {
mTetheringConnector.startTethering(request, TEST_CALLER_PKG, TEST_ATTRIBUTION_TAG,
result);
verify(mTethering, atLeastOnce()).isTetheringWithSoftApConfigEnabled();
result.assertResult(TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
verify(mTethering).isTetherProvisioningRequired();
verifyNoMoreInteractionsForTethering();
verifyStartTetheringRequestFails(WIFI_REQUEST_NO_CONFIG, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
runAsTetherPrivileged((result) -> {
mTetheringConnector.startTethering(request, TEST_WRONG_PACKAGE,
TEST_ATTRIBUTION_TAG, result);
verify(mTethering, atLeastOnce()).isTetheringWithSoftApConfigEnabled();
verify(mTethering, never()).startTethering(
eq(new TetheringRequest(request)), eq(TEST_WRONG_PACKAGE), eq(result));
result.assertResult(TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
verifyNoMoreInteractionsForTethering();
verifyStartTetheringRequestSucceeds(WIFI_REQUEST_NO_CONFIG, result);
});
runAsTetherPrivileged((result) -> {
runStartTethering(result, request);
verifyNoMoreInteractionsForTethering();
verifyStartTetheringRequestWithWrongPackageFails(WIFI_REQUEST_NO_CONFIG, result);
});
runAsWriteSettings((result) -> {
mTetheringConnector.startTethering(request, TEST_CALLER_PKG, TEST_ATTRIBUTION_TAG,
result);
verify(mTethering, atLeastOnce()).isTetheringWithSoftApConfigEnabled();
result.assertResult(TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
verifyNoMoreInteractionsForTethering();
verifyStartTetheringRequestFails(WIFI_REQUEST_NO_CONFIG, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
runAsWriteSettingsWhenWriteSettingsAllowed((result) -> {
runStartTethering(result, request);
verify(mTethering, atLeastOnce()).isTetheringWithSoftApConfigEnabled();
verify(mTethering).isTetherProvisioningRequired();
verifyNoMoreInteractionsForTethering();
verifyStartTetheringRequestSucceeds(WIFI_REQUEST_NO_CONFIG, result);
});
runAsTetheringDisallowed((result) -> {
mTetheringConnector.startTethering(request, TEST_CALLER_PKG, TEST_ATTRIBUTION_TAG,
result);
verify(mTethering, atLeastOnce()).isTetheringWithSoftApConfigEnabled();
verify(mTethering).isTetheringSupported();
verify(mTethering).isTetheringAllowed();
result.assertResult(TETHER_ERROR_UNSUPPORTED);
verifyNoMoreInteractionsForTethering();
verifyStartTetheringRequestFails(WIFI_REQUEST_NO_CONFIG, result,
TETHER_ERROR_UNSUPPORTED);
});
// Not wifi -> fail
runAsDeviceOwner((result) -> {
verifyStartTetheringRequestFails(USB_REQUEST, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
// No SoftApConfiguration -> fail
runAsDeviceOwner((result) -> {
verifyStartTetheringRequestFails(WIFI_REQUEST_NO_CONFIG, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
// With SoftApConfiguration -> success
runAsDeviceOwner((result) -> {
verifyStartTetheringRequestSucceeds(WIFI_REQUEST_WITH_CONFIG, result);
});
runAsDeviceOwnerWhenDeviceOwnerBypassNotEnabled((result) -> {
verifyStartTetheringRequestFails(WIFI_REQUEST_WITH_CONFIG, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
// Not wifi -> fail
runAsCarrierPrivileged((result) -> {
verifyStartTetheringRequestFails(USB_REQUEST, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
// No SoftApConfiguration -> fail
runAsCarrierPrivileged((result) -> {
verifyStartTetheringRequestFails(WIFI_REQUEST_NO_CONFIG, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
// With SoftApConfiguration -> success
runAsCarrierPrivileged((result) -> {
verifyStartTetheringRequestSucceeds(WIFI_REQUEST_WITH_CONFIG, result);
});
runAsCarrierPrivilegedWhenCarrierPrivilegeBypassNotEnabled((result) -> {
verifyStartTetheringRequestFails(WIFI_REQUEST_WITH_CONFIG, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
}
@Test
public void testStartTetheringWithInterfaceSucceeds() throws Exception {
final TetheringRequestParcel request = new TetheringRequestParcel();
request.tetheringType = TETHERING_VIRTUAL;
request.interfaceName = "avf_tap_fixed";
final TetheringRequest request = new TetheringRequest.Builder(TETHERING_VIRTUAL)
.setInterfaceName("avf_tap_fixed")
.build();
runAsNetworkSettings((result) -> {
runStartTethering(result, request);
verifyStartTetheringRequestSucceeds(request, result);
verifyNoMoreInteractionsForTethering();
});
}
@ -599,84 +612,110 @@ public final class TetheringServiceTest {
});
}
private void verifyHasPermissionForStopTetheringRequest(TetheringRequest request,
private void verifyStopTetheringRequestSucceeds(final TetheringRequest request,
final TestTetheringResult result) throws Exception {
mTetheringConnector.stopTetheringRequest(request, TEST_CALLER_PKG,
TEST_ATTRIBUTION_TAG, result);
verify(mTethering).stopTetheringRequest(any(), any());
verify(mTethering).isTetheringSupported();
verify(mTethering).isTetheringAllowed();
reset(mTethering);
result.assertResult(NO_RESULT);
}
private void verifyDoesNotHavePermissionForStopTetheringRequest(TetheringRequest request,
final TestTetheringResult result) throws Exception {
private void verifyStopTetheringRequestFails(final TetheringRequest request,
final TestTetheringResult result, int resultCode) throws Exception {
mTetheringConnector.stopTetheringRequest(request, TEST_CALLER_PKG,
TEST_ATTRIBUTION_TAG, result);
verify(mTethering, never()).stopTetheringRequest(any(), any());
reset(mTethering);
result.assertResult(resultCode);
}
private void verifyStopTetheringRequestWithWrongPackageFails(final TetheringRequest request,
final TestTetheringResult result) throws Exception {
mTetheringConnector.stopTetheringRequest(request, TEST_WRONG_PACKAGE,
TEST_ATTRIBUTION_TAG, result);
verify(mTethering, never()).stopTetheringRequest(any(), any());
reset(mTethering);
result.assertResult(TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
reset(mTethering);
}
private void verifyStopTetheringRequestWithTetheringDisallowed(TetheringRequest request,
final TestTetheringResult result) throws Exception {
mTetheringConnector.stopTetheringRequest(request, TEST_CALLER_PKG,
TEST_ATTRIBUTION_TAG, result);
verify(mTethering, never()).stopTetheringRequest(any(), any());
result.assertResult(TETHER_ERROR_UNSUPPORTED);
reset(mTethering);
}
@Test
public void testStopTetheringRequest() throws Exception {
TetheringRequest request = new TetheringRequest.Builder(TETHERING_WIFI).build();
runAsNoPermission((result) -> {
verifyDoesNotHavePermissionForStopTetheringRequest(request, result);
verifyStopTetheringRequestFails(WIFI_REQUEST_NO_CONFIG, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
runAsTetherPrivileged((result) -> {
verifyHasPermissionForStopTetheringRequest(request, result);
verifyStopTetheringRequestSucceeds(WIFI_REQUEST_NO_CONFIG, result);
});
runAsTetherPrivileged((result) -> {
verifyStopTetheringRequestWithWrongPackageFails(WIFI_REQUEST_NO_CONFIG, result);
});
runAsWriteSettings((result) -> {
verifyDoesNotHavePermissionForStopTetheringRequest(request, result);
verifyStopTetheringRequestFails(WIFI_REQUEST_NO_CONFIG, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
runAsWriteSettingsWhenWriteSettingsAllowed((result) -> {
verifyHasPermissionForStopTetheringRequest(request, result);
// Note: This can't happen in practice since WRITE_SETTINGS is only allowed on V- and
// stopTetheringRequest is only allowed on B+, but we test here for completeness.
verifyStopTetheringRequestSucceeds(WIFI_REQUEST_NO_CONFIG, result);
});
runAsTetheringDisallowed((result) -> {
verifyStopTetheringRequestWithTetheringDisallowed(request, result);
verifyStopTetheringRequestFails(WIFI_REQUEST_NO_CONFIG, result,
TETHER_ERROR_UNSUPPORTED);
});
runAsNetworkSettings((result) -> {
verifyHasPermissionForStopTetheringRequest(request, result);
verifyStopTetheringRequestSucceeds(WIFI_REQUEST_NO_CONFIG, result);
});
// Not wifi -> fail
runAsDeviceOwner((result) -> {
TetheringRequest notWifi = new TetheringRequest.Builder(TETHERING_USB).build();
verifyDoesNotHavePermissionForStopTetheringRequest(notWifi, result);
verifyStopTetheringRequestFails(USB_REQUEST, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
// No config -> fail
// No SoftApConfiguration -> fail
runAsDeviceOwner((result) -> {
TetheringRequest noConfig = new TetheringRequest.Builder(TETHERING_WIFI).build();
verifyDoesNotHavePermissionForStopTetheringRequest(noConfig, result);
verifyStopTetheringRequestFails(WIFI_REQUEST_NO_CONFIG, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
// With config -> success
TetheringRequest withConfig = new TetheringRequest.Builder(TETHERING_WIFI)
.setSoftApConfiguration(new SoftApConfiguration.Builder().build())
.build();
// With SoftApConfiguration -> success
runAsDeviceOwner((result) -> {
verifyHasPermissionForStopTetheringRequest(withConfig, result);
verifyStopTetheringRequestSucceeds(WIFI_REQUEST_WITH_CONFIG, result);
});
runAsDeviceOwnerWhenDeviceOwnerBypassNotEnabled((result) -> {
verifyDoesNotHavePermissionForStopTetheringRequest(withConfig, result);
verifyStopTetheringRequestFails(WIFI_REQUEST_WITH_CONFIG, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
// Not wifi -> fail
runAsCarrierPrivileged((result) -> {
verifyStopTetheringRequestFails(USB_REQUEST, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
// No SoftApConfiguration -> fail
runAsCarrierPrivileged((result) -> {
verifyStopTetheringRequestFails(WIFI_REQUEST_NO_CONFIG, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
// With SoftApConfiguration -> success
runAsCarrierPrivileged((result) -> {
verifyStopTetheringRequestSucceeds(WIFI_REQUEST_WITH_CONFIG, result);
});
runAsCarrierPrivilegedWhenCarrierPrivilegeBypassNotEnabled((result) -> {
verifyStopTetheringRequestFails(WIFI_REQUEST_WITH_CONFIG, result,
TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION);
});
}

11
Tethering/tests/unit/src/com/android/networkstack/tethering/util/TetheringPermissionsUtilsTest.java
View file

@ -67,4 +67,15 @@ public class TetheringPermissionsUtilsTest {
when(mDevicePolicyManager.isDeviceOwnerApp(TEST_PACKAGE)).thenReturn(true);
assertThat(mTetheringPermissionsUtils.isDeviceOwner(TEST_UID, TEST_PACKAGE)).isTrue();
}
@Test
public void testHasCarrierPrivilege() {
when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(TEST_PACKAGE))
.thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS);
assertThat(mTetheringPermissionsUtils.isCarrierPrivileged(TEST_PACKAGE)).isFalse();
when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(TEST_PACKAGE))
.thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS);
assertThat(mTetheringPermissionsUtils.isCarrierPrivileged(TEST_PACKAGE)).isTrue();
}
}