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 from topic "revert-1626206-replaceUidRange-MSYTKFNGUE" am: 2576238aec am: 37cb1551a0

Browse source 
Original change: https://android-review.googlesource.com/c/platform/frameworks/base/+/1645768

Change-Id: Ic7f04ad2af282654f5a57c9e25e8dad9b78f114c
This commit is contained in:
Anthony Stange 2021-03-18 17:26:18 +00:00 • committed by Automerger Merge Worker
commit a2c19b719d
9 changed files with 185 additions and 308 deletions
Download patch file Download diff file Expand all files Collapse all files

9
framework/api/module-lib-current.txt
View file

@ -36,18 +36,9 @@ package android.net {
} }
public final class NetworkCapabilities implements android.os.Parcelable { public final class NetworkCapabilities implements android.os.Parcelable {
method @Nullable public java.util.Set<android.util.Range<java.lang.Integer>> getUids();
field public static final int TRANSPORT_TEST = 7; // 0x7 field public static final int TRANSPORT_TEST = 7; // 0x7
} }
public static final class NetworkCapabilities.Builder {
method @NonNull public android.net.NetworkCapabilities.Builder setUids(@Nullable java.util.Set<android.util.Range<java.lang.Integer>>);
}
public static class NetworkRequest.Builder {
method @NonNull public android.net.NetworkRequest.Builder setUids(@Nullable java.util.Set<android.util.Range<java.lang.Integer>>);
}
public class ParseException extends java.lang.RuntimeException { public class ParseException extends java.lang.RuntimeException {
ctor public ParseException(@NonNull String); ctor public ParseException(@NonNull String);
ctor public ParseException(@NonNull String, @NonNull Throwable); ctor public ParseException(@NonNull String, @NonNull Throwable);

52
framework/src/android/net/NetworkCapabilities.java
View file

@ -22,7 +22,6 @@ import android.annotation.IntDef;
import android.annotation.NonNull; import android.annotation.NonNull;
import android.annotation.Nullable; import android.annotation.Nullable;
import android.annotation.RequiresPermission; import android.annotation.RequiresPermission;
import android.annotation.SuppressLint;
import android.annotation.SystemApi; import android.annotation.SystemApi;
import android.compat.annotation.UnsupportedAppUsage; import android.compat.annotation.UnsupportedAppUsage;
import android.net.ConnectivityManager.NetworkCallback; import android.net.ConnectivityManager.NetworkCallback;
@ -33,7 +32,6 @@ import android.os.Parcelable;
import android.os.Process; import android.os.Process;
import android.text.TextUtils; import android.text.TextUtils;
import android.util.ArraySet; import android.util.ArraySet;
import android.util.Range;
import android.util.proto.ProtoOutputStream; import android.util.proto.ProtoOutputStream;
import com.android.internal.annotations.VisibleForTesting; import com.android.internal.annotations.VisibleForTesting;
@ -155,7 +153,7 @@ public final class NetworkCapabilities implements Parcelable {
setTransportInfo(null); setTransportInfo(null);
} }
mSignalStrength = nc.mSignalStrength; mSignalStrength = nc.mSignalStrength;
mUids = (nc.mUids == null) ? null : new ArraySet<>(nc.mUids); setUids(nc.mUids); // Will make the defensive copy
setAdministratorUids(nc.getAdministratorUids()); setAdministratorUids(nc.getAdministratorUids());
mOwnerUid = nc.mOwnerUid; mOwnerUid = nc.mOwnerUid;
mUnwantedNetworkCapabilities = nc.mUnwantedNetworkCapabilities; mUnwantedNetworkCapabilities = nc.mUnwantedNetworkCapabilities;
@ -1460,8 +1458,9 @@ public final class NetworkCapabilities implements Parcelable {
* @hide * @hide
*/ */
public @NonNull NetworkCapabilities setSingleUid(int uid) { public @NonNull NetworkCapabilities setSingleUid(int uid) {
mUids = new ArraySet<>(1); final ArraySet<UidRange> identity = new ArraySet<>(1);
mUids.add(new UidRange(uid, uid)); identity.add(new UidRange(uid, uid));
setUids(identity);
return this; return this;
} }
@ -1470,34 +1469,22 @@ public final class NetworkCapabilities implements Parcelable {
* This makes a copy of the set so that callers can't modify it after the call. * This makes a copy of the set so that callers can't modify it after the call.
* @hide * @hide
*/ */
public @NonNull NetworkCapabilities setUids(@Nullable Set<Range<Integer>> uids) { public @NonNull NetworkCapabilities setUids(Set<UidRange> uids) {
mUids = UidRange.fromIntRanges(uids); if (null == uids) {
mUids = null;
} else {
mUids = new ArraySet<>(uids);
}
return this; return this;
} }
/** /**
* Get the list of UIDs this network applies to. * Get the list of UIDs this network applies to.
* This returns a copy of the set so that callers can't modify the original object. * This returns a copy of the set so that callers can't modify the original object.
*
* @return the list of UIDs this network applies to. If {@code null}, then the network applies
* to all UIDs.
* @hide * @hide
*/ */
@SystemApi(client = SystemApi.Client.MODULE_LIBRARIES) public @Nullable Set<UidRange> getUids() {
@SuppressLint("NullableCollection") return null == mUids ? null : new ArraySet<>(mUids);
public @Nullable Set<Range<Integer>> getUids() {
return UidRange.toIntRanges(mUids);
}
/**
* Get the list of UIDs this network applies to.
* This returns a copy of the set so that callers can't modify the original object.
* @hide
*/
public @Nullable Set<UidRange> getUidRanges() {
if (mUids == null) return null;
return new ArraySet<>(mUids);
} }
/** /**
@ -2667,21 +2654,6 @@ public final class NetworkCapabilities implements Parcelable {
return this; return this;
} }
/**
* Set the list of UIDs this network applies to.
*
* @param uids the list of UIDs this network applies to, or {@code null} if this network
* applies to all UIDs.
* @return this builder
* @hide
*/
@NonNull
@SystemApi(client = SystemApi.Client.MODULE_LIBRARIES)
public Builder setUids(@Nullable Set<Range<Integer>> uids) {
mCaps.setUids(uids);
return this;
}
/** /**
* Builds the instance of the capabilities. * Builds the instance of the capabilities.
* *

9
framework/src/android/net/NetworkRequest.java
View file

@ -36,7 +36,6 @@ import static android.net.NetworkCapabilities.TRANSPORT_TEST;
import android.annotation.NonNull; import android.annotation.NonNull;
import android.annotation.Nullable; import android.annotation.Nullable;
import android.annotation.RequiresPermission; import android.annotation.RequiresPermission;
import android.annotation.SuppressLint;
import android.annotation.SystemApi; import android.annotation.SystemApi;
import android.compat.annotation.UnsupportedAppUsage; import android.compat.annotation.UnsupportedAppUsage;
import android.net.NetworkCapabilities.NetCapability; import android.net.NetworkCapabilities.NetCapability;
@ -46,7 +45,6 @@ import android.os.Parcel;
import android.os.Parcelable; import android.os.Parcelable;
import android.os.Process; import android.os.Process;
import android.text.TextUtils; import android.text.TextUtils;
import android.util.Range;
import android.util.proto.ProtoOutputStream; import android.util.proto.ProtoOutputStream;
import java.util.Arrays; import java.util.Arrays;
@ -279,14 +277,11 @@ public class NetworkRequest implements Parcelable {
* Set the watched UIDs for this request. This will be reset and wiped out unless * Set the watched UIDs for this request. This will be reset and wiped out unless
* the calling app holds the CHANGE_NETWORK_STATE permission. * the calling app holds the CHANGE_NETWORK_STATE permission.
* *
* @param uids The watched UIDs as a set of {@code Range<Integer>}, or null for everything. * @param uids The watched UIDs as a set of UidRanges, or null for everything.
* @return The builder to facilitate chaining. * @return The builder to facilitate chaining.
* @hide * @hide
*/ */
@NonNull public Builder setUids(Set<UidRange> uids) {
@SystemApi(client = SystemApi.Client.MODULE_LIBRARIES)
@SuppressLint("MissingGetterMatchingBuilder")
public Builder setUids(@Nullable Set<Range<Integer>> uids) {
mNetworkCapabilities.setUids(uids); mNetworkCapabilities.setUids(uids);
return this; return this;
} }

31
framework/src/android/net/UidRange.java
View file

@ -20,11 +20,8 @@ import android.annotation.Nullable;
import android.os.Parcel; import android.os.Parcel;
import android.os.Parcelable; import android.os.Parcelable;
import android.os.UserHandle; import android.os.UserHandle;
import android.util.ArraySet;
import android.util.Range;
import java.util.Collection; import java.util.Collection;
import java.util.Set;
/** /**
* An inclusive range of UIDs. * An inclusive range of UIDs.
@ -152,32 +149,4 @@ public final class UidRange implements Parcelable {
} }
return false; return false;
} }
/**
* Convert a set of {@code Range<Integer>} to a set of {@link UidRange}.
*/
@Nullable
public static ArraySet<UidRange> fromIntRanges(@Nullable Set<Range<Integer>> ranges) {
if (null == ranges) return null;
final ArraySet<UidRange> uids = new ArraySet<>();
for (Range<Integer> range : ranges) {
uids.add(new UidRange(range.getLower(), range.getUpper()));
}
return uids;
}
/**
* Convert a set of {@link UidRange} to a set of {@code Range<Integer>}.
*/
@Nullable
public static ArraySet<Range<Integer>> toIntRanges(@Nullable Set<UidRange> ranges) {
if (null == ranges) return null;
final ArraySet<Range<Integer>> uids = new ArraySet<>();
for (UidRange range : ranges) {
uids.add(new Range<Integer>(range.start, range.stop));
}
return uids;
}
} }

22
services/core/java/com/android/server/ConnectivityService.java
View file

@ -1339,7 +1339,7 @@ public class ConnectivityService extends IConnectivityManager.Stub
netCap.addCapability(NET_CAPABILITY_INTERNET); netCap.addCapability(NET_CAPABILITY_INTERNET);
netCap.addCapability(NET_CAPABILITY_NOT_VCN_MANAGED); netCap.addCapability(NET_CAPABILITY_NOT_VCN_MANAGED);
netCap.removeCapability(NET_CAPABILITY_NOT_VPN); netCap.removeCapability(NET_CAPABILITY_NOT_VPN);
netCap.setUids(UidRange.toIntRanges(Collections.singleton(uids))); netCap.setUids(Collections.singleton(uids));
return netCap; return netCap;
} }
@ -2860,7 +2860,7 @@ public class ConnectivityService extends IConnectivityManager.Stub
if (0 == defaultRequest.mRequests.size()) { if (0 == defaultRequest.mRequests.size()) {
pw.println("none, this should never occur."); pw.println("none, this should never occur.");
} else { } else {
pw.println(defaultRequest.mRequests.get(0).networkCapabilities.getUidRanges()); pw.println(defaultRequest.mRequests.get(0).networkCapabilities.getUids());
} }
pw.decreaseIndent(); pw.decreaseIndent();
pw.decreaseIndent(); pw.decreaseIndent();
@ -5275,8 +5275,9 @@ public class ConnectivityService extends IConnectivityManager.Stub
private Set<UidRange> getUids() { private Set<UidRange> getUids() {
// networkCapabilities.getUids() returns a defensive copy. // networkCapabilities.getUids() returns a defensive copy.
// multilayer requests will all have the same uids so return the first one. // multilayer requests will all have the same uids so return the first one.
final Set<UidRange> uids = mRequests.get(0).networkCapabilities.getUidRanges(); final Set<UidRange> uids = null == mRequests.get(0).networkCapabilities.getUids()
return (null == uids) ? new ArraySet<>() : uids; ? new ArraySet<>() : mRequests.get(0).networkCapabilities.getUids();
return uids;
} }
NetworkRequestInfo(@NonNull final NetworkRequest r, @Nullable final PendingIntent pi, NetworkRequestInfo(@NonNull final NetworkRequest r, @Nullable final PendingIntent pi,
@ -6082,7 +6083,7 @@ public class ConnectivityService extends IConnectivityManager.Stub
for (final NetworkRequestInfo nri : mDefaultNetworkRequests) { for (final NetworkRequestInfo nri : mDefaultNetworkRequests) {
// Currently, all network requests will have the same uids therefore checking the first // Currently, all network requests will have the same uids therefore checking the first
// one is sufficient. If/when uids are tracked at the nri level, this can change. // one is sufficient. If/when uids are tracked at the nri level, this can change.
final Set<UidRange> uids = nri.mRequests.get(0).networkCapabilities.getUidRanges(); final Set<UidRange> uids = nri.mRequests.get(0).networkCapabilities.getUids();
if (null == uids) { if (null == uids) {
continue; continue;
} }
@ -6523,7 +6524,7 @@ public class ConnectivityService extends IConnectivityManager.Stub
return; return;
} }
final Set<UidRange> ranges = nai.networkCapabilities.getUidRanges(); final Set<UidRange> ranges = nai.networkCapabilities.getUids();
final int vpnAppUid = nai.networkCapabilities.getOwnerUid(); final int vpnAppUid = nai.networkCapabilities.getOwnerUid();
// TODO: this create a window of opportunity for apps to receive traffic between the time // TODO: this create a window of opportunity for apps to receive traffic between the time
// when the old rules are removed and the time when new rules are added. To fix this, // when the old rules are removed and the time when new rules are added. To fix this,
@ -6888,8 +6889,8 @@ public class ConnectivityService extends IConnectivityManager.Stub
private void updateUids(NetworkAgentInfo nai, NetworkCapabilities prevNc, private void updateUids(NetworkAgentInfo nai, NetworkCapabilities prevNc,
NetworkCapabilities newNc) { NetworkCapabilities newNc) {
Set<UidRange> prevRanges = null == prevNc ? null : prevNc.getUidRanges(); Set<UidRange> prevRanges = null == prevNc ? null : prevNc.getUids();
Set<UidRange> newRanges = null == newNc ? null : newNc.getUidRanges(); Set<UidRange> newRanges = null == newNc ? null : newNc.getUids();
if (null == prevRanges) prevRanges = new ArraySet<>(); if (null == prevRanges) prevRanges = new ArraySet<>();
if (null == newRanges) newRanges = new ArraySet<>(); if (null == newRanges) newRanges = new ArraySet<>();
final Set<UidRange> prevRangesCopy = new ArraySet<>(prevRanges); final Set<UidRange> prevRangesCopy = new ArraySet<>(prevRanges);
@ -9220,7 +9221,7 @@ public class ConnectivityService extends IConnectivityManager.Stub
final ArrayList<NetworkRequest> nrs = new ArrayList<>(); final ArrayList<NetworkRequest> nrs = new ArrayList<>();
nrs.add(createNetworkRequest(NetworkRequest.Type.REQUEST, pref.capabilities)); nrs.add(createNetworkRequest(NetworkRequest.Type.REQUEST, pref.capabilities));
nrs.add(createDefaultRequest()); nrs.add(createDefaultRequest());
setNetworkRequestUids(nrs, UidRange.fromIntRanges(pref.capabilities.getUids())); setNetworkRequestUids(nrs, pref.capabilities.getUids());
final NetworkRequestInfo nri = new NetworkRequestInfo(nrs); final NetworkRequestInfo nri = new NetworkRequestInfo(nrs);
result.add(nri); result.add(nri);
} }
@ -9436,8 +9437,9 @@ public class ConnectivityService extends IConnectivityManager.Stub
private static void setNetworkRequestUids(@NonNull final List<NetworkRequest> requests, private static void setNetworkRequestUids(@NonNull final List<NetworkRequest> requests,
@NonNull final Set<UidRange> uids) { @NonNull final Set<UidRange> uids) {
final Set<UidRange> ranges = new ArraySet<>(uids);
for (final NetworkRequest req : requests) { for (final NetworkRequest req : requests) {
req.networkCapabilities.setUids(UidRange.toIntRanges(uids)); req.networkCapabilities.setUids(ranges);
} }
} }

173
tests/net/common/java/android/net/NetworkCapabilitiesTest.java
View file

@ -69,7 +69,6 @@ import android.net.wifi.aware.WifiAwareNetworkSpecifier;
import android.os.Build; import android.os.Build;
import android.test.suitebuilder.annotation.SmallTest; import android.test.suitebuilder.annotation.SmallTest;
import android.util.ArraySet; import android.util.ArraySet;
import android.util.Range;
import androidx.test.runner.AndroidJUnit4; import androidx.test.runner.AndroidJUnit4;
@ -241,93 +240,72 @@ public class NetworkCapabilitiesTest {
@Test @Test
public void testSetUids() { public void testSetUids() {
final NetworkCapabilities netCap = new NetworkCapabilities(); final NetworkCapabilities netCap = new NetworkCapabilities();
// Null uids match all UIDs final Set<UidRange> uids = new ArraySet<>();
netCap.setUids(null); uids.add(new UidRange(50, 100));
assertTrue(netCap.appliesToUid(10)); uids.add(new UidRange(3000, 4000));
assertTrue(netCap.appliesToUid(200)); netCap.setUids(uids);
assertTrue(netCap.appliesToUid(50));
assertTrue(netCap.appliesToUid(80));
assertTrue(netCap.appliesToUid(100));
assertTrue(netCap.appliesToUid(3000)); assertTrue(netCap.appliesToUid(3000));
assertTrue(netCap.appliesToUid(10010)); assertTrue(netCap.appliesToUid(3001));
assertFalse(netCap.appliesToUid(10));
assertFalse(netCap.appliesToUid(25));
assertFalse(netCap.appliesToUid(49));
assertFalse(netCap.appliesToUid(101));
assertFalse(netCap.appliesToUid(2000));
assertFalse(netCap.appliesToUid(100000));
assertTrue(netCap.appliesToUidRange(new UidRange(50, 100))); assertTrue(netCap.appliesToUidRange(new UidRange(50, 100)));
assertTrue(netCap.appliesToUidRange(new UidRange(70, 72))); assertTrue(netCap.appliesToUidRange(new UidRange(70, 72)));
assertTrue(netCap.appliesToUidRange(new UidRange(3500, 3912))); assertTrue(netCap.appliesToUidRange(new UidRange(3500, 3912)));
assertFalse(netCap.appliesToUidRange(new UidRange(1, 100)));
assertFalse(netCap.appliesToUidRange(new UidRange(49, 100)));
assertFalse(netCap.appliesToUidRange(new UidRange(1, 10)));
assertFalse(netCap.appliesToUidRange(new UidRange(60, 101)));
assertFalse(netCap.appliesToUidRange(new UidRange(60, 3400)));
NetworkCapabilities netCap2 = new NetworkCapabilities();
// A new netcap object has null UIDs, so anything will satisfy it.
assertTrue(netCap2.satisfiedByUids(netCap));
// Still not equal though.
assertFalse(netCap2.equalsUids(netCap));
netCap2.setUids(uids);
assertTrue(netCap2.satisfiedByUids(netCap));
assertTrue(netCap.equalsUids(netCap2));
assertTrue(netCap2.equalsUids(netCap));
uids.add(new UidRange(600, 700));
netCap2.setUids(uids);
assertFalse(netCap2.satisfiedByUids(netCap));
assertFalse(netCap.appliesToUid(650));
assertTrue(netCap2.appliesToUid(650));
netCap.combineCapabilities(netCap2);
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))); assertTrue(netCap.appliesToUidRange(new UidRange(1, 100000)));
assertFalse(netCap2.appliesToUid(500));
if (isAtLeastS()) { assertFalse(netCap2.appliesToUidRange(new UidRange(1, 100000)));
final Set<Range<Integer>> uids = new ArraySet<>(); assertTrue(new NetworkCapabilities().satisfiedByUids(netCap));
uids.add(uidRange(50, 100));
uids.add(uidRange(3000, 4000));
netCap.setUids(uids);
assertTrue(netCap.appliesToUid(50));
assertTrue(netCap.appliesToUid(80));
assertTrue(netCap.appliesToUid(100));
assertTrue(netCap.appliesToUid(3000));
assertTrue(netCap.appliesToUid(3001));
assertFalse(netCap.appliesToUid(10));
assertFalse(netCap.appliesToUid(25));
assertFalse(netCap.appliesToUid(49));
assertFalse(netCap.appliesToUid(101));
assertFalse(netCap.appliesToUid(2000));
assertFalse(netCap.appliesToUid(100000));
assertTrue(netCap.appliesToUidRange(new UidRange(50, 100)));
assertTrue(netCap.appliesToUidRange(new UidRange(70, 72)));
assertTrue(netCap.appliesToUidRange(new UidRange(3500, 3912)));
assertFalse(netCap.appliesToUidRange(new UidRange(1, 100)));
assertFalse(netCap.appliesToUidRange(new UidRange(49, 100)));
assertFalse(netCap.appliesToUidRange(new UidRange(1, 10)));
assertFalse(netCap.appliesToUidRange(new UidRange(60, 101)));
assertFalse(netCap.appliesToUidRange(new UidRange(60, 3400)));
NetworkCapabilities netCap2 = new NetworkCapabilities();
// A new netcap object has null UIDs, so anything will satisfy it.
assertTrue(netCap2.satisfiedByUids(netCap));
// Still not equal though.
assertFalse(netCap2.equalsUids(netCap));
netCap2.setUids(uids);
assertTrue(netCap2.satisfiedByUids(netCap));
assertTrue(netCap.equalsUids(netCap2));
assertTrue(netCap2.equalsUids(netCap));
uids.add(uidRange(600, 700));
netCap2.setUids(uids);
assertFalse(netCap2.satisfiedByUids(netCap));
assertFalse(netCap.appliesToUid(650));
assertTrue(netCap2.appliesToUid(650));
netCap.combineCapabilities(netCap2);
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));
assertTrue(netCap.satisfiedByUids(netCap2));
netCap2.setUids(null);
assertTrue(netCap2.satisfiedByUids(netCap));
assertTrue(netCap.satisfiedByUids(netCap2));
}
} }
@Test @Test
public void testParcelNetworkCapabilities() { public void testParcelNetworkCapabilities() {
final Set<Range<Integer>> uids = new ArraySet<>(); final Set<UidRange> uids = new ArraySet<>();
uids.add(uidRange(50, 100)); uids.add(new UidRange(50, 100));
uids.add(uidRange(3000, 4000)); uids.add(new UidRange(3000, 4000));
final NetworkCapabilities netCap = new NetworkCapabilities() final NetworkCapabilities netCap = new NetworkCapabilities()
.addCapability(NET_CAPABILITY_INTERNET) .addCapability(NET_CAPABILITY_INTERNET)
.setUids(uids)
.addCapability(NET_CAPABILITY_EIMS) .addCapability(NET_CAPABILITY_EIMS)
.addCapability(NET_CAPABILITY_NOT_METERED); .addCapability(NET_CAPABILITY_NOT_METERED);
if (isAtLeastS()) { if (isAtLeastS()) {
netCap.setSubIds(Set.of(TEST_SUBID1, TEST_SUBID2)); netCap.setSubIds(Set.of(TEST_SUBID1, TEST_SUBID2));
netCap.setUids(uids);
} else if (isAtLeastR()) { } else if (isAtLeastR()) {
netCap.setOwnerUid(123); netCap.setOwnerUid(123);
netCap.setAdministratorUids(new int[] {5, 11}); netCap.setAdministratorUids(new int[] {5, 11});
@ -562,16 +540,12 @@ public class NetworkCapabilitiesTest {
assertFalse(nc1.satisfiedByNetworkCapabilities(nc2)); assertFalse(nc1.satisfiedByNetworkCapabilities(nc2));
} }
private ArraySet<Range<Integer>> uidRanges(int from, int to) { private ArraySet<UidRange> uidRange(int from, int to) {
final ArraySet<Range<Integer>> range = new ArraySet<>(1); final ArraySet<UidRange> range = new ArraySet<>(1);
range.add(uidRange(from, to)); range.add(new UidRange(from, to));
return range; return range;
} }
private Range<Integer> uidRange(int from, int to) {
return new Range<Integer>(from, to);
}
@Test @IgnoreUpTo(Build.VERSION_CODES.Q) @Test @IgnoreUpTo(Build.VERSION_CODES.Q)
public void testSetAdministratorUids() { public void testSetAdministratorUids() {
NetworkCapabilities nc = NetworkCapabilities nc =
@ -627,23 +601,23 @@ public class NetworkCapabilitiesTest {
} catch (IllegalStateException expected) {} } catch (IllegalStateException expected) {}
nc1.setSSID(TEST_SSID); nc1.setSSID(TEST_SSID);
if (isAtLeastS()) { nc1.setUids(uidRange(10, 13));
nc1.setUids(uidRanges(10, 13)); assertNotEquals(nc1, nc2);
assertNotEquals(nc1, nc2); nc2.combineCapabilities(nc1); // Everything + 10~13 is still everything.
nc2.combineCapabilities(nc1); // Everything + 10~13 is still everything. assertNotEquals(nc1, nc2);
assertNotEquals(nc1, nc2); nc1.combineCapabilities(nc2); // 10~13 + everything is everything.
nc1.combineCapabilities(nc2); // 10~13 + everything is everything. assertEquals(nc1, nc2);
assertEquals(nc1, nc2); nc1.setUids(uidRange(10, 13));
nc1.setUids(uidRanges(10, 13)); nc2.setUids(uidRange(20, 23));
nc2.setUids(uidRanges(20, 23)); assertNotEquals(nc1, nc2);
assertNotEquals(nc1, nc2); nc1.combineCapabilities(nc2);
nc1.combineCapabilities(nc2); assertTrue(nc1.appliesToUid(12));
assertTrue(nc1.appliesToUid(12)); assertFalse(nc2.appliesToUid(12));
assertFalse(nc2.appliesToUid(12)); assertTrue(nc1.appliesToUid(22));
assertTrue(nc1.appliesToUid(22)); assertTrue(nc2.appliesToUid(22));
assertTrue(nc2.appliesToUid(22));
// Verify the subscription id list can be combined only when they are equal. // Verify the subscription id list can be combined only when they are equal.
if (isAtLeastS()) {
nc1.setSubIds(Set.of(TEST_SUBID1, TEST_SUBID2)); nc1.setSubIds(Set.of(TEST_SUBID1, TEST_SUBID2));
nc2.setSubIds(Set.of(TEST_SUBID2)); nc2.setSubIds(Set.of(TEST_SUBID2));
assertThrows(IllegalStateException.class, () -> nc2.combineCapabilities(nc1)); assertThrows(IllegalStateException.class, () -> nc2.combineCapabilities(nc1));
@ -799,11 +773,8 @@ public class NetworkCapabilitiesTest {
if (isAtLeastR()) { if (isAtLeastR()) {
assertTrue(DIFFERENT_TEST_SSID.equals(nc2.getSsid())); assertTrue(DIFFERENT_TEST_SSID.equals(nc2.getSsid()));
} }
if (isAtLeastS()) {
nc1.setUids(uidRanges(10, 13)); nc1.setUids(uidRange(10, 13));
} else {
nc1.setUids(null);
}
nc2.set(nc1); // Overwrites, as opposed to combineCapabilities nc2.set(nc1); // Overwrites, as opposed to combineCapabilities
assertEquals(nc1, nc2); assertEquals(nc1, nc2);

4
tests/net/integration/util/com/android/server/NetworkAgentWrapper.java
View file

@ -44,11 +44,11 @@ import android.net.NetworkProvider;
import android.net.NetworkSpecifier; import android.net.NetworkSpecifier;
import android.net.QosFilter; import android.net.QosFilter;
import android.net.SocketKeepalive; import android.net.SocketKeepalive;
import android.net.UidRange;
import android.os.ConditionVariable; import android.os.ConditionVariable;
import android.os.HandlerThread; import android.os.HandlerThread;
import android.os.Message; import android.os.Message;
import android.util.Log; import android.util.Log;
import android.util.Range;
import com.android.net.module.util.ArrayTrackRecord; import com.android.net.module.util.ArrayTrackRecord;
import com.android.server.connectivity.ConnectivityConstants; import com.android.server.connectivity.ConnectivityConstants;
@ -222,7 +222,7 @@ public class NetworkAgentWrapper implements TestableNetworkCallback.HasNetwork {
mNetworkAgent.sendNetworkCapabilities(mNetworkCapabilities); mNetworkAgent.sendNetworkCapabilities(mNetworkCapabilities);
} }
public void setUids(Set<Range<Integer>> uids) { public void setUids(Set<UidRange> uids) {
mNetworkCapabilities.setUids(uids); mNetworkCapabilities.setUids(uids);
mNetworkAgent.sendNetworkCapabilities(mNetworkCapabilities); mNetworkAgent.sendNetworkCapabilities(mNetworkCapabilities);
} }

60
tests/net/java/com/android/server/ConnectivityServiceTest.java
View file

@ -267,7 +267,6 @@ import android.text.TextUtils;
import android.util.ArraySet; import android.util.ArraySet;
import android.util.Log; import android.util.Log;
import android.util.Pair; import android.util.Pair;
import android.util.Range;
import android.util.SparseArray; import android.util.SparseArray;
import androidx.test.InstrumentationRegistry; import androidx.test.InstrumentationRegistry;
@ -1159,7 +1158,7 @@ public class ConnectivityServiceTest {
} }
public void setUids(Set<UidRange> uids) { public void setUids(Set<UidRange> uids) {
mNetworkCapabilities.setUids(UidRange.toIntRanges(uids)); mNetworkCapabilities.setUids(uids);
if (mAgentRegistered) { if (mAgentRegistered) {
mMockNetworkAgent.setNetworkCapabilities(mNetworkCapabilities, true); mMockNetworkAgent.setNetworkCapabilities(mNetworkCapabilities, true);
} }
@ -1449,8 +1448,6 @@ public class ConnectivityServiceTest {
} }
private static final int PRIMARY_USER = 0; private static final int PRIMARY_USER = 0;
private static final UidRange PRIMARY_UIDRANGE =
UidRange.createForUser(UserHandle.of(PRIMARY_USER));
private static final int APP1_UID = UserHandle.getUid(PRIMARY_USER, 10100); private static final int APP1_UID = UserHandle.getUid(PRIMARY_USER, 10100);
private static final int APP2_UID = UserHandle.getUid(PRIMARY_USER, 10101); private static final int APP2_UID = UserHandle.getUid(PRIMARY_USER, 10101);
private static final int VPN_UID = UserHandle.getUid(PRIMARY_USER, 10043); private static final int VPN_UID = UserHandle.getUid(PRIMARY_USER, 10043);
@ -6934,7 +6931,7 @@ public class ConnectivityServiceTest {
final int uid = Process.myUid(); final int uid = Process.myUid();
NetworkCapabilities nc = mCm.getNetworkCapabilities(mMockVpn.getNetwork()); NetworkCapabilities nc = mCm.getNetworkCapabilities(mMockVpn.getNetwork());
assertNotNull("nc=" + nc, nc.getUids()); assertNotNull("nc=" + nc, nc.getUids());
assertEquals(nc.getUids(), UidRange.toIntRanges(uidRangesForUids(uid))); assertEquals(nc.getUids(), uidRangesForUids(uid));
assertVpnTransportInfo(nc, VpnManager.TYPE_VPN_SERVICE); assertVpnTransportInfo(nc, VpnManager.TYPE_VPN_SERVICE);
// Set an underlying network and expect to see the VPN transports change. // Set an underlying network and expect to see the VPN transports change.
@ -6959,13 +6956,10 @@ public class ConnectivityServiceTest {
// Expect that the VPN UID ranges contain both |uid| and the UID range for the newly-added // Expect that the VPN UID ranges contain both |uid| and the UID range for the newly-added
// restricted user. // restricted user.
final UidRange rRange = UidRange.createForUser(UserHandle.of(RESTRICTED_USER));
final Range<Integer> restrictUidRange = new Range<Integer>(rRange.start, rRange.stop);
final Range<Integer> singleUidRange = new Range<Integer>(uid, uid);
callback.expectCapabilitiesThat(mMockVpn, (caps) callback.expectCapabilitiesThat(mMockVpn, (caps)
-> caps.getUids().size() == 2 -> caps.getUids().size() == 2
&& caps.getUids().contains(singleUidRange) && caps.getUids().contains(new UidRange(uid, uid))
&& caps.getUids().contains(restrictUidRange) && caps.getUids().contains(createUidRange(RESTRICTED_USER))
&& caps.hasTransport(TRANSPORT_VPN) && caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_WIFI)); && caps.hasTransport(TRANSPORT_WIFI));
@ -6974,8 +6968,8 @@ public class ConnectivityServiceTest {
callback.expectCallback(CallbackEntry.LOST, mWiFiNetworkAgent); callback.expectCallback(CallbackEntry.LOST, mWiFiNetworkAgent);
callback.expectCapabilitiesThat(mMockVpn, (caps) callback.expectCapabilitiesThat(mMockVpn, (caps)
-> caps.getUids().size() == 2 -> caps.getUids().size() == 2
&& caps.getUids().contains(singleUidRange) && caps.getUids().contains(new UidRange(uid, uid))
&& caps.getUids().contains(restrictUidRange) && caps.getUids().contains(createUidRange(RESTRICTED_USER))
&& caps.hasTransport(TRANSPORT_VPN) && caps.hasTransport(TRANSPORT_VPN)
&& !caps.hasTransport(TRANSPORT_WIFI)); && !caps.hasTransport(TRANSPORT_WIFI));
@ -6989,7 +6983,7 @@ public class ConnectivityServiceTest {
// change made just before that (i.e., loss of TRANSPORT_WIFI) is preserved. // change made just before that (i.e., loss of TRANSPORT_WIFI) is preserved.
callback.expectCapabilitiesThat(mMockVpn, (caps) callback.expectCapabilitiesThat(mMockVpn, (caps)
-> caps.getUids().size() == 1 -> caps.getUids().size() == 1
&& caps.getUids().contains(singleUidRange) && caps.getUids().contains(new UidRange(uid, uid))
&& caps.hasTransport(TRANSPORT_VPN) && caps.hasTransport(TRANSPORT_VPN)
&& !caps.hasTransport(TRANSPORT_WIFI)); && !caps.hasTransport(TRANSPORT_WIFI));
} }
@ -7647,7 +7641,7 @@ public class ConnectivityServiceTest {
assertNotNull(underlying); assertNotNull(underlying);
mMockVpn.setVpnType(VpnManager.TYPE_VPN_LEGACY); mMockVpn.setVpnType(VpnManager.TYPE_VPN_LEGACY);
// The legacy lockdown VPN only supports userId 0. // The legacy lockdown VPN only supports userId 0.
final Set<UidRange> ranges = Collections.singleton(PRIMARY_UIDRANGE); final Set<UidRange> ranges = Collections.singleton(createUidRange(PRIMARY_USER));
mMockVpn.registerAgent(ranges); mMockVpn.registerAgent(ranges);
mMockVpn.setUnderlyingNetworks(new Network[]{underlying}); mMockVpn.setUnderlyingNetworks(new Network[]{underlying});
mMockVpn.connect(true); mMockVpn.connect(true);
@ -8609,7 +8603,7 @@ public class ConnectivityServiceTest {
lp.addRoute(new RouteInfo(new IpPrefix(Inet4Address.ANY, 0), null)); lp.addRoute(new RouteInfo(new IpPrefix(Inet4Address.ANY, 0), null));
lp.addRoute(new RouteInfo(new IpPrefix(Inet6Address.ANY, 0), RTN_UNREACHABLE)); lp.addRoute(new RouteInfo(new IpPrefix(Inet6Address.ANY, 0), RTN_UNREACHABLE));
// The uid range needs to cover the test app so the network is visible to it. // The uid range needs to cover the test app so the network is visible to it.
final Set<UidRange> vpnRange = Collections.singleton(PRIMARY_UIDRANGE); final Set<UidRange> vpnRange = Collections.singleton(createUidRange(PRIMARY_USER));
mMockVpn.establish(lp, VPN_UID, vpnRange); mMockVpn.establish(lp, VPN_UID, vpnRange);
assertVpnUidRangesUpdated(true, vpnRange, VPN_UID); assertVpnUidRangesUpdated(true, vpnRange, VPN_UID);
@ -8637,7 +8631,7 @@ public class ConnectivityServiceTest {
lp.addRoute(new RouteInfo(new IpPrefix(Inet6Address.ANY, 0), null)); lp.addRoute(new RouteInfo(new IpPrefix(Inet6Address.ANY, 0), null));
lp.addRoute(new RouteInfo(new IpPrefix(Inet4Address.ANY, 0), null)); lp.addRoute(new RouteInfo(new IpPrefix(Inet4Address.ANY, 0), null));
// The uid range needs to cover the test app so the network is visible to it. // The uid range needs to cover the test app so the network is visible to it.
final Set<UidRange> vpnRange = Collections.singleton(PRIMARY_UIDRANGE); final Set<UidRange> vpnRange = Collections.singleton(createUidRange(PRIMARY_USER));
mMockVpn.establish(lp, Process.SYSTEM_UID, vpnRange); mMockVpn.establish(lp, Process.SYSTEM_UID, vpnRange);
assertVpnUidRangesUpdated(true, vpnRange, Process.SYSTEM_UID); assertVpnUidRangesUpdated(true, vpnRange, Process.SYSTEM_UID);
@ -8653,7 +8647,7 @@ public class ConnectivityServiceTest {
lp.addRoute(new RouteInfo(new IpPrefix("192.0.2.0/24"), null, "tun0")); lp.addRoute(new RouteInfo(new IpPrefix("192.0.2.0/24"), null, "tun0"));
lp.addRoute(new RouteInfo(new IpPrefix(Inet6Address.ANY, 0), RTN_UNREACHABLE)); lp.addRoute(new RouteInfo(new IpPrefix(Inet6Address.ANY, 0), RTN_UNREACHABLE));
// The uid range needs to cover the test app so the network is visible to it. // The uid range needs to cover the test app so the network is visible to it.
final Set<UidRange> vpnRange = Collections.singleton(PRIMARY_UIDRANGE); final Set<UidRange> vpnRange = Collections.singleton(createUidRange(PRIMARY_USER));
mMockVpn.establish(lp, Process.SYSTEM_UID, vpnRange); mMockVpn.establish(lp, Process.SYSTEM_UID, vpnRange);
assertVpnUidRangesUpdated(true, vpnRange, Process.SYSTEM_UID); assertVpnUidRangesUpdated(true, vpnRange, Process.SYSTEM_UID);
@ -8668,7 +8662,7 @@ public class ConnectivityServiceTest {
lp.addRoute(new RouteInfo(new IpPrefix(Inet4Address.ANY, 0), null)); lp.addRoute(new RouteInfo(new IpPrefix(Inet4Address.ANY, 0), null));
lp.addRoute(new RouteInfo(new IpPrefix(Inet6Address.ANY, 0), null)); lp.addRoute(new RouteInfo(new IpPrefix(Inet6Address.ANY, 0), null));
// The uid range needs to cover the test app so the network is visible to it. // The uid range needs to cover the test app so the network is visible to it.
final Set<UidRange> vpnRange = Collections.singleton(PRIMARY_UIDRANGE); final Set<UidRange> vpnRange = Collections.singleton(createUidRange(PRIMARY_USER));
mMockVpn.establish(lp, VPN_UID, vpnRange); mMockVpn.establish(lp, VPN_UID, vpnRange);
assertVpnUidRangesUpdated(true, vpnRange, VPN_UID); assertVpnUidRangesUpdated(true, vpnRange, VPN_UID);
@ -8720,7 +8714,7 @@ public class ConnectivityServiceTest {
lp.addRoute(new RouteInfo(new IpPrefix(Inet4Address.ANY, 0), RTN_UNREACHABLE)); lp.addRoute(new RouteInfo(new IpPrefix(Inet4Address.ANY, 0), RTN_UNREACHABLE));
lp.addRoute(new RouteInfo(new IpPrefix(Inet6Address.ANY, 0), null)); lp.addRoute(new RouteInfo(new IpPrefix(Inet6Address.ANY, 0), null));
// The uid range needs to cover the test app so the network is visible to it. // The uid range needs to cover the test app so the network is visible to it.
final UidRange vpnRange = PRIMARY_UIDRANGE; final UidRange vpnRange = createUidRange(PRIMARY_USER);
final Set<UidRange> vpnRanges = Collections.singleton(vpnRange); final Set<UidRange> vpnRanges = Collections.singleton(vpnRange);
mMockVpn.establish(lp, VPN_UID, vpnRanges); mMockVpn.establish(lp, VPN_UID, vpnRanges);
assertVpnUidRangesUpdated(true, vpnRanges, VPN_UID); assertVpnUidRangesUpdated(true, vpnRanges, VPN_UID);
@ -9001,7 +8995,7 @@ public class ConnectivityServiceTest {
private void setupConnectionOwnerUid(int vpnOwnerUid, @VpnManager.VpnType int vpnType) private void setupConnectionOwnerUid(int vpnOwnerUid, @VpnManager.VpnType int vpnType)
throws Exception { throws Exception {
final Set<UidRange> vpnRange = Collections.singleton(PRIMARY_UIDRANGE); final Set<UidRange> vpnRange = Collections.singleton(createUidRange(PRIMARY_USER));
mMockVpn.setVpnType(vpnType); mMockVpn.setVpnType(vpnType);
mMockVpn.establish(new LinkProperties(), vpnOwnerUid, vpnRange); mMockVpn.establish(new LinkProperties(), vpnOwnerUid, vpnRange);
assertVpnUidRangesUpdated(true, vpnRange, vpnOwnerUid); assertVpnUidRangesUpdated(true, vpnRange, vpnOwnerUid);
@ -9561,7 +9555,7 @@ public class ConnectivityServiceTest {
lp.setInterfaceName("tun0"); lp.setInterfaceName("tun0");
lp.addRoute(new RouteInfo(new IpPrefix(Inet4Address.ANY, 0), null)); lp.addRoute(new RouteInfo(new IpPrefix(Inet4Address.ANY, 0), null));
lp.addRoute(new RouteInfo(new IpPrefix(Inet6Address.ANY, 0), null)); lp.addRoute(new RouteInfo(new IpPrefix(Inet6Address.ANY, 0), null));
final UidRange vpnRange = PRIMARY_UIDRANGE; final UidRange vpnRange = createUidRange(PRIMARY_USER);
Set<UidRange> vpnRanges = Collections.singleton(vpnRange); Set<UidRange> vpnRanges = Collections.singleton(vpnRange);
mMockVpn.establish(lp, VPN_UID, vpnRanges); mMockVpn.establish(lp, VPN_UID, vpnRanges);
assertVpnUidRangesUpdated(true, vpnRanges, VPN_UID); assertVpnUidRangesUpdated(true, vpnRanges, VPN_UID);
@ -9759,7 +9753,7 @@ public class ConnectivityServiceTest {
.thenReturn(hasFeature); .thenReturn(hasFeature);
} }
private Range<Integer> getNriFirstUidRange( private UidRange getNriFirstUidRange(
@NonNull final ConnectivityService.NetworkRequestInfo nri) { @NonNull final ConnectivityService.NetworkRequestInfo nri) {
return nri.mRequests.get(0).networkCapabilities.getUids().iterator().next(); return nri.mRequests.get(0).networkCapabilities.getUids().iterator().next();
} }
@ -9942,11 +9936,11 @@ public class ConnectivityServiceTest {
pref)); pref));
// Sort by uid to access nris by index // Sort by uid to access nris by index
nris.sort(Comparator.comparingInt(nri -> getNriFirstUidRange(nri).getLower())); nris.sort(Comparator.comparingInt(nri -> getNriFirstUidRange(nri).start));
assertEquals(TEST_PACKAGE_UID, (int) getNriFirstUidRange(nris.get(0)).getLower()); assertEquals(TEST_PACKAGE_UID, getNriFirstUidRange(nris.get(0)).start);
assertEquals(TEST_PACKAGE_UID, (int) getNriFirstUidRange(nris.get(0)).getUpper()); assertEquals(TEST_PACKAGE_UID, getNriFirstUidRange(nris.get(0)).stop);
assertEquals(testPackageNameUid2, (int) getNriFirstUidRange(nris.get(1)).getLower()); assertEquals(testPackageNameUid2, getNriFirstUidRange(nris.get(1)).start);
assertEquals(testPackageNameUid2, (int) getNriFirstUidRange(nris.get(1)).getUpper()); assertEquals(testPackageNameUid2, getNriFirstUidRange(nris.get(1)).stop);
} }
@Test @Test
@ -9976,17 +9970,17 @@ public class ConnectivityServiceTest {
// UIDs for all users and all managed packages should be present. // UIDs for all users and all managed packages should be present.
// Two users each with two packages. // Two users each with two packages.
final int expectedUidSize = 2; final int expectedUidSize = 2;
final List<Range<Integer>> uids = final List<UidRange> uids =
new ArrayList<>(nris.get(0).mRequests.get(0).networkCapabilities.getUids()); new ArrayList<>(nris.get(0).mRequests.get(0).networkCapabilities.getUids());
assertEquals(expectedUidSize, uids.size()); assertEquals(expectedUidSize, uids.size());
// Sort by uid to access nris by index // Sort by uid to access nris by index
uids.sort(Comparator.comparingInt(uid -> uid.getLower())); uids.sort(Comparator.comparingInt(uid -> uid.start));
final int secondUserTestPackageUid = UserHandle.getUid(secondUser, TEST_PACKAGE_UID); final int secondUserTestPackageUid = UserHandle.getUid(secondUser, TEST_PACKAGE_UID);
assertEquals(TEST_PACKAGE_UID, (int) uids.get(0).getLower()); assertEquals(TEST_PACKAGE_UID, uids.get(0).start);
assertEquals(TEST_PACKAGE_UID, (int) uids.get(0).getUpper()); assertEquals(TEST_PACKAGE_UID, uids.get(0).stop);
assertEquals(secondUserTestPackageUid, (int) uids.get(1).getLower()); assertEquals(secondUserTestPackageUid, uids.get(1).start);
assertEquals(secondUserTestPackageUid, (int) uids.get(1).getUpper()); assertEquals(secondUserTestPackageUid, uids.get(1).stop);
} }
@Test @Test

133
tests/net/java/com/android/server/connectivity/VpnTest.java
View file

@ -23,7 +23,6 @@ import static android.content.pm.UserInfo.FLAG_RESTRICTED;
import static android.net.ConnectivityManager.NetworkCallback; import static android.net.ConnectivityManager.NetworkCallback;
import static android.net.INetd.IF_STATE_DOWN; import static android.net.INetd.IF_STATE_DOWN;
import static android.net.INetd.IF_STATE_UP; import static android.net.INetd.IF_STATE_UP;
import static android.os.UserHandle.PER_USER_RANGE;
import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals;
@ -75,6 +74,7 @@ import android.net.Network;
import android.net.NetworkCapabilities; import android.net.NetworkCapabilities;
import android.net.NetworkInfo.DetailedState; import android.net.NetworkInfo.DetailedState;
import android.net.RouteInfo; import android.net.RouteInfo;
import android.net.UidRange;
import android.net.UidRangeParcel; import android.net.UidRangeParcel;
import android.net.VpnManager; import android.net.VpnManager;
import android.net.VpnService; import android.net.VpnService;
@ -181,7 +181,8 @@ public class VpnTest {
mPackages.put(PKGS[i], PKG_UIDS[i]); mPackages.put(PKGS[i], PKG_UIDS[i]);
} }
} }
private static final Range<Integer> PRI_USER_RANGE = uidRangeForUser(primaryUser.id); private static final UidRange PRI_USER_RANGE =
UidRange.createForUser(UserHandle.of(primaryUser.id));
@Mock(answer = Answers.RETURNS_DEEP_STUBS) private Context mContext; @Mock(answer = Answers.RETURNS_DEEP_STUBS) private Context mContext;
@Mock private UserManager mUserManager; @Mock private UserManager mUserManager;
@ -259,21 +260,6 @@ public class VpnTest {
.thenReturn(tunnelResp); .thenReturn(tunnelResp);
} }
private Set<Range<Integer>> rangeSet(Range<Integer> ... ranges) {
final Set<Range<Integer>> range = new ArraySet<>();
for (Range<Integer> r : ranges) range.add(r);
return range;
}
private static Range<Integer> uidRangeForUser(int userId) {
return new Range<Integer>(userId * PER_USER_RANGE, (userId + 1) * PER_USER_RANGE - 1);
}
private Range<Integer> uidRange(int start, int stop) {
return new Range<Integer>(start, stop);
}
@Test @Test
public void testRestrictedProfilesAreAddedToVpn() { public void testRestrictedProfilesAreAddedToVpn() {
setMockedUsers(primaryUser, secondaryUser, restrictedProfileA, restrictedProfileB); setMockedUsers(primaryUser, secondaryUser, restrictedProfileA, restrictedProfileB);
@ -282,10 +268,12 @@ public class VpnTest {
// Assume the user can have restricted profiles. // Assume the user can have restricted profiles.
doReturn(true).when(mUserManager).canHaveRestrictedProfile(); doReturn(true).when(mUserManager).canHaveRestrictedProfile();
final Set<Range<Integer>> ranges = final Set<UidRange> ranges =
vpn.createUserAndRestrictedProfilesRanges(primaryUser.id, null, null); vpn.createUserAndRestrictedProfilesRanges(primaryUser.id, null, null);
assertEquals(rangeSet(PRI_USER_RANGE, uidRangeForUser(restrictedProfileA.id)), ranges); assertEquals(new ArraySet<>(Arrays.asList(new UidRange[] {
PRI_USER_RANGE, UidRange.createForUser(UserHandle.of(restrictedProfileA.id))
})), ranges);
} }
@Test @Test
@ -293,10 +281,10 @@ public class VpnTest {
setMockedUsers(primaryUser, managedProfileA); setMockedUsers(primaryUser, managedProfileA);
final Vpn vpn = createVpn(primaryUser.id); final Vpn vpn = createVpn(primaryUser.id);
final Set<Range<Integer>> ranges = vpn.createUserAndRestrictedProfilesRanges(primaryUser.id, final Set<UidRange> ranges = vpn.createUserAndRestrictedProfilesRanges(primaryUser.id,
null, null); null, null);
assertEquals(rangeSet(PRI_USER_RANGE), ranges); assertEquals(new ArraySet<>(Arrays.asList(new UidRange[] { PRI_USER_RANGE })), ranges);
} }
@Test @Test
@ -304,38 +292,35 @@ public class VpnTest {
setMockedUsers(primaryUser, restrictedProfileA, managedProfileA); setMockedUsers(primaryUser, restrictedProfileA, managedProfileA);
final Vpn vpn = createVpn(primaryUser.id); final Vpn vpn = createVpn(primaryUser.id);
final Set<Range<Integer>> ranges = new ArraySet<>(); final Set<UidRange> ranges = new ArraySet<>();
vpn.addUserToRanges(ranges, primaryUser.id, null, null); vpn.addUserToRanges(ranges, primaryUser.id, null, null);
assertEquals(rangeSet(PRI_USER_RANGE), ranges); assertEquals(new ArraySet<>(Arrays.asList(new UidRange[] { PRI_USER_RANGE })), ranges);
} }
@Test @Test
public void testUidAllowAndDenylist() throws Exception { public void testUidAllowAndDenylist() throws Exception {
final Vpn vpn = createVpn(primaryUser.id); final Vpn vpn = createVpn(primaryUser.id);
final Range<Integer> user = PRI_USER_RANGE; final UidRange user = PRI_USER_RANGE;
final int userStart = user.getLower();
final int userStop = user.getUpper();
final String[] packages = {PKGS[0], PKGS[1], PKGS[2]}; final String[] packages = {PKGS[0], PKGS[1], PKGS[2]};
// Allowed list // Allowed list
final Set<Range<Integer>> allow = vpn.createUserAndRestrictedProfilesRanges(primaryUser.id, final Set<UidRange> allow = vpn.createUserAndRestrictedProfilesRanges(primaryUser.id,
Arrays.asList(packages), null /* disallowedApplications */); Arrays.asList(packages), null);
assertEquals(rangeSet( assertEquals(new ArraySet<>(Arrays.asList(new UidRange[] {
uidRange(userStart + PKG_UIDS[0], userStart + PKG_UIDS[0]), new UidRange(user.start + PKG_UIDS[0], user.start + PKG_UIDS[0]),
uidRange(userStart + PKG_UIDS[1], userStart + PKG_UIDS[2])), new UidRange(user.start + PKG_UIDS[1], user.start + PKG_UIDS[2])
allow); })), allow);
// Denied list // Denied list
final Set<Range<Integer>> disallow = final Set<UidRange> disallow = vpn.createUserAndRestrictedProfilesRanges(primaryUser.id,
vpn.createUserAndRestrictedProfilesRanges(primaryUser.id, null, Arrays.asList(packages));
null /* allowedApplications */, Arrays.asList(packages)); assertEquals(new ArraySet<>(Arrays.asList(new UidRange[] {
assertEquals(rangeSet( new UidRange(user.start, user.start + PKG_UIDS[0] - 1),
uidRange(userStart, userStart + PKG_UIDS[0] - 1), new UidRange(user.start + PKG_UIDS[0] + 1, user.start + PKG_UIDS[1] - 1),
uidRange(userStart + PKG_UIDS[0] + 1, userStart + PKG_UIDS[1] - 1), /* Empty range between UIDS[1] and UIDS[2], should be excluded, */
/* Empty range between UIDS[1] and UIDS[2], should be excluded, */ new UidRange(user.start + PKG_UIDS[2] + 1, user.stop)
uidRange(userStart + PKG_UIDS[2] + 1, userStop)), })), disallow);
disallow);
} }
@Test @Test
@ -365,86 +350,84 @@ public class VpnTest {
@Test @Test
public void testLockdownChangingPackage() throws Exception { public void testLockdownChangingPackage() throws Exception {
final Vpn vpn = createVpn(primaryUser.id); final Vpn vpn = createVpn(primaryUser.id);
final Range<Integer> user = PRI_USER_RANGE; final UidRange user = PRI_USER_RANGE;
final int userStart = user.getLower();
final int userStop = user.getUpper();
// Set always-on without lockdown. // Set always-on without lockdown.
assertTrue(vpn.setAlwaysOnPackage(PKGS[1], false, null)); assertTrue(vpn.setAlwaysOnPackage(PKGS[1], false, null));
// Set always-on with lockdown. // Set always-on with lockdown.
assertTrue(vpn.setAlwaysOnPackage(PKGS[1], true, null)); assertTrue(vpn.setAlwaysOnPackage(PKGS[1], true, null));
verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] { verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] {
new UidRangeParcel(userStart, userStart + PKG_UIDS[1] - 1), new UidRangeParcel(user.start, user.start + PKG_UIDS[1] - 1),
new UidRangeParcel(userStart + PKG_UIDS[1] + 1, userStop) new UidRangeParcel(user.start + PKG_UIDS[1] + 1, user.stop)
})); }));
// Switch to another app. // Switch to another app.
assertTrue(vpn.setAlwaysOnPackage(PKGS[3], true, null)); assertTrue(vpn.setAlwaysOnPackage(PKGS[3], true, null));
verify(mConnectivityManager).setRequireVpnForUids(false, toRanges(new UidRangeParcel[] { verify(mConnectivityManager).setRequireVpnForUids(false, toRanges(new UidRangeParcel[] {
new UidRangeParcel(userStart, userStart + PKG_UIDS[1] - 1), new UidRangeParcel(user.start, user.start + PKG_UIDS[1] - 1),
new UidRangeParcel(userStart + PKG_UIDS[1] + 1, userStop) new UidRangeParcel(user.start + PKG_UIDS[1] + 1, user.stop)
})); }));
verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] { verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] {
new UidRangeParcel(userStart, userStart + PKG_UIDS[3] - 1), new UidRangeParcel(user.start, user.start + PKG_UIDS[3] - 1),
new UidRangeParcel(userStart + PKG_UIDS[3] + 1, userStop) new UidRangeParcel(user.start + PKG_UIDS[3] + 1, user.stop)
})); }));
} }
@Test @Test
public void testLockdownAllowlist() throws Exception { public void testLockdownAllowlist() throws Exception {
final Vpn vpn = createVpn(primaryUser.id); final Vpn vpn = createVpn(primaryUser.id);
final Range<Integer> user = PRI_USER_RANGE; final UidRange user = PRI_USER_RANGE;
final int userStart = user.getLower();
final int userStop = user.getUpper();
// Set always-on with lockdown and allow app PKGS[2] from lockdown. // Set always-on with lockdown and allow app PKGS[2] from lockdown.
assertTrue(vpn.setAlwaysOnPackage( assertTrue(vpn.setAlwaysOnPackage(
PKGS[1], true, Collections.singletonList(PKGS[2]))); PKGS[1], true, Collections.singletonList(PKGS[2])));
verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] { verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] {
new UidRangeParcel(userStart, userStart + PKG_UIDS[1] - 1), new UidRangeParcel(user.start, user.start + PKG_UIDS[1] - 1),
new UidRangeParcel(userStart + PKG_UIDS[2] + 1, userStop) new UidRangeParcel(user.start + PKG_UIDS[2] + 1, user.stop)
})); }));
// Change allowed app list to PKGS[3]. // Change allowed app list to PKGS[3].
assertTrue(vpn.setAlwaysOnPackage( assertTrue(vpn.setAlwaysOnPackage(
PKGS[1], true, Collections.singletonList(PKGS[3]))); PKGS[1], true, Collections.singletonList(PKGS[3])));
verify(mConnectivityManager).setRequireVpnForUids(false, toRanges(new UidRangeParcel[] { verify(mConnectivityManager).setRequireVpnForUids(false, toRanges(new UidRangeParcel[] {
new UidRangeParcel(userStart + PKG_UIDS[2] + 1, userStop) new UidRangeParcel(user.start + PKG_UIDS[2] + 1, user.stop)
})); }));
verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] { verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] {
new UidRangeParcel(userStart + PKG_UIDS[1] + 1, userStart + PKG_UIDS[3] - 1), new UidRangeParcel(user.start + PKG_UIDS[1] + 1, user.start + PKG_UIDS[3] - 1),
new UidRangeParcel(userStart + PKG_UIDS[3] + 1, userStop) new UidRangeParcel(user.start + PKG_UIDS[3] + 1, user.stop)
})); }));
// Change the VPN app. // Change the VPN app.
assertTrue(vpn.setAlwaysOnPackage( assertTrue(vpn.setAlwaysOnPackage(
PKGS[0], true, Collections.singletonList(PKGS[3]))); PKGS[0], true, Collections.singletonList(PKGS[3])));
verify(mConnectivityManager).setRequireVpnForUids(false, toRanges(new UidRangeParcel[] { verify(mConnectivityManager).setRequireVpnForUids(false, toRanges(new UidRangeParcel[] {
new UidRangeParcel(userStart, userStart + PKG_UIDS[1] - 1), new UidRangeParcel(user.start, user.start + PKG_UIDS[1] - 1),
new UidRangeParcel(userStart + PKG_UIDS[1] + 1, userStart + PKG_UIDS[3] - 1) new UidRangeParcel(user.start + PKG_UIDS[1] + 1, user.start + PKG_UIDS[3] - 1)
})); }));
verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] { verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] {
new UidRangeParcel(userStart, userStart + PKG_UIDS[0] - 1), new UidRangeParcel(user.start, user.start + PKG_UIDS[0] - 1),
new UidRangeParcel(userStart + PKG_UIDS[0] + 1, userStart + PKG_UIDS[3] - 1) new UidRangeParcel(user.start + PKG_UIDS[0] + 1, user.start + PKG_UIDS[3] - 1)
})); }));
// Remove the list of allowed packages. // Remove the list of allowed packages.
assertTrue(vpn.setAlwaysOnPackage(PKGS[0], true, null)); assertTrue(vpn.setAlwaysOnPackage(PKGS[0], true, null));
verify(mConnectivityManager).setRequireVpnForUids(false, toRanges(new UidRangeParcel[] { verify(mConnectivityManager).setRequireVpnForUids(false, toRanges(new UidRangeParcel[] {
new UidRangeParcel(userStart + PKG_UIDS[0] + 1, userStart + PKG_UIDS[3] - 1), new UidRangeParcel(user.start + PKG_UIDS[0] + 1, user.start + PKG_UIDS[3] - 1),
new UidRangeParcel(userStart + PKG_UIDS[3] + 1, userStop) new UidRangeParcel(user.start + PKG_UIDS[3] + 1, user.stop)
})); }));
verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] { verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] {
new UidRangeParcel(userStart + PKG_UIDS[0] + 1, userStop), new UidRangeParcel(user.start + PKG_UIDS[0] + 1, user.stop),
})); }));
// Add the list of allowed packages. // Add the list of allowed packages.
assertTrue(vpn.setAlwaysOnPackage( assertTrue(vpn.setAlwaysOnPackage(
PKGS[0], true, Collections.singletonList(PKGS[1]))); PKGS[0], true, Collections.singletonList(PKGS[1])));
verify(mConnectivityManager).setRequireVpnForUids(false, toRanges(new UidRangeParcel[] { verify(mConnectivityManager).setRequireVpnForUids(false, toRanges(new UidRangeParcel[] {
new UidRangeParcel(userStart + PKG_UIDS[0] + 1, userStop) new UidRangeParcel(user.start + PKG_UIDS[0] + 1, user.stop)
})); }));
verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] { verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] {
new UidRangeParcel(userStart + PKG_UIDS[0] + 1, userStart + PKG_UIDS[1] - 1), new UidRangeParcel(user.start + PKG_UIDS[0] + 1, user.start + PKG_UIDS[1] - 1),
new UidRangeParcel(userStart + PKG_UIDS[1] + 1, userStop) new UidRangeParcel(user.start + PKG_UIDS[1] + 1, user.stop)
})); }));
// Try allowing a package with a comma, should be rejected. // Try allowing a package with a comma, should be rejected.
@ -456,12 +439,12 @@ public class VpnTest {
assertTrue(vpn.setAlwaysOnPackage( assertTrue(vpn.setAlwaysOnPackage(
PKGS[0], true, Arrays.asList("com.foo.app", PKGS[2], "com.bar.app"))); PKGS[0], true, Arrays.asList("com.foo.app", PKGS[2], "com.bar.app")));
verify(mConnectivityManager).setRequireVpnForUids(false, toRanges(new UidRangeParcel[] { verify(mConnectivityManager).setRequireVpnForUids(false, toRanges(new UidRangeParcel[] {
new UidRangeParcel(userStart + PKG_UIDS[0] + 1, userStart + PKG_UIDS[1] - 1), new UidRangeParcel(user.start + PKG_UIDS[0] + 1, user.start + PKG_UIDS[1] - 1),
new UidRangeParcel(userStart + PKG_UIDS[1] + 1, userStop) new UidRangeParcel(user.start + PKG_UIDS[1] + 1, user.stop)
})); }));
verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] { verify(mConnectivityManager).setRequireVpnForUids(true, toRanges(new UidRangeParcel[] {
new UidRangeParcel(userStart + PKG_UIDS[0] + 1, userStart + PKG_UIDS[2] - 1), new UidRangeParcel(user.start + PKG_UIDS[0] + 1, user.start + PKG_UIDS[2] - 1),
new UidRangeParcel(userStart + PKG_UIDS[2] + 1, userStop) new UidRangeParcel(user.start + PKG_UIDS[2] + 1, user.stop)
})); }));
} }
@ -469,7 +452,7 @@ public class VpnTest {
public void testLockdownRuleRepeatability() throws Exception { public void testLockdownRuleRepeatability() throws Exception {
final Vpn vpn = createVpn(primaryUser.id); final Vpn vpn = createVpn(primaryUser.id);
final UidRangeParcel[] primaryUserRangeParcel = new UidRangeParcel[] { final UidRangeParcel[] primaryUserRangeParcel = new UidRangeParcel[] {
new UidRangeParcel(PRI_USER_RANGE.getLower(), PRI_USER_RANGE.getUpper())}; new UidRangeParcel(PRI_USER_RANGE.start, PRI_USER_RANGE.stop)};
// Given legacy lockdown is already enabled, // Given legacy lockdown is already enabled,
vpn.setLockdown(true); vpn.setLockdown(true);
verify(mConnectivityManager, times(1)).setRequireVpnForUids(true, verify(mConnectivityManager, times(1)).setRequireVpnForUids(true,
@ -501,7 +484,7 @@ public class VpnTest {
public void testLockdownRuleReversibility() throws Exception { public void testLockdownRuleReversibility() throws Exception {
final Vpn vpn = createVpn(primaryUser.id); final Vpn vpn = createVpn(primaryUser.id);
final UidRangeParcel[] entireUser = { final UidRangeParcel[] entireUser = {
new UidRangeParcel(PRI_USER_RANGE.getLower(), PRI_USER_RANGE.getUpper()) new UidRangeParcel(PRI_USER_RANGE.start, PRI_USER_RANGE.stop)
}; };
final UidRangeParcel[] exceptPkg0 = { final UidRangeParcel[] exceptPkg0 = {
new UidRangeParcel(entireUser[0].start, entireUser[0].start + PKG_UIDS[0] - 1), new UidRangeParcel(entireUser[0].start, entireUser[0].start + PKG_UIDS[0] - 1),