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 "Do faster bitmask checks on NetworkCapabilities" into main

Browse source
This commit is contained in:
Shai Barack 2024-04-02 18:32:40 +00:00 • committed by Gerrit Code Review
commit 0634c7c4d2
2 changed files with 80 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -749,22 +749,22 @@ public final class NetworkCapabilities implements Parcelable {
* Network capabilities that are expected to be mutable, i.e., can change while a particular
* network is connected.
*/
private static final long MUTABLE_CAPABILITIES = BitUtils.packBitList(
private static final long MUTABLE_CAPABILITIES =
// TRUSTED can change when user explicitly connects to an untrusted network in Settings.
// http://b/18206275
NET_CAPABILITY_TRUSTED,
NET_CAPABILITY_VALIDATED,
NET_CAPABILITY_CAPTIVE_PORTAL,
NET_CAPABILITY_NOT_ROAMING,
NET_CAPABILITY_FOREGROUND,
NET_CAPABILITY_NOT_CONGESTED,
NET_CAPABILITY_NOT_SUSPENDED,
NET_CAPABILITY_PARTIAL_CONNECTIVITY,
NET_CAPABILITY_TEMPORARILY_NOT_METERED,
NET_CAPABILITY_NOT_VCN_MANAGED,
(1L << NET_CAPABILITY_TRUSTED) |
(1L << NET_CAPABILITY_VALIDATED) |
(1L << NET_CAPABILITY_CAPTIVE_PORTAL) |
(1L << NET_CAPABILITY_NOT_ROAMING) |
(1L << NET_CAPABILITY_FOREGROUND) |
(1L << NET_CAPABILITY_NOT_CONGESTED) |
(1L << NET_CAPABILITY_NOT_SUSPENDED) |
(1L << NET_CAPABILITY_PARTIAL_CONNECTIVITY) |
(1L << NET_CAPABILITY_TEMPORARILY_NOT_METERED) |
(1L << NET_CAPABILITY_NOT_VCN_MANAGED) |
// The value of NET_CAPABILITY_HEAD_UNIT is 32, which cannot use int to do bit shift,
// otherwise there will be an overflow. Use long to do bit shift instead.
NET_CAPABILITY_HEAD_UNIT);
(1L << NET_CAPABILITY_HEAD_UNIT);
/**
* Network capabilities that are not allowed in NetworkRequests. This exists because the
@ -784,10 +784,10 @@ public final class NetworkCapabilities implements Parcelable {
/**
* Capabilities that are set by default when the object is constructed.
*/
private static final long DEFAULT_CAPABILITIES = BitUtils.packBitList(
NET_CAPABILITY_NOT_RESTRICTED,
NET_CAPABILITY_TRUSTED,
NET_CAPABILITY_NOT_VPN);
private static final long DEFAULT_CAPABILITIES =
(1L << NET_CAPABILITY_NOT_RESTRICTED) |
(1L << NET_CAPABILITY_TRUSTED) |
(1L << NET_CAPABILITY_NOT_VPN);
/**
* Capabilities that are managed by ConnectivityService.
@ -795,11 +795,10 @@ public final class NetworkCapabilities implements Parcelable {
*/
@VisibleForTesting
public static final long CONNECTIVITY_MANAGED_CAPABILITIES =
BitUtils.packBitList(
NET_CAPABILITY_VALIDATED,
NET_CAPABILITY_CAPTIVE_PORTAL,
NET_CAPABILITY_FOREGROUND,
NET_CAPABILITY_PARTIAL_CONNECTIVITY);
(1L << NET_CAPABILITY_VALIDATED) |
(1L << NET_CAPABILITY_CAPTIVE_PORTAL) |
(1L << NET_CAPABILITY_FOREGROUND) |
(1L << NET_CAPABILITY_PARTIAL_CONNECTIVITY);
/**
* Capabilities that are allowed for all test networks. This list must be set so that it is safe
@ -808,15 +807,14 @@ public final class NetworkCapabilities implements Parcelable {
* IMS, SUPL, etc.
*/
private static final long TEST_NETWORKS_ALLOWED_CAPABILITIES =
BitUtils.packBitList(
NET_CAPABILITY_NOT_METERED,
NET_CAPABILITY_TEMPORARILY_NOT_METERED,
NET_CAPABILITY_NOT_RESTRICTED,
NET_CAPABILITY_NOT_VPN,
NET_CAPABILITY_NOT_ROAMING,
NET_CAPABILITY_NOT_CONGESTED,
NET_CAPABILITY_NOT_SUSPENDED,
NET_CAPABILITY_NOT_VCN_MANAGED);
(1L << NET_CAPABILITY_NOT_METERED) |
(1L << NET_CAPABILITY_TEMPORARILY_NOT_METERED) |
(1L << NET_CAPABILITY_NOT_RESTRICTED) |
(1L << NET_CAPABILITY_NOT_VPN) |
(1L << NET_CAPABILITY_NOT_ROAMING) |
(1L << NET_CAPABILITY_NOT_CONGESTED) |
(1L << NET_CAPABILITY_NOT_SUSPENDED) |
(1L << NET_CAPABILITY_NOT_VCN_MANAGED);
/**
* Extra allowed capabilities for test networks that do not have TRANSPORT_CELLULAR. Test
@ -824,7 +822,9 @@ public final class NetworkCapabilities implements Parcelable {
* the risk of being used by running apps.
*/
private static final long TEST_NETWORKS_EXTRA_ALLOWED_CAPABILITIES_ON_NON_CELL =
BitUtils.packBitList(NET_CAPABILITY_CBS, NET_CAPABILITY_DUN, NET_CAPABILITY_RCS);
(1L << NET_CAPABILITY_CBS) |
(1L << NET_CAPABILITY_DUN) |
(1L << NET_CAPABILITY_RCS);
/**
* Adds the given capability to this {@code NetworkCapability} instance.
@ -1174,7 +1174,7 @@ public final class NetworkCapabilities implements Parcelable {
* @hide
*/
public void maybeMarkCapabilitiesRestricted() {
if (NetworkCapabilitiesUtils.inferRestrictedCapability(this)) {
if (NetworkCapabilitiesUtils.inferRestrictedCapability(mNetworkCapabilities)) {
removeCapability(NET_CAPABILITY_NOT_RESTRICTED);
}
}
@ -1368,12 +1368,11 @@ public final class NetworkCapabilities implements Parcelable {
* Allowed transports on an unrestricted test network (in addition to TRANSPORT_TEST).
*/
private static final long UNRESTRICTED_TEST_NETWORKS_ALLOWED_TRANSPORTS =
BitUtils.packBitList(
TRANSPORT_TEST,
// Test eth networks are created with EthernetManager#setIncludeTestInterfaces
TRANSPORT_ETHERNET,
// Test VPN networks can be created but their UID ranges must be empty.
TRANSPORT_VPN);
(1L << TRANSPORT_TEST) |
// Test eth networks are created with EthernetManager#setIncludeTestInterfaces
(1L << TRANSPORT_ETHERNET) |
// Test VPN networks can be created but their UID ranges must be empty.
(1L << TRANSPORT_VPN);
/**
* Adds the given transport type to this {@code NetworkCapability} instance.

81
staticlibs/framework/com/android/net/module/util/NetworkCapabilitiesUtils.java
View file

@ -45,7 +45,7 @@ import static android.net.NetworkCapabilities.TRANSPORT_VPN;
import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
import static android.net.NetworkCapabilities.TRANSPORT_WIFI_AWARE;
import static com.android.net.module.util.BitUtils.packBitList;
import static com.android.net.module.util.BitUtils.packBits;
import static com.android.net.module.util.BitUtils.unpackBits;
import android.annotation.NonNull;
@ -89,41 +89,41 @@ public final class NetworkCapabilitiesUtils {
* and {@code FORCE_RESTRICTED_CAPABILITIES}.
*/
@VisibleForTesting
public static final long RESTRICTED_CAPABILITIES = packBitList(
NET_CAPABILITY_BIP,
NET_CAPABILITY_CBS,
NET_CAPABILITY_DUN,
NET_CAPABILITY_EIMS,
NET_CAPABILITY_ENTERPRISE,
NET_CAPABILITY_FOTA,
NET_CAPABILITY_IA,
NET_CAPABILITY_IMS,
NET_CAPABILITY_MCX,
NET_CAPABILITY_RCS,
NET_CAPABILITY_VEHICLE_INTERNAL,
NET_CAPABILITY_VSIM,
NET_CAPABILITY_XCAP,
NET_CAPABILITY_MMTEL);
public static final long RESTRICTED_CAPABILITIES =
(1L << NET_CAPABILITY_BIP) |
(1L << NET_CAPABILITY_CBS) |
(1L << NET_CAPABILITY_DUN) |
(1L << NET_CAPABILITY_EIMS) |
(1L << NET_CAPABILITY_ENTERPRISE) |
(1L << NET_CAPABILITY_FOTA) |
(1L << NET_CAPABILITY_IA) |
(1L << NET_CAPABILITY_IMS) |
(1L << NET_CAPABILITY_MCX) |
(1L << NET_CAPABILITY_RCS) |
(1L << NET_CAPABILITY_VEHICLE_INTERNAL) |
(1L << NET_CAPABILITY_VSIM) |
(1L << NET_CAPABILITY_XCAP) |
(1L << NET_CAPABILITY_MMTEL);
/**
* Capabilities that force network to be restricted.
* See {@code NetworkCapabilities#maybeMarkCapabilitiesRestricted}.
*/
private static final long FORCE_RESTRICTED_CAPABILITIES = packBitList(
NET_CAPABILITY_ENTERPRISE,
NET_CAPABILITY_OEM_PAID,
NET_CAPABILITY_OEM_PRIVATE);
private static final long FORCE_RESTRICTED_CAPABILITIES =
(1L << NET_CAPABILITY_ENTERPRISE) |
(1L << NET_CAPABILITY_OEM_PAID) |
(1L << NET_CAPABILITY_OEM_PRIVATE);
/**
* Capabilities that suggest that a network is unrestricted.
* See {@code NetworkCapabilities#maybeMarkCapabilitiesRestricted}.
*/
@VisibleForTesting
public static final long UNRESTRICTED_CAPABILITIES = packBitList(
NET_CAPABILITY_INTERNET,
NET_CAPABILITY_MMS,
NET_CAPABILITY_SUPL,
NET_CAPABILITY_WIFI_P2P);
public static final long UNRESTRICTED_CAPABILITIES =
(1L << NET_CAPABILITY_INTERNET) |
(1L << NET_CAPABILITY_MMS) |
(1L << NET_CAPABILITY_SUPL) |
(1L << NET_CAPABILITY_WIFI_P2P);
/**
* Get a transport that can be used to classify a network when displaying its info to users.
@ -159,28 +159,33 @@ public final class NetworkCapabilitiesUtils {
*
* @return {@code true} if the network should be restricted.
*/
// TODO: Use packBits(nc.getCapabilities()) to check more easily using bit masks.
public static boolean inferRestrictedCapability(NetworkCapabilities nc) {
return inferRestrictedCapability(packBits(nc.getCapabilities()));
}
/**
* Infers that all the capabilities it provides are typically provided by restricted networks
* or not.
*
* @param capabilities see {@link NetworkCapabilities#getCapabilities()}
*
* @return {@code true} if the network should be restricted.
*/
public static boolean inferRestrictedCapability(long capabilities) {
// Check if we have any capability that forces the network to be restricted.
for (int capability : unpackBits(FORCE_RESTRICTED_CAPABILITIES)) {
if (nc.hasCapability(capability)) {
return true;
}
if ((capabilities & FORCE_RESTRICTED_CAPABILITIES) != 0) {
return true;
}
// Verify there aren't any unrestricted capabilities. If there are we say
// the whole thing is unrestricted unless it is forced to be restricted.
for (int capability : unpackBits(UNRESTRICTED_CAPABILITIES)) {
if (nc.hasCapability(capability)) {
return false;
}
if ((capabilities & UNRESTRICTED_CAPABILITIES) != 0) {
return false;
}
// Must have at least some restricted capabilities.
for (int capability : unpackBits(RESTRICTED_CAPABILITIES)) {
if (nc.hasCapability(capability)) {
return true;
}
if ((capabilities & RESTRICTED_CAPABILITIES) != 0) {
return true;
}
return false;
}