1/*
2 * Copyright (C) 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.server.connectivity.tethering;
18
19import static android.content.Context.TELEPHONY_SERVICE;
20import static android.net.ConnectivityManager.TYPE_ETHERNET;
21import static android.net.ConnectivityManager.TYPE_MOBILE;
22import static android.net.ConnectivityManager.TYPE_MOBILE_DUN;
23import static android.net.ConnectivityManager.TYPE_MOBILE_HIPRI;
24import static com.android.internal.R.array.config_mobile_hotspot_provision_app;
25import static com.android.internal.R.array.config_tether_bluetooth_regexs;
26import static com.android.internal.R.array.config_tether_dhcp_range;
27import static com.android.internal.R.array.config_tether_usb_regexs;
28import static com.android.internal.R.array.config_tether_upstream_types;
29import static com.android.internal.R.array.config_tether_wifi_regexs;
30import static com.android.internal.R.string.config_mobile_hotspot_provision_app_no_ui;
31
32import android.content.Context;
33import android.content.res.Resources;
34import android.net.ConnectivityManager;
35import android.net.util.SharedLog;
36import android.telephony.TelephonyManager;
37import android.text.TextUtils;
38
39import com.android.internal.annotations.VisibleForTesting;
40import com.android.internal.R;
41
42import java.io.PrintWriter;
43import java.util.ArrayList;
44import java.util.Arrays;
45import java.util.Collection;
46import java.util.StringJoiner;
47
48
49/**
50 * A utility class to encapsulate the various tethering configuration elements.
51 *
52 * This configuration data includes elements describing upstream properties
53 * (preferred and required types of upstream connectivity as well as default
54 * DNS servers to use if none are available) and downstream properties (such
55 * as regular expressions use to match suitable downstream interfaces and the
56 * DHCPv4 ranges to use).
57 *
58 * @hide
59 */
60public class TetheringConfiguration {
61    private static final String TAG = TetheringConfiguration.class.getSimpleName();
62
63    private static final String[] EMPTY_STRING_ARRAY = new String[0];
64
65    @VisibleForTesting
66    public static final int DUN_NOT_REQUIRED = 0;
67    public static final int DUN_REQUIRED = 1;
68    public static final int DUN_UNSPECIFIED = 2;
69
70    // USB is  192.168.42.1 and 255.255.255.0
71    // Wifi is 192.168.43.1 and 255.255.255.0
72    // BT is limited to max default of 5 connections. 192.168.44.1 to 192.168.48.1
73    // with 255.255.255.0
74    // P2P is 192.168.49.1 and 255.255.255.0
75    private static final String[] DHCP_DEFAULT_RANGE = {
76        "192.168.42.2", "192.168.42.254", "192.168.43.2", "192.168.43.254",
77        "192.168.44.2", "192.168.44.254", "192.168.45.2", "192.168.45.254",
78        "192.168.46.2", "192.168.46.254", "192.168.47.2", "192.168.47.254",
79        "192.168.48.2", "192.168.48.254", "192.168.49.2", "192.168.49.254",
80    };
81
82    private final String[] DEFAULT_IPV4_DNS = {"8.8.4.4", "8.8.8.8"};
83
84    public final String[] tetherableUsbRegexs;
85    public final String[] tetherableWifiRegexs;
86    public final String[] tetherableBluetoothRegexs;
87    public final int dunCheck;
88    public final boolean isDunRequired;
89    public final Collection<Integer> preferredUpstreamIfaceTypes;
90    public final String[] dhcpRanges;
91    public final String[] defaultIPv4DNS;
92
93    public final String[] provisioningApp;
94    public final String provisioningAppNoUi;
95
96    public TetheringConfiguration(Context ctx, SharedLog log) {
97        final SharedLog configLog = log.forSubComponent("config");
98
99        tetherableUsbRegexs = getResourceStringArray(ctx, config_tether_usb_regexs);
100        // TODO: Evaluate deleting this altogether now that Wi-Fi always passes
101        // us an interface name. Careful consideration needs to be given to
102        // implications for Settings and for provisioning checks.
103        tetherableWifiRegexs = getResourceStringArray(ctx, config_tether_wifi_regexs);
104        tetherableBluetoothRegexs = getResourceStringArray(ctx, config_tether_bluetooth_regexs);
105
106        dunCheck = checkDunRequired(ctx);
107        configLog.log("DUN check returned: " + dunCheckString(dunCheck));
108
109        preferredUpstreamIfaceTypes = getUpstreamIfaceTypes(ctx, dunCheck);
110        isDunRequired = preferredUpstreamIfaceTypes.contains(TYPE_MOBILE_DUN);
111
112        dhcpRanges = getDhcpRanges(ctx);
113        defaultIPv4DNS = copy(DEFAULT_IPV4_DNS);
114
115        provisioningApp = getResourceStringArray(ctx, config_mobile_hotspot_provision_app);
116        provisioningAppNoUi = getProvisioningAppNoUi(ctx);
117
118        configLog.log(toString());
119    }
120
121    public boolean isUsb(String iface) {
122        return matchesDownstreamRegexs(iface, tetherableUsbRegexs);
123    }
124
125    public boolean isWifi(String iface) {
126        return matchesDownstreamRegexs(iface, tetherableWifiRegexs);
127    }
128
129    public boolean isBluetooth(String iface) {
130        return matchesDownstreamRegexs(iface, tetherableBluetoothRegexs);
131    }
132
133    public boolean hasMobileHotspotProvisionApp() {
134        return !TextUtils.isEmpty(provisioningAppNoUi);
135    }
136
137    public void dump(PrintWriter pw) {
138        dumpStringArray(pw, "tetherableUsbRegexs", tetherableUsbRegexs);
139        dumpStringArray(pw, "tetherableWifiRegexs", tetherableWifiRegexs);
140        dumpStringArray(pw, "tetherableBluetoothRegexs", tetherableBluetoothRegexs);
141
142        pw.print("isDunRequired: ");
143        pw.println(isDunRequired);
144
145        dumpStringArray(pw, "preferredUpstreamIfaceTypes",
146                preferredUpstreamNames(preferredUpstreamIfaceTypes));
147
148        dumpStringArray(pw, "dhcpRanges", dhcpRanges);
149        dumpStringArray(pw, "defaultIPv4DNS", defaultIPv4DNS);
150
151        dumpStringArray(pw, "provisioningApp", provisioningApp);
152        pw.print("provisioningAppNoUi: ");
153        pw.println(provisioningAppNoUi);
154    }
155
156    public String toString() {
157        final StringJoiner sj = new StringJoiner(" ");
158        sj.add(String.format("tetherableUsbRegexs:%s", makeString(tetherableUsbRegexs)));
159        sj.add(String.format("tetherableWifiRegexs:%s", makeString(tetherableWifiRegexs)));
160        sj.add(String.format("tetherableBluetoothRegexs:%s",
161                makeString(tetherableBluetoothRegexs)));
162        sj.add(String.format("isDunRequired:%s", isDunRequired));
163        sj.add(String.format("preferredUpstreamIfaceTypes:%s",
164                makeString(preferredUpstreamNames(preferredUpstreamIfaceTypes))));
165        sj.add(String.format("provisioningApp:%s", makeString(provisioningApp)));
166        sj.add(String.format("provisioningAppNoUi:%s", provisioningAppNoUi));
167        return String.format("TetheringConfiguration{%s}", sj.toString());
168    }
169
170    private static void dumpStringArray(PrintWriter pw, String label, String[] values) {
171        pw.print(label);
172        pw.print(": ");
173
174        if (values != null) {
175            final StringJoiner sj = new StringJoiner(", ", "[", "]");
176            for (String value : values) { sj.add(value); }
177            pw.print(sj.toString());
178        } else {
179            pw.print("null");
180        }
181
182        pw.println();
183    }
184
185    private static String makeString(String[] strings) {
186        if (strings == null) return "null";
187        final StringJoiner sj = new StringJoiner(",", "[", "]");
188        for (String s : strings) sj.add(s);
189        return sj.toString();
190    }
191
192    private static String[] preferredUpstreamNames(Collection<Integer> upstreamTypes) {
193        String[] upstreamNames = null;
194
195        if (upstreamTypes != null) {
196            upstreamNames = new String[upstreamTypes.size()];
197            int i = 0;
198            for (Integer netType : upstreamTypes) {
199                upstreamNames[i] = ConnectivityManager.getNetworkTypeName(netType);
200                i++;
201            }
202        }
203
204        return upstreamNames;
205    }
206
207    public static int checkDunRequired(Context ctx) {
208        final TelephonyManager tm = (TelephonyManager) ctx.getSystemService(TELEPHONY_SERVICE);
209        return (tm != null) ? tm.getTetherApnRequired() : DUN_UNSPECIFIED;
210    }
211
212    private static String dunCheckString(int dunCheck) {
213        switch (dunCheck) {
214            case DUN_NOT_REQUIRED: return "DUN_NOT_REQUIRED";
215            case DUN_REQUIRED:     return "DUN_REQUIRED";
216            case DUN_UNSPECIFIED:  return "DUN_UNSPECIFIED";
217            default:
218                return String.format("UNKNOWN (%s)", dunCheck);
219        }
220    }
221
222    private static Collection<Integer> getUpstreamIfaceTypes(Context ctx, int dunCheck) {
223        final int ifaceTypes[] = ctx.getResources().getIntArray(config_tether_upstream_types);
224        final ArrayList<Integer> upstreamIfaceTypes = new ArrayList<>(ifaceTypes.length);
225        for (int i : ifaceTypes) {
226            switch (i) {
227                case TYPE_MOBILE:
228                case TYPE_MOBILE_HIPRI:
229                    if (dunCheck == DUN_REQUIRED) continue;
230                    break;
231                case TYPE_MOBILE_DUN:
232                    if (dunCheck == DUN_NOT_REQUIRED) continue;
233                    break;
234            }
235            upstreamIfaceTypes.add(i);
236        }
237
238        // Fix up upstream interface types for DUN or mobile. NOTE: independent
239        // of the value of |dunCheck|, cell data of one form or another is
240        // *always* an upstream, regardless of the upstream interface types
241        // specified by configuration resources.
242        if (dunCheck == DUN_REQUIRED) {
243            appendIfNotPresent(upstreamIfaceTypes, TYPE_MOBILE_DUN);
244        } else if (dunCheck == DUN_NOT_REQUIRED) {
245            appendIfNotPresent(upstreamIfaceTypes, TYPE_MOBILE);
246            appendIfNotPresent(upstreamIfaceTypes, TYPE_MOBILE_HIPRI);
247        } else {
248            // Fix upstream interface types for case DUN_UNSPECIFIED.
249            // Do not modify if a cellular interface type is already present in the
250            // upstream interface types. Add TYPE_MOBILE and TYPE_MOBILE_HIPRI if no
251            // cellular interface types are found in the upstream interface types.
252            if (!(containsOneOf(upstreamIfaceTypes,
253                    TYPE_MOBILE_DUN, TYPE_MOBILE, TYPE_MOBILE_HIPRI))) {
254                upstreamIfaceTypes.add(TYPE_MOBILE);
255                upstreamIfaceTypes.add(TYPE_MOBILE_HIPRI);
256            }
257        }
258
259        // Always make sure our good friend Ethernet is present.
260        // TODO: consider unilaterally forcing this at the front.
261        prependIfNotPresent(upstreamIfaceTypes, TYPE_ETHERNET);
262
263        return upstreamIfaceTypes;
264    }
265
266    private static boolean matchesDownstreamRegexs(String iface, String[] regexs) {
267        for (String regex : regexs) {
268            if (iface.matches(regex)) return true;
269        }
270        return false;
271    }
272
273    private static String[] getDhcpRanges(Context ctx) {
274        final String[] fromResource = getResourceStringArray(ctx, config_tether_dhcp_range);
275        if ((fromResource.length > 0) && (fromResource.length % 2 == 0)) {
276            return fromResource;
277        }
278        return copy(DHCP_DEFAULT_RANGE);
279    }
280
281    private static String getProvisioningAppNoUi(Context ctx) {
282        try {
283            return ctx.getResources().getString(config_mobile_hotspot_provision_app_no_ui);
284        } catch (Resources.NotFoundException e) {
285            return "";
286        }
287    }
288
289    private static String[] getResourceStringArray(Context ctx, int resId) {
290        try {
291            final String[] strArray = ctx.getResources().getStringArray(resId);
292            return (strArray != null) ? strArray : EMPTY_STRING_ARRAY;
293        } catch (Resources.NotFoundException e404) {
294            return EMPTY_STRING_ARRAY;
295        }
296    }
297
298    private static String[] copy(String[] strarray) {
299        return Arrays.copyOf(strarray, strarray.length);
300    }
301
302    private static void prependIfNotPresent(ArrayList<Integer> list, int value) {
303        if (list.contains(value)) return;
304        list.add(0, value);
305    }
306
307    private static void appendIfNotPresent(ArrayList<Integer> list, int value) {
308        if (list.contains(value)) return;
309        list.add(value);
310    }
311
312    private static boolean containsOneOf(ArrayList<Integer> list, Integer... values) {
313        for (Integer value : values) {
314            if (list.contains(value)) return true;
315        }
316        return false;
317    }
318}
319