| /* |
| * Copyright (C) 2010 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.wifi; |
| |
| import android.app.AppGlobals; |
| import android.app.admin.DeviceAdminInfo; |
| import android.app.admin.DevicePolicyManagerInternal; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.pm.ApplicationInfo; |
| import android.content.pm.PackageManager; |
| import android.net.IpConfiguration; |
| import android.net.IpConfiguration.IpAssignment; |
| import android.net.IpConfiguration.ProxySettings; |
| import android.net.NetworkInfo.DetailedState; |
| import android.net.ProxyInfo; |
| import android.net.StaticIpConfiguration; |
| import android.net.wifi.ScanResult; |
| import android.net.wifi.WifiConfiguration; |
| import android.net.wifi.WifiConfiguration.KeyMgmt; |
| import android.net.wifi.WifiConfiguration.Status; |
| import android.net.wifi.WifiEnterpriseConfig; |
| import android.net.wifi.WifiInfo; |
| import android.net.wifi.WifiManager; |
| import android.net.wifi.WifiSsid; |
| import android.net.wifi.WpsInfo; |
| import android.net.wifi.WpsResult; |
| import android.os.Environment; |
| import android.os.FileObserver; |
| import android.os.Process; |
| import android.os.RemoteException; |
| import android.os.SystemClock; |
| import android.os.UserHandle; |
| import android.provider.Settings; |
| import android.security.Credentials; |
| import android.security.KeyChain; |
| import android.security.KeyStore; |
| import android.text.TextUtils; |
| import android.util.LocalLog; |
| import android.util.Log; |
| import android.util.SparseArray; |
| |
| import com.android.server.LocalServices; |
| import com.android.internal.R; |
| import com.android.server.net.DelayedDiskWrite; |
| import com.android.server.net.IpConfigStore; |
| import com.android.server.wifi.anqp.ANQPElement; |
| import com.android.server.wifi.anqp.Constants; |
| import com.android.server.wifi.hotspot2.ANQPData; |
| import com.android.server.wifi.hotspot2.AnqpCache; |
| import com.android.server.wifi.hotspot2.NetworkDetail; |
| import com.android.server.wifi.hotspot2.PasspointMatch; |
| import com.android.server.wifi.hotspot2.SupplicantBridge; |
| import com.android.server.wifi.hotspot2.Utils; |
| import com.android.server.wifi.hotspot2.omadm.MOManager; |
| import com.android.server.wifi.hotspot2.pps.Credential; |
| import com.android.server.wifi.hotspot2.pps.HomeSP; |
| |
| import java.io.BufferedInputStream; |
| import java.io.BufferedReader; |
| import java.io.DataInputStream; |
| import java.io.DataOutputStream; |
| import java.io.EOFException; |
| import java.io.File; |
| import java.io.FileDescriptor; |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.FileReader; |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.nio.charset.StandardCharsets; |
| import java.security.PrivateKey; |
| import java.security.cert.Certificate; |
| import java.security.cert.CertificateException; |
| import java.util.ArrayList; |
| import java.util.BitSet; |
| import java.util.Calendar; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| import java.util.Set; |
| import java.util.concurrent.atomic.AtomicBoolean; |
| import java.util.concurrent.atomic.AtomicInteger; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| import java.util.zip.CRC32; |
| import java.util.zip.Checksum; |
| |
| import static android.net.wifi.WifiConfiguration.INVALID_NETWORK_ID; |
| |
| |
| /** |
| * This class provides the API to manage configured |
| * wifi networks. The API is not thread safe is being |
| * used only from WifiStateMachine. |
| * |
| * It deals with the following |
| * - Add/update/remove a WifiConfiguration |
| * The configuration contains two types of information. |
| * = IP and proxy configuration that is handled by WifiConfigStore and |
| * is saved to disk on any change. |
| * |
| * The format of configuration file is as follows: |
| * <version> |
| * <netA_key1><netA_value1><netA_key2><netA_value2>...<EOS> |
| * <netB_key1><netB_value1><netB_key2><netB_value2>...<EOS> |
| * .. |
| * |
| * (key, value) pairs for a given network are grouped together and can |
| * be in any order. A EOS at the end of a set of (key, value) pairs |
| * indicates that the next set of (key, value) pairs are for a new |
| * network. A network is identified by a unique ID_KEY. If there is no |
| * ID_KEY in the (key, value) pairs, the data is discarded. |
| * |
| * An invalid version on read would result in discarding the contents of |
| * the file. On the next write, the latest version is written to file. |
| * |
| * Any failures during read or write to the configuration file are ignored |
| * without reporting to the user since the likelihood of these errors are |
| * low and the impact on connectivity is low. |
| * |
| * = SSID & security details that is pushed to the supplicant. |
| * supplicant saves these details to the disk on calling |
| * saveConfigCommand(). |
| * |
| * We have two kinds of APIs exposed: |
| * > public API calls that provide fine grained control |
| * - enableNetwork, disableNetwork, addOrUpdateNetwork(), |
| * removeNetwork(). For these calls, the config is not persisted |
| * to the disk. (TODO: deprecate these calls in WifiManager) |
| * > The new API calls - selectNetwork(), saveNetwork() & forgetNetwork(). |
| * These calls persist the supplicant config to disk. |
| * |
| * - Maintain a list of configured networks for quick access |
| * |
| */ |
| public class WifiConfigStore extends IpConfigStore { |
| |
| private Context mContext; |
| public static final String TAG = "WifiConfigStore"; |
| private static final boolean DBG = true; |
| private static boolean VDBG = false; |
| private static boolean VVDBG = false; |
| |
| private static final String SUPPLICANT_CONFIG_FILE = "/data/misc/wifi/wpa_supplicant.conf"; |
| private static final String SUPPLICANT_CONFIG_FILE_BACKUP = SUPPLICANT_CONFIG_FILE + ".tmp"; |
| private static final String PPS_FILE = "/data/misc/wifi/PerProviderSubscription.conf"; |
| |
| /* configured networks with network id as the key */ |
| private final ConfigurationMap mConfiguredNetworks = new ConfigurationMap(); |
| |
| /* A network id is a unique identifier for a network configured in the |
| * supplicant. Network ids are generated when the supplicant reads |
| * the configuration file at start and can thus change for networks. |
| * We store the IP configuration for networks along with a unique id |
| * that is generated from SSID and security type of the network. A mapping |
| * from the generated unique id to network id of the network is needed to |
| * map supplicant config to IP configuration. */ |
| |
| /* Stores a map of NetworkId to ScanCache */ |
| private HashMap<Integer, ScanDetailCache> mScanDetailCaches; |
| |
| /** |
| * Framework keeps a list of (the CRC32 hashes of) all SSIDs that where deleted by user, |
| * so as, framework knows not to re-add those SSIDs automatically to the Saved networks |
| */ |
| private Set<Long> mDeletedSSIDs = new HashSet<Long>(); |
| |
| /** |
| * Framework keeps a list of ephemeral SSIDs that where deleted by user, |
| * so as, framework knows not to autojoin again those SSIDs based on scorer input. |
| * The list is never cleared up. |
| * |
| * The SSIDs are encoded in a String as per definition of WifiConfiguration.SSID field. |
| */ |
| public Set<String> mDeletedEphemeralSSIDs = new HashSet<String>(); |
| |
| /* Tracks the highest priority of configured networks */ |
| private int mLastPriority = -1; |
| |
| private static final String ipConfigFile = Environment.getDataDirectory() + |
| "/misc/wifi/ipconfig.txt"; |
| |
| private static final String networkHistoryConfigFile = Environment.getDataDirectory() + |
| "/misc/wifi/networkHistory.txt"; |
| |
| private static final String autoJoinConfigFile = Environment.getDataDirectory() + |
| "/misc/wifi/autojoinconfig.txt"; |
| |
| /* Network History Keys */ |
| private static final String SSID_KEY = "SSID"; |
| private static final String CONFIG_KEY = "CONFIG"; |
| private static final String CHOICE_KEY = "CHOICE"; |
| private static final String LINK_KEY = "LINK"; |
| private static final String BSSID_KEY = "BSSID"; |
| private static final String BSSID_KEY_END = "/BSSID"; |
| private static final String RSSI_KEY = "RSSI"; |
| private static final String FREQ_KEY = "FREQ"; |
| private static final String DATE_KEY = "DATE"; |
| private static final String MILLI_KEY = "MILLI"; |
| private static final String BLACKLIST_MILLI_KEY = "BLACKLIST_MILLI"; |
| private static final String NETWORK_ID_KEY = "ID"; |
| private static final String PRIORITY_KEY = "PRIORITY"; |
| private static final String DEFAULT_GW_KEY = "DEFAULT_GW"; |
| private static final String AUTH_KEY = "AUTH"; |
| private static final String STATUS_KEY = "AUTO_JOIN_STATUS"; |
| private static final String BSSID_STATUS_KEY = "BSSID_STATUS"; |
| private static final String SELF_ADDED_KEY = "SELF_ADDED"; |
| private static final String FAILURE_KEY = "FAILURE"; |
| private static final String DID_SELF_ADD_KEY = "DID_SELF_ADD"; |
| private static final String PEER_CONFIGURATION_KEY = "PEER_CONFIGURATION"; |
| private static final String CREATOR_UID_KEY = "CREATOR_UID_KEY"; |
| private static final String CONNECT_UID_KEY = "CONNECT_UID_KEY"; |
| private static final String UPDATE_UID_KEY = "UPDATE_UID"; |
| private static final String SUPPLICANT_STATUS_KEY = "SUP_STATUS"; |
| private static final String SUPPLICANT_DISABLE_REASON_KEY = "SUP_DIS_REASON"; |
| private static final String FQDN_KEY = "FQDN"; |
| private static final String NUM_CONNECTION_FAILURES_KEY = "CONNECT_FAILURES"; |
| private static final String NUM_IP_CONFIG_FAILURES_KEY = "IP_CONFIG_FAILURES"; |
| private static final String NUM_AUTH_FAILURES_KEY = "AUTH_FAILURES"; |
| private static final String SCORER_OVERRIDE_KEY = "SCORER_OVERRIDE"; |
| private static final String SCORER_OVERRIDE_AND_SWITCH_KEY = "SCORER_OVERRIDE_AND_SWITCH"; |
| private static final String VALIDATED_INTERNET_ACCESS_KEY = "VALIDATED_INTERNET_ACCESS"; |
| private static final String NO_INTERNET_ACCESS_REPORTS_KEY = "NO_INTERNET_ACCESS_REPORTS"; |
| private static final String EPHEMERAL_KEY = "EPHEMERAL"; |
| private static final String NUM_ASSOCIATION_KEY = "NUM_ASSOCIATION"; |
| private static final String DELETED_CRC32_KEY = "DELETED_CRC32"; |
| private static final String DELETED_EPHEMERAL_KEY = "DELETED_EPHEMERAL"; |
| private static final String JOIN_ATTEMPT_BOOST_KEY = "JOIN_ATTEMPT_BOOST"; |
| private static final String CREATOR_NAME_KEY = "CREATOR_NAME"; |
| private static final String UPDATE_NAME_KEY = "UPDATE_NAME"; |
| private static final String USER_APPROVED_KEY = "USER_APPROVED"; |
| private static final String CREATION_TIME_KEY = "CREATION_TIME"; |
| private static final String UPDATE_TIME_KEY = "UPDATE_TIME"; |
| |
| private static final String SEPARATOR = ": "; |
| private static final String NL = "\n"; |
| |
| private static final String THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_5G_KEY |
| = "THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_5G"; |
| private static final String THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_24G_KEY |
| = "THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_24G"; |
| private static final String THRESHOLD_UNBLACKLIST_HARD_5G_KEY |
| = "THRESHOLD_UNBLACKLIST_HARD_5G"; |
| private static final String THRESHOLD_UNBLACKLIST_SOFT_5G_KEY |
| = "THRESHOLD_UNBLACKLIST_SOFT_5G"; |
| private static final String THRESHOLD_UNBLACKLIST_HARD_24G_KEY |
| = "THRESHOLD_UNBLACKLIST_HARD_24G"; |
| private static final String THRESHOLD_UNBLACKLIST_SOFT_24G_KEY |
| = "THRESHOLD_UNBLACKLIST_SOFT_24G"; |
| private static final String THRESHOLD_GOOD_RSSI_5_KEY |
| = "THRESHOLD_GOOD_RSSI_5"; |
| private static final String THRESHOLD_LOW_RSSI_5_KEY |
| = "THRESHOLD_LOW_RSSI_5"; |
| private static final String THRESHOLD_BAD_RSSI_5_KEY |
| = "THRESHOLD_BAD_RSSI_5"; |
| private static final String THRESHOLD_GOOD_RSSI_24_KEY |
| = "THRESHOLD_GOOD_RSSI_24"; |
| private static final String THRESHOLD_LOW_RSSI_24_KEY |
| = "THRESHOLD_LOW_RSSI_24"; |
| private static final String THRESHOLD_BAD_RSSI_24_KEY |
| = "THRESHOLD_BAD_RSSI_24"; |
| |
| private static final String THRESHOLD_MAX_TX_PACKETS_FOR_NETWORK_SWITCHING_KEY |
| = "THRESHOLD_MAX_TX_PACKETS_FOR_NETWORK_SWITCHING"; |
| private static final String THRESHOLD_MAX_RX_PACKETS_FOR_NETWORK_SWITCHING_KEY |
| = "THRESHOLD_MAX_RX_PACKETS_FOR_NETWORK_SWITCHING"; |
| |
| private static final String THRESHOLD_MAX_TX_PACKETS_FOR_FULL_SCANS_KEY |
| = "THRESHOLD_MAX_TX_PACKETS_FOR_FULL_SCANS"; |
| private static final String THRESHOLD_MAX_RX_PACKETS_FOR_FULL_SCANS_KEY |
| = "THRESHOLD_MAX_RX_PACKETS_FOR_FULL_SCANS"; |
| |
| private static final String THRESHOLD_MAX_TX_PACKETS_FOR_PARTIAL_SCANS_KEY |
| = "THRESHOLD_MAX_TX_PACKETS_FOR_PARTIAL_SCANS"; |
| private static final String THRESHOLD_MAX_RX_PACKETS_FOR_PARTIAL_SCANS_KEY |
| = "THRESHOLD_MAX_RX_PACKETS_FOR_PARTIAL_SCANS"; |
| |
| private static final String MAX_NUM_ACTIVE_CHANNELS_FOR_PARTIAL_SCANS_KEY |
| = "MAX_NUM_ACTIVE_CHANNELS_FOR_PARTIAL_SCANS"; |
| private static final String MAX_NUM_PASSIVE_CHANNELS_FOR_PARTIAL_SCANS_KEY |
| = "MAX_NUM_PASSIVE_CHANNELS_FOR_PARTIAL_SCANS"; |
| |
| private static final String A_BAND_PREFERENCE_RSSI_THRESHOLD_LOW_KEY = |
| "A_BAND_PREFERENCE_RSSI_THRESHOLD_LOW"; |
| private static final String A_BAND_PREFERENCE_RSSI_THRESHOLD_KEY = |
| "A_BAND_PREFERENCE_RSSI_THRESHOLD"; |
| private static final String G_BAND_PREFERENCE_RSSI_THRESHOLD_KEY = |
| "G_BAND_PREFERENCE_RSSI_THRESHOLD"; |
| |
| private static final String ENABLE_AUTOJOIN_WHILE_ASSOCIATED_KEY |
| = "ENABLE_AUTOJOIN_WHILE_ASSOCIATED: "; |
| |
| private static final String ASSOCIATED_PARTIAL_SCAN_PERIOD_KEY |
| = "ASSOCIATED_PARTIAL_SCAN_PERIOD"; |
| private static final String ASSOCIATED_FULL_SCAN_BACKOFF_KEY |
| = "ASSOCIATED_FULL_SCAN_BACKOFF_PERIOD"; |
| private static final String ALWAYS_ENABLE_SCAN_WHILE_ASSOCIATED_KEY |
| = "ALWAYS_ENABLE_SCAN_WHILE_ASSOCIATED"; |
| private static final String ONLY_LINK_SAME_CREDENTIAL_CONFIGURATIONS_KEY |
| = "ONLY_LINK_SAME_CREDENTIAL_CONFIGURATIONS"; |
| |
| private static final String ENABLE_FULL_BAND_SCAN_WHEN_ASSOCIATED_KEY |
| = "ENABLE_FULL_BAND_SCAN_WHEN_ASSOCIATED"; |
| |
| private static final String ENABLE_HAL_BASED_PNO |
| = "ENABLE_HAL_BASED_PNO"; |
| |
| // The three below configurations are mainly for power stats and CPU usage tracking |
| // allowing to incrementally disable framework features |
| private static final String ENABLE_AUTO_JOIN_WHILE_ASSOCIATED_KEY |
| = "ENABLE_AUTO_JOIN_WHILE_ASSOCIATED"; |
| private static final String ENABLE_CHIP_WAKE_UP_WHILE_ASSOCIATED_KEY |
| = "ENABLE_CHIP_WAKE_UP_WHILE_ASSOCIATED"; |
| private static final String ENABLE_RSSI_POLL_WHILE_ASSOCIATED_KEY |
| = "ENABLE_RSSI_POLL_WHILE_ASSOCIATED_KEY"; |
| |
| public static final String idStringVarName = "id_str"; |
| |
| // The Wifi verbose log is provided as a way to persist the verbose logging settings |
| // for testing purpose. |
| // It is not intended for normal use. |
| private static final String WIFI_VERBOSE_LOGS_KEY |
| = "WIFI_VERBOSE_LOGS"; |
| |
| // As we keep deleted PSK WifiConfiguration for a while, the PSK of |
| // those deleted WifiConfiguration is set to this random unused PSK |
| private static final String DELETED_CONFIG_PSK = "Mjkd86jEMGn79KhKll298Uu7-deleted"; |
| |
| public int maxTxPacketForFullScans = 8; |
| public int maxRxPacketForFullScans = 16; |
| |
| public int maxTxPacketForPartialScans = 40; |
| public int maxRxPacketForPartialScans = 80; |
| |
| public int associatedFullScanMaxIntervalMilli = 300000; |
| |
| // Sane value for roam blacklisting (not switching to a network if already associated) |
| // 2 days |
| public int networkSwitchingBlackListPeriodMilli = 2 * 24 * 60 * 60 * 1000; |
| |
| public int bandPreferenceBoostFactor5 = 5; // Boost by 5 dB per dB above threshold |
| public int bandPreferencePenaltyFactor5 = 2; // Penalize by 2 dB per dB below threshold |
| |
| public int badLinkSpeed24 = 6; |
| public int badLinkSpeed5 = 12; |
| public int goodLinkSpeed24 = 24; |
| public int goodLinkSpeed5 = 36; |
| |
| public int maxAuthErrorsToBlacklist = 4; |
| public int maxConnectionErrorsToBlacklist = 4; |
| public int wifiConfigBlacklistMinTimeMilli = 1000 * 60 * 5; |
| |
| // How long a disconnected config remain considered as the last user selection |
| public int wifiConfigLastSelectionHysteresis = 1000 * 60 * 3; |
| |
| // Boost RSSI values of associated networks |
| public int associatedHysteresisHigh = +14; |
| public int associatedHysteresisLow = +8; |
| |
| boolean showNetworks = true; // TODO set this back to false, used for debugging 17516271 |
| |
| public boolean roamOnAny = false; |
| public boolean onlyLinkSameCredentialConfigurations = true; |
| |
| public boolean enableLinkDebouncing = true; |
| public boolean enable5GHzPreference = true; |
| public boolean enableWifiCellularHandoverUserTriggeredAdjustment = true; |
| |
| public int currentNetworkBoost = 25; |
| public int scanResultRssiLevelPatchUp = -85; |
| |
| public static final int maxNumScanCacheEntries = 128; |
| |
| public final AtomicBoolean enableHalBasedPno = new AtomicBoolean(true); |
| public final AtomicBoolean enableSsidWhitelist = new AtomicBoolean(true); |
| public final AtomicBoolean enableAutoJoinWhenAssociated = new AtomicBoolean(true); |
| public final AtomicBoolean enableFullBandScanWhenAssociated = new AtomicBoolean(true); |
| public final AtomicBoolean enableChipWakeUpWhenAssociated = new AtomicBoolean(true); |
| public final AtomicBoolean enableRssiPollWhenAssociated = new AtomicBoolean(true); |
| public final AtomicInteger thresholdInitialAutoJoinAttemptMin5RSSI = |
| new AtomicInteger(WifiConfiguration.INITIAL_AUTO_JOIN_ATTEMPT_MIN_5); |
| public final AtomicInteger thresholdInitialAutoJoinAttemptMin24RSSI = |
| new AtomicInteger(WifiConfiguration.INITIAL_AUTO_JOIN_ATTEMPT_MIN_24); |
| public final AtomicInteger thresholdUnblacklistThreshold5Hard |
| = new AtomicInteger(WifiConfiguration.UNBLACKLIST_THRESHOLD_5_HARD); |
| public final AtomicInteger thresholdUnblacklistThreshold5Soft |
| = new AtomicInteger(WifiConfiguration.UNBLACKLIST_THRESHOLD_5_SOFT); |
| public final AtomicInteger thresholdUnblacklistThreshold24Hard |
| = new AtomicInteger(WifiConfiguration.UNBLACKLIST_THRESHOLD_24_HARD); |
| public final AtomicInteger thresholdUnblacklistThreshold24Soft |
| = new AtomicInteger(WifiConfiguration.UNBLACKLIST_THRESHOLD_24_SOFT); |
| public final AtomicInteger thresholdGoodRssi5 = |
| new AtomicInteger(WifiConfiguration.GOOD_RSSI_5); |
| public final AtomicInteger thresholdLowRssi5 = new AtomicInteger(WifiConfiguration.LOW_RSSI_5); |
| public final AtomicInteger thresholdBadRssi5 = new AtomicInteger(WifiConfiguration.BAD_RSSI_5); |
| public final AtomicInteger thresholdGoodRssi24 = |
| new AtomicInteger(WifiConfiguration.GOOD_RSSI_24); |
| public final AtomicInteger thresholdLowRssi24 = new AtomicInteger(WifiConfiguration.LOW_RSSI_24); |
| public final AtomicInteger thresholdBadRssi24 = new AtomicInteger(WifiConfiguration.BAD_RSSI_24); |
| public final AtomicInteger maxTxPacketForNetworkSwitching = new AtomicInteger(40); |
| public final AtomicInteger maxRxPacketForNetworkSwitching = new AtomicInteger(80); |
| public final AtomicInteger enableVerboseLogging = new AtomicInteger(0); |
| public final AtomicInteger bandPreferenceBoostThreshold5 = |
| new AtomicInteger(WifiConfiguration.A_BAND_PREFERENCE_RSSI_THRESHOLD); |
| public final AtomicInteger associatedFullScanBackoff = |
| new AtomicInteger(12); // Will be divided by 8 by WifiStateMachine |
| public final AtomicInteger bandPreferencePenaltyThreshold5 = |
| new AtomicInteger(WifiConfiguration.G_BAND_PREFERENCE_RSSI_THRESHOLD); |
| public final AtomicInteger alwaysEnableScansWhileAssociated = new AtomicInteger(0); |
| public final AtomicInteger maxNumPassiveChannelsForPartialScans = new AtomicInteger(2); |
| public final AtomicInteger maxNumActiveChannelsForPartialScans = new AtomicInteger(6); |
| public final AtomicInteger wifiDisconnectedShortScanIntervalMilli = new AtomicInteger(15000); |
| public final AtomicInteger wifiDisconnectedLongScanIntervalMilli = new AtomicInteger(120000); |
| public final AtomicInteger wifiAssociatedShortScanIntervalMilli = new AtomicInteger(20000); |
| public final AtomicInteger wifiAssociatedLongScanIntervalMilli = new AtomicInteger(180000); |
| |
| private static final Map<String, Object> sKeyMap = new HashMap<>(); |
| |
| /** |
| * Regex pattern for extracting a connect choice. |
| * Matches a strings like the following: |
| * <configKey>=([0:9]+) |
| */ |
| private static Pattern mConnectChoice = |
| Pattern.compile("(.*)=([0-9]+)"); |
| |
| |
| /* Enterprise configuration keys */ |
| /** |
| * In old configurations, the "private_key" field was used. However, newer |
| * configurations use the key_id field with the engine_id set to "keystore". |
| * If this field is found in the configuration, the migration code is |
| * triggered. |
| */ |
| public static final String OLD_PRIVATE_KEY_NAME = "private_key"; |
| |
| /** |
| * This represents an empty value of an enterprise field. |
| * NULL is used at wpa_supplicant to indicate an empty value |
| */ |
| static final String EMPTY_VALUE = "NULL"; |
| |
| // Internal use only |
| private static final String[] ENTERPRISE_CONFIG_SUPPLICANT_KEYS = new String[] { |
| WifiEnterpriseConfig.EAP_KEY, WifiEnterpriseConfig.PHASE2_KEY, |
| WifiEnterpriseConfig.IDENTITY_KEY, WifiEnterpriseConfig.ANON_IDENTITY_KEY, |
| WifiEnterpriseConfig.PASSWORD_KEY, WifiEnterpriseConfig.CLIENT_CERT_KEY, |
| WifiEnterpriseConfig.CA_CERT_KEY, WifiEnterpriseConfig.SUBJECT_MATCH_KEY, |
| WifiEnterpriseConfig.ENGINE_KEY, WifiEnterpriseConfig.ENGINE_ID_KEY, |
| WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY, WifiEnterpriseConfig.ALTSUBJECT_MATCH_KEY, |
| WifiEnterpriseConfig.DOM_SUFFIX_MATCH_KEY |
| }; |
| |
| |
| /** |
| * If Connectivity Service has triggered an unwanted network disconnect |
| */ |
| public long lastUnwantedNetworkDisconnectTimestamp = 0; |
| |
| /** |
| * The maximum number of times we will retry a connection to an access point |
| * for which we have failed in acquiring an IP address from DHCP. A value of |
| * N means that we will make N+1 connection attempts in all. |
| * <p> |
| * See {@link Settings.Secure#WIFI_MAX_DHCP_RETRY_COUNT}. This is the default |
| * value if a Settings value is not present. |
| */ |
| private static final int DEFAULT_MAX_DHCP_RETRIES = 9; |
| |
| |
| private final LocalLog mLocalLog; |
| private final WpaConfigFileObserver mFileObserver; |
| |
| private WifiNative mWifiNative; |
| private final KeyStore mKeyStore = KeyStore.getInstance(); |
| |
| /** |
| * The lastSelectedConfiguration is used to remember which network |
| * was selected last by the user. |
| * The connection to this network may not be successful, as well |
| * the selection (i.e. network priority) might not be persisted. |
| * WiFi state machine is the only object that sets this variable. |
| */ |
| private String lastSelectedConfiguration = null; |
| |
| /** |
| * Cached PNO list, it is updated when WifiConfiguration changes due to user input. |
| */ |
| ArrayList<WifiNative.WifiPnoNetwork> mCachedPnoList |
| = new ArrayList<WifiNative.WifiPnoNetwork>(); |
| |
| /* |
| * BSSID blacklist, i.e. list of BSSID we want to avoid |
| */ |
| HashSet<String> mBssidBlacklist = new HashSet<String>(); |
| |
| /* |
| * Lost config list, whenever we read a config from networkHistory.txt that was not in |
| * wpa_supplicant.conf |
| */ |
| HashSet<String> mLostConfigsDbg = new HashSet<String>(); |
| |
| private final AnqpCache mAnqpCache; |
| private final SupplicantBridge mSupplicantBridge; |
| private final MOManager mMOManager; |
| private final SIMAccessor mSIMAccessor; |
| |
| private WifiStateMachine mWifiStateMachine; |
| |
| WifiConfigStore(Context c, WifiStateMachine w, WifiNative wn) { |
| mContext = c; |
| mWifiNative = wn; |
| mWifiStateMachine = w; |
| |
| // A map for value setting in readAutoJoinConfig() - replacing the replicated code. |
| sKeyMap.put(ENABLE_AUTO_JOIN_WHILE_ASSOCIATED_KEY, enableAutoJoinWhenAssociated); |
| sKeyMap.put(ENABLE_FULL_BAND_SCAN_WHEN_ASSOCIATED_KEY, enableFullBandScanWhenAssociated); |
| sKeyMap.put(ENABLE_CHIP_WAKE_UP_WHILE_ASSOCIATED_KEY, enableChipWakeUpWhenAssociated); |
| sKeyMap.put(ENABLE_RSSI_POLL_WHILE_ASSOCIATED_KEY, enableRssiPollWhenAssociated); |
| sKeyMap.put(THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_5G_KEY, thresholdInitialAutoJoinAttemptMin5RSSI); |
| sKeyMap.put(THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_24G_KEY, thresholdInitialAutoJoinAttemptMin24RSSI); |
| sKeyMap.put(THRESHOLD_UNBLACKLIST_HARD_5G_KEY, thresholdUnblacklistThreshold5Hard); |
| sKeyMap.put(THRESHOLD_UNBLACKLIST_SOFT_5G_KEY, thresholdUnblacklistThreshold5Soft); |
| sKeyMap.put(THRESHOLD_UNBLACKLIST_HARD_24G_KEY, thresholdUnblacklistThreshold24Hard); |
| sKeyMap.put(THRESHOLD_UNBLACKLIST_SOFT_24G_KEY, thresholdUnblacklistThreshold24Soft); |
| sKeyMap.put(THRESHOLD_GOOD_RSSI_5_KEY, thresholdGoodRssi5); |
| sKeyMap.put(THRESHOLD_LOW_RSSI_5_KEY, thresholdLowRssi5); |
| sKeyMap.put(THRESHOLD_BAD_RSSI_5_KEY, thresholdBadRssi5); |
| sKeyMap.put(THRESHOLD_GOOD_RSSI_24_KEY, thresholdGoodRssi24); |
| sKeyMap.put(THRESHOLD_LOW_RSSI_24_KEY, thresholdLowRssi24); |
| sKeyMap.put(THRESHOLD_BAD_RSSI_24_KEY, thresholdBadRssi24); |
| sKeyMap.put(THRESHOLD_MAX_TX_PACKETS_FOR_NETWORK_SWITCHING_KEY, maxTxPacketForNetworkSwitching); |
| sKeyMap.put(THRESHOLD_MAX_RX_PACKETS_FOR_NETWORK_SWITCHING_KEY, maxRxPacketForNetworkSwitching); |
| sKeyMap.put(THRESHOLD_MAX_TX_PACKETS_FOR_FULL_SCANS_KEY, maxTxPacketForNetworkSwitching); |
| sKeyMap.put(THRESHOLD_MAX_RX_PACKETS_FOR_FULL_SCANS_KEY, maxRxPacketForNetworkSwitching); |
| sKeyMap.put(THRESHOLD_MAX_TX_PACKETS_FOR_PARTIAL_SCANS_KEY, maxTxPacketForNetworkSwitching); |
| sKeyMap.put(THRESHOLD_MAX_RX_PACKETS_FOR_PARTIAL_SCANS_KEY, maxRxPacketForNetworkSwitching); |
| sKeyMap.put(WIFI_VERBOSE_LOGS_KEY, enableVerboseLogging); |
| sKeyMap.put(A_BAND_PREFERENCE_RSSI_THRESHOLD_KEY, bandPreferenceBoostThreshold5); |
| sKeyMap.put(ASSOCIATED_PARTIAL_SCAN_PERIOD_KEY, wifiAssociatedShortScanIntervalMilli); |
| sKeyMap.put(ASSOCIATED_PARTIAL_SCAN_PERIOD_KEY, wifiAssociatedShortScanIntervalMilli); |
| |
| sKeyMap.put(ASSOCIATED_FULL_SCAN_BACKOFF_KEY, associatedFullScanBackoff); |
| sKeyMap.put(G_BAND_PREFERENCE_RSSI_THRESHOLD_KEY, bandPreferencePenaltyThreshold5); |
| sKeyMap.put(ALWAYS_ENABLE_SCAN_WHILE_ASSOCIATED_KEY, alwaysEnableScansWhileAssociated); |
| sKeyMap.put(MAX_NUM_PASSIVE_CHANNELS_FOR_PARTIAL_SCANS_KEY, maxNumPassiveChannelsForPartialScans); |
| sKeyMap.put(MAX_NUM_ACTIVE_CHANNELS_FOR_PARTIAL_SCANS_KEY, maxNumActiveChannelsForPartialScans); |
| sKeyMap.put(ENABLE_HAL_BASED_PNO, enableHalBasedPno); |
| sKeyMap.put(ENABLE_HAL_BASED_PNO, enableSsidWhitelist); |
| |
| if (showNetworks) { |
| mLocalLog = mWifiNative.getLocalLog(); |
| mFileObserver = new WpaConfigFileObserver(); |
| mFileObserver.startWatching(); |
| } else { |
| mLocalLog = null; |
| mFileObserver = null; |
| } |
| |
| wifiAssociatedShortScanIntervalMilli.set(mContext.getResources().getInteger( |
| R.integer.config_wifi_associated_short_scan_interval)); |
| wifiAssociatedLongScanIntervalMilli.set(mContext.getResources().getInteger( |
| R.integer.config_wifi_associated_short_scan_interval)); |
| wifiDisconnectedShortScanIntervalMilli.set(mContext.getResources().getInteger( |
| R.integer.config_wifi_disconnected_short_scan_interval)); |
| wifiDisconnectedLongScanIntervalMilli.set(mContext.getResources().getInteger( |
| R.integer.config_wifi_disconnected_long_scan_interval)); |
| |
| onlyLinkSameCredentialConfigurations = mContext.getResources().getBoolean( |
| R.bool.config_wifi_only_link_same_credential_configurations); |
| maxNumActiveChannelsForPartialScans.set(mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_associated_partial_scan_max_num_active_channels)); |
| maxNumPassiveChannelsForPartialScans.set(mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_associated_partial_scan_max_num_passive_channels)); |
| associatedFullScanMaxIntervalMilli = mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_associated_full_scan_max_interval); |
| associatedFullScanBackoff.set(mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_associated_full_scan_backoff)); |
| enableLinkDebouncing = mContext.getResources().getBoolean( |
| R.bool.config_wifi_enable_disconnection_debounce); |
| |
| enable5GHzPreference = mContext.getResources().getBoolean( |
| R.bool.config_wifi_enable_5GHz_preference); |
| |
| bandPreferenceBoostFactor5 = mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_5GHz_preference_boost_factor); |
| bandPreferencePenaltyFactor5 = mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_5GHz_preference_penalty_factor); |
| |
| bandPreferencePenaltyThreshold5.set(mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_5GHz_preference_penalty_threshold)); |
| bandPreferenceBoostThreshold5.set(mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_5GHz_preference_boost_threshold)); |
| |
| associatedHysteresisHigh = mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_current_association_hysteresis_high); |
| associatedHysteresisLow = mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_current_association_hysteresis_low); |
| |
| thresholdBadRssi5.set(mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_wifi_score_bad_rssi_threshold_5GHz)); |
| thresholdLowRssi5.set(mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_wifi_score_low_rssi_threshold_5GHz)); |
| thresholdGoodRssi5.set(mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_wifi_score_good_rssi_threshold_5GHz)); |
| thresholdBadRssi24.set(mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_wifi_score_bad_rssi_threshold_24GHz)); |
| thresholdLowRssi24.set(mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_wifi_score_low_rssi_threshold_24GHz)); |
| thresholdGoodRssi24.set(mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_wifi_score_good_rssi_threshold_24GHz)); |
| |
| enableWifiCellularHandoverUserTriggeredAdjustment = mContext.getResources().getBoolean( |
| R.bool.config_wifi_framework_cellular_handover_enable_user_triggered_adjustment); |
| |
| badLinkSpeed24 = mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_wifi_score_bad_link_speed_24); |
| badLinkSpeed5 = mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_wifi_score_bad_link_speed_5); |
| goodLinkSpeed24 = mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_wifi_score_good_link_speed_24); |
| goodLinkSpeed5 = mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_wifi_score_good_link_speed_5); |
| |
| maxAuthErrorsToBlacklist = mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_max_auth_errors_to_blacklist); |
| maxConnectionErrorsToBlacklist = mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_max_connection_errors_to_blacklist); |
| wifiConfigBlacklistMinTimeMilli = mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_network_black_list_min_time_milli); |
| |
| enableAutoJoinWhenAssociated.set(mContext.getResources().getBoolean( |
| R.bool.config_wifi_framework_enable_associated_network_selection)); |
| |
| currentNetworkBoost = mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_current_network_boost); |
| |
| scanResultRssiLevelPatchUp = mContext.getResources().getInteger( |
| R.integer.config_wifi_framework_scan_result_rssi_level_patchup_value); |
| |
| networkSwitchingBlackListPeriodMilli = mContext.getResources().getInteger( |
| R.integer.config_wifi_network_switching_blacklist_time); |
| |
| enableHalBasedPno.set(mContext.getResources().getBoolean( |
| R.bool.config_wifi_hal_pno_enable)); |
| |
| enableSsidWhitelist.set(mContext.getResources().getBoolean( |
| R.bool.config_wifi_ssid_white_list_enable)); |
| if (!enableHalBasedPno.get() && enableSsidWhitelist.get()) { |
| enableSsidWhitelist.set(false); |
| } |
| |
| boolean hs2on = mContext.getResources().getBoolean(R.bool.config_wifi_hotspot2_enabled); |
| Log.d(Utils.hs2LogTag(getClass()), "Passpoint is " + (hs2on ? "enabled" : "disabled")); |
| |
| mMOManager = new MOManager(new File(PPS_FILE), hs2on); |
| mAnqpCache = new AnqpCache(); |
| mSupplicantBridge = new SupplicantBridge(mWifiNative, this); |
| mScanDetailCaches = new HashMap<>(); |
| |
| mSIMAccessor = new SIMAccessor(mContext); |
| } |
| |
| public void trimANQPCache(boolean all) { |
| mAnqpCache.clear(all, DBG); |
| } |
| |
| void enableVerboseLogging(int verbose) { |
| enableVerboseLogging.set(verbose); |
| if (verbose > 0) { |
| VDBG = true; |
| showNetworks = true; |
| } else { |
| VDBG = false; |
| } |
| if (verbose > 1) { |
| VVDBG = true; |
| } else { |
| VVDBG = false; |
| } |
| } |
| |
| class WpaConfigFileObserver extends FileObserver { |
| |
| public WpaConfigFileObserver() { |
| super(SUPPLICANT_CONFIG_FILE, CLOSE_WRITE); |
| } |
| |
| @Override |
| public void onEvent(int event, String path) { |
| if (event == CLOSE_WRITE) { |
| File file = new File(SUPPLICANT_CONFIG_FILE); |
| if (VDBG) localLog("wpa_supplicant.conf changed; new size = " + file.length()); |
| } |
| } |
| } |
| |
| |
| /** |
| * Fetch the list of configured networks |
| * and enable all stored networks in supplicant. |
| */ |
| void loadAndEnableAllNetworks() { |
| if (DBG) log("Loading config and enabling all networks "); |
| loadConfiguredNetworks(); |
| enableAllNetworks(); |
| } |
| |
| int getConfiguredNetworksSize() { |
| return mConfiguredNetworks.size(); |
| } |
| |
| private List<WifiConfiguration> |
| getConfiguredNetworks(Map<String, String> pskMap) { |
| List<WifiConfiguration> networks = new ArrayList<>(); |
| for(WifiConfiguration config : mConfiguredNetworks.values()) { |
| WifiConfiguration newConfig = new WifiConfiguration(config); |
| // When updating this condition, update WifiStateMachine's CONNECT_NETWORK handler to |
| // correctly handle updating existing configs that are filtered out here. |
| if (config.autoJoinStatus == WifiConfiguration.AUTO_JOIN_DELETED || config.ephemeral) { |
| // Do not enumerate and return this configuration to any one, |
| // for instance WiFi Picker. |
| // instead treat it as unknown. the configuration can still be retrieved |
| // directly by the key or networkId |
| continue; |
| } |
| |
| if (pskMap != null && config.allowedKeyManagement != null |
| && config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_PSK) |
| && pskMap.containsKey(config.SSID)) { |
| newConfig.preSharedKey = pskMap.get(config.SSID); |
| } |
| networks.add(newConfig); |
| } |
| return networks; |
| } |
| |
| /** |
| * This function returns all configuration, and is used for cebug and creating bug reports. |
| */ |
| private List<WifiConfiguration> |
| getAllConfiguredNetworks() { |
| List<WifiConfiguration> networks = new ArrayList<>(); |
| for(WifiConfiguration config : mConfiguredNetworks.values()) { |
| WifiConfiguration newConfig = new WifiConfiguration(config); |
| networks.add(newConfig); |
| } |
| return networks; |
| } |
| |
| /** |
| * Fetch the list of currently configured networks |
| * @return List of networks |
| */ |
| List<WifiConfiguration> getConfiguredNetworks() { |
| return getConfiguredNetworks(null); |
| } |
| |
| /** |
| * Fetch the list of currently configured networks, filled with real preSharedKeys |
| * @return List of networks |
| */ |
| List<WifiConfiguration> getPrivilegedConfiguredNetworks() { |
| Map<String, String> pskMap = getCredentialsBySsidMap(); |
| return getConfiguredNetworks(pskMap); |
| } |
| |
| /** |
| * Find matching network for this scanResult |
| */ |
| WifiConfiguration getMatchingConfig(ScanResult scanResult) { |
| |
| for (Map.Entry entry : mScanDetailCaches.entrySet()) { |
| Integer netId = (Integer) entry.getKey(); |
| ScanDetailCache cache = (ScanDetailCache) entry.getValue(); |
| WifiConfiguration config = getWifiConfiguration(netId); |
| if (config == null) |
| continue; |
| if (cache.get(scanResult.BSSID) != null) { |
| return config; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Fetch the preSharedKeys for all networks. |
| * @return a map from Ssid to preSharedKey. |
| */ |
| private Map<String, String> getCredentialsBySsidMap() { |
| return readNetworkVariablesFromSupplicantFile("psk"); |
| } |
| |
| /** |
| * Fetch the list of currently configured networks that were recently seen |
| * |
| * @return List of networks |
| */ |
| List<WifiConfiguration> getRecentConfiguredNetworks(int milli, boolean copy) { |
| List<WifiConfiguration> networks = new ArrayList<WifiConfiguration>(); |
| |
| for (WifiConfiguration config : mConfiguredNetworks.values()) { |
| if (config.autoJoinStatus == WifiConfiguration.AUTO_JOIN_DELETED || config.ephemeral) { |
| // Do not enumerate and return this configuration to any one, |
| // instead treat it as unknown. the configuration can still be retrieved |
| // directly by the key or networkId |
| continue; |
| } |
| |
| // Calculate the RSSI for scan results that are more recent than milli |
| ScanDetailCache cache = getScanDetailCache(config); |
| if (cache == null) { |
| continue; |
| } |
| config.setVisibility(cache.getVisibility(milli)); |
| if (config.visibility == null) { |
| continue; |
| } |
| if (config.visibility.rssi5 == WifiConfiguration.INVALID_RSSI && |
| config.visibility.rssi24 == WifiConfiguration.INVALID_RSSI) { |
| continue; |
| } |
| if (copy) { |
| networks.add(new WifiConfiguration(config)); |
| } else { |
| networks.add(config); |
| } |
| } |
| return networks; |
| } |
| |
| /** |
| * Update the configuration and BSSID with latest RSSI value. |
| */ |
| void updateConfiguration(WifiInfo info) { |
| WifiConfiguration config = getWifiConfiguration(info.getNetworkId()); |
| if (config != null && getScanDetailCache(config) != null) { |
| ScanDetail scanDetail = getScanDetailCache(config).getScanDetail(info.getBSSID()); |
| if (scanDetail != null) { |
| ScanResult result = scanDetail.getScanResult(); |
| long previousSeen = result.seen; |
| int previousRssi = result.level; |
| |
| // Update the scan result |
| scanDetail.setSeen(); |
| result.level = info.getRssi(); |
| |
| // Average the RSSI value |
| result.averageRssi(previousRssi, previousSeen, |
| WifiAutoJoinController.mScanResultMaximumAge); |
| if (VDBG) { |
| loge("updateConfiguration freq=" + result.frequency |
| + " BSSID=" + result.BSSID |
| + " RSSI=" + result.level |
| + " " + config.configKey()); |
| } |
| } |
| } |
| } |
| |
| /** |
| * get the Wificonfiguration for this netId |
| * |
| * @return Wificonfiguration |
| */ |
| WifiConfiguration getWifiConfiguration(int netId) { |
| return mConfiguredNetworks.get(netId); |
| } |
| |
| /** |
| * Get the Wificonfiguration for this key |
| * @return Wificonfiguration |
| */ |
| WifiConfiguration getWifiConfiguration(String key) { |
| return mConfiguredNetworks.getByConfigKey(key); |
| } |
| |
| /** |
| * Enable all networks and save config. This will be a no-op if the list |
| * of configured networks indicates all networks as being enabled |
| */ |
| void enableAllNetworks() { |
| long now = System.currentTimeMillis(); |
| boolean networkEnabledStateChanged = false; |
| |
| for(WifiConfiguration config : mConfiguredNetworks.values()) { |
| |
| if(config != null && config.status == Status.DISABLED && !config.ephemeral |
| && (config.autoJoinStatus |
| <= WifiConfiguration.AUTO_JOIN_DISABLED_ON_AUTH_FAILURE)) { |
| |
| // Wait for 5 minutes before reenabling config that have known, repeated connection |
| // or DHCP failures |
| if (config.disableReason == WifiConfiguration.DISABLED_DHCP_FAILURE |
| || config.disableReason == WifiConfiguration.DISABLED_ASSOCIATION_REJECT |
| || config.disableReason == WifiConfiguration.DISABLED_AUTH_FAILURE) { |
| if (config.blackListTimestamp != 0 |
| && now > config.blackListTimestamp |
| && (now - config.blackListTimestamp) < wifiConfigBlacklistMinTimeMilli) { |
| continue; |
| } |
| } |
| |
| if(mWifiNative.enableNetwork(config.networkId, false)) { |
| networkEnabledStateChanged = true; |
| config.status = Status.ENABLED; |
| |
| // Reset the blacklist condition |
| config.numConnectionFailures = 0; |
| config.numIpConfigFailures = 0; |
| config.numAuthFailures = 0; |
| |
| // Reenable the wifi configuration |
| config.setAutoJoinStatus(WifiConfiguration.AUTO_JOIN_ENABLED); |
| } else { |
| loge("Enable network failed on " + config.networkId); |
| |
| } |
| } |
| } |
| |
| if (networkEnabledStateChanged) { |
| mWifiNative.saveConfig(); |
| sendConfiguredNetworksChangedBroadcast(); |
| } |
| } |
| |
| private boolean setNetworkPriorityNative(int netId, int priority) { |
| return mWifiNative.setNetworkVariable(netId, |
| WifiConfiguration.priorityVarName, Integer.toString(priority)); |
| } |
| |
| private boolean setSSIDNative(int netId, String ssid) { |
| return mWifiNative.setNetworkVariable(netId, WifiConfiguration.ssidVarName, |
| encodeSSID(ssid)); |
| } |
| |
| public boolean updateLastConnectUid(WifiConfiguration config, int uid) { |
| if (config != null) { |
| if (config.lastConnectUid != uid) { |
| config.lastConnectUid = uid; |
| config.dirty = true; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Selects the specified network for connection. This involves |
| * updating the priority of all the networks and enabling the given |
| * network while disabling others. |
| * |
| * Selecting a network will leave the other networks disabled and |
| * a call to enableAllNetworks() needs to be issued upon a connection |
| * or a failure event from supplicant |
| * |
| * @param config network to select for connection |
| * @param updatePriorities makes config highest priority network |
| * @return false if the network id is invalid |
| */ |
| boolean selectNetwork(WifiConfiguration config, boolean updatePriorities, int uid) { |
| if (VDBG) localLog("selectNetwork", config.networkId); |
| if (config.networkId == INVALID_NETWORK_ID) return false; |
| |
| // Reset the priority of each network at start or if it goes too high. |
| if (mLastPriority == -1 || mLastPriority > 1000000) { |
| for(WifiConfiguration config2 : mConfiguredNetworks.values()) { |
| if (updatePriorities) { |
| if (config2.networkId != INVALID_NETWORK_ID) { |
| config2.priority = 0; |
| setNetworkPriorityNative(config2.networkId, config.priority); |
| } |
| } |
| } |
| mLastPriority = 0; |
| } |
| |
| // Set to the highest priority and save the configuration. |
| if (updatePriorities) { |
| config.priority = ++mLastPriority; |
| setNetworkPriorityNative(config.networkId, config.priority); |
| buildPnoList(); |
| } |
| |
| if (config.isPasspoint()) { |
| /* need to slap on the SSID of selected bssid to work */ |
| if (getScanDetailCache(config).size() != 0) { |
| ScanDetail result = getScanDetailCache(config).getFirst(); |
| if (result == null) { |
| loge("Could not find scan result for " + config.BSSID); |
| } else { |
| log("Setting SSID for " + config.networkId + " to" + result.getSSID()); |
| setSSIDNative(config.networkId, result.getSSID()); |
| config.SSID = result.getSSID(); |
| } |
| |
| } else { |
| loge("Could not find bssid for " + config); |
| } |
| } |
| |
| if (updatePriorities) |
| mWifiNative.saveConfig(); |
| else |
| mWifiNative.selectNetwork(config.networkId); |
| |
| updateLastConnectUid(config, uid); |
| writeKnownNetworkHistory(false); |
| |
| /* Enable the given network while disabling all other networks */ |
| enableNetworkWithoutBroadcast(config.networkId, true); |
| |
| /* Avoid saving the config & sending a broadcast to prevent settings |
| * from displaying a disabled list of networks */ |
| return true; |
| } |
| |
| /** |
| * Add/update the specified configuration and save config |
| * |
| * @param config WifiConfiguration to be saved |
| * @return network update result |
| */ |
| NetworkUpdateResult saveNetwork(WifiConfiguration config, int uid) { |
| WifiConfiguration conf; |
| |
| // A new network cannot have null SSID |
| if (config == null || (config.networkId == INVALID_NETWORK_ID && |
| config.SSID == null)) { |
| return new NetworkUpdateResult(INVALID_NETWORK_ID); |
| } |
| if (VDBG) localLog("WifiConfigStore: saveNetwork netId", config.networkId); |
| if (VDBG) { |
| loge("WifiConfigStore saveNetwork, size=" + mConfiguredNetworks.size() |
| + " SSID=" + config.SSID |
| + " Uid=" + Integer.toString(config.creatorUid) |
| + "/" + Integer.toString(config.lastUpdateUid)); |
| } |
| |
| if (mDeletedEphemeralSSIDs.remove(config.SSID)) { |
| if (VDBG) { |
| loge("WifiConfigStore: removed from ephemeral blacklist: " + config.SSID); |
| } |
| // NOTE: This will be flushed to disk as part of the addOrUpdateNetworkNative call |
| // below, since we're creating/modifying a config. |
| } |
| |
| boolean newNetwork = (config.networkId == INVALID_NETWORK_ID); |
| NetworkUpdateResult result = addOrUpdateNetworkNative(config, uid); |
| int netId = result.getNetworkId(); |
| |
| if (VDBG) localLog("WifiConfigStore: saveNetwork got it back netId=", netId); |
| |
| /* enable a new network */ |
| if (newNetwork && netId != INVALID_NETWORK_ID) { |
| if (VDBG) localLog("WifiConfigStore: will enable netId=", netId); |
| |
| mWifiNative.enableNetwork(netId, false); |
| conf = mConfiguredNetworks.get(netId); |
| if (conf != null) |
| conf.status = Status.ENABLED; |
| } |
| |
| conf = mConfiguredNetworks.get(netId); |
| if (conf != null) { |
| if (conf.autoJoinStatus != WifiConfiguration.AUTO_JOIN_ENABLED) { |
| if (VDBG) localLog("WifiConfigStore: re-enabling: " + conf.SSID); |
| |
| // reenable autojoin, since new information has been provided |
| conf.setAutoJoinStatus(WifiConfiguration.AUTO_JOIN_ENABLED); |
| enableNetworkWithoutBroadcast(conf.networkId, false); |
| } |
| if (VDBG) { |
| loge("WifiConfigStore: saveNetwork got config back netId=" |
| + Integer.toString(netId) |
| + " uid=" + Integer.toString(config.creatorUid)); |
| } |
| } |
| |
| mWifiNative.saveConfig(); |
| sendConfiguredNetworksChangedBroadcast(conf, result.isNewNetwork() ? |
| WifiManager.CHANGE_REASON_ADDED : WifiManager.CHANGE_REASON_CONFIG_CHANGE); |
| return result; |
| } |
| |
| /** |
| * Firmware is roaming away from this BSSID, and this BSSID was on 5GHz, and it's RSSI was good, |
| * this means we have a situation where we would want to remain on this BSSID but firmware |
| * is not successful at it. |
| * This situation is observed on a small number of Access Points, b/17960587 |
| * In that situation, blacklist this BSSID really hard so as framework will not attempt to |
| * roam to it for the next 8 hours. We do not to keep flipping between 2.4 and 5GHz band.. |
| * TODO: review the blacklisting strategy so as to make it softer and adaptive |
| * @param info |
| */ |
| void driverRoamedFrom(WifiInfo info) { |
| if (info != null |
| && info.getBSSID() != null |
| && ScanResult.is5GHz(info.getFrequency()) |
| && info.getRssi() > (bandPreferenceBoostThreshold5.get() + 3)) { |
| WifiConfiguration config = getWifiConfiguration(info.getNetworkId()); |
| if (config != null) { |
| if (getScanDetailCache(config) != null) { |
| ScanResult result = getScanDetailCache(config).get(info.getBSSID()); |
| if (result != null) { |
| result.setAutoJoinStatus(ScanResult.AUTO_ROAM_DISABLED + 1); |
| } |
| } |
| } |
| } |
| } |
| |
| void noteRoamingFailure(WifiConfiguration config, int reason) { |
| if (config == null) return; |
| config.lastRoamingFailure = System.currentTimeMillis(); |
| config.roamingFailureBlackListTimeMilli |
| = 2 * (config.roamingFailureBlackListTimeMilli + 1000); |
| if (config.roamingFailureBlackListTimeMilli |
| > networkSwitchingBlackListPeriodMilli) { |
| config.roamingFailureBlackListTimeMilli = |
| networkSwitchingBlackListPeriodMilli; |
| } |
| config.lastRoamingFailureReason = reason; |
| } |
| |
| void saveWifiConfigBSSID(WifiConfiguration config) { |
| // Sanity check the config is valid |
| if (config == null || (config.networkId == INVALID_NETWORK_ID && |
| config.SSID == null)) { |
| return; |
| } |
| |
| // If an app specified a BSSID then dont over-write it |
| if (config.BSSID != null && config.BSSID != "any") { |
| return; |
| } |
| |
| // If autojoin specified a BSSID then write it in the network block |
| if (config.autoJoinBSSID != null) { |
| loge("saveWifiConfigBSSID Setting BSSID for " + config.configKey() |
| + " to " + config.autoJoinBSSID); |
| if (!mWifiNative.setNetworkVariable( |
| config.networkId, |
| WifiConfiguration.bssidVarName, |
| config.autoJoinBSSID)) { |
| loge("failed to set BSSID: " + config.autoJoinBSSID); |
| } else if (config.autoJoinBSSID.equals("any")) { |
| // Paranoia, we just want to make sure that we restore the config to normal |
| mWifiNative.saveConfig(); |
| } |
| } |
| } |
| |
| |
| void updateStatus(int netId, DetailedState state) { |
| if (netId != INVALID_NETWORK_ID) { |
| WifiConfiguration config = mConfiguredNetworks.get(netId); |
| if (config == null) return; |
| switch (state) { |
| case CONNECTED: |
| config.status = Status.CURRENT; |
| //we successfully connected, hence remove the blacklist |
| config.setAutoJoinStatus(WifiConfiguration.AUTO_JOIN_ENABLED); |
| break; |
| case DISCONNECTED: |
| //If network is already disabled, keep the status |
| if (config.status == Status.CURRENT) { |
| config.status = Status.ENABLED; |
| } |
| break; |
| default: |
| //do nothing, retain the existing state |
| break; |
| } |
| } |
| } |
| |
| |
| /** |
| * Disable an ephemeral SSID for the purpose of auto-joining thru scored. |
| * This SSID will never be scored anymore. |
| * The only way to "un-disable it" is if the user create a network for that SSID and then |
| * forget it. |
| * |
| * @param SSID caller must ensure that the SSID passed thru this API match |
| * the WifiConfiguration.SSID rules, and thus be surrounded by quotes. |
| * @return the {@link WifiConfiguration} corresponding to this SSID, if any, so that we can |
| * disconnect if this is the current network. |
| */ |
| WifiConfiguration disableEphemeralNetwork(String SSID) { |
| if (SSID == null) { |
| return null; |
| } |
| |
| WifiConfiguration foundConfig = mConfiguredNetworks.getEphemeral(SSID); |
| |
| mDeletedEphemeralSSIDs.add(SSID); |
| loge("Forget ephemeral SSID " + SSID + " num=" + mDeletedEphemeralSSIDs.size()); |
| |
| if (foundConfig != null) { |
| loge("Found ephemeral config in disableEphemeralNetwork: " + foundConfig.networkId); |
| } |
| |
| // Force a write, because the mDeletedEphemeralSSIDs list has changed even though the |
| // configurations may not have. |
| writeKnownNetworkHistory(true); |
| |
| return foundConfig; |
| } |
| |
| /** |
| * Forget the specified network and save config |
| * |
| * @param netId network to forget |
| * @return {@code true} if it succeeds, {@code false} otherwise |
| */ |
| boolean forgetNetwork(int netId) { |
| if (showNetworks) localLog("forgetNetwork", netId); |
| |
| WifiConfiguration config = mConfiguredNetworks.get(netId); |
| boolean remove = removeConfigAndSendBroadcastIfNeeded(netId); |
| if (!remove) { |
| //success but we dont want to remove the network from supplicant conf file |
| return true; |
| } |
| if (mWifiNative.removeNetwork(netId)) { |
| if (config != null && config.isPasspoint()) { |
| writePasspointConfigs(config.FQDN, null); |
| } |
| mWifiNative.saveConfig(); |
| writeKnownNetworkHistory(true); |
| return true; |
| } else { |
| loge("Failed to remove network " + netId); |
| return false; |
| } |
| } |
| |
| /** |
| * Add/update a network. Note that there is no saveConfig operation. |
| * This function is retained for compatibility with the public |
| * API. The more powerful saveNetwork() is used by the |
| * state machine |
| * |
| * @param config wifi configuration to add/update |
| * @return network Id |
| */ |
| int addOrUpdateNetwork(WifiConfiguration config, int uid) { |
| if (showNetworks) localLog("addOrUpdateNetwork id=", config.networkId); |
| //adding unconditional message to chase b/15111865 |
| Log.e(TAG, " key=" + config.configKey() + " netId=" + Integer.toString(config.networkId) |
| + " uid=" + Integer.toString(config.creatorUid) |
| + "/" + Integer.toString(config.lastUpdateUid)); |
| |
| if (config.isPasspoint()) { |
| /* create a temporary SSID with providerFriendlyName */ |
| Long csum = getChecksum(config.FQDN); |
| config.SSID = csum.toString(); |
| config.enterpriseConfig.setDomainSuffixMatch(config.FQDN); |
| } |
| |
| NetworkUpdateResult result = addOrUpdateNetworkNative(config, uid); |
| if (result.getNetworkId() != WifiConfiguration.INVALID_NETWORK_ID) { |
| WifiConfiguration conf = mConfiguredNetworks.get(result.getNetworkId()); |
| if (conf != null) { |
| sendConfiguredNetworksChangedBroadcast(conf, |
| result.isNewNetwork ? WifiManager.CHANGE_REASON_ADDED : |
| WifiManager.CHANGE_REASON_CONFIG_CHANGE); |
| } |
| } |
| |
| return result.getNetworkId(); |
| } |
| |
| |
| /** |
| * Get the Wifi PNO list |
| * |
| * @return list of WifiNative.WifiPnoNetwork |
| */ |
| private void buildPnoList() { |
| mCachedPnoList = new ArrayList<WifiNative.WifiPnoNetwork>(); |
| |
| ArrayList<WifiConfiguration> sortedWifiConfigurations |
| = new ArrayList<WifiConfiguration>(getConfiguredNetworks()); |
| Log.e(TAG, "buildPnoList sortedWifiConfigurations size " + sortedWifiConfigurations.size()); |
| if (sortedWifiConfigurations.size() != 0) { |
| // Sort by descending priority |
| Collections.sort(sortedWifiConfigurations, new Comparator<WifiConfiguration>() { |
| public int compare(WifiConfiguration a, WifiConfiguration b) { |
| return a.priority >= b.priority ? 1 : -1; |
| } |
| }); |
| } |
| |
| for (WifiConfiguration config : sortedWifiConfigurations) { |
| // Initialize the RSSI threshold with sane value: |
| // Use the 2.4GHz threshold since most WifiConfigurations are dual bands |
| // There is very little penalty with triggering too soon, i.e. if PNO finds a network |
| // that has an RSSI too low for us to attempt joining it. |
| int threshold = thresholdInitialAutoJoinAttemptMin24RSSI.get(); |
| Log.e(TAG, "found sortedWifiConfigurations : " + config.configKey()); |
| WifiNative.WifiPnoNetwork network = mWifiNative.new WifiPnoNetwork(config, threshold); |
| mCachedPnoList.add(network); |
| } |
| } |
| |
| String[] getWhiteListedSsids(WifiConfiguration config) { |
| int num_ssids = 0; |
| String nonQuoteSSID; |
| int length; |
| if (enableSsidWhitelist.get() == false) |
| return null; |
| List<String> list = new ArrayList<String>(); |
| if (config == null) |
| return null; |
| if (config.linkedConfigurations == null) { |
| return null; |
| } |
| if (config.SSID == null || TextUtils.isEmpty(config.SSID)) { |
| return null; |
| } |
| for (String configKey : config.linkedConfigurations.keySet()) { |
| |
| // Sanity check that the linked configuration is still valid |
| WifiConfiguration link = getWifiConfiguration(configKey); |
| if (link == null) { |
| continue; |
| } |
| |
| if (link.autoJoinStatus != WifiConfiguration.AUTO_JOIN_ENABLED) { |
| continue; |
| } |
| |
| if (link.hiddenSSID == true) { |
| continue; |
| } |
| |
| if (link.SSID == null || TextUtils.isEmpty(link.SSID)) { |
| continue; |
| } |
| |
| length = link.SSID.length(); |
| if (length > 2 && (link.SSID.charAt(0) == '"') && link.SSID.charAt(length - 1) == '"') { |
| nonQuoteSSID = link.SSID.substring(1, length - 1); |
| } else { |
| nonQuoteSSID = link.SSID; |
| } |
| |
| list.add(nonQuoteSSID); |
| } |
| |
| if (list.size() != 0) { |
| length = config.SSID.length(); |
| if (length > 2 && (config.SSID.charAt(0) == '"') |
| && config.SSID.charAt(length - 1) == '"') { |
| nonQuoteSSID = config.SSID.substring(1, length - 1); |
| } else { |
| nonQuoteSSID = config.SSID; |
| } |
| |
| list.add(nonQuoteSSID); |
| } |
| |
| return (String[])list.toArray(new String[0]); |
| } |
| |
| /** |
| * Remove a network. Note that there is no saveConfig operation. |
| * This function is retained for compatibility with the public |
| * API. The more powerful forgetNetwork() is used by the |
| * state machine for network removal |
| * |
| * @param netId network to be removed |
| * @return {@code true} if it succeeds, {@code false} otherwise |
| */ |
| boolean removeNetwork(int netId) { |
| if (showNetworks) localLog("removeNetwork", netId); |
| WifiConfiguration config = mConfiguredNetworks.get(netId); |
| boolean ret = mWifiNative.removeNetwork(netId); |
| if (ret) { |
| removeConfigAndSendBroadcastIfNeeded(netId); |
| if (config != null && config.isPasspoint()) { |
| writePasspointConfigs(config.FQDN, null); |
| } |
| } |
| return ret; |
| } |
| |
| |
| static private Long getChecksum(String source) { |
| Checksum csum = new CRC32(); |
| csum.update(source.getBytes(), 0, source.getBytes().length); |
| return csum.getValue(); |
| } |
| |
| private boolean removeConfigAndSendBroadcastIfNeeded(int netId) { |
| WifiConfiguration config = mConfiguredNetworks.get(netId); |
| if (config != null) { |
| if (VDBG) { |
| loge("removeNetwork " + Integer.toString(netId) + " key=" + |
| config.configKey() + " config.id=" + Integer.toString(config.networkId)); |
| } |
| |
| // cancel the last user choice |
| if (config.configKey().equals(lastSelectedConfiguration)) { |
| lastSelectedConfiguration = null; |
| } |
| |
| // Remove any associated keys |
| if (config.enterpriseConfig != null) { |
| removeKeys(config.enterpriseConfig); |
| } |
| |
| if (config.selfAdded || config.linkedConfigurations != null |
| || config.allowedKeyManagement.get(KeyMgmt.WPA_PSK)) { |
| if (!TextUtils.isEmpty(config.SSID)) { |
| /* Remember that we deleted this PSK SSID */ |
| if (config.SSID != null) { |
| Long csum = getChecksum(config.SSID); |
| mDeletedSSIDs.add(csum); |
| loge("removeNetwork " + Integer.toString(netId) |
| + " key=" + config.configKey() |
| + " config.id=" + Integer.toString(config.networkId) |
| + " crc=" + csum); |
| } else { |
| loge("removeNetwork " + Integer.toString(netId) |
| + " key=" + config.configKey() |
| + " config.id=" + Integer.toString(config.networkId)); |
| } |
| } |
| } |
| |
| mConfiguredNetworks.remove(netId); |
| mScanDetailCaches.remove(netId); |
| |
| writeIpAndProxyConfigurations(); |
| sendConfiguredNetworksChangedBroadcast(config, WifiManager.CHANGE_REASON_REMOVED); |
| writeKnownNetworkHistory(true); |
| } |
| return true; |
| } |
| |
| /* |
| * Remove all networks associated with an application |
| * |
| * @param packageName name of the package of networks to remove |
| * @return {@code true} if all networks removed successfully, {@code false} otherwise |
| */ |
| boolean removeNetworksForApp(ApplicationInfo app) { |
| if (app == null || app.packageName == null) { |
| return false; |
| } |
| |
| boolean success = true; |
| |
| WifiConfiguration [] copiedConfigs = |
| mConfiguredNetworks.values().toArray(new WifiConfiguration[0]); |
| for (WifiConfiguration config : copiedConfigs) { |
| if (app.uid != config.creatorUid || !app.packageName.equals(config.creatorName)) { |
| continue; |
| } |
| if (showNetworks) { |
| localLog("Removing network " + config.SSID |
| + ", application \"" + app.packageName + "\" uninstalled" |
| + " from user " + UserHandle.getUserId(app.uid)); |
| } |
| success &= removeNetwork(config.networkId); |
| } |
| |
| mWifiNative.saveConfig(); |
| |
| return success; |
| } |
| |
| boolean removeNetworksForUser(int userId) { |
| boolean success = true; |
| |
| WifiConfiguration[] copiedConfigs = |
| mConfiguredNetworks.values().toArray(new WifiConfiguration[0]); |
| for (WifiConfiguration config : copiedConfigs) { |
| if (userId != UserHandle.getUserId(config.creatorUid)) { |
| continue; |
| } |
| success &= removeNetwork(config.networkId); |
| if (showNetworks) { |
| localLog("Removing network " + config.SSID |
| + ", user " + userId + " removed"); |
| } |
| } |
| |
| return success; |
| } |
| |
| /** |
| * Enable a network. Note that there is no saveConfig operation. |
| * This function is retained for compatibility with the public |
| * API. The more powerful selectNetwork()/saveNetwork() is used by the |
| * state machine for connecting to a network |
| * |
| * @param netId network to be enabled |
| * @return {@code true} if it succeeds, {@code false} otherwise |
| */ |
| boolean enableNetwork(int netId, boolean disableOthers, int uid) { |
| boolean ret = enableNetworkWithoutBroadcast(netId, disableOthers); |
| if (disableOthers) { |
| if (VDBG) localLog("enableNetwork(disableOthers=true, uid=" + uid + ") ", netId); |
| updateLastConnectUid(getWifiConfiguration(netId), uid); |
| writeKnownNetworkHistory(false); |
| sendConfiguredNetworksChangedBroadcast(); |
| } else { |
| if (VDBG) localLog("enableNetwork(disableOthers=false) ", netId); |
| WifiConfiguration enabledNetwork; |
| synchronized(mConfiguredNetworks) { // !!! Useless synchronization! |
| enabledNetwork = mConfiguredNetworks.get(netId); |
| } |
| // check just in case the network was removed by someone else. |
| if (enabledNetwork != null) { |
| sendConfiguredNetworksChangedBroadcast(enabledNetwork, |
| WifiManager.CHANGE_REASON_CONFIG_CHANGE); |
| } |
| } |
| return ret; |
| } |
| |
| boolean enableNetworkWithoutBroadcast(int netId, boolean disableOthers) { |
| boolean ret = mWifiNative.enableNetwork(netId, disableOthers); |
| |
| WifiConfiguration config = mConfiguredNetworks.get(netId); |
| if (config != null) config.status = Status.ENABLED; |
| |
| if (disableOthers) { |
| markAllNetworksDisabledExcept(netId); |
| } |
| return ret; |
| } |
| |
| void disableAllNetworks() { |
| if (VDBG) localLog("disableAllNetworks"); |
| boolean networkDisabled = false; |
| for (WifiConfiguration enabled : mConfiguredNetworks.getEnabledNetworks()) { |
| if(mWifiNative.disableNetwork(enabled.networkId)) { |
| networkDisabled = true; |
| enabled.status = Status.DISABLED; |
| } else { |
| loge("Disable network failed on " + enabled.networkId); |
| } |
| } |
| |
| if (networkDisabled) { |
| sendConfiguredNetworksChangedBroadcast(); |
| } |
| } |
| /** |
| * Disable a network. Note that there is no saveConfig operation. |
| * @param netId network to be disabled |
| * @return {@code true} if it succeeds, {@code false} otherwise |
| */ |
| boolean disableNetwork(int netId) { |
| boolean ret = disableNetwork(netId, WifiConfiguration.DISABLED_UNKNOWN_REASON); |
| if (ret) { |
| mWifiStateMachine.registerNetworkDisabled(netId); |
| } |
| return ret; |
| } |
| |
| /** |
| * Disable a network. Note that there is no saveConfig operation. |
| * @param netId network to be disabled |
| * @param reason reason code network was disabled |
| * @return {@code true} if it succeeds, {@code false} otherwise |
| */ |
| boolean disableNetwork(int netId, int reason) { |
| if (VDBG) localLog("disableNetwork", netId); |
| boolean ret = mWifiNative.disableNetwork(netId); |
| WifiConfiguration network = null; |
| WifiConfiguration config = mConfiguredNetworks.get(netId); |
| |
| if (VDBG) { |
| if (config != null) { |
| loge("disableNetwork netId=" + Integer.toString(netId) |
| + " SSID=" + config.SSID |
| + " disabled=" + (config.status == Status.DISABLED) |
| + " reason=" + Integer.toString(config.disableReason)); |
| } |
| } |
| /* Only change the reason if the network was not previously disabled |
| /* and the reason is not DISABLED_BY_WIFI_MANAGER, that is, if a 3rd party |
| * set its configuration as disabled, then leave it disabled */ |
| if (config != null) { |
| if (config.status != Status.DISABLED |
| && config.disableReason != WifiConfiguration.DISABLED_BY_WIFI_MANAGER) { |
| config.status = Status.DISABLED; |
| config.disableReason = reason; |
| network = config; |
| } |
| if (reason == WifiConfiguration.DISABLED_BY_WIFI_MANAGER) { |
| // Make sure autojoin wont reenable this configuration without further user |
| // intervention |
| config.status = Status.DISABLED; |
| config.autoJoinStatus = WifiConfiguration.AUTO_JOIN_DISABLED_USER_ACTION; |
| } |
| } |
| if (network != null) { |
| sendConfiguredNetworksChangedBroadcast(network, |
| WifiManager.CHANGE_REASON_CONFIG_CHANGE); |
| } |
| return ret; |
| } |
| |
| /** |
| * Save the configured networks in supplicant to disk |
| * @return {@code true} if it succeeds, {@code false} otherwise |
| */ |
| boolean saveConfig() { |
| return mWifiNative.saveConfig(); |
| } |
| |
| /** |
| * Start WPS pin method configuration with pin obtained |
| * from the access point |
| * @param config WPS configuration |
| * @return Wps result containing status and pin |
| */ |
| WpsResult startWpsWithPinFromAccessPoint(WpsInfo config) { |
| WpsResult result = new WpsResult(); |
| if (mWifiNative.startWpsRegistrar(config.BSSID, config.pin)) { |
| /* WPS leaves all networks disabled */ |
| markAllNetworksDisabled(); |
| result.status = WpsResult.Status.SUCCESS; |
| } else { |
| loge("Failed to start WPS pin method configuration"); |
| result.status = WpsResult.Status.FAILURE; |
| } |
| return result; |
| } |
| |
| /** |
| * Start WPS pin method configuration with pin obtained |
| * from the device |
| * @return WpsResult indicating status and pin |
| */ |
| WpsResult startWpsWithPinFromDevice(WpsInfo config) { |
| WpsResult result = new WpsResult(); |
| result.pin = mWifiNative.startWpsPinDisplay(config.BSSID); |
| /* WPS leaves all networks disabled */ |
| if (!TextUtils.isEmpty(result.pin)) { |
| markAllNetworksDisabled(); |
| result.status = WpsResult.Status.SUCCESS; |
| } else { |
| loge("Failed to start WPS pin method configuration"); |
| result.status = WpsResult.Status.FAILURE; |
| } |
| return result; |
| } |
| |
| /** |
| * Start WPS push button configuration |
| * @param config WPS configuration |
| * @return WpsResult indicating status and pin |
| */ |
| WpsResult startWpsPbc(WpsInfo config) { |
| WpsResult result = new WpsResult(); |
| if (mWifiNative.startWpsPbc(config.BSSID)) { |
| /* WPS leaves all networks disabled */ |
| markAllNetworksDisabled(); |
| result.status = WpsResult.Status.SUCCESS; |
| } else { |
| loge("Failed to start WPS push button configuration"); |
| result.status = WpsResult.Status.FAILURE; |
| } |
| return result; |
| } |
| |
| /** |
| * Fetch the static IP configuration for a given network id |
| */ |
| StaticIpConfiguration getStaticIpConfiguration(int netId) { |
| WifiConfiguration config = mConfiguredNetworks.get(netId); |
| if (config != null) { |
| return config.getStaticIpConfiguration(); |
| } |
| return null; |
| } |
| |
| /** |
| * Set the static IP configuration for a given network id |
| */ |
| void setStaticIpConfiguration(int netId, StaticIpConfiguration staticIpConfiguration) { |
| WifiConfiguration config = mConfiguredNetworks.get(netId); |
| if (config != null) { |
| config.setStaticIpConfiguration(staticIpConfiguration); |
| } |
| } |
| |
| /** |
| * set default GW MAC address |
| */ |
| void setDefaultGwMacAddress(int netId, String macAddress) { |
| WifiConfiguration config = mConfiguredNetworks.get(netId); |
| if (config != null) { |
| //update defaultGwMacAddress |
| config.defaultGwMacAddress = macAddress; |
| } |
| } |
| |
| |
| /** |
| * Fetch the proxy properties for a given network id |
| * @param netId id |
| * @return ProxyInfo for the network id |
| */ |
| ProxyInfo getProxyProperties(int netId) { |
| WifiConfiguration config = mConfiguredNetworks.get(netId); |
| if (config != null) { |
| return config.getHttpProxy(); |
| } |
| return null; |
| } |
| |
| /** |
| * Return if the specified network is using static IP |
| * @param netId id |
| * @return {@code true} if using static ip for netId |
| */ |
| boolean isUsingStaticIp(int netId) { |
| WifiConfiguration config = mConfiguredNetworks.get(netId); |
| if (config != null && config.getIpAssignment() == IpAssignment.STATIC) { |
| return true; |
| } |
| return false; |
| } |
| |
| boolean isEphemeral(int netId) { |
| WifiConfiguration config = mConfiguredNetworks.get(netId); |
| return config != null && config.ephemeral; |
| } |
| |
| /** |
| * Should be called when a single network configuration is made. |
| * @param network The network configuration that changed. |
| * @param reason The reason for the change, should be one of WifiManager.CHANGE_REASON_ADDED, |
| * WifiManager.CHANGE_REASON_REMOVED, or WifiManager.CHANGE_REASON_CHANGE. |
| */ |
| private void sendConfiguredNetworksChangedBroadcast(WifiConfiguration network, |
| int reason) { |
| Intent intent = new Intent(WifiManager.CONFIGURED_NETWORKS_CHANGED_ACTION); |
| intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT); |
| intent.putExtra(WifiManager.EXTRA_MULTIPLE_NETWORKS_CHANGED, false); |
| intent.putExtra(WifiManager.EXTRA_WIFI_CONFIGURATION, network); |
| intent.putExtra(WifiManager.EXTRA_CHANGE_REASON, reason); |
| mContext.sendBroadcastAsUser(intent, UserHandle.ALL); |
| } |
| |
| /** |
| * Should be called when multiple network configuration changes are made. |
| */ |
| private void sendConfiguredNetworksChangedBroadcast() { |
| Intent intent = new Intent(WifiManager.CONFIGURED_NETWORKS_CHANGED_ACTION); |
| intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT); |
| intent.putExtra(WifiManager.EXTRA_MULTIPLE_NETWORKS_CHANGED, true); |
| mContext.sendBroadcastAsUser(intent, UserHandle.ALL); |
| } |
| |
| void loadConfiguredNetworks() { |
| |
| mLastPriority = 0; |
| |
| mConfiguredNetworks.clear(); |
| |
| int last_id = -1; |
| boolean done = false; |
| while (!done) { |
| |
| String listStr = mWifiNative.listNetworks(last_id); |
| if (listStr == null) |
| return; |
| |
| String[] lines = listStr.split("\n"); |
| |
| if (showNetworks) { |
| localLog("WifiConfigStore: loadConfiguredNetworks: "); |
| for (String net : lines) { |
| localLog(net); |
| } |
| } |
| |
| // Skip the first line, which is a header |
| for (int i = 1; i < lines.length; i++) { |
| String[] result = lines[i].split("\t"); |
| // network-id | ssid | bssid | flags |
| WifiConfiguration config = new WifiConfiguration(); |
| try { |
| config.networkId = Integer.parseInt(result[0]); |
| last_id = config.networkId; |
| } catch(NumberFormatException e) { |
| loge("Failed to read network-id '" + result[0] + "'"); |
| continue; |
| } |
| if (result.length > 3) { |
| if (result[3].indexOf("[CURRENT]") != -1) |
| config.status = WifiConfiguration.Status.CURRENT; |
| else if (result[3].indexOf("[DISABLED]") != -1) |
| config.status = WifiConfiguration.Status.DISABLED; |
| else |
| config.status = WifiConfiguration.Status.ENABLED; |
| } else { |
| config.status = WifiConfiguration.Status.ENABLED; |
| } |
| |
| readNetworkVariables(config); |
| |
| Checksum csum = new CRC32(); |
| if (config.SSID != null) { |
| csum.update(config.SSID.getBytes(), 0, config.SSID.getBytes().length); |
| long d = csum.getValue(); |
| if (mDeletedSSIDs.contains(d)) { |
| loge(" got CRC for SSID " + config.SSID + " -> " + d + ", was deleted"); |
| } |
| } |
| |
| if (config.priority > mLastPriority) { |
| mLastPriority = config.priority; |
| } |
| |
| config.setIpAssignment(IpAssignment.DHCP); |
| config.setProxySettings(ProxySettings.NONE); |
| |
| if (mConfiguredNetworks.getByConfigKey(config.configKey()) != null) { |
| // That SSID is already known, just ignore this duplicate entry |
| if (showNetworks) localLog("discarded duplicate network ", config.networkId); |
| } else if(WifiServiceImpl.isValid(config)){ |
| mConfiguredNetworks.put(config.networkId, config); |
| if (showNetworks) localLog("loaded configured network", config.networkId); |
| } else { |
| if (showNetworks) log("Ignoring loaded configured for network " + config.networkId |
| + " because config are not valid"); |
| } |
| } |
| |
| done = (lines.length == 1); |
| } |
| |
| readPasspointConfig(); |
| readIpAndProxyConfigurations(); |
| readNetworkHistory(); |
| readAutoJoinConfig(); |
| |
| buildPnoList(); |
| |
| sendConfiguredNetworksChangedBroadcast(); |
| |
| if (showNetworks) localLog("loadConfiguredNetworks loaded " + mConfiguredNetworks.size() + " networks"); |
| |
| if (mConfiguredNetworks.isEmpty()) { |
| // no networks? Lets log if the file contents |
| logKernelTime(); |
| logContents(SUPPLICANT_CONFIG_FILE); |
| logContents(SUPPLICANT_CONFIG_FILE_BACKUP); |
| logContents(networkHistoryConfigFile); |
| } |
| } |
| |
| private void logContents(String file) { |
| localLog("--- Begin " + file + " ---", true); |
| BufferedReader reader = null; |
| try { |
| reader = new BufferedReader(new FileReader(file)); |
| for (String line = reader.readLine(); line != null; line = reader.readLine()) { |
| localLog(line, true); |
| } |
| } catch (FileNotFoundException e) { |
| localLog("Could not open " + file + ", " + e, true); |
| } catch (IOException e) { |
| localLog("Could not read " + file + ", " + e, true); |
| } finally { |
| try { |
| if (reader != null) { |
| reader.close(); |
| } |
| } catch (IOException e) { |
| // Just ignore the fact that we couldn't close |
| } |
| } |
| localLog("--- End " + file + " Contents ---", true); |
| } |
| |
| private Map<String, String> readNetworkVariablesFromSupplicantFile(String key) { |
| Map<String, String> result = new HashMap<>(); |
| BufferedReader reader = null; |
| if (VDBG) loge("readNetworkVariablesFromSupplicantFile key=" + key); |
| |
| try { |
| reader = new BufferedReader(new FileReader(SUPPLICANT_CONFIG_FILE)); |
| boolean found = false; |
| String networkSsid = null; |
| String value = null; |
| |
| for (String line = reader.readLine(); line != null; line = reader.readLine()) { |
| |
| if (line.matches("[ \\t]*network=\\{")) { |
| found = true; |
| networkSsid = null; |
| value = null; |
| } else if (line.matches("[ \\t]*\\}")) { |
| found = false; |
| networkSsid = null; |
| value = null; |
| } |
| |
| if (found) { |
| String trimmedLine = line.trim(); |
| if (trimmedLine.startsWith("ssid=")) { |
| networkSsid = trimmedLine.substring(5); |
| } else if (trimmedLine.startsWith(key + "=")) { |
| value = trimmedLine.substring(key.length() + 1); |
| } |
| |
| if (networkSsid != null && value != null) { |
| result.put(networkSsid, value); |
| } |
| } |
| } |
| } catch (FileNotFoundException e) { |
| if (VDBG) loge("Could not open " + SUPPLICANT_CONFIG_FILE + ", " + e); |
| } catch (IOException e) { |
| if (VDBG) loge("Could not read " + SUPPLICANT_CONFIG_FILE + ", " + e); |
| } finally { |
| try { |
| if (reader != null) { |
| reader.close(); |
| } |
| } catch (IOException e) { |
| // Just ignore the fact that we couldn't close |
| } |
| } |
| |
| return result; |
| } |
| |
| private String readNetworkVariableFromSupplicantFile(String ssid, String key) { |
| long start = SystemClock.elapsedRealtimeNanos(); |
| Map<String, String> data = readNetworkVariablesFromSupplicantFile(key); |
| long end = SystemClock.elapsedRealtimeNanos(); |
| |
| if (VDBG) { |
| loge("readNetworkVariableFromSupplicantFile ssid=[" + ssid + "] key=" + key |
| + " duration=" + (long)(end - start)); |
| } |
| return data.get(ssid); |
| } |
| |
| /* Mark all networks except specified netId as disabled */ |
| private void markAllNetworksDisabledExcept(int netId) { |
| for(WifiConfiguration config : mConfiguredNetworks.values()) { |
| if(config != null && config.networkId != netId) { |
| if (config.status != Status.DISABLED) { |
| config.status = Status.DISABLED; |
| config.disableReason = WifiConfiguration.DISABLED_UNKNOWN_REASON; |
| } |
| } |
| } |
| } |
| |
| private void markAllNetworksDisabled() { |
| markAllNetworksDisabledExcept(INVALID_NETWORK_ID); |
| } |
| |
| boolean needsUnlockedKeyStore() { |
| |
| // Any network using certificates to authenticate access requires |
| // unlocked key store; unless the certificates can be stored with |
| // hardware encryption |
| |
| for(WifiConfiguration config : mConfiguredNetworks.values()) { |
| |
| if (config.allowedKeyManagement.get(KeyMgmt.WPA_EAP) |
| && config.allowedKeyManagement.get(KeyMgmt.IEEE8021X)) { |
| |
| if (needsSoftwareBackedKeyStore(config.enterpriseConfig)) { |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| void readPasspointConfig() { |
| |
| List<HomeSP> homeSPs; |
| try { |
| homeSPs = mMOManager.loadAllSPs(); |
| } catch (IOException e) { |
| loge("Could not read " + PPS_FILE + " : " + e); |
| return; |
| } |
| |
| mConfiguredNetworks.populatePasspointData(homeSPs, mWifiNative); |
| } |
| |
| public void writePasspointConfigs(final String fqdn, final HomeSP homeSP) { |
| mWriter.write(PPS_FILE, new DelayedDiskWrite.Writer() { |
| @Override |
| public void onWriteCalled(DataOutputStream out) throws IOException { |
| try { |
| if (homeSP != null) { |
| mMOManager.addSP(homeSP); |
| } |
| else { |
| mMOManager.removeSP(fqdn); |
| } |
| } catch (IOException e) { |
| loge("Could not write " + PPS_FILE + " : " + e); |
| } |
| } |
| }, false); |
| } |
| |
| public void writeKnownNetworkHistory(boolean force) { |
| boolean needUpdate = force; |
| |
| /* Make a copy */ |
| final List<WifiConfiguration> networks = new ArrayList<WifiConfiguration>(); |
| for (WifiConfiguration config : mConfiguredNetworks.values()) { |
| networks.add(new WifiConfiguration(config)); |
| if (config.dirty == true) { |
| loge(" rewrite network history for " + config.configKey()); |
| config.dirty = false; |
| needUpdate = true; |
| } |
| } |
| if (VDBG) { |
| loge(" writeKnownNetworkHistory() num networks:" + |
| mConfiguredNetworks.size() + " needWrite=" + needUpdate); |
| } |
| if (needUpdate == false) { |
| return; |
| } |
| mWriter.write(networkHistoryConfigFile, new DelayedDiskWrite.Writer() { |
| public void onWriteCalled(DataOutputStream out) throws IOException { |
| for (WifiConfiguration config : networks) { |
| //loge("onWriteCalled write SSID: " + config.SSID); |
| /* if (config.getLinkProperties() != null) |
| loge(" lp " + config.getLinkProperties().toString()); |
| else |
| loge("attempt config w/o lp"); |
| */ |
| |
| if (VDBG) { |
| int num = 0; |
| int numlink = 0; |
| if (config.connectChoices != null) { |
| num = config.connectChoices.size(); |
| } |
| if (config.linkedConfigurations != null) { |
| numlink = config.linkedConfigurations.size(); |
| } |
| loge("saving network history: " + config.configKey() + " gw: " + |
| config.defaultGwMacAddress + " autojoin-status: " + |
| config.autoJoinStatus + " ephemeral=" + config.ephemeral |
| + " choices:" + Integer.toString(num) |
| + " link:" + Integer.toString(numlink) |
| + " status:" + Integer.toString(config.status) |
| + " nid:" + Integer.toString(config.networkId)); |
| } |
| |
| if (!WifiServiceImpl.isValid(config)) |
| continue; |
| |
| if (config.SSID == null) { |
| if (VDBG) { |
| loge("writeKnownNetworkHistory trying to write config with null SSID"); |
| } |
| continue; |
| } |
| if (VDBG) { |
| loge("writeKnownNetworkHistory write config " + config.configKey()); |
| } |
| out.writeUTF(CONFIG_KEY + SEPARATOR + config.configKey() + NL); |
| |
| if (config.SSID != null) { |
| out.writeUTF(SSID_KEY + SEPARATOR + config.SSID + NL); |
| } |
| if (config.FQDN != null) { |
| out.writeUTF(FQDN_KEY + SEPARATOR + config.FQDN + NL); |
| } |
| |
| out.writeUTF(PRIORITY_KEY + SEPARATOR + |
| Integer.toString(config.priority) + NL); |
| out.writeUTF(STATUS_KEY + SEPARATOR + |
| Integer.toString(config.autoJoinStatus) + NL); |
| out.writeUTF(SUPPLICANT_STATUS_KEY + SEPARATOR + |
| Integer.toString(config.status) + NL); |
| out.writeUTF(SUPPLICANT_DISABLE_REASON_KEY + SEPARATOR + |
| Integer.toString(config.disableReason) + NL); |
| out.writeUTF(NETWORK_ID_KEY + SEPARATOR + |
| Integer.toString(config.networkId) + NL); |
| out.writeUTF(SELF_ADDED_KEY + SEPARATOR + |
| Boolean.toString(config.selfAdded) + NL); |
| out.writeUTF(DID_SELF_ADD_KEY + SEPARATOR + |
| Boolean.toString(config.didSelfAdd) + NL); |
| out.writeUTF(NO_INTERNET_ACCESS_REPORTS_KEY + SEPARATOR + |
| Integer.toString(config.numNoInternetAccessReports) + NL); |
| out.writeUTF(VALIDATED_INTERNET_ACCESS_KEY + SEPARATOR + |
| Boolean.toString(config.validatedInternetAccess) + NL); |
| out.writeUTF(EPHEMERAL_KEY + SEPARATOR + |
| Boolean.toString(config.ephemeral) + NL); |
| if (config.creationTime != null) { |
| out.writeUTF(CREATION_TIME_KEY + SEPARATOR + config.creationTime + NL); |
| } |
| if (config.updateTime != null) { |
| out.writeUTF(UPDATE_TIME_KEY + SEPARATOR + config.updateTime + NL); |
| } |
| if (config.peerWifiConfiguration != null) { |
| out.writeUTF(PEER_CONFIGURATION_KEY + SEPARATOR + |
| config.peerWifiConfiguration + NL); |
| } |
| out.writeUTF(NUM_CONNECTION_FAILURES_KEY + SEPARATOR + |
| Integer.toString(config.numConnectionFailures) + NL); |
| out.writeUTF(NUM_AUTH_FAILURES_KEY + SEPARATOR + |
| Integer.toString(config.numAuthFailures) + NL); |
| out.writeUTF(NUM_IP_CONFIG_FAILURES_KEY + SEPARATOR + |
| Integer.toString(config.numIpConfigFailures) + NL); |
| out.writeUTF(SCORER_OVERRIDE_KEY + SEPARATOR + |
| Integer.toString(config.numScorerOverride) + NL); |
| out.writeUTF(SCORER_OVERRIDE_AND_SWITCH_KEY + SEPARATOR + |
| Integer.toString(config.numScorerOverrideAndSwitchedNetwork) + NL); |
| out.writeUTF(NUM_ASSOCIATION_KEY + SEPARATOR + |
| Integer.toString(config.numAssociation) + NL); |
| out.writeUTF(JOIN_ATTEMPT_BOOST_KEY + SEPARATOR + |
| Integer.toString(config.autoJoinUseAggressiveJoinAttemptThreshold)+ NL); |
| //out.writeUTF(BLACKLIST_MILLI_KEY + SEPARATOR + |
| // Long.toString(config.blackListTimestamp) + NL); |
| out.writeUTF(CREATOR_UID_KEY + SEPARATOR + |
| Integer.toString(config.creatorUid) + NL); |
| out.writeUTF(CONNECT_UID_KEY + SEPARATOR + |
| Integer.toString(config.lastConnectUid) + NL); |
| out.writeUTF(UPDATE_UID_KEY + SEPARATOR + |
| Integer.toString(config.lastUpdateUid) + NL); |
| out.writeUTF(CREATOR_NAME_KEY + SEPARATOR + |
| config.creatorName + NL); |
| out.writeUTF(UPDATE_NAME_KEY + SEPARATOR + |
| config.lastUpdateName + NL); |
| out.writeUTF(USER_APPROVED_KEY + SEPARATOR + |
| Integer.toString(config.userApproved) + NL); |
| String allowedKeyManagementString = |
| makeString(config.allowedKeyManagement, |
| WifiConfiguration.KeyMgmt.strings); |
| out.writeUTF(AUTH_KEY + SEPARATOR + |
| allowedKeyManagementString + NL); |
| |
| if (config.connectChoices != null) { |
| for (String key : config.connectChoices.keySet()) { |
| Integer choice = config.connectChoices.get(key); |
| out.writeUTF(CHOICE_KEY + SEPARATOR + |
| key + "=" + choice.toString() + NL); |
| } |
| } |
| if (config.linkedConfigurations != null) { |
| log("writeKnownNetworkHistory write linked " |
| + config.linkedConfigurations.size()); |
| |
| for (String key : config.linkedConfigurations.keySet()) { |
| out.writeUTF(LINK_KEY + SEPARATOR + key + NL); |
| } |
| } |
| |
| String macAddress = config.defaultGwMacAddress; |
| if (macAddress != null) { |
| out.writeUTF(DEFAULT_GW_KEY + SEPARATOR + macAddress + NL); |
| } |
| |
| if (getScanDetailCache(config) != null) { |
| for (ScanDetail scanDetail : getScanDetailCache(config).values()) { |
| ScanResult result = scanDetail.getScanResult(); |
| out.writeUTF(BSSID_KEY + SEPARATOR + |
| result.BSSID + NL); |
| |
| out.writeUTF(FREQ_KEY + SEPARATOR + |
| Integer.toString(result.frequency) + NL); |
| |
| out.writeUTF(RSSI_KEY + SEPARATOR + |
| Integer.toString(result.level) + NL); |
| |
| out.writeUTF(BSSID_STATUS_KEY + SEPARATOR + |
| Integer.toString(result.autoJoinStatus) + NL); |
| |
| //if (result.seen != 0) { |
| // out.writeUTF(MILLI_KEY + SEPARATOR + Long.toString(result.seen) |
| // + NL); |
| //} |
| out.writeUTF(BSSID_KEY_END + NL); |
| } |
| } |
| if (config.lastFailure != null) { |
| out.writeUTF(FAILURE_KEY + SEPARATOR + config.lastFailure + NL); |
| } |
| out.writeUTF(NL); |
| // Add extra blank lines for clarity |
| out.writeUTF(NL); |
| out.writeUTF(NL); |
| } |
| if (mDeletedSSIDs != null && mDeletedSSIDs.size() > 0) { |
| for (Long i : mDeletedSSIDs) { |
| out.writeUTF(DELETED_CRC32_KEY); |
| out.writeUTF(String.valueOf(i)); |
| out.writeUTF(NL); |
| } |
| } |
| if (mDeletedEphemeralSSIDs != null && mDeletedEphemeralSSIDs.size() > 0) { |
| for (String ssid : mDeletedEphemeralSSIDs) { |
| out.writeUTF(DELETED_EPHEMERAL_KEY); |
| out.writeUTF(ssid); |
| out.writeUTF(NL); |
| } |
| } |
| } |
| }); |
| } |
| |
| public void setLastSelectedConfiguration(int netId) { |
| if (VDBG) { |
| loge("setLastSelectedConfiguration " + Integer.toString(netId)); |
| } |
| if (netId == WifiConfiguration.INVALID_NETWORK_ID) { |
| lastSelectedConfiguration = null; |
| } else { |
| WifiConfiguration selected = getWifiConfiguration(netId); |
| if (selected == null) { |
| lastSelectedConfiguration = null; |
| } else { |
| lastSelectedConfiguration = selected.configKey(); |
| selected.numConnectionFailures = 0; |
| selected.numIpConfigFailures = 0; |
| selected.numAuthFailures = 0; |
| selected.numNoInternetAccessReports = 0; |
| if (VDBG) { |
| loge("setLastSelectedConfiguration now: " + lastSelectedConfiguration); |
| } |
| } |
| } |
| } |
| |
| public String getLastSelectedConfiguration() { |
| return lastSelectedConfiguration; |
| } |
| |
| public boolean isLastSelectedConfiguration(WifiConfiguration config) { |
| return (lastSelectedConfiguration != null |
| && config != null |
| && lastSelectedConfiguration.equals(config.configKey())); |
| } |
| |
| private void readNetworkHistory() { |
| if (showNetworks) { |
| localLog("readNetworkHistory() path:" + networkHistoryConfigFile); |
| } |
| |
| try (DataInputStream in = |
| new DataInputStream(new BufferedInputStream( |
| new FileInputStream(networkHistoryConfigFile)))) { |
| |
| String bssid = null; |
| String ssid = null; |
| |
| int freq = 0; |
| int status = 0; |
| long seen = 0; |
| int rssi = WifiConfiguration.INVALID_RSSI; |
| String caps = null; |
| |
| WifiConfiguration config = null; |
| while (true) { |
| String line = in.readUTF(); |
| if (line == null) { |
| break; |
| } |
| int colon = line.indexOf(':'); |
| if (colon < 0) { |
| continue; |
| } |
| |
| String key = line.substring(0, colon).trim(); |
| String value = line.substring(colon + 1).trim(); |
| |
| if (key.equals(CONFIG_KEY)) { |
| |
| config = mConfiguredNetworks.getByConfigKey(value); |
| |
| // skip reading that configuration data |
| // since we don't have a corresponding network ID |
| if (config == null) { |
| localLog("readNetworkHistory didnt find netid for hash=" |
| + Integer.toString(value.hashCode()) |
| + " key: " + value); |
| mLostConfigsDbg.add(value); |
| continue; |
| } else { |
| // After an upgrade count old connections as owned by system |
| if (config.creatorName == null || config.lastUpdateName == null) { |
| config.creatorName = |
| mContext.getPackageManager().getNameForUid(Process.SYSTEM_UID); |
| config.lastUpdateName = config.creatorName; |
| |
| if (DBG) Log.w(TAG, "Upgrading network " + config.networkId |
| + " to " + config.creatorName); |
| } |
| } |
| } else if (config != null) { |
| switch (key) { |
| case SSID_KEY: |
| if (config.isPasspoint()) { |
| break; |
| } |
| ssid = value; |
| if (config.SSID != null && !config.SSID.equals(ssid)) { |
| loge("Error parsing network history file, mismatched SSIDs"); |
| config = null; //error |
| ssid = null; |
| } else { |
| config.SSID = ssid; |
| } |
| break; |
| case FQDN_KEY: |
| // Check for literal 'null' to be backwards compatible. |
| config.FQDN = value.equals("null") ? null : value; |
| break; |
| case DEFAULT_GW_KEY: |
| config.defaultGwMacAddress = value; |
| break; |
| case STATUS_KEY: |
| config.autoJoinStatus = Integer.parseInt(value); |
| break; |
| case SUPPLICANT_DISABLE_REASON_KEY: |
| config.disableReason = Integer.parseInt(value); |
| break; |
| case SELF_ADDED_KEY: |
| config.selfAdded = Boolean.parseBoolean(value); |
| break; |
| case DID_SELF_ADD_KEY: |
| config.didSelfAdd = Boolean.parseBoolean(value); |
| break; |
| case NO_INTERNET_ACCESS_REPORTS_KEY: |
| config.numNoInternetAccessReports = Integer.parseInt(value); |
| break; |
| case VALIDATED_INTERNET_ACCESS_KEY: |
| config.validatedInternetAccess = Boolean.parseBoolean(value); |
| break; |
| case CREATION_TIME_KEY: |
| config.creationTime = value; |
| break; |
| case UPDATE_TIME_KEY: |
| config.updateTime = value; |
| break; |
| case EPHEMERAL_KEY: |
| config.ephemeral = Boolean.parseBoolean(value); |
| break; |
| case CREATOR_UID_KEY: |
| config.creatorUid = Integer.parseInt(value); |
| break; |
| case BLACKLIST_MILLI_KEY: |
| config.blackListTimestamp = Long.parseLong(value); |
| break; |
| case NUM_CONNECTION_FAILURES_KEY: |
| config.numConnectionFailures = Integer.parseInt(value); |
| break; |
| case NUM_IP_CONFIG_FAILURES_KEY: |
| config.numIpConfigFailures = Integer.parseInt(value); |
| break; |
| case NUM_AUTH_FAILURES_KEY: |
| config.numIpConfigFailures = Integer.parseInt(value); |
| break; |
| case SCORER_OVERRIDE_KEY: |
| config.numScorerOverride = Integer.parseInt(value); |
| break; |
| case SCORER_OVERRIDE_AND_SWITCH_KEY: |
| config.numScorerOverrideAndSwitchedNetwork = Integer.parseInt(value); |
| break; |
| case NUM_ASSOCIATION_KEY: |
| config.numAssociation = Integer.parseInt(value); |
| break; |
| case JOIN_ATTEMPT_BOOST_KEY: |
| config.autoJoinUseAggressiveJoinAttemptThreshold = |
| Integer.parseInt(value); |
| break; |
| case CONNECT_UID_KEY: |
| config.lastConnectUid = Integer.parseInt(value); |
| break; |
| case UPDATE_UID_KEY: |
| config.lastUpdateUid = Integer.parseInt(value); |
| break; |
| case FAILURE_KEY: |
| config.lastFailure = value; |
| break; |
| case PEER_CONFIGURATION_KEY: |
| config.peerWifiConfiguration = value; |
| break; |
| case CHOICE_KEY: |
| String configKey = ""; |
| int choice = 0; |
| Matcher match = mConnectChoice.matcher(value); |
| if (!match.find()) { |
| if (DBG) Log.d(TAG, "WifiConfigStore: connectChoice: " + |
| " Couldnt match pattern : " + value); |
| } else { |
| configKey = match.group(1); |
| try { |
| choice = Integer.parseInt(match.group(2)); |
| } catch (NumberFormatException e) { |
| choice = 0; |
| } |
| if (choice > 0) { |
| if (config.connectChoices == null) { |
| config.connectChoices = new HashMap<>(); |
| } |
| config.connectChoices.put(configKey, choice); |
| } |
| } |
| break; |
| case LINK_KEY: |
| if (config.linkedConfigurations == null) { |
| config.linkedConfigurations = new HashMap<>(); |
| } |
| else { |
| config.linkedConfigurations.put(value, -1); |
| } |
| break; |
| case BSSID_KEY: |
| status = 0; |
| ssid = null; |
| bssid = null; |
| freq = 0; |
| seen = 0; |
| rssi = WifiConfiguration.INVALID_RSSI; |
| caps = ""; |
| break; |
| case RSSI_KEY: |
| rssi = Integer.parseInt(value); |
| break; |
| case BSSID_STATUS_KEY: |
| status = Integer.parseInt(value); |
| break; |
| case FREQ_KEY: |
| freq = Integer.parseInt(value); |
| break; |
| case DATE_KEY: |
| /* |
| * when reading the configuration from file we don't update the date |
| * so as to avoid reading back stale or non-sensical data that would |
| * depend on network time. |
| * The date of a WifiConfiguration should only come from actual scan result. |
| * |
| String s = key.replace(FREQ_KEY, ""); |
| seen = Integer.getInteger(s); |
| */ |
| break; |
| case BSSID_KEY_END: |
| if ((bssid != null) && (ssid != null)) { |
| |
| if (getScanDetailCache(config) != null) { |
| WifiSsid wssid = WifiSsid.createFromAsciiEncoded(ssid); |
| ScanDetail scanDetail = new ScanDetail(wssid, bssid, |
| caps, rssi, freq, (long) 0, seen); |
| getScanDetailCache(config).put(scanDetail); |
| scanDetail.getScanResult().autoJoinStatus = status; |
| } |
| } |
| break; |
| case DELETED_CRC32_KEY: |
| mDeletedSSIDs.add(Long.parseLong(value)); |
| break; |
| case DELETED_EPHEMERAL_KEY: |
| if (!TextUtils.isEmpty(value)) { |
| mDeletedEphemeralSSIDs.add(value); |
| } |
| break; |
| case CREATOR_NAME_KEY: |
| config.creatorName = value; |
| break; |
| case UPDATE_NAME_KEY: |
| config.lastUpdateName = value; |
| break; |
| case USER_APPROVED_KEY: |
| config.userApproved = Integer.parseInt(value); |
| break; |
| } |
| } |
| } |
| } catch (NumberFormatException e) { |
| Log.e(TAG, "readNetworkHistory: failed to read, revert to default, " + e, e); |
| } catch (EOFException e) { |
| // do nothing |
| } catch (IOException e) { |
| Log.e(TAG, "readNetworkHistory: No config file, revert to default, " + e, e); |
| } |
| } |
| |
| private void readAutoJoinConfig() { |
| try (BufferedReader reader = new BufferedReader(new FileReader(autoJoinConfigFile))) { |
| for (String key = reader.readLine(); key != null; key = reader.readLine()) { |
| Log.d(TAG, "readAutoJoinConfig line: " + key); |
| |
| int split = key.indexOf(':'); |
| if (split < 0) { |
| continue; |
| } |
| |
| String name = key.substring(0, split); |
| Object reference = sKeyMap.get(name); |
| if (reference == null) { |
| continue; |
| } |
| |
| try { |
| int value = Integer.parseInt(key.substring(split+1).trim()); |
| if (reference.getClass() == AtomicBoolean.class) { |
| ((AtomicBoolean)reference).set(value != 0); |
| } |
| else { |
| ((AtomicInteger)reference).set(value); |
| } |
| Log.d(TAG,"readAutoJoinConfig: " + name + " = " + value); |
| } |
| catch (NumberFormatException nfe) { |
| Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key); |
| } |
| } |
| } catch (IOException e) { |
| loge("readAutoJoinStatus: Error parsing configuration" + e); |
| } |
| } |
| |
| |
| private void writeIpAndProxyConfigurations() { |
| final SparseArray<IpConfiguration> networks = new SparseArray<IpConfiguration>(); |
| for(WifiConfiguration config : mConfiguredNetworks.values()) { |
| if (!config.ephemeral && config.autoJoinStatus != WifiConfiguration.AUTO_JOIN_DELETED) { |
| networks.put(configKey(config), config.getIpConfiguration()); |
| } |
| } |
| |
| super.writeIpAndProxyConfigurations(ipConfigFile, networks); |
| } |
| |
| private void readIpAndProxyConfigurations() { |
| SparseArray<IpConfiguration> networks = super.readIpAndProxyConfigurations(ipConfigFile); |
| |
| if (networks == null || networks.size() == 0) { |
| // IpConfigStore.readIpAndProxyConfigurations has already logged an error. |
| return; |
| } |
| |
| for (int i = 0; i < networks.size(); i++) { |
| int id = networks.keyAt(i); |
| WifiConfiguration config = mConfiguredNetworks.getByConfigKeyID(id); |
| // This is the only place the map is looked up through a (dangerous) hash-value! |
| |
| if (config == null || config.autoJoinStatus == WifiConfiguration.AUTO_JOIN_DELETED || |
| config.ephemeral) { |
| loge("configuration found for missing network, nid=" + id |
| +", ignored, networks.size=" + Integer.toString(networks.size())); |
| } else { |
| config.setIpConfiguration(networks.valueAt(i)); |
| } |
| } |
| } |
| |
| /* |
| * Convert string to Hexadecimal before passing to wifi native layer |
| * In native function "doCommand()" have trouble in converting Unicode character string to UTF8 |
| * conversion to hex is required because SSIDs can have space characters in them; |
| * and that can confuses the supplicant because it uses space charaters as delimiters |
| */ |
| |
| public static String encodeSSID(String str){ |
| return Utils.toHex(removeDoubleQuotes(str).getBytes(StandardCharsets.UTF_8)); |
| } |
| |
| private NetworkUpdateResult addOrUpdateNetworkNative(WifiConfiguration config, int uid) { |
| /* |
| * If the supplied networkId is INVALID_NETWORK_ID, we create a new empty |
| * network configuration. Otherwise, the networkId should |
| * refer to an existing configuration. |
| */ |
| |
| if (VDBG) localLog("addOrUpdateNetworkNative " + config.getPrintableSsid()); |
| if (config.isPasspoint() && !mMOManager.isEnabled()) { |
| Log.e(TAG, "Passpoint is not enabled"); |
| return new NetworkUpdateResult(INVALID_NETWORK_ID); |
| } |
| |
| int netId = config.networkId; |
| boolean newNetwork = false; |
| // networkId of INVALID_NETWORK_ID means we want to create a new network |
| if (netId == INVALID_NETWORK_ID) { |
| WifiConfiguration savedConfig = mConfiguredNetworks.getByConfigKey(config.configKey()); |
| if (savedConfig != null) { |
| netId = savedConfig.networkId; |
| } else { |
| if (mMOManager.getHomeSP(config.FQDN) != null) { |
| loge("addOrUpdateNetworkNative passpoint " + config.FQDN |
| + " was found, but no network Id"); |
| } |
| newNetwork = true; |
| netId = mWifiNative.addNetwork(); |
| if (netId < 0) { |
| loge("Failed to add a network!"); |
| return new NetworkUpdateResult(INVALID_NETWORK_ID); |
| } else { |
| loge("addOrUpdateNetworkNative created netId=" + netId); |
| } |
| } |
| } |
| |
| boolean updateFailed = true; |
| |
| setVariables: { |
| |
| if (config.SSID != null && |
| !mWifiNative.setNetworkVariable( |
| netId, |
| WifiConfiguration.ssidVarName, |
| encodeSSID(config.SSID))) { |
| loge("failed to set SSID: "+config.SSID); |
| break setVariables; |
| } |
| |
| if (config.isPasspoint()) { |
| if (!mWifiNative.setNetworkVariable( |
| netId, |
| idStringVarName, |
| '"' + config.FQDN + '"')) { |
| loge("failed to set id_str: " + config.FQDN); |
| break setVariables; |
| } |
| } |
| |
| if (config.BSSID != null) { |
| log("Setting BSSID for " + config.configKey() + " to " + config.BSSID); |
| if (!mWifiNative.setNetworkVariable( |
| netId, |
| WifiConfiguration.bssidVarName, |
| config.BSSID)) { |
| loge("failed to set BSSID: " + config.BSSID); |
| break setVariables; |
| } |
| } |
| |
| String allowedKeyManagementString = |
| makeString(config.allowedKeyManagement, WifiConfiguration.KeyMgmt.strings); |
| if (config.allowedKeyManagement.cardinality() != 0 && |
| !mWifiNative.setNetworkVariable( |
| netId, |
| WifiConfiguration.KeyMgmt.varName, |
| allowedKeyManagementString)) { |
| loge("failed to set key_mgmt: "+ |
| allowedKeyManagementString); |
| break setVariables; |
| } |
| |
| String allowedProtocolsString = |
| makeString(config.allowedProtocols, WifiConfiguration.Protocol.strings); |
| if (config.allowedProtocols.cardinality() != 0 && |
| !mWifiNative.setNetworkVariable( |
| netId, |
| WifiConfiguration.Protocol.varName, |
| allowedProtocolsString)) { |
| loge("failed to set proto: "+ |
| allowedProtocolsString); |
| break setVariables; |
| } |
| |
| String allowedAuthAlgorithmsString = |
| makeString(config.allowedAuthAlgorithms, WifiConfiguration.AuthAlgorithm.strings); |
| if (config.allowedAuthAlgorithms.cardinality() != 0 && |
| !mWifiNative.setNetworkVariable( |
| netId, |
| WifiConfiguration.AuthAlgorithm.varName, |
| allowedAuthAlgorithmsString)) { |
| loge("failed to set auth_alg: "+ |
| allowedAuthAlgorithmsString); |
| break setVariables; |
| } |
| |
| String allowedPairwiseCiphersString = |
| makeString(config.allowedPairwiseCiphers, |
| WifiConfiguration.PairwiseCipher.strings); |
| if (config.allowedPairwiseCiphers.cardinality() != 0 && |
| !mWifiNative.setNetworkVariable( |
| netId, |
| WifiConfiguration.PairwiseCipher.varName, |
| allowedPairwiseCiphersString)) { |
| loge("failed to set pairwise: "+ |
| allowedPairwiseCiphersString); |
| break setVariables; |
| } |
| |
| String allowedGroupCiphersString = |
| makeString(config.allowedGroupCiphers, WifiConfiguration.GroupCipher.strings); |
| if (config.allowedGroupCiphers.cardinality() != 0 && |
| !mWifiNative.setNetworkVariable( |
| netId, |
| WifiConfiguration.GroupCipher.varName, |
| allowedGroupCiphersString)) { |
| loge("failed to set group: "+ |
| allowedGroupCiphersString); |
| break setVariables; |
| } |
| |
| // Prevent client screw-up by passing in a WifiConfiguration we gave it |
| // by preventing "*" as a key. |
| if (config.preSharedKey != null && !config.preSharedKey.equals("*") && |
| !mWifiNative.setNetworkVariable( |
| netId, |
| WifiConfiguration.pskVarName, |
| config.preSharedKey)) { |
| loge("failed to set psk"); |
| break setVariables; |
| } |
| |
| boolean hasSetKey = false; |
| if (config.wepKeys != null) { |
| for (int i = 0; i < config.wepKeys.length; i++) { |
| // Prevent client screw-up by passing in a WifiConfiguration we gave it |
| // by preventing "*" as a key. |
| if (config.wepKeys[i] != null && !config.wepKeys[i].equals("*")) { |
| if (!mWifiNative.setNetworkVariable( |
| netId, |
| WifiConfiguration.wepKeyVarNames[i], |
| config.wepKeys[i])) { |
| loge("failed to set wep_key" + i + ": " + config.wepKeys[i]); |
| break setVariables; |
| } |
| hasSetKey = true; |
| } |
| } |
| } |
| |
| if (hasSetKey) { |
| if (!mWifiNative.setNetworkVariable( |
| netId, |
| WifiConfiguration.wepTxKeyIdxVarName, |
| Integer.toString(config.wepTxKeyIndex))) { |
| loge("failed to set wep_tx_keyidx: " + config.wepTxKeyIndex); |
| break setVariables; |
| } |
| } |
| |
| if (!mWifiNative.setNetworkVariable( |
| netId, |
| WifiConfiguration.priorityVarName, |
| Integer.toString(config.priority))) { |
| loge(config.SSID + ": failed to set priority: " |
| +config.priority); |
| break setVariables; |
| } |
| |
| if (config.hiddenSSID && !mWifiNative.setNetworkVariable( |
| netId, |
| WifiConfiguration.hiddenSSIDVarName, |
| Integer.toString(config.hiddenSSID ? 1 : 0))) { |
| loge(config.SSID + ": failed to set hiddenSSID: "+ |
| config.hiddenSSID); |
| break setVariables; |
| } |
| |
| if (config.requirePMF && !mWifiNative.setNetworkVariable( |
| netId, |
| WifiConfiguration.pmfVarName, |
| "2")) { |
| loge(config.SSID + ": failed to set requirePMF: "+ |
| config.requirePMF); |
| break setVariables; |
| } |
| |
| if (config.updateIdentifier != null && !mWifiNative.setNetworkVariable( |
| netId, |
| WifiConfiguration.updateIdentiferVarName, |
| config.updateIdentifier)) { |
| loge(config.SSID + ": failed to set updateIdentifier: "+ |
| config.updateIdentifier); |
| break setVariables; |
| } |
| |
| if (config.enterpriseConfig != null && |
| config.enterpriseConfig.getEapMethod() != WifiEnterpriseConfig.Eap.NONE) { |
| |
| WifiEnterpriseConfig enterpriseConfig = config.enterpriseConfig; |
| |
| if (needsKeyStore(enterpriseConfig)) { |
| /** |
| * Keyguard settings may eventually be controlled by device policy. |
| * We check here if keystore is unlocked before installing |
| * credentials. |
| * TODO: Do we need a dialog here ? |
| */ |
| if (mKeyStore.state() != KeyStore.State.UNLOCKED) { |
| loge(config.SSID + ": key store is locked"); |
| break setVariables; |
| } |
| |
| try { |
| /* config passed may include only fields being updated. |
| * In order to generate the key id, fetch uninitialized |
| * fields from the currently tracked configuration |
| */ |
| WifiConfiguration currentConfig = mConfiguredNetworks.get(netId); |
| String keyId = config.getKeyIdForCredentials(currentConfig); |
| |
| if (!installKeys(enterpriseConfig, keyId)) { |
| loge(config.SSID + ": failed to install keys"); |
| break setVariables; |
| } |
| } catch (IllegalStateException e) { |
| loge(config.SSID + " invalid config for key installation"); |
| break setVariables; |
| } |
| } |
| |
| HashMap<String, String> enterpriseFields = enterpriseConfig.getFields(); |
| for (String key : enterpriseFields.keySet()) { |
| String value = enterpriseFields.get(key); |
| if (key.equals("password") && value != null && value.equals("*")) { |
| // No need to try to set an obfuscated password, which will fail |
| continue; |
| } |
| if (key.equals(WifiEnterpriseConfig.REALM_KEY) |
| || key.equals(WifiEnterpriseConfig.PLMN_KEY)) { |
| // No need to save realm or PLMN in supplicant |
| continue; |
| } |
| if (!mWifiNative.setNetworkVariable( |
| netId, |
| key, |
| value)) { |
| removeKeys(enterpriseConfig); |
| loge(config.SSID + ": failed to set " + key + |
| ": " + value); |
| break setVariables; |
| } |
| } |
| } |
| updateFailed = false; |
| } // End of setVariables |
| |
| if (updateFailed) { |
| if (newNetwork) { |
| mWifiNative.removeNetwork(netId); |
| loge("Failed to set a network variable, removed network: " + netId); |
| } |
| return new NetworkUpdateResult(INVALID_NETWORK_ID); |
| } |
| |
| /* An update of the network variables requires reading them |
| * back from the supplicant to update mConfiguredNetworks. |
| * This is because some of the variables (SSID, wep keys & |
| * passphrases) reflect different values when read back than |
| * when written. For example, wep key is stored as * irrespective |
| * of the value sent to the supplicant |
| */ |
| WifiConfiguration currentConfig = mConfiguredNetworks.get(netId); |
| if (currentConfig == null) { |
| currentConfig = new WifiConfiguration(); |
| currentConfig.setIpAssignment(IpAssignment.DHCP); |
| currentConfig.setProxySettings(ProxySettings.NONE); |
| currentConfig.networkId = netId; |
| if (config != null) { |
| // Carry over the creation parameters |
| currentConfig.selfAdded = config.selfAdded; |
| currentConfig.didSelfAdd = config.didSelfAdd; |
| currentConfig.ephemeral = config.ephemeral; |
| currentConfig.autoJoinUseAggressiveJoinAttemptThreshold |
| = config.autoJoinUseAggressiveJoinAttemptThreshold; |
| currentConfig.lastConnectUid = config.lastConnectUid; |
| currentConfig.lastUpdateUid = config.lastUpdateUid; |
| currentConfig.creatorUid = config.creatorUid; |
| currentConfig.creatorName = config.creatorName; |
| currentConfig.lastUpdateName = config.lastUpdateName; |
| currentConfig.peerWifiConfiguration = config.peerWifiConfiguration; |
| currentConfig.FQDN = config.FQDN; |
| currentConfig.providerFriendlyName = config.providerFriendlyName; |
| currentConfig.roamingConsortiumIds = config.roamingConsortiumIds; |
| currentConfig.validatedInternetAccess = config.validatedInternetAccess; |
| currentConfig.numNoInternetAccessReports = config.numNoInternetAccessReports; |
| currentConfig.updateTime = config.updateTime; |
| currentConfig.creationTime = config.creationTime; |
| } |
| if (DBG) { |
| log("created new config netId=" + Integer.toString(netId) |
| + " uid=" + Integer.toString(currentConfig.creatorUid) |
| + " name=" + currentConfig.creatorName); |
| } |
| } |
| |
| /* save HomeSP object for passpoint networks */ |
| HomeSP homeSP = null; |
| |
| if (config.isPasspoint()) { |
| try { |
| Credential credential = |
| new Credential(config.enterpriseConfig, mKeyStore, !newNetwork); |
| HashSet<Long> roamingConsortiumIds = new HashSet<Long>(); |
| for (Long roamingConsortiumId : config.roamingConsortiumIds) { |
| roamingConsortiumIds.add(roamingConsortiumId); |
| } |
| |
| homeSP = new HomeSP(Collections.<String, Long>emptyMap(), config.FQDN, |
| roamingConsortiumIds, Collections.<String>emptySet(), |
| Collections.<Long>emptySet(), Collections.<Long>emptyList(), |
| config.providerFriendlyName, null, credential); |
| |
| log("created a homeSP object for " + config.networkId + ":" + config.SSID); |
| |
| /* fix enterprise config properties for passpoint */ |
| currentConfig.enterpriseConfig.setRealm(config.enterpriseConfig.getRealm()); |
| currentConfig.enterpriseConfig.setPlmn(config.enterpriseConfig.getPlmn()); |
| } |
| catch (IOException ioe) { |
| Log.e(TAG, "Failed to create Passpoint config: " + ioe); |
| return new NetworkUpdateResult(INVALID_NETWORK_ID); |
| } |
| } |
| |
| if (uid != WifiConfiguration.UNKNOWN_UID) { |
| if (newNetwork) { |
| currentConfig.creatorUid = uid; |
| } else { |
| currentConfig.lastUpdateUid = uid; |
| } |
| } |
| |
| // For debug, record the time the configuration was modified |
| StringBuilder sb = new StringBuilder(); |
| sb.append("time="); |
| Calendar c = Calendar.getInstance(); |
| c.setTimeInMillis(System.currentTimeMillis()); |
| sb.append(String.format("%tm-%td %tH:%tM:%tS.%tL", c, c, c, c, c, c)); |
| |
| if (newNetwork) { |
| currentConfig.dirty = true; |
| currentConfig.creationTime = sb.toString(); |
| } else { |
| currentConfig.updateTime = sb.toString(); |
| } |
| |
| if (currentConfig.autoJoinStatus == WifiConfiguration.AUTO_JOIN_DELETED) { |
| // Make sure the configuration is not deleted anymore since we just |
| // added or modified it. |
| currentConfig.setAutoJoinStatus(WifiConfiguration.AUTO_JOIN_ENABLED); |
| currentConfig.selfAdded = false; |
| currentConfig.didSelfAdd = false; |
| if (DBG) { |
| log("remove deleted status netId=" + Integer.toString(netId) |
| + " " + currentConfig.configKey()); |
| } |
| } |
| |
| if (currentConfig.status == WifiConfiguration.Status.ENABLED) { |
| // Make sure autojoin remain in sync with user modifying the configuration |
| currentConfig.setAutoJoinStatus(WifiConfiguration.AUTO_JOIN_ENABLED); |
| } |
| |
| if (currentConfig.configKey().equals(getLastSelectedConfiguration()) && |
| currentConfig.ephemeral) { |
| // Make the config non-ephemeral since the user just explicitly clicked it. |
| currentConfig.ephemeral = false; |
| if (DBG) log("remove ephemeral status netId=" + Integer.toString(netId) |
| + " " + currentConfig.configKey()); |
| } |
| |
| if (VDBG) log("will read network variables netId=" + Integer.toString(netId)); |
| |
| readNetworkVariables(currentConfig); |
| |
| // Persist configuration paramaters that are not saved by supplicant. |
| if (config.lastUpdateName != null) { |
| currentConfig.lastUpdateName = config.lastUpdateName; |
| } |
| if (config.lastUpdateUid != WifiConfiguration.UNKNOWN_UID) { |
| currentConfig.lastUpdateUid = config.lastUpdateUid; |
| } |
| |
| mConfiguredNetworks.put(netId, currentConfig); |
| |
| NetworkUpdateResult result = writeIpAndProxyConfigurationsOnChange(currentConfig, config); |
| result.setIsNewNetwork(newNetwork); |
| result.setNetworkId(netId); |
| |
| if (homeSP != null) { |
| writePasspointConfigs(null, homeSP); |
| } |
| writeKnownNetworkHistory(false); |
| |
| return result; |
| } |
| |
| public WifiConfiguration getWifiConfigForHomeSP(HomeSP homeSP) { |
| WifiConfiguration config = mConfiguredNetworks.getByFQDN(homeSP.getFQDN()); |
| if (config == null) { |
| Log.e(TAG, "Could not find network for homeSP " + homeSP.getFQDN()); |
| } |
| return config; |
| } |
| |
| private HomeSP getHomeSPForConfig(WifiConfiguration config) { |
| WifiConfiguration storedConfig = mConfiguredNetworks.get(config.networkId); |
| return storedConfig != null && storedConfig.isPasspoint() ? |
| mMOManager.getHomeSP(storedConfig.FQDN) : null; |
| } |
| |
| public ScanDetailCache getScanDetailCache(WifiConfiguration config) { |
| if (config == null) return null; |
| ScanDetailCache cache = mScanDetailCaches.get(config.networkId); |
| if (cache == null && config.networkId != WifiConfiguration.INVALID_NETWORK_ID) { |
| cache = new ScanDetailCache(config); |
| mScanDetailCaches.put(config.networkId, cache); |
| } |
| return cache; |
| } |
| |
| /** |
| * This function run thru the Saved WifiConfigurations and check if some should be linked. |
| * @param config |
| */ |
| public void linkConfiguration(WifiConfiguration config) { |
| |
| if (getScanDetailCache(config) != null && getScanDetailCache(config).size() > 6) { |
| // Ignore configurations with large number of BSSIDs |
| return; |
| } |
| if (!config.allowedKeyManagement.get(KeyMgmt.WPA_PSK)) { |
| // Only link WPA_PSK config |
| return; |
| } |
| for (WifiConfiguration link : mConfiguredNetworks.values()) { |
| boolean doLink = false; |
| |
| if (link.configKey().equals(config.configKey())) { |
| continue; |
| } |
| |
| if (link.autoJoinStatus == WifiConfiguration.AUTO_JOIN_DELETED || link.ephemeral) { |
| continue; |
| } |
| |
| // Autojoin will be allowed to dynamically jump from a linked configuration |
| // to another, hence only link configurations that have equivalent level of security |
| if (!link.allowedKeyManagement.equals(config.allowedKeyManagement)) { |
| continue; |
| } |
| |
| ScanDetailCache linkedScanDetailCache = getScanDetailCache(link); |
| if (linkedScanDetailCache != null && linkedScanDetailCache.size() > 6) { |
| // Ignore configurations with large number of BSSIDs |
| continue; |
| } |
| |
| if (config.defaultGwMacAddress != null && link.defaultGwMacAddress != null) { |
| // If both default GW are known, link only if they are equal |
| if (config.defaultGwMacAddress.equals(link.defaultGwMacAddress)) { |
| if (VDBG) { |
| loge("linkConfiguration link due to same gw " + link.SSID + |
| " and " + config.SSID + " GW " + config.defaultGwMacAddress); |
| } |
| doLink = true; |
| } |
| } else { |
| // We do not know BOTH default gateways hence we will try to link |
| // hoping that WifiConfigurations are indeed behind the same gateway. |
| // once both WifiConfiguration have been tried and thus once both efault gateways |
| // are known we will revisit the choice of linking them |
| if ((getScanDetailCache(config) != null) |
| && (getScanDetailCache(config).size() <= 6)) { |
| |
| for (String abssid : getScanDetailCache(config).keySet()) { |
| for (String bbssid : linkedScanDetailCache.keySet()) { |
| if (VVDBG) { |
| loge("linkConfiguration try to link due to DBDC BSSID match " |
| + link.SSID + |
| " and " + config.SSID + " bssida " + abssid |
| + " bssidb " + bbssid); |
| } |
| if (abssid.regionMatches(true, 0, bbssid, 0, 16)) { |
| // If first 16 ascii characters of BSSID matches, |
| // we assume this is a DBDC |
| doLink = true; |
| } |
| } |
| } |
| } |
| } |
| |
| if (doLink == true && onlyLinkSameCredentialConfigurations) { |
| String apsk = readNetworkVariableFromSupplicantFile(link.SSID, "psk"); |
| String bpsk = readNetworkVariableFromSupplicantFile(config.SSID, "psk"); |
| if (apsk == null || bpsk == null |
| || TextUtils.isEmpty(apsk) || TextUtils.isEmpty(apsk) |
| || apsk.equals("*") || apsk.equals(DELETED_CONFIG_PSK) |
| || !apsk.equals(bpsk)) { |
| doLink = false; |
| } |
| } |
| |
| if (doLink) { |
| if (VDBG) { |
| loge("linkConfiguration: will link " + link.configKey() |
| + " and " + config.configKey()); |
| } |
| if (link.linkedConfigurations == null) { |
| link.linkedConfigurations = new HashMap<String, Integer>(); |
| } |
| if (config.linkedConfigurations == null) { |
| config.linkedConfigurations = new HashMap<String, Integer>(); |
| } |
| if (link.linkedConfigurations.get(config.configKey()) == null) { |
| link.linkedConfigurations.put(config.configKey(), Integer.valueOf(1)); |
| link.dirty = true; |
| } |
| if (config.linkedConfigurations.get(link.configKey()) == null) { |
| config.linkedConfigurations.put(link.configKey(), Integer.valueOf(1)); |
| config.dirty = true; |
| } |
| } else { |
| if (link.linkedConfigurations != null |
| && (link.linkedConfigurations.get(config.configKey()) != null)) { |
| if (VDBG) { |
| loge("linkConfiguration: un-link " + config.configKey() |
| + " from " + link.configKey()); |
| } |
| link.dirty = true; |
| link.linkedConfigurations.remove(config.configKey()); |
| } |
| if (config.linkedConfigurations != null |
| && (config.linkedConfigurations.get(link.configKey()) != null)) { |
| if (VDBG) { |
| loge("linkConfiguration: un-link " + link.configKey() |
| + " from " + config.configKey()); |
| } |
| config.dirty = true; |
| config.linkedConfigurations.remove(link.configKey()); |
| } |
| } |
| } |
| } |
| |
| public HashSet<Integer> makeChannelList(WifiConfiguration config, int age, boolean restrict) { |
| if (config == null) |
| return null; |
| long now_ms = System.currentTimeMillis(); |
| |
| HashSet<Integer> channels = new HashSet<Integer>(); |
| |
| //get channels for this configuration, if there are at least 2 BSSIDs |
| if (getScanDetailCache(config) == null && config.linkedConfigurations == null) { |
| return null; |
| } |
| |
| if (VDBG) { |
| StringBuilder dbg = new StringBuilder(); |
| dbg.append("makeChannelList age=" + Integer.toString(age) |
| + " for " + config.configKey() |
| + " max=" + maxNumActiveChannelsForPartialScans); |
| if (getScanDetailCache(config) != null) { |
| dbg.append(" bssids=" + getScanDetailCache(config).size()); |
| } |
| if (config.linkedConfigurations != null) { |
| dbg.append(" linked=" + config.linkedConfigurations.size()); |
| } |
| loge(dbg.toString()); |
| } |
| |
| int numChannels = 0; |
| if (getScanDetailCache(config) != null && getScanDetailCache(config).size() > 0) { |
| for (ScanDetail scanDetail : getScanDetailCache(config).values()) { |
| ScanResult result = scanDetail.getScanResult(); |
| //TODO : cout active and passive channels separately |
| if (numChannels > maxNumActiveChannelsForPartialScans.get()) { |
| break; |
| } |
| if (VDBG) { |
| boolean test = (now_ms - result.seen) < age; |
| loge("has " + result.BSSID + " freq=" + Integer.toString(result.frequency) |
| + " age=" + Long.toString(now_ms - result.seen) + " ?=" + test); |
| } |
| if (((now_ms - result.seen) < age)/*||(!restrict || result.is24GHz())*/) { |
| channels.add(result.frequency); |
| numChannels++; |
| } |
| } |
| } |
| |
| //get channels for linked configurations |
| if (config.linkedConfigurations != null) { |
| for (String key : config.linkedConfigurations.keySet()) { |
| WifiConfiguration linked = getWifiConfiguration(key); |
| if (linked == null) |
| continue; |
| if (getScanDetailCache(linked) == null) { |
| continue; |
| } |
| for (ScanDetail scanDetail : getScanDetailCache(linked).values()) { |
| ScanResult result = scanDetail.getScanResult(); |
| if (VDBG) { |
| loge("has link: " + result.BSSID |
| + " freq=" + Integer.toString(result.frequency) |
| + " age=" + Long.toString(now_ms - result.seen)); |
| } |
| if (numChannels > maxNumActiveChannelsForPartialScans.get()) { |
| break; |
| } |
| if (((now_ms - result.seen) < age)/*||(!restrict || result.is24GHz())*/) { |
| channels.add(result.frequency); |
| numChannels++; |
| } |
| } |
| } |
| } |
| return channels; |
| } |
| |
| private Map<HomeSP, PasspointMatch> matchPasspointNetworks(ScanDetail scanDetail) { |
| if (!mMOManager.isConfigured()) { |
| return null; |
| } |
| NetworkDetail networkDetail = scanDetail.getNetworkDetail(); |
| if (!networkDetail.hasInterworking()) { |
| return null; |
| } |
| updateAnqpCache(scanDetail, networkDetail.getANQPElements()); |
| |
| Map<HomeSP, PasspointMatch> matches = matchNetwork(scanDetail, true); |
| Log.d(Utils.hs2LogTag(getClass()), scanDetail.getSSID() + |
| " pass 1 matches: " + toMatchString(matches)); |
| return matches; |
| } |
| |
| private Map<HomeSP, PasspointMatch> matchNetwork(ScanDetail scanDetail, boolean query) { |
| NetworkDetail networkDetail = scanDetail.getNetworkDetail(); |
| |
| ANQPData anqpData = mAnqpCache.getEntry(networkDetail); |
| |
| Map<Constants.ANQPElementType, ANQPElement> anqpElements = |
| anqpData != null ? anqpData.getANQPElements() : null; |
| |
| boolean queried = !query; |
| Collection<HomeSP> homeSPs = mMOManager.getLoadedSPs().values(); |
| Map<HomeSP, PasspointMatch> matches = new HashMap<>(homeSPs.size()); |
| Log.d(Utils.hs2LogTag(getClass()), "match nwk " + scanDetail.toKeyString() + |
| ", anqp " + ( anqpData != null ? "present" : "missing" ) + |
| ", query " + query + ", home sps: " + homeSPs.size()); |
| |
| for (HomeSP homeSP : homeSPs) { |
| PasspointMatch match = homeSP.match(networkDetail, anqpElements, mSIMAccessor); |
| |
| Log.d(Utils.hs2LogTag(getClass()), " -- " + |
| homeSP.getFQDN() + ": match " + match + ", queried " + queried); |
| |
| if (match == PasspointMatch.Incomplete && !queried) { |
| if (mAnqpCache.initiate(networkDetail)) { |
| mSupplicantBridge.startANQP(scanDetail); |
| } |
| queried = true; |
| } |
| matches.put(homeSP, match); |
| } |
| return matches; |
| } |
| |
| public void notifyANQPDone(Long bssid, boolean success) { |
| mSupplicantBridge.notifyANQPDone(bssid, success); |
| } |
| |
| public void notifyANQPResponse(ScanDetail scanDetail, |
| Map<Constants.ANQPElementType, ANQPElement> anqpElements) { |
| |
| updateAnqpCache(scanDetail, anqpElements); |
| if (anqpElements == null || anqpElements.isEmpty()) { |
| return; |
| } |
| scanDetail.propagateANQPInfo(anqpElements); |
| |
| Map<HomeSP, PasspointMatch> matches = matchNetwork(scanDetail, false); |
| Log.d(Utils.hs2LogTag(getClass()), scanDetail.getSSID() + |
| " pass 2 matches: " + toMatchString(matches)); |
| |
| cacheScanResultForPasspointConfigs(scanDetail, matches); |
| } |
| |
| |
| private void updateAnqpCache(ScanDetail scanDetail, |
| Map<Constants.ANQPElementType,ANQPElement> anqpElements) |
| { |
| NetworkDetail networkDetail = scanDetail.getNetworkDetail(); |
| |
| if (anqpElements == null) { |
| // Try to pull cached data if query failed. |
| ANQPData data = mAnqpCache.getEntry(networkDetail); |
| if (data != null) { |
| scanDetail.propagateANQPInfo(data.getANQPElements()); |
| } |
| return; |
| } |
| |
| mAnqpCache.update(networkDetail, anqpElements); |
| } |
| |
| private static String toMatchString(Map<HomeSP, PasspointMatch> matches) { |
| StringBuilder sb = new StringBuilder(); |
| for (Map.Entry<HomeSP, PasspointMatch> entry : matches.entrySet()) { |
| sb.append(' ').append(entry.getKey().getFQDN()).append("->").append(entry.getValue()); |
| } |
| return sb.toString(); |
| } |
| |
| private void cacheScanResultForPasspointConfigs(ScanDetail scanDetail, |
| Map<HomeSP,PasspointMatch> matches) { |
| |
| for (Map.Entry<HomeSP, PasspointMatch> entry : matches.entrySet()) { |
| PasspointMatch match = entry.getValue(); |
| if (match == PasspointMatch.HomeProvider || match == PasspointMatch.RoamingProvider) { |
| WifiConfiguration config = getWifiConfigForHomeSP(entry.getKey()); |
| if (config != null) { |
| cacheScanResultForConfig(config, scanDetail, entry.getValue()); |
| } else { |
| Log.w(Utils.hs2LogTag(getClass()), "Failed to find config for '" + |
| entry.getKey().getFQDN() + "'"); |
| /* perhaps the configuration was deleted?? */ |
| } |
| } |
| } |
| } |
| |
| private void cacheScanResultForConfig( |
| WifiConfiguration config, ScanDetail scanDetail, PasspointMatch passpointMatch) { |
| |
| ScanResult scanResult = scanDetail.getScanResult(); |
| |
| if (config.autoJoinStatus >= WifiConfiguration.AUTO_JOIN_DELETED) { |
| if (VVDBG) { |
| loge("updateSavedNetworkHistory(): found a deleted, skip it... " |
| + config.configKey()); |
| } |
| // The scan result belongs to a deleted config: |
| // - increment numConfigFound to remember that we found a config |
| // matching for this scan result |
| // - dont do anything since the config was deleted, just skip... |
| return; |
| } |
| |
| ScanDetailCache scanDetailCache = getScanDetailCache(config); |
| if (scanDetailCache == null) { |
| Log.w(TAG, "Could not allocate scan cache for " + config.SSID); |
| return; |
| } |
| |
| // Adding a new BSSID |
| ScanResult result = scanDetailCache.get(scanResult.BSSID); |
| if (result != null) { |
| // transfer the black list status |
| scanResult.autoJoinStatus = result.autoJoinStatus; |
| scanResult.blackListTimestamp = result.blackListTimestamp; |
| scanResult.numIpConfigFailures = result.numIpConfigFailures; |
| scanResult.numConnection = result.numConnection; |
| scanResult.isAutoJoinCandidate = result.isAutoJoinCandidate; |
| } |
| |
| if (config.ephemeral) { |
| // For an ephemeral Wi-Fi config, the ScanResult should be considered |
| // untrusted. |
| scanResult.untrusted = true; |
| } |
| |
| if (scanDetailCache.size() > (maxNumScanCacheEntries + 64)) { |
| long now_dbg = 0; |
| if (VVDBG) { |
| loge(" Will trim config " + config.configKey() |
| + " size " + scanDetailCache.size()); |
| |
| for (ScanDetail sd : scanDetailCache.values()) { |
| loge(" " + sd.getBSSIDString() + " " + sd.getSeen()); |
| } |
| now_dbg = SystemClock.elapsedRealtimeNanos(); |
| } |
| // Trim the scan result cache to maxNumScanCacheEntries entries max |
| // Since this operation is expensive, make sure it is not performed |
| // until the cache has grown significantly above the trim treshold |
| scanDetailCache.trim(maxNumScanCacheEntries); |
| if (VVDBG) { |
| long diff = SystemClock.elapsedRealtimeNanos() - now_dbg; |
| loge(" Finished trimming config, time(ns) " + diff); |
| for (ScanDetail sd : scanDetailCache.values()) { |
| loge(" " + sd.getBSSIDString() + " " + sd.getSeen()); |
| } |
| } |
| } |
| |
| // Add the scan result to this WifiConfiguration |
| if (passpointMatch != null) |
| scanDetailCache.put(scanDetail, passpointMatch, getHomeSPForConfig(config)); |
| else |
| scanDetailCache.put(scanDetail); |
| |
| // Since we added a scan result to this configuration, re-attempt linking |
| linkConfiguration(config); |
| } |
| |
| |
| // Update the WifiConfiguration database with the new scan result |
| // A scan result can be associated to multiple WifiConfigurations |
| public boolean updateSavedNetworkHistory(ScanDetail scanDetail) { |
| |
| ScanResult scanResult = scanDetail.getScanResult(); |
| NetworkDetail networkDetail = scanDetail.getNetworkDetail(); |
| |
| int numConfigFound = 0; |
| if (scanResult == null) |
| return false; |
| |
| String SSID = "\"" + scanResult.SSID + "\""; |
| |
| if (networkDetail.hasInterworking()) { |
| Map<HomeSP, PasspointMatch> matches = matchPasspointNetworks(scanDetail); |
| if (matches != null) { |
| cacheScanResultForPasspointConfigs(scanDetail, matches); |
| return matches.size() != 0; |
| } |
| } |
| |
| for (WifiConfiguration config : mConfiguredNetworks.values()) { |
| boolean found = false; |
| |
| if (config.SSID == null || !config.SSID.equals(SSID)) { |
| // SSID mismatch |
| if (VVDBG) { |
| loge("updateSavedNetworkHistory(): SSID mismatch " + config.configKey() |
| + " SSID=" + config.SSID + " " + SSID); |
| } |
| continue; |
| } |
| if (VDBG) { |
| loge("updateSavedNetworkHistory(): try " + config.configKey() |
| + " SSID=" + config.SSID + " " + scanResult.SSID |
| + " " + scanResult.capabilities |
| + " ajst=" + config.autoJoinStatus); |
| } |
| if (scanResult.capabilities.contains("WEP") |
| && config.configKey().contains("WEP")) { |
| found = true; |
| } else if (scanResult.capabilities.contains("PSK") |
| && config.configKey().contains("PSK")) { |
| found = true; |
| } else if (scanResult.capabilities.contains("EAP") |
| && config.configKey().contains("EAP")) { |
| found = true; |
| } else if (!scanResult.capabilities.contains("WEP") |
| && !scanResult.capabilities.contains("PSK") |
| && !scanResult.capabilities.contains("EAP") |
| && !config.configKey().contains("WEP") |
| && !config.configKey().contains("PSK") |
| && !config.configKey().contains("EAP")) { |
| found = true; |
| } |
| |
| if (found) { |
| numConfigFound ++; |
| cacheScanResultForConfig(config, scanDetail, null); |
| } |
| |
| if (VDBG && found) { |
| String status = ""; |
| if (scanResult.autoJoinStatus > 0) { |
| status = " status=" + Integer.toString(scanResult.autoJoinStatus); |
| } |
| loge(" got known scan result " + |
| scanResult.BSSID + " key : " |
| + config.configKey() + " num: " + |
| Integer.toString(getScanDetailCache(config).size()) |
| + " rssi=" + Integer.toString(scanResult.level) |
| + " freq=" + Integer.toString(scanResult.frequency) |
| + status); |
| } |
| } |
| return numConfigFound != 0; |
| } |
| |
| /* Compare current and new configuration and write to file on change */ |
| private NetworkUpdateResult writeIpAndProxyConfigurationsOnChange( |
| WifiConfiguration currentConfig, |
| WifiConfiguration newConfig) { |
| boolean ipChanged = false; |
| boolean proxyChanged = false; |
| |
| if (VDBG) { |
| loge("writeIpAndProxyConfigurationsOnChange: " + currentConfig.SSID + " -> " + |
| newConfig.SSID + " path: " + ipConfigFile); |
| } |
| |
| |
| switch (newConfig.getIpAssignment()) { |
| case STATIC: |
| if (currentConfig.getIpAssignment() != newConfig.getIpAssignment()) { |
| ipChanged = true; |
| } else { |
| ipChanged = !Objects.equals( |
| currentConfig.getStaticIpConfiguration(), |
| newConfig.getStaticIpConfiguration()); |
| } |
| break; |
| case DHCP: |
| if (currentConfig.getIpAssignment() != newConfig.getIpAssignment()) { |
| ipChanged = true; |
| } |
| break; |
| case UNASSIGNED: |
| /* Ignore */ |
| break; |
| default: |
| loge("Ignore invalid ip assignment during write"); |
| break; |
| } |
| |
| switch (newConfig.getProxySettings()) { |
| case STATIC: |
| case PAC: |
| ProxyInfo newHttpProxy = newConfig.getHttpProxy(); |
| ProxyInfo currentHttpProxy = currentConfig.getHttpProxy(); |
| |
| if (newHttpProxy != null) { |
| proxyChanged = !newHttpProxy.equals(currentHttpProxy); |
| } else { |
| proxyChanged = (currentHttpProxy != null); |
| } |
| break; |
| case NONE: |
| if (currentConfig.getProxySettings() != newConfig.getProxySettings()) { |
| proxyChanged = true; |
| } |
| break; |
| case UNASSIGNED: |
| /* Ignore */ |
| break; |
| default: |
| loge("Ignore invalid proxy configuration during write"); |
| break; |
| } |
| |
| if (ipChanged) { |
| currentConfig.setIpAssignment(newConfig.getIpAssignment()); |
| currentConfig.setStaticIpConfiguration(newConfig.getStaticIpConfiguration()); |
| log("IP config changed SSID = " + currentConfig.SSID); |
| if (currentConfig.getStaticIpConfiguration() != null) { |
| log(" static configuration: " + |
| currentConfig.getStaticIpConfiguration().toString()); |
| } |
| } |
| |
| if (proxyChanged) { |
| currentConfig.setProxySettings(newConfig.getProxySettings()); |
| currentConfig.setHttpProxy(newConfig.getHttpProxy()); |
| log("proxy changed SSID = " + currentConfig.SSID); |
| if (currentConfig.getHttpProxy() != null) { |
| log(" proxyProperties: " + currentConfig.getHttpProxy().toString()); |
| } |
| } |
| |
| if (ipChanged || proxyChanged) { |
| writeIpAndProxyConfigurations(); |
| sendConfiguredNetworksChangedBroadcast(currentConfig, |
| WifiManager.CHANGE_REASON_CONFIG_CHANGE); |
| } |
| return new NetworkUpdateResult(ipChanged, proxyChanged); |
| } |
| |
| /** Returns true if a particular config key needs to be quoted when passed to the supplicant. */ |
| private boolean enterpriseConfigKeyShouldBeQuoted(String key) { |
| switch (key) { |
| case WifiEnterpriseConfig.EAP_KEY: |
| case WifiEnterpriseConfig.ENGINE_KEY: |
| return false; |
| default: |
| return true; |
| } |
| } |
| |
| /** |
| * Read the variables from the supplicant daemon that are needed to |
| * fill in the WifiConfiguration object. |
| * |
| * @param config the {@link WifiConfiguration} object to be filled in. |
| */ |
| private void readNetworkVariables(WifiConfiguration config) { |
| |
| int netId = config.networkId; |
| if (netId < 0) |
| return; |
| |
| /* |
| * TODO: maybe should have a native method that takes an array of |
| * variable names and returns an array of values. But we'd still |
| * be doing a round trip to the supplicant daemon for each variable. |
| */ |
| String value; |
| |
| value = mWifiNative.getNetworkVariable(netId, WifiConfiguration.ssidVarName); |
| if (!TextUtils.isEmpty(value)) { |
| if (value.charAt(0) != '"') { |
| config.SSID = "\"" + WifiSsid.createFromHex(value).toString() + "\""; |
| //TODO: convert a hex string that is not UTF-8 decodable to a P-formatted |
| //supplicant string |
| } else { |
| config.SSID = value; |
| } |
| } else { |
| config.SSID = null; |
| } |
| |
| value = mWifiNative.getNetworkVariable(netId, WifiConfiguration.bssidVarName); |
| if (!TextUtils.isEmpty(value)) { |
| config.BSSID = value; |
| } else { |
| config.BSSID = null; |
| } |
| |
| value = mWifiNative.getNetworkVariable(netId, WifiConfiguration.priorityVarName); |
| config.priority = -1; |
| if (!TextUtils.isEmpty(value)) { |
| try { |
| config.priority = Integer.parseInt(value); |
| } catch (NumberFormatException ignore) { |
| } |
| } |
| |
| value = mWifiNative.getNetworkVariable(netId, WifiConfiguration.hiddenSSIDVarName); |
| config.hiddenSSID = false; |
| if (!TextUtils.isEmpty(value)) { |
| try { |
| config.hiddenSSID = Integer.parseInt(value) != 0; |
| } catch (NumberFormatException ignore) { |
| } |
| } |
| |
| value = mWifiNative.getNetworkVariable(netId, WifiConfiguration.wepTxKeyIdxVarName); |
| config.wepTxKeyIndex = -1; |
| if (!TextUtils.isEmpty(value)) { |
| try { |
| config.wepTxKeyIndex = Integer.parseInt(value); |
| } catch (NumberFormatException ignore) { |
| } |
| } |
| |
| for (int i = 0; i < 4; i++) { |
| value = mWifiNative.getNetworkVariable(netId, |
| WifiConfiguration.wepKeyVarNames[i]); |
| if (!TextUtils.isEmpty(value)) { |
| config.wepKeys[i] = value; |
| } else { |
| config.wepKeys[i] = null; |
| } |
| } |
| |
| value = mWifiNative.getNetworkVariable(netId, WifiConfiguration.pskVarName); |
| if (!TextUtils.isEmpty(value)) { |
| config.preSharedKey = value; |
| } else { |
| config.preSharedKey = null; |
| } |
| |
| readNetworkBitsetVariable(config.networkId, config.allowedProtocols, |
| WifiConfiguration.Protocol.varName, WifiConfiguration.Protocol.strings); |
| |
| readNetworkBitsetVariable(config.networkId, config.allowedKeyManagement, |
| WifiConfiguration.KeyMgmt.varName, WifiConfiguration.KeyMgmt.strings); |
| |
| readNetworkBitsetVariable(config.networkId, config.allowedAuthAlgorithms, |
| WifiConfiguration.AuthAlgorithm.varName, WifiConfiguration.AuthAlgorithm.strings); |
| |
| readNetworkBitsetVariable(config.networkId, config.allowedPairwiseCiphers, |
| WifiConfiguration.PairwiseCipher.varName, WifiConfiguration.PairwiseCipher.strings); |
| |
| readNetworkBitsetVariable(config.networkId, config.allowedGroupCiphers, |
| WifiConfiguration.GroupCipher.varName, WifiConfiguration.GroupCipher.strings); |
| |
| if (config.enterpriseConfig == null) { |
| config.enterpriseConfig = new WifiEnterpriseConfig(); |
| } |
| HashMap<String, String> enterpriseFields = config.enterpriseConfig.getFields(); |
| for (String key : ENTERPRISE_CONFIG_SUPPLICANT_KEYS) { |
| value = mWifiNative.getNetworkVariable(netId, key); |
| if (!TextUtils.isEmpty(value)) { |
| if (!enterpriseConfigKeyShouldBeQuoted(key)) { |
| value = removeDoubleQuotes(value); |
| } |
| enterpriseFields.put(key, value); |
| } else { |
| enterpriseFields.put(key, EMPTY_VALUE); |
| } |
| } |
| |
| if (migrateOldEapTlsNative(config.enterpriseConfig, netId)) { |
| saveConfig(); |
| } |
| |
| migrateCerts(config.enterpriseConfig); |
| // initializeSoftwareKeystoreFlag(config.enterpriseConfig, mKeyStore); |
| } |
| |
| private static String removeDoubleQuotes(String string) { |
| int length = string.length(); |
| if ((length > 1) && (string.charAt(0) == '"') |
| && (string.charAt(length - 1) == '"')) { |
| return string.substring(1, length - 1); |
| } |
| return string; |
| } |
| |
| private static String makeString(BitSet set, String[] strings) { |
| StringBuffer buf = new StringBuffer(); |
| int nextSetBit = -1; |
| |
| /* Make sure all set bits are in [0, strings.length) to avoid |
| * going out of bounds on strings. (Shouldn't happen, but...) */ |
| set = set.get(0, strings.length); |
| |
| while ((nextSetBit = set.nextSetBit(nextSetBit + 1)) != -1) { |
| buf.append(strings[nextSetBit].replace('_', '-')).append(' '); |
| } |
| |
| // remove trailing space |
| if (set.cardinality() > 0) { |
| buf.setLength(buf.length() - 1); |
| } |
| |
| return buf.toString(); |
| } |
| |
| private int lookupString(String string, String[] strings) { |
| int size = strings.length; |
| |
| string = string.replace('-', '_'); |
| |
| for (int i = 0; i < size; i++) |
| if (string.equals(strings[i])) |
| return i; |
| |
| // if we ever get here, we should probably add the |
| // value to WifiConfiguration to reflect that it's |
| // supported by the WPA supplicant |
| loge("Failed to look-up a string: " + string); |
| |
| return -1; |
| } |
| |
| /* return the allowed key management based on a scan result */ |
| |
| public WifiConfiguration wifiConfigurationFromScanResult(ScanDetail scanDetail) { |
| |
| ScanResult result = scanDetail.getScanResult(); |
| WifiConfiguration config = new WifiConfiguration(); |
| |
| config.SSID = "\"" + result.SSID + "\""; |
| |
| if (VDBG) { |
| loge("WifiConfiguration from scan results " + |
| config.SSID + " cap " + result.capabilities); |
| } |
| if (result.capabilities.contains("WEP")) { |
| config.allowedKeyManagement.set(KeyMgmt.NONE); |
| config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN); //? |
| config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED); |
| } |
| |
| if (result.capabilities.contains("PSK")) { |
| config.allowedKeyManagement.set(KeyMgmt.WPA_PSK); |
| } |
| |
| if (result.capabilities.contains("EAP")) { |
| //this is probably wrong, as we don't have a way to enter the enterprise config |
| config.allowedKeyManagement.set(KeyMgmt.WPA_EAP); |
| config.allowedKeyManagement.set(KeyMgmt.IEEE8021X); |
| } |
| |
| /* getScanDetailCache(config).put(scanDetail); */ |
| |
| return config; |
| } |
| |
| |
| /* Returns a unique for a given configuration */ |
| private static int configKey(WifiConfiguration config) { |
| String key = config.configKey(); |
| return key.hashCode(); |
| } |
| |
| void dump(FileDescriptor fd, PrintWriter pw, String[] args) { |
| pw.println("Dump of WifiConfigStore"); |
| pw.println("mLastPriority " + mLastPriority); |
| pw.println("Configured networks"); |
| for (WifiConfiguration conf : getAllConfiguredNetworks()) { |
| pw.println(conf); |
| } |
| pw.println(); |
| if (mLostConfigsDbg != null && mLostConfigsDbg.size() > 0) { |
| pw.println("LostConfigs: "); |
| for (String s : mLostConfigsDbg) { |
| pw.println(s); |
| } |
| } |
| if (mLocalLog != null) { |
| pw.println("WifiConfigStore - Log Begin ----"); |
| mLocalLog.dump(fd, pw, args); |
| pw.println("WifiConfigStore - Log End ----"); |
| } |
| if (mMOManager.isConfigured()) { |
| pw.println("Begin dump of ANQP Cache"); |
| mAnqpCache.dump(pw); |
| pw.println("End dump of ANQP Cache"); |
| } |
| } |
| |
| public String getConfigFile() { |
| return ipConfigFile; |
| } |
| |
| protected void loge(String s) { |
| loge(s, false); |
| } |
| |
| protected void loge(String s, boolean stack) { |
| if (stack) { |
| Log.e(TAG, s + " stack:" + Thread.currentThread().getStackTrace()[2].getMethodName() |
| + " - " + Thread.currentThread().getStackTrace()[3].getMethodName() |
| + " - " + Thread.currentThread().getStackTrace()[4].getMethodName() |
| + " - " + Thread.currentThread().getStackTrace()[5].getMethodName()); |
| } else { |
| Log.e(TAG, s); |
| } |
| } |
| |
| private void logKernelTime() { |
| long kernelTimeMs = System.nanoTime()/(1000*1000); |
| StringBuilder builder = new StringBuilder(); |
| builder.append("kernel time = ").append(kernelTimeMs/1000).append(".").append |
| (kernelTimeMs%1000).append("\n"); |
| localLog(builder.toString()); |
| } |
| |
| protected void log(String s) { |
| Log.d(TAG, s); |
| } |
| |
| private void localLog(String s) { |
| if (mLocalLog != null) { |
| mLocalLog.log(s); |
| } |
| } |
| |
| private void localLog(String s, boolean force) { |
| localLog(s); |
| if (force) loge(s); |
| } |
| |
| private void localLog(String s, int netId) { |
| if (mLocalLog == null) { |
| return; |
| } |
| |
| WifiConfiguration config; |
| synchronized(mConfiguredNetworks) { // !!! Useless synchronization |
| config = mConfiguredNetworks.get(netId); |
| } |
| |
| if (config != null) { |
| mLocalLog.log(s + " " + config.getPrintableSsid() + " " + netId |
| + " status=" + config.status |
| + " key=" + config.configKey()); |
| } else { |
| mLocalLog.log(s + " " + netId); |
| } |
| } |
| |
| // Certificate and private key management for EnterpriseConfig |
| static boolean needsKeyStore(WifiEnterpriseConfig config) { |
| // Has no keys to be installed |
| if (config.getClientCertificate() == null && config.getCaCertificate() == null) |
| return false; |
| return true; |
| } |
| |
| static boolean isHardwareBackedKey(PrivateKey key) { |
| return KeyChain.isBoundKeyAlgorithm(key.getAlgorithm()); |
| } |
| |
| static boolean hasHardwareBackedKey(Certificate certificate) { |
| return KeyChain.isBoundKeyAlgorithm(certificate.getPublicKey().getAlgorithm()); |
| } |
| |
| static boolean needsSoftwareBackedKeyStore(WifiEnterpriseConfig config) { |
| String client = config.getClientCertificateAlias(); |
| if (!TextUtils.isEmpty(client)) { |
| // a valid client certificate is configured |
| |
| // BUGBUG: keyStore.get() never returns certBytes; because it is not |
| // taking WIFI_UID as a parameter. It always looks for certificate |
| // with SYSTEM_UID, and never finds any Wifi certificates. Assuming that |
| // all certificates need software keystore until we get the get() API |
| // fixed. |
| |
| return true; |
| } |
| |
| /* |
| try { |
| |
| if (DBG) Slog.d(TAG, "Loading client certificate " + Credentials |
| .USER_CERTIFICATE + client); |
| |
| CertificateFactory factory = CertificateFactory.getInstance("X.509"); |
| if (factory == null) { |
| Slog.e(TAG, "Error getting certificate factory"); |
| return; |
| } |
| |
| byte[] certBytes = keyStore.get(Credentials.USER_CERTIFICATE + client); |
| if (certBytes != null) { |
| Certificate cert = (X509Certificate) factory.generateCertificate( |
| new ByteArrayInputStream(certBytes)); |
| |
| if (cert != null) { |
| mNeedsSoftwareKeystore = hasHardwareBackedKey(cert); |
| |
| if (DBG) Slog.d(TAG, "Loaded client certificate " + Credentials |
| .USER_CERTIFICATE + client); |
| if (DBG) Slog.d(TAG, "It " + (mNeedsSoftwareKeystore ? "needs" : |
| "does not need" ) + " software key store"); |
| } else { |
| Slog.d(TAG, "could not generate certificate"); |
| } |
| } else { |
| Slog.e(TAG, "Could not load client certificate " + Credentials |
| .USER_CERTIFICATE + client); |
| mNeedsSoftwareKeystore = true; |
| } |
| |
| } catch(CertificateException e) { |
| Slog.e(TAG, "Could not read certificates"); |
| mCaCert = null; |
| mClientCertificate = null; |
| } |
| */ |
| |
| return false; |
| } |
| |
| boolean isNetworkConfigured(WifiConfiguration config) { |
| // Check if either we have a network Id or a WifiConfiguration |
| // matching the one we are trying to add. |
| |
| if(config.networkId != INVALID_NETWORK_ID) { |
| return (mConfiguredNetworks.get(config.networkId) != null); |
| } |
| |
| return (mConfiguredNetworks.getByConfigKey(config.configKey()) != null); |
| } |
| |
| /** |
| * Checks if uid has access to modify the configuration corresponding to networkId. |
| * |
| * Factors involved in modifiability of a config are as follows. |
| * If uid is a Device Owner app then it has full control over the device, including WiFi |
| * configs. |
| * If the modification is only for administrative annotation (e.g. when connecting) or the |
| * config is not lockdown eligible (currently that means any config not last updated by the DO) |
| * then the creator of config or an app holding OVERRIDE_CONFIG_WIFI can modify the config. |
| * If the config is lockdown eligible and the modification is substantial (not annotation) |
| * then the requirement to be able to modify the config by the uid is as follows: |
| * a) the uid has to hold OVERRIDE_CONFIG_WIFI and |
| * b) the lockdown feature should be disabled. |
| */ |
| boolean canModifyNetwork(int uid, int networkId, boolean onlyAnnotate) { |
| WifiConfiguration config = mConfiguredNetworks.get(networkId); |
| |
| if (config == null) { |
| loge("canModifyNetwork: cannot find config networkId " + networkId); |
| return false; |
| } |
| |
| final DevicePolicyManagerInternal dpmi = LocalServices.getService( |
| DevicePolicyManagerInternal.class); |
| |
| final boolean isUidDeviceOwner = dpmi != null && dpmi.isActiveAdminWithPolicy(uid, |
| DeviceAdminInfo.USES_POLICY_DEVICE_OWNER); |
| |
| if (isUidDeviceOwner) { |
| // Device Owner has full control over the device, including WiFi Configs |
| return true; |
| } |
| |
| final boolean isCreator = (config.creatorUid == uid); |
| |
| if (onlyAnnotate) { |
| return isCreator || checkConfigOverridePermission(uid); |
| } |
| |
| // Check if device has DPM capability. If it has and dpmi is still null, then we |
| // treat this case with suspicion and bail out. |
| if (mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_DEVICE_ADMIN) |
| && dpmi == null) { |
| return false; |
| } |
| |
| // WiFi config lockdown related logic. At this point we know uid NOT to be a Device Owner. |
| |
| final boolean isConfigEligibleForLockdown = dpmi != null && dpmi.isActiveAdminWithPolicy( |
| config.creatorUid, DeviceAdminInfo.USES_POLICY_DEVICE_OWNER); |
| if (!isConfigEligibleForLockdown) { |
| return isCreator || checkConfigOverridePermission(uid); |
| } |
| |
| final ContentResolver resolver = mContext.getContentResolver(); |
| final boolean isLockdownFeatureEnabled = Settings.Global.getInt(resolver, |
| Settings.Global.WIFI_DEVICE_OWNER_CONFIGS_LOCKDOWN, 0) != 0; |
| return !isLockdownFeatureEnabled && checkConfigOverridePermission(uid); |
| } |
| |
| /** |
| * Checks if uid has access to modify config. |
| */ |
| boolean canModifyNetwork(int uid, WifiConfiguration config, boolean onlyAnnotate) { |
| if (config == null) { |
| loge("canModifyNetowrk recieved null configuration"); |
| return false; |
| } |
| |
| // Resolve the correct network id. |
| int netid; |
| if (config.networkId != INVALID_NETWORK_ID){ |
| netid = config.networkId; |
| } else { |
| WifiConfiguration test = mConfiguredNetworks.getByConfigKey(config.configKey()); |
| if (test == null) { |
| return false; |
| } else { |
| netid = test.networkId; |
| } |
| } |
| |
| return canModifyNetwork(uid, netid, onlyAnnotate); |
| } |
| |
| boolean checkConfigOverridePermission(int uid) { |
| try { |
| return (AppGlobals.getPackageManager().checkUidPermission( |
| android.Manifest.permission.OVERRIDE_WIFI_CONFIG, uid) |
| == PackageManager.PERMISSION_GRANTED); |
| } catch (RemoteException e) { |
| return false; |
| } |
| } |
| |
| /** called when CS ask WiFistateMachine to disconnect the current network |
| * because the score is bad. |
| */ |
| void handleBadNetworkDisconnectReport(int netId, WifiInfo info) { |
| /* TODO verify the bad network is current */ |
| WifiConfiguration config = mConfiguredNetworks.get(netId); |
| if (config != null) { |
| if ((info.getRssi() < WifiConfiguration.UNWANTED_BLACKLIST_SOFT_RSSI_24 |
| && info.is24GHz()) || (info.getRssi() < |
| WifiConfiguration.UNWANTED_BLACKLIST_SOFT_RSSI_5 && info.is5GHz())) { |
| // We got disconnected and RSSI was bad, so disable light |
| config.setAutoJoinStatus(WifiConfiguration.AUTO_JOIN_TEMPORARY_DISABLED |
| + WifiConfiguration.UNWANTED_BLACKLIST_SOFT_BUMP); |
| loge("handleBadNetworkDisconnectReport (+4) " |
| + Integer.toString(netId) + " " + info); |
| } else { |
| // We got disabled but RSSI is good, so disable hard |
| config.setAutoJoinStatus(WifiConfiguration.AUTO_JOIN_TEMPORARY_DISABLED |
| + WifiConfiguration.UNWANTED_BLACKLIST_HARD_BUMP); |
| loge("handleBadNetworkDisconnectReport (+8) " |
| + Integer.toString(netId) + " " + info); |
| } |
| } |
| // Record last time Connectivity Service switched us away from WiFi and onto Cell |
| lastUnwantedNetworkDisconnectTimestamp = System.currentTimeMillis(); |
| } |
| |
| boolean handleBSSIDBlackList(int netId, String BSSID, boolean enable) { |
| boolean found = false; |
| if (BSSID == null) |
| return found; |
| |
| // Look for the BSSID in our config store |
| for (WifiConfiguration config : mConfiguredNetworks.values()) { |
| if (getScanDetailCache(config) != null) { |
| for (ScanDetail scanDetail : getScanDetailCache(config).values()) { |
| if (scanDetail.getBSSIDString().equals(BSSID)) { |
| if (enable) { |
| scanDetail.getScanResult().setAutoJoinStatus(ScanResult.ENABLED); |
| } else { |
| // Black list the BSSID we were trying to join |
| // so as the Roam state machine |
| // doesn't pick it up over and over |
| scanDetail.getScanResult().setAutoJoinStatus( |
| ScanResult.AUTO_ROAM_DISABLED); |
| found = true; |
| } |
| } |
| } |
| } |
| } |
| return found; |
| } |
| |
| int getMaxDhcpRetries() { |
| return Settings.Global.getInt(mContext.getContentResolver(), |
| Settings.Global.WIFI_MAX_DHCP_RETRY_COUNT, |
| DEFAULT_MAX_DHCP_RETRIES); |
| } |
| |
| void clearBssidBlacklist() { |
| if (!mWifiStateMachine.useHalBasedAutoJoinOffload()) { |
| if(DBG) { |
| Log.d(TAG, "No blacklist allowed without epno enabled"); |
| } |
| return; |
| } |
| mBssidBlacklist = new HashSet<String>(); |
| mWifiNative.clearBlacklist(); |
| mWifiNative.setBssidBlacklist(null); |
| } |
| |
| void blackListBssid(String BSSID) { |
| if (!mWifiStateMachine.useHalBasedAutoJoinOffload()) { |
| if(DBG) { |
| Log.d(TAG, "No blacklist allowed without epno enabled"); |
| } |
| return; |
| } |
| if (BSSID == null) |
| return; |
| mBssidBlacklist.add(BSSID); |
| // Blacklist at wpa_supplicant |
| mWifiNative.addToBlacklist(BSSID); |
| // Blacklist at firmware |
| String list[] = new String[mBssidBlacklist.size()]; |
| int count = 0; |
| for (String bssid : mBssidBlacklist) { |
| list[count++] = bssid; |
| } |
| mWifiNative.setBssidBlacklist(list); |
| } |
| |
| void handleSSIDStateChange(int netId, boolean enabled, String message, String BSSID) { |
| WifiConfiguration config = mConfiguredNetworks.get(netId); |
| if (config != null) { |
| if (enabled) { |
| loge("Ignoring SSID re-enabled from supplicant: " + config.configKey() + |
| " had autoJoinStatus=" + Integer.toString(config.autoJoinStatus) |
| + " self added " + config.selfAdded + " ephemeral " + config.ephemeral); |
| //We should not re-enable the BSSID based on Supplicant reanable. |
| // Framework will re-enable it after its own blacklist timer expires |
| } else { |
| loge("SSID temp disabled for " + config.configKey() + |
| " had autoJoinStatus=" + Integer.toString(config.autoJoinStatus) |
| + " self added " + config.selfAdded + " ephemeral " + config.ephemeral); |
| if (message != null) { |
| loge(" message=" + message); |
| } |
| if (config.selfAdded && config.lastConnected == 0) { |
| // This is a network we self added, and we never succeeded, |
| // the user did not create this network and never entered its credentials, |
| // so we want to be very aggressive in disabling it completely. |
| removeConfigAndSendBroadcastIfNeeded(config.networkId); |
| } else { |
| if (message != null) { |
| if (message.contains("no identity")) { |
| config.setAutoJoinStatus( |
| WifiConfiguration.AUTO_JOIN_DISABLED_NO_CREDENTIALS); |
| if (DBG) { |
| loge("no identity blacklisted " + config.configKey() + " to " |
| + Integer.toString(config.autoJoinStatus)); |
| } |
| } else if (message.contains("WRONG_KEY") |
| || message.contains("AUTH_FAILED")) { |
| // This configuration has received an auth failure, so disable it |
| // temporarily because we don't want auto-join to try it out. |
| // this network may be re-enabled by the "usual" |
| // enableAllNetwork function |
| config.numAuthFailures++; |
| if (config.numAuthFailures > maxAuthErrorsToBlacklist) { |
| config.setAutoJoinStatus |
| (WifiConfiguration.AUTO_JOIN_DISABLED_ON_AUTH_FAILURE); |
| disableNetwork(netId, |
| WifiConfiguration.DISABLED_AUTH_FAILURE); |
| loge("Authentication failure, blacklist " + config.configKey() + " " |
| + Integer.toString(config.networkId) |
| + " num failures " + config.numAuthFailures); |
| } |
| } else if (message.contains("DHCP FAILURE")) { |
| config.numIpConfigFailures++; |
| config.lastConnectionFailure = System.currentTimeMillis(); |
| int maxRetries = getMaxDhcpRetries(); |
| // maxRetries == 0 means keep trying forever |
| if (maxRetries > 0 && config.numIpConfigFailures > maxRetries) { |
| /** |
| * If we've exceeded the maximum number of retries for DHCP |
| * to a given network, disable the network |
| */ |
| config.setAutoJoinStatus |
| (WifiConfiguration.AUTO_JOIN_DISABLED_ON_AUTH_FAILURE); |
| disableNetwork(netId, WifiConfiguration.DISABLED_DHCP_FAILURE); |
| loge("DHCP failure, blacklist " + config.configKey() + " " |
| + Integer.toString(config.networkId) |
| + " num failures " + config.numIpConfigFailures); |
| } |
| |
| // Also blacklist the BSSId if we find it |
| ScanResult result = null; |
| String bssidDbg = ""; |
| if (getScanDetailCache(config) != null && BSSID != null) { |
| result = getScanDetailCache(config).get(BSSID); |
| } |
| if (result != null) { |
| result.numIpConfigFailures ++; |
| bssidDbg = BSSID + " ipfail=" + result.numIpConfigFailures; |
| if (result.numIpConfigFailures > 3) { |
| // Tell supplicant to stop trying this BSSID |
| mWifiNative.addToBlacklist(BSSID); |
| result.setAutoJoinStatus(ScanResult.AUTO_JOIN_DISABLED); |
| } |
| } |
| |
| if (DBG) { |
| loge("blacklisted " + config.configKey() + " to " |
| + config.autoJoinStatus |
| + " due to IP config failures, count=" |
| + config.numIpConfigFailures |
| + " disableReason=" + config.disableReason |
| + " " + bssidDbg); |
| } |
| } else if (message.contains("CONN_FAILED")) { |
| config.numConnectionFailures++; |
| if (config.numConnectionFailures > maxConnectionErrorsToBlacklist) { |
| config.setAutoJoinStatus |
| (WifiConfiguration.AUTO_JOIN_DISABLED_ON_AUTH_FAILURE); |
| disableNetwork(netId, |
| WifiConfiguration.DISABLED_ASSOCIATION_REJECT); |
| loge("Connection failure, blacklist " + config.configKey() + " " |
| + config.networkId |
| + " num failures " + config.numConnectionFailures); |
| } |
| } |
| message.replace("\n", ""); |
| message.replace("\r", ""); |
| config.lastFailure = message; |
| } |
| } |
| } |
| } |
| } |
| |
| boolean installKeys(WifiEnterpriseConfig config, String name) { |
| boolean ret = true; |
| String privKeyName = Credentials.USER_PRIVATE_KEY + name; |
| String userCertName = Credentials.USER_CERTIFICATE + name; |
| String caCertName = Credentials.CA_CERTIFICATE + name; |
| if (config.getClientCertificate() != null) { |
| byte[] privKeyData = config.getClientPrivateKey().getEncoded(); |
| if (isHardwareBackedKey(config.getClientPrivateKey())) { |
| // Hardware backed key store is secure enough to store keys un-encrypted, this |
| // removes the need for user to punch a PIN to get access to these keys |
| if (DBG) Log.d(TAG, "importing keys " + name + " in hardware backed store"); |
| ret = mKeyStore.importKey(privKeyName, privKeyData, android.os.Process.WIFI_UID, |
| KeyStore.FLAG_NONE); |
| } else { |
| // Software backed key store is NOT secure enough to store keys un-encrypted. |
| // Save keys encrypted so they are protected with user's PIN. User will |
| // have to unlock phone before being able to use these keys and connect to |
| // networks. |
| if (DBG) Log.d(TAG, "importing keys " + name + " in software backed store"); |
| ret = mKeyStore.importKey(privKeyName, privKeyData, Process.WIFI_UID, |
| KeyStore.FLAG_ENCRYPTED); |
| } |
| if (ret == false) { |
| return ret; |
| } |
| |
| ret = putCertInKeyStore(userCertName, config.getClientCertificate()); |
| if (ret == false) { |
| // Remove private key installed |
| mKeyStore.delete(privKeyName, Process.WIFI_UID); |
| return ret; |
| } |
| } |
| |
| if (config.getCaCertificate() != null) { |
| ret = putCertInKeyStore(caCertName, config.getCaCertificate()); |
| if (ret == false) { |
| if (config.getClientCertificate() != null) { |
| // Remove client key+cert |
| mKeyStore.delete(privKeyName, Process.WIFI_UID); |
| mKeyStore.delete(userCertName, Process.WIFI_UID); |
| } |
| return ret; |
| } |
| } |
| |
| // Set alias names |
| if (config.getClientCertificate() != null) { |
| config.setClientCertificateAlias(name); |
| config.resetClientKeyEntry(); |
| } |
| |
| if (config.getCaCertificate() != null) { |
| config.setCaCertificateAlias(name); |
| config.resetCaCertificate(); |
| } |
| |
| return ret; |
| } |
| |
| private boolean putCertInKeyStore(String name, Certificate cert) { |
| try { |
| byte[] certData = Credentials.convertToPem(cert); |
| if (DBG) Log.d(TAG, "putting certificate " + name + " in keystore"); |
| return mKeyStore.put(name, certData, Process.WIFI_UID, KeyStore.FLAG_NONE); |
| |
| } catch (IOException e1) { |
| return false; |
| } catch (CertificateException e2) { |
| return false; |
| } |
| } |
| |
| void removeKeys(WifiEnterpriseConfig config) { |
| String client = config.getClientCertificateAlias(); |
| // a valid client certificate is configured |
| if (!TextUtils.isEmpty(client)) { |
| if (DBG) Log.d(TAG, "removing client private key and user cert"); |
| mKeyStore.delete(Credentials.USER_PRIVATE_KEY + client, Process.WIFI_UID); |
| mKeyStore.delete(Credentials.USER_CERTIFICATE + client, Process.WIFI_UID); |
| } |
| |
| String ca = config.getCaCertificateAlias(); |
| // a valid ca certificate is configured |
| if (!TextUtils.isEmpty(ca)) { |
| if (DBG) Log.d(TAG, "removing CA cert"); |
| mKeyStore.delete(Credentials.CA_CERTIFICATE + ca, Process.WIFI_UID); |
| } |
| } |
| |
| |
| /** Migrates the old style TLS config to the new config style. This should only be used |
| * when restoring an old wpa_supplicant.conf or upgrading from a previous |
| * platform version. |
| * @return true if the config was updated |
| * @hide |
| */ |
| boolean migrateOldEapTlsNative(WifiEnterpriseConfig config, int netId) { |
| String oldPrivateKey = mWifiNative.getNetworkVariable(netId, OLD_PRIVATE_KEY_NAME); |
| /* |
| * If the old configuration value is not present, then there is nothing |
| * to do. |
| */ |
| if (TextUtils.isEmpty(oldPrivateKey)) { |
| return false; |
| } else { |
| // Also ignore it if it's empty quotes. |
| oldPrivateKey = removeDoubleQuotes(oldPrivateKey); |
| if (TextUtils.isEmpty(oldPrivateKey)) { |
| return false; |
| } |
| } |
| |
| config.setFieldValue(WifiEnterpriseConfig.ENGINE_KEY, WifiEnterpriseConfig.ENGINE_ENABLE); |
| config.setFieldValue(WifiEnterpriseConfig.ENGINE_ID_KEY, |
| WifiEnterpriseConfig.ENGINE_ID_KEYSTORE); |
| |
| /* |
| * The old key started with the keystore:// URI prefix, but we don't |
| * need that anymore. Trim it off if it exists. |
| */ |
| final String keyName; |
| if (oldPrivateKey.startsWith(WifiEnterpriseConfig.KEYSTORE_URI)) { |
| keyName = new String( |
| oldPrivateKey.substring(WifiEnterpriseConfig.KEYSTORE_URI.length())); |
| } else { |
| keyName = oldPrivateKey; |
| } |
| config.setFieldValue(WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY, keyName); |
| |
| mWifiNative.setNetworkVariable(netId, WifiEnterpriseConfig.ENGINE_KEY, |
| config.getFieldValue(WifiEnterpriseConfig.ENGINE_KEY, "")); |
| |
| mWifiNative.setNetworkVariable(netId, WifiEnterpriseConfig.ENGINE_ID_KEY, |
| config.getFieldValue(WifiEnterpriseConfig.ENGINE_ID_KEY, "")); |
| |
| mWifiNative.setNetworkVariable(netId, WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY, |
| config.getFieldValue(WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY, "")); |
| |
| // Remove old private_key string so we don't run this again. |
| mWifiNative.setNetworkVariable(netId, OLD_PRIVATE_KEY_NAME, EMPTY_VALUE); |
| |
| return true; |
| } |
| |
| /** Migrate certs from global pool to wifi UID if not already done */ |
| void migrateCerts(WifiEnterpriseConfig config) { |
| String client = config.getClientCertificateAlias(); |
| // a valid client certificate is configured |
| if (!TextUtils.isEmpty(client)) { |
| if (!mKeyStore.contains(Credentials.USER_PRIVATE_KEY + client, Process.WIFI_UID)) { |
| mKeyStore.duplicate(Credentials.USER_PRIVATE_KEY + client, -1, |
| Credentials.USER_PRIVATE_KEY + client, Process.WIFI_UID); |
| mKeyStore.duplicate(Credentials.USER_CERTIFICATE + client, -1, |
| Credentials.USER_CERTIFICATE + client, Process.WIFI_UID); |
| } |
| } |
| |
| String ca = config.getCaCertificateAlias(); |
| // a valid ca certificate is configured |
| if (!TextUtils.isEmpty(ca)) { |
| if (!mKeyStore.contains(Credentials.CA_CERTIFICATE + ca, Process.WIFI_UID)) { |
| mKeyStore.duplicate(Credentials.CA_CERTIFICATE + ca, -1, |
| Credentials.CA_CERTIFICATE + ca, Process.WIFI_UID); |
| } |
| } |
| } |
| |
| private void readNetworkBitsetVariable(int netId, BitSet variable, String varName, |
| String[] strings) { |
| String value = mWifiNative.getNetworkVariable(netId, varName); |
| if (!TextUtils.isEmpty(value)) { |
| variable.clear(); |
| String vals[] = value.split(" "); |
| for (String val : vals) { |
| int index = lookupString(val, strings); |
| if (0 <= index) { |
| variable.set(index); |
| } |
| } |
| } |
| } |
| } |