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

Remove NetworkCapabilities#combine*

Browse Source 
This is no longer used outside of tests, and can be safely
removed.

Also this family of methods is fairly confusing, as while
it's well defined for some members, many later additions
had to be written so as to dissallow some combinations when
the workings of this family of methods didn't match the
semantics of some members, making them possibly dangerous
to use and at least exhibit difficult to understand semantics.

Test: FrameworksNetTests
      m
Change-Id: Ia69c20afa16c2153839891f6e33331caa9da33ff
This commit is contained in:
Chalard Jean
2021-12-13 21:13:23 +09:00
parent bbb7ae75d1
commit bdf4f2987d
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 * 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 * 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); return mTransportTypes == (1 << transportType);
} }
private void combineTransportTypes(NetworkCapabilities nc) {
this.mTransportTypes |= nc.mTransportTypes;
}
private boolean satisfiedByTransportTypes(NetworkCapabilities nc) { private boolean satisfiedByTransportTypes(NetworkCapabilities nc) {
return ((this.mTransportTypes == 0) return ((this.mTransportTypes == 0)
|| ((this.mTransportTypes & nc.mTransportTypes) != 0)); || ((this.mTransportTypes & nc.mTransportTypes) != 0));
@@ -1292,26 +1276,6 @@ public final class NetworkCapabilities implements Parcelable {
return Arrays.equals(mAdministratorUids, nc.mAdministratorUids); 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. * Value indicating that link bandwidth is unspecified.
* @hide * @hide
@@ -1374,12 +1338,6 @@ public final class NetworkCapabilities implements Parcelable {
return mLinkDownBandwidthKbps; 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) { private boolean satisfiedByLinkBandwidths(NetworkCapabilities nc) {
return !(this.mLinkUpBandwidthKbps > nc.mLinkUpBandwidthKbps return !(this.mLinkUpBandwidthKbps > nc.mLinkUpBandwidthKbps
|| this.mLinkDownBandwidthKbps > nc.mLinkDownBandwidthKbps); || this.mLinkDownBandwidthKbps > nc.mLinkDownBandwidthKbps);
@@ -1466,13 +1424,6 @@ public final class NetworkCapabilities implements Parcelable {
return mTransportInfo; 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) { private boolean satisfiedBySpecifier(NetworkCapabilities nc) {
return mNetworkSpecifier == null || mNetworkSpecifier.canBeSatisfiedBy(nc.mNetworkSpecifier) return mNetworkSpecifier == null || mNetworkSpecifier.canBeSatisfiedBy(nc.mNetworkSpecifier)
|| nc.mNetworkSpecifier instanceof MatchAllNetworkSpecifier; || nc.mNetworkSpecifier instanceof MatchAllNetworkSpecifier;
@@ -1482,13 +1433,6 @@ public final class NetworkCapabilities implements Parcelable {
return Objects.equals(mNetworkSpecifier, nc.mNetworkSpecifier); 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) { private boolean equalsTransportInfo(NetworkCapabilities nc) {
return Objects.equals(mTransportInfo, nc.mTransportInfo); return Objects.equals(mTransportInfo, nc.mTransportInfo);
} }
@@ -1543,10 +1487,6 @@ public final class NetworkCapabilities implements Parcelable {
return mSignalStrength; return mSignalStrength;
} }
private void combineSignalStrength(NetworkCapabilities nc) {
this.mSignalStrength = Math.max(this.mSignalStrength, nc.mSignalStrength);
}
private boolean satisfiedBySignalStrength(NetworkCapabilities nc) { private boolean satisfiedBySignalStrength(NetworkCapabilities nc) {
return this.mSignalStrength <= nc.mSignalStrength; return this.mSignalStrength <= nc.mSignalStrength;
} }
@@ -1739,20 +1679,6 @@ public final class NetworkCapabilities implements Parcelable {
return false; 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. * The SSID of the network, or null if not applicable or unknown.
* <p> * <p>
@@ -1795,42 +1721,6 @@ public final class NetworkCapabilities implements Parcelable {
return mSSID == null || mSSID.equals(nc.mSSID); 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}. * 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); 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) { private boolean equalsRequestor(NetworkCapabilities nc) {
return mRequestorUid == nc.mRequestorUid return mRequestorUid == nc.mRequestorUid
&& TextUtils.equals(mRequestorPackageName, nc.mRequestorPackageName); && TextUtils.equals(mRequestorPackageName, nc.mRequestorPackageName);
@@ -2483,20 +2354,6 @@ public final class NetworkCapabilities implements Parcelable {
return false; 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 * Returns a bitmask of all the applicable redactions (based on the permissions held by the
* receiving app) to be performed on this object. * 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(netCap2.satisfiedByUids(netCap));
assertFalse(netCap.appliesToUid(650)); assertFalse(netCap.appliesToUid(650));
assertTrue(netCap2.appliesToUid(650)); assertTrue(netCap2.appliesToUid(650));
netCap.combineCapabilities(netCap2); netCap.setUids(uids);
assertTrue(netCap2.satisfiedByUids(netCap)); assertTrue(netCap2.satisfiedByUids(netCap));
assertTrue(netCap.appliesToUid(650)); assertTrue(netCap.appliesToUid(650));
assertFalse(netCap.appliesToUid(500)); 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. // Null uids satisfies everything.
netCap.setUids(null); netCap.setUids(null);
assertTrue(netCap2.satisfiedByUids(netCap)); 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 @Test
public void testSetCapabilities() { public void testSetCapabilities() {
final int[] REQUIRED_CAPABILITIES = new int[] { final int[] REQUIRED_CAPABILITIES = new int[] {
@@ -801,29 +696,6 @@ public class NetworkCapabilitiesTest {
.addTransportType(TRANSPORT_WIFI); .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 @Test
public void testSet() { public void testSet() {
NetworkCapabilities nc1 = new NetworkCapabilities(); NetworkCapabilities nc1 = new NetworkCapabilities();