LineageOS/android_packages_modules_Connectivity
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge "Remove NetworkCapabilities#combine*" am: 5469fa6e59

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

Change-Id: I4b385d93b24ea85240dde589b2357543fb80c122
This commit is contained in:
Jean Chalard
2021-12-14 11:14:57 +00:00
committed by Automerger Merge Worker
parent cef564eb4f 5469fa6e59
commit d5c9c3f4ae
2 changed files with 1 additions and 272 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
framework/src/android/net/NetworkCapabilities.java
View File

@@ -787,18 +787,6 @@ public final class NetworkCapabilities implements Parcelable {
}
}
private void combineNetCapabilities(@NonNull NetworkCapabilities nc) {
final long wantedCaps = this.mNetworkCapabilities | nc.mNetworkCapabilities;
final long forbiddenCaps =
this.mForbiddenNetworkCapabilities | nc.mForbiddenNetworkCapabilities;
if ((wantedCaps & forbiddenCaps) != 0) {
throw new IllegalArgumentException(
"Cannot have the same capability in wanted and forbidden lists.");
}
this.mNetworkCapabilities = wantedCaps;
this.mForbiddenNetworkCapabilities = forbiddenCaps;
}
/**
* Convenience function that returns a human-readable description of the first mutable
* capability we find. Used to present an error message to apps that request mutable
@@ -1109,10 +1097,6 @@ public final class NetworkCapabilities implements Parcelable {
return mTransportTypes == (1 << transportType);
}
private void combineTransportTypes(NetworkCapabilities nc) {
this.mTransportTypes |= nc.mTransportTypes;
}
private boolean satisfiedByTransportTypes(NetworkCapabilities nc) {
return ((this.mTransportTypes == 0)
|| ((this.mTransportTypes & nc.mTransportTypes) != 0));
@@ -1292,26 +1276,6 @@ public final class NetworkCapabilities implements Parcelable {
return Arrays.equals(mAdministratorUids, nc.mAdministratorUids);
}
/**
* Combine the administrator UIDs of the capabilities.
*
* <p>This is only legal if either of the administrators lists are empty, or if they are equal.
* Combining administrator UIDs is only possible for combining non-overlapping sets of UIDs.
*
* <p>If both administrator lists are non-empty but not equal, they conflict with each other. In
* this case, it would not make sense to add them together.
*/
private void combineAdministratorUids(@NonNull final NetworkCapabilities nc) {
if (nc.mAdministratorUids.length == 0) return;
if (mAdministratorUids.length == 0) {
mAdministratorUids = Arrays.copyOf(nc.mAdministratorUids, nc.mAdministratorUids.length);
return;
}
if (!equalsAdministratorUids(nc)) {
throw new IllegalStateException("Can't combine two different administrator UID lists");
}
}
/**
* Value indicating that link bandwidth is unspecified.
* @hide
@@ -1374,12 +1338,6 @@ public final class NetworkCapabilities implements Parcelable {
return mLinkDownBandwidthKbps;
}
private void combineLinkBandwidths(NetworkCapabilities nc) {
this.mLinkUpBandwidthKbps =
Math.max(this.mLinkUpBandwidthKbps, nc.mLinkUpBandwidthKbps);
this.mLinkDownBandwidthKbps =
Math.max(this.mLinkDownBandwidthKbps, nc.mLinkDownBandwidthKbps);
}
private boolean satisfiedByLinkBandwidths(NetworkCapabilities nc) {
return !(this.mLinkUpBandwidthKbps > nc.mLinkUpBandwidthKbps
|| this.mLinkDownBandwidthKbps > nc.mLinkDownBandwidthKbps);
@@ -1466,13 +1424,6 @@ public final class NetworkCapabilities implements Parcelable {
return mTransportInfo;
}
private void combineSpecifiers(NetworkCapabilities nc) {
if (mNetworkSpecifier != null && !mNetworkSpecifier.equals(nc.mNetworkSpecifier)) {
throw new IllegalStateException("Can't combine two networkSpecifiers");
}
setNetworkSpecifier(nc.mNetworkSpecifier);
}
private boolean satisfiedBySpecifier(NetworkCapabilities nc) {
return mNetworkSpecifier == null || mNetworkSpecifier.canBeSatisfiedBy(nc.mNetworkSpecifier)
|| nc.mNetworkSpecifier instanceof MatchAllNetworkSpecifier;
@@ -1482,13 +1433,6 @@ public final class NetworkCapabilities implements Parcelable {
return Objects.equals(mNetworkSpecifier, nc.mNetworkSpecifier);
}
private void combineTransportInfos(NetworkCapabilities nc) {
if (mTransportInfo != null && !mTransportInfo.equals(nc.mTransportInfo)) {
throw new IllegalStateException("Can't combine two TransportInfos");
}
setTransportInfo(nc.mTransportInfo);
}
private boolean equalsTransportInfo(NetworkCapabilities nc) {
return Objects.equals(mTransportInfo, nc.mTransportInfo);
}
@@ -1543,10 +1487,6 @@ public final class NetworkCapabilities implements Parcelable {
return mSignalStrength;
}
private void combineSignalStrength(NetworkCapabilities nc) {
this.mSignalStrength = Math.max(this.mSignalStrength, nc.mSignalStrength);
}
private boolean satisfiedBySignalStrength(NetworkCapabilities nc) {
return this.mSignalStrength <= nc.mSignalStrength;
}
@@ -1739,20 +1679,6 @@ public final class NetworkCapabilities implements Parcelable {
return false;
}
/**
* Combine the UIDs this network currently applies to with the UIDs the passed
* NetworkCapabilities apply to.
* nc is assumed nonnull.
*/
private void combineUids(@NonNull NetworkCapabilities nc) {
if (null == nc.mUids || null == mUids) {
mUids = null;
return;
}
mUids.addAll(nc.mUids);
}
/**
* The SSID of the network, or null if not applicable or unknown.
* <p>
@@ -1795,42 +1721,6 @@ public final class NetworkCapabilities implements Parcelable {
return mSSID == null || mSSID.equals(nc.mSSID);
}
/**
* Combine SSIDs of the capabilities.
* <p>
* This is only legal if either the SSID of this object is null, or both SSIDs are
* equal.
* @hide
*/
private void combineSSIDs(@NonNull NetworkCapabilities nc) {
if (mSSID != null && !mSSID.equals(nc.mSSID)) {
throw new IllegalStateException("Can't combine two SSIDs");
}
setSSID(nc.mSSID);
}
/**
* Combine a set of Capabilities to this one. Useful for coming up with the complete set.
* <p>
* Note that this method may break an invariant of having a particular capability in either
* wanted or forbidden lists but never in both. Requests that have the same capability in
* both lists will never be satisfied.
* @hide
*/
public void combineCapabilities(@NonNull NetworkCapabilities nc) {
combineNetCapabilities(nc);
combineTransportTypes(nc);
combineLinkBandwidths(nc);
combineSpecifiers(nc);
combineTransportInfos(nc);
combineSignalStrength(nc);
combineUids(nc);
combineSSIDs(nc);
combineRequestor(nc);
combineAdministratorUids(nc);
combineSubscriptionIds(nc);
}
/**
* Check if our requirements are satisfied by the given {@code NetworkCapabilities}.
*
@@ -2406,25 +2296,6 @@ public final class NetworkCapabilities implements Parcelable {
return TextUtils.equals(mRequestorPackageName, nc.mRequestorPackageName);
}
/**
* Combine requestor info of the capabilities.
* <p>
* This is only legal if either the requestor info of this object is reset, or both info are
* equal.
* nc is assumed nonnull.
*/
private void combineRequestor(@NonNull NetworkCapabilities nc) {
if (mRequestorUid != Process.INVALID_UID && mRequestorUid != nc.mOwnerUid) {
throw new IllegalStateException("Can't combine two uids");
}
if (mRequestorPackageName != null
&& !mRequestorPackageName.equals(nc.mRequestorPackageName)) {
throw new IllegalStateException("Can't combine two package names");
}
setRequestorUid(nc.mRequestorUid);
setRequestorPackageName(nc.mRequestorPackageName);
}
private boolean equalsRequestor(NetworkCapabilities nc) {
return mRequestorUid == nc.mRequestorUid
&& TextUtils.equals(mRequestorPackageName, nc.mRequestorPackageName);
@@ -2483,20 +2354,6 @@ public final class NetworkCapabilities implements Parcelable {
return false;
}
/**
* Combine subscription ID set of the capabilities.
*
* <p>This is only legal if the subscription Ids are equal.
*
* <p>If both subscription IDs are not equal, they belong to different subscription
* (or no subscription). In this case, it would not make sense to add them together.
*/
private void combineSubscriptionIds(@NonNull NetworkCapabilities nc) {
if (!Objects.equals(mSubIds, nc.mSubIds)) {
throw new IllegalStateException("Can't combine two subscription ID sets");
}
}
/**
* Returns a bitmask of all the applicable redactions (based on the permissions held by the
* receiving app) to be performed on this object.

130
tests/common/java/android/net/NetworkCapabilitiesTest.java
View File

@@ -285,19 +285,11 @@ public class NetworkCapabilitiesTest {
assertFalse(netCap2.satisfiedByUids(netCap));
assertFalse(netCap.appliesToUid(650));
assertTrue(netCap2.appliesToUid(650));
netCap.combineCapabilities(netCap2);
netCap.setUids(uids);
assertTrue(netCap2.satisfiedByUids(netCap));
assertTrue(netCap.appliesToUid(650));
assertFalse(netCap.appliesToUid(500));
assertTrue(new NetworkCapabilities().satisfiedByUids(netCap));
netCap.combineCapabilities(new NetworkCapabilities());
assertTrue(netCap.appliesToUid(500));
assertTrue(netCap.appliesToUidRange(new UidRange(1, 100000)));
assertFalse(netCap2.appliesToUid(500));
assertFalse(netCap2.appliesToUidRange(new UidRange(1, 100000)));
assertTrue(new NetworkCapabilities().satisfiedByUids(netCap));
// Null uids satisfies everything.
netCap.setUids(null);
assertTrue(netCap2.satisfiedByUids(netCap));
@@ -589,103 +581,6 @@ public class NetworkCapabilitiesTest {
}
}
@Test
public void testCombineCapabilities() {
NetworkCapabilities nc1 = new NetworkCapabilities();
NetworkCapabilities nc2 = new NetworkCapabilities();
if (isAtLeastS()) {
nc1.addForbiddenCapability(NET_CAPABILITY_CAPTIVE_PORTAL);
}
nc1.addCapability(NET_CAPABILITY_NOT_ROAMING);
assertNotEquals(nc1, nc2);
nc2.combineCapabilities(nc1);
assertEquals(nc1, nc2);
assertTrue(nc2.hasCapability(NET_CAPABILITY_NOT_ROAMING));
if (isAtLeastS()) {
assertTrue(nc2.hasForbiddenCapability(NET_CAPABILITY_CAPTIVE_PORTAL));
}
if (isAtLeastS()) {
// This will effectively move NOT_ROAMING capability from required to forbidden for nc1.
nc1.addForbiddenCapability(NET_CAPABILITY_NOT_ROAMING);
// It is not allowed to have the same capability in both wanted and forbidden list.
assertThrows(IllegalArgumentException.class, () -> nc2.combineCapabilities(nc1));
// Remove forbidden capability to continue other tests.
nc1.removeForbiddenCapability(NET_CAPABILITY_NOT_ROAMING);
}
nc1.setSSID(TEST_SSID);
nc2.combineCapabilities(nc1);
if (isAtLeastR()) {
assertTrue(TEST_SSID.equals(nc2.getSsid()));
}
// Because they now have the same SSID, the following call should not throw
nc2.combineCapabilities(nc1);
nc1.setSSID(DIFFERENT_TEST_SSID);
try {
nc2.combineCapabilities(nc1);
fail("Expected IllegalStateException: can't combine different SSIDs");
} catch (IllegalStateException expected) {}
nc1.setSSID(TEST_SSID);
if (isAtLeastS()) {
nc1.setUids(uidRanges(10, 13));
assertNotEquals(nc1, nc2);
nc2.combineCapabilities(nc1); // Everything + 10~13 is still everything.
assertNotEquals(nc1, nc2);
nc1.combineCapabilities(nc2); // 10~13 + everything is everything.
assertEquals(nc1, nc2);
nc1.setUids(uidRanges(10, 13));
nc2.setUids(uidRanges(20, 23));
assertNotEquals(nc1, nc2);
nc1.combineCapabilities(nc2);
assertTrue(nc1.appliesToUid(12));
assertFalse(nc2.appliesToUid(12));
assertTrue(nc1.appliesToUid(22));
assertTrue(nc2.appliesToUid(22));
// Verify the subscription id list can be combined only when they are equal.
nc1.setSubscriptionIds(Set.of(TEST_SUBID1, TEST_SUBID2));
nc2.setSubscriptionIds(Set.of(TEST_SUBID2));
assertThrows(IllegalStateException.class, () -> nc2.combineCapabilities(nc1));
nc2.setSubscriptionIds(Set.of());
assertThrows(IllegalStateException.class, () -> nc2.combineCapabilities(nc1));
nc2.setSubscriptionIds(Set.of(TEST_SUBID2, TEST_SUBID1));
nc2.combineCapabilities(nc1);
assertEquals(Set.of(TEST_SUBID2, TEST_SUBID1), nc2.getSubscriptionIds());
}
}
@Test @IgnoreUpTo(Build.VERSION_CODES.Q)
public void testCombineCapabilities_AdministratorUids() {
final NetworkCapabilities nc1 = new NetworkCapabilities();
final NetworkCapabilities nc2 = new NetworkCapabilities();
final int[] adminUids = {3, 6, 12};
nc1.setAdministratorUids(adminUids);
nc2.combineCapabilities(nc1);
assertTrue(nc2.equalsAdministratorUids(nc1));
assertArrayEquals(nc2.getAdministratorUids(), adminUids);
final int[] adminUidsOtherOrder = {3, 12, 6};
nc1.setAdministratorUids(adminUidsOtherOrder);
assertTrue(nc2.equalsAdministratorUids(nc1));
final int[] adminUids2 = {11, 1, 12, 3, 6};
nc1.setAdministratorUids(adminUids2);
assertFalse(nc2.equalsAdministratorUids(nc1));
assertFalse(Arrays.equals(nc2.getAdministratorUids(), adminUids2));
try {
nc2.combineCapabilities(nc1);
fail("Shouldn't be able to combine different lists of admin UIDs");
} catch (IllegalStateException expected) { }
}
@Test
public void testSetCapabilities() {
final int[] REQUIRED_CAPABILITIES = new int[] {
@@ -801,29 +696,6 @@ public class NetworkCapabilitiesTest {
.addTransportType(TRANSPORT_WIFI);
}
@Test
public void testCombineTransportInfo() {
NetworkCapabilities nc1 = new NetworkCapabilities();
nc1.setTransportInfo(new TestTransportInfo());
NetworkCapabilities nc2 = new NetworkCapabilities();
// new TransportInfo so that object is not #equals to nc1's TransportInfo (that's where
// combine fails)
nc2.setTransportInfo(new TestTransportInfo());
try {
nc1.combineCapabilities(nc2);
fail("Should not be able to combine NetworkCabilities which contain TransportInfos");
} catch (IllegalStateException expected) {
// empty
}
// verify that can combine with identical TransportInfo objects
NetworkCapabilities nc3 = new NetworkCapabilities();
nc3.setTransportInfo(nc1.getTransportInfo());
nc1.combineCapabilities(nc3);
}
@Test
public void testSet() {
NetworkCapabilities nc1 = new NetworkCapabilities();