Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move TetheringConfiguration out to its own file

Browse Source 
Test: as follows
    - built (bullhead)
    - flashed
    - booted
    - runtest frameworks-net
    - vanilla tethering works
        - changing from no dun requirement to dun shows dun required
Bug: 32163131

Change-Id: I488449570dff057311b37335923ce6a199b363b7
This commit is contained in:
Erik Kline
2017-01-21 14:33:56 +09:00
parent 7f018500dc
commit 79868f8c57
2 changed files with 164 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
services/core/java/com/android/server/connectivity/Tethering.java
View File

@@ -76,6 +76,7 @@ import com.android.internal.util.StateMachine;
import com.android.server.connectivity.tethering.IControlsTethering;
import com.android.server.connectivity.tethering.IPv6TetheringCoordinator;
import com.android.server.connectivity.tethering.IPv6TetheringInterfaceServices;
import com.android.server.connectivity.tethering.TetheringConfiguration;
import com.android.server.connectivity.tethering.TetherInterfaceStateMachine;
import com.android.server.connectivity.tethering.UpstreamNetworkMonitor;
import com.android.server.net.BaseNetworkObserver;
@@ -118,10 +119,6 @@ public class Tethering extends BaseNetworkObserver implements IControlsTethering
// used to synchronize public access to members
private final Object mPublicSync;
private static final Integer MOBILE_TYPE = new Integer(ConnectivityManager.TYPE_MOBILE);
private static final Integer HIPRI_TYPE = new Integer(ConnectivityManager.TYPE_MOBILE_HIPRI);
private static final Integer DUN_TYPE = new Integer(ConnectivityManager.TYPE_MOBILE_DUN);
private final INetworkManagementService mNMService;
private final INetworkStatsService mStatsService;
private final INetworkPolicyManager mPolicyManager;
@@ -1690,119 +1687,4 @@ public class Tethering extends BaseNetworkObserver implements IControlsTethering
private static String[] copy(String[] strarray) {
return Arrays.copyOf(strarray, strarray.length);
}
private static class TetheringConfiguration {
private static final int DUN_NOT_REQUIRED = 0;
private static final int DUN_REQUIRED = 1;
private static final int DUN_UNSPECIFIED = 2;
// USB is 192.168.42.1 and 255.255.255.0
// Wifi is 192.168.43.1 and 255.255.255.0
// BT is limited to max default of 5 connections. 192.168.44.1 to 192.168.48.1
// with 255.255.255.0
// P2P is 192.168.49.1 and 255.255.255.0
private static final String[] DHCP_DEFAULT_RANGE = {
"192.168.42.2", "192.168.42.254", "192.168.43.2", "192.168.43.254",
"192.168.44.2", "192.168.44.254", "192.168.45.2", "192.168.45.254",
"192.168.46.2", "192.168.46.254", "192.168.47.2", "192.168.47.254",
"192.168.48.2", "192.168.48.254", "192.168.49.2", "192.168.49.254",
};
private final String[] DEFAULT_IPV4_DNS = {"8.8.4.4", "8.8.8.8"};
public final String[] tetherableUsbRegexs;
public final String[] tetherableWifiRegexs;
public final String[] tetherableBluetoothRegexs;
public final boolean isDunRequired;
public final Collection<Integer> preferredUpstreamIfaceTypes;
public final String[] dhcpRanges;
public final String[] defaultIPv4DNS;
public TetheringConfiguration(Context ctx) {
tetherableUsbRegexs = ctx.getResources().getStringArray(
com.android.internal.R.array.config_tether_usb_regexs);
tetherableWifiRegexs = ctx.getResources().getStringArray(
com.android.internal.R.array.config_tether_wifi_regexs);
tetherableBluetoothRegexs = ctx.getResources().getStringArray(
com.android.internal.R.array.config_tether_bluetooth_regexs);
isDunRequired = checkDunRequired(ctx);
preferredUpstreamIfaceTypes = getUpstreamIfaceTypes(ctx, isDunRequired);
dhcpRanges = getDhcpRanges(ctx);
defaultIPv4DNS = copy(DEFAULT_IPV4_DNS);
}
public boolean isUsb(String iface) {
for (String regex : tetherableUsbRegexs) {
if (iface.matches(regex)) return true;
}
return false;
}
public boolean isWifi(String iface) {
for (String regex : tetherableWifiRegexs) {
if (iface.matches(regex)) return true;
}
return false;
}
public boolean isBluetooth(String iface) {
for (String regex : tetherableBluetoothRegexs) {
if (iface.matches(regex)) return true;
}
return false;
}
private static boolean checkDunRequired(Context ctx) {
final TelephonyManager tm = ctx.getSystemService(TelephonyManager.class);
final int secureSetting =
(tm != null) ? tm.getTetherApnRequired() : DUN_UNSPECIFIED;
return (secureSetting == DUN_REQUIRED);
}
private static Collection<Integer> getUpstreamIfaceTypes(Context ctx, boolean requiresDun) {
final int ifaceTypes[] = ctx.getResources().getIntArray(
com.android.internal.R.array.config_tether_upstream_types);
final ArrayList<Integer> upstreamIfaceTypes = new ArrayList<>(ifaceTypes.length);
for (int i : ifaceTypes) {
upstreamIfaceTypes.add(i);
}
// Fix up upstream interface types for DUN or mobile.
// TODO: Perform this filtering step in the above for loop.
if (requiresDun) {
while (upstreamIfaceTypes.contains(MOBILE_TYPE)) {
upstreamIfaceTypes.remove(MOBILE_TYPE);
}
while (upstreamIfaceTypes.contains(HIPRI_TYPE)) {
upstreamIfaceTypes.remove(HIPRI_TYPE);
}
if (!upstreamIfaceTypes.contains(DUN_TYPE)) {
upstreamIfaceTypes.add(DUN_TYPE);
}
} else {
while (upstreamIfaceTypes.contains(DUN_TYPE)) {
upstreamIfaceTypes.remove(DUN_TYPE);
}
if (!upstreamIfaceTypes.contains(MOBILE_TYPE)) {
upstreamIfaceTypes.add(MOBILE_TYPE);
}
if (!upstreamIfaceTypes.contains(HIPRI_TYPE)) {
upstreamIfaceTypes.add(HIPRI_TYPE);
}
}
return upstreamIfaceTypes;
}
private static String[] getDhcpRanges(Context ctx) {
final String[] fromResource = ctx.getResources().getStringArray(
com.android.internal.R.array.config_tether_dhcp_range);
if ((fromResource.length > 0) && (fromResource.length % 2 == 0)) {
return fromResource;
}
return copy(DHCP_DEFAULT_RANGE);
}
}
}

163
services/core/java/com/android/server/connectivity/tethering/TetheringConfiguration.java Normal file
View File

@@ -0,0 +1,163 @@
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.server.connectivity.tethering;
import static android.net.ConnectivityManager.TYPE_MOBILE;
import static android.net.ConnectivityManager.TYPE_MOBILE_DUN;
import static android.net.ConnectivityManager.TYPE_MOBILE_HIPRI;
import android.content.Context;
import android.content.res.Resources;
import android.telephony.TelephonyManager;
import android.util.Log;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
/**
* A utility class to encapsulate the various tethering configuration elements.
*
* This configuration data includes elements describing upstream properties
* (preferred and required types of upstream connectivity as well as default
* DNS servers to use if none are available) and downstream properties (such
* as regular expressions use to match suitable downstream interfaces and the
* DHCPv4 ranges to use).
*
* @hide
*/
public class TetheringConfiguration {
private static final String TAG = TetheringConfiguration.class.getSimpleName();
private static final int DUN_NOT_REQUIRED = 0;
private static final int DUN_REQUIRED = 1;
private static final int DUN_UNSPECIFIED = 2;
// USB is 192.168.42.1 and 255.255.255.0
// Wifi is 192.168.43.1 and 255.255.255.0
// BT is limited to max default of 5 connections. 192.168.44.1 to 192.168.48.1
// with 255.255.255.0
// P2P is 192.168.49.1 and 255.255.255.0
private static final String[] DHCP_DEFAULT_RANGE = {
"192.168.42.2", "192.168.42.254", "192.168.43.2", "192.168.43.254",
"192.168.44.2", "192.168.44.254", "192.168.45.2", "192.168.45.254",
"192.168.46.2", "192.168.46.254", "192.168.47.2", "192.168.47.254",
"192.168.48.2", "192.168.48.254", "192.168.49.2", "192.168.49.254",
};
private final String[] DEFAULT_IPV4_DNS = {"8.8.4.4", "8.8.8.8"};
public final String[] tetherableUsbRegexs;
public final String[] tetherableWifiRegexs;
public final String[] tetherableBluetoothRegexs;
public final boolean isDunRequired;
public final Collection<Integer> preferredUpstreamIfaceTypes;
public final String[] dhcpRanges;
public final String[] defaultIPv4DNS;
public TetheringConfiguration(Context ctx) {
tetherableUsbRegexs = ctx.getResources().getStringArray(
com.android.internal.R.array.config_tether_usb_regexs);
tetherableWifiRegexs = ctx.getResources().getStringArray(
com.android.internal.R.array.config_tether_wifi_regexs);
tetherableBluetoothRegexs = ctx.getResources().getStringArray(
com.android.internal.R.array.config_tether_bluetooth_regexs);
isDunRequired = checkDunRequired(ctx);
preferredUpstreamIfaceTypes = getUpstreamIfaceTypes(ctx, isDunRequired);
dhcpRanges = getDhcpRanges(ctx);
defaultIPv4DNS = copy(DEFAULT_IPV4_DNS);
}
public boolean isUsb(String iface) {
return matchesDownstreamRegexs(iface, tetherableUsbRegexs);
}
public boolean isWifi(String iface) {
return matchesDownstreamRegexs(iface, tetherableWifiRegexs);
}
public boolean isBluetooth(String iface) {
return matchesDownstreamRegexs(iface, tetherableBluetoothRegexs);
}
private static boolean checkDunRequired(Context ctx) {
final TelephonyManager tm = ctx.getSystemService(TelephonyManager.class);
final int secureSetting =
(tm != null) ? tm.getTetherApnRequired() : DUN_UNSPECIFIED;
return (secureSetting == DUN_REQUIRED);
}
private static Collection<Integer> getUpstreamIfaceTypes(Context ctx, boolean requiresDun) {
final int ifaceTypes[] = ctx.getResources().getIntArray(
com.android.internal.R.array.config_tether_upstream_types);
final ArrayList<Integer> upstreamIfaceTypes = new ArrayList<>(ifaceTypes.length);
for (int i : ifaceTypes) {
switch (i) {
case TYPE_MOBILE:
case TYPE_MOBILE_HIPRI:
if (requiresDun) continue;
break;
case TYPE_MOBILE_DUN:
if (!requiresDun) continue;
break;
}
upstreamIfaceTypes.add(i);
}
// Fix up upstream interface types for DUN or mobile. NOTE: independent
// of the value of |requiresDun|, cell data of one form or another is
// *always* an upstream, regardless of the upstream interface types
// specified by configuration resources.
if (requiresDun) {
if (!upstreamIfaceTypes.contains(TYPE_MOBILE_DUN)) {
upstreamIfaceTypes.add(TYPE_MOBILE_DUN);
}
} else {
if (!upstreamIfaceTypes.contains(TYPE_MOBILE)) {
upstreamIfaceTypes.add(TYPE_MOBILE);
}
if (!upstreamIfaceTypes.contains(TYPE_MOBILE_HIPRI)) {
upstreamIfaceTypes.add(TYPE_MOBILE_HIPRI);
}
}
return upstreamIfaceTypes;
}
private static boolean matchesDownstreamRegexs(String iface, String[] regexs) {
for (String regex : regexs) {
if (iface.matches(regex)) return true;
}
return false;
}
private static String[] getDhcpRanges(Context ctx) {
final String[] fromResource = ctx.getResources().getStringArray(
com.android.internal.R.array.config_tether_dhcp_range);
if ((fromResource.length > 0) && (fromResource.length % 2 == 0)) {
return fromResource;
}
return copy(DHCP_DEFAULT_RANGE);
}
private static String[] copy(String[] strarray) {
return Arrays.copyOf(strarray, strarray.length);
}
}