1 /* 2 * Copyright (C) 2024 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.server.wifi; 18 19 import static com.android.server.wifi.WifiSettingsConfigStore.WIFI_WEP_ALLOWED; 20 21 import android.annotation.NonNull; 22 import android.net.wifi.WifiInfo; 23 import android.os.Handler; 24 import android.os.HandlerThread; 25 import android.util.LocalLog; 26 import android.util.Log; 27 28 import com.android.wifi.flags.FeatureFlags; 29 30 import java.io.FileDescriptor; 31 import java.io.PrintWriter; 32 33 /** 34 * Class used to control WEP network usage. 35 * Start to access this class from android 16 and flag: wep_disabled_in_apm is true. 36 */ 37 public class WepNetworkUsageController { 38 private static final String TAG = "WepNetworkUsageController"; 39 40 private final HandlerThread mHandlerThread; 41 private final WifiDeviceStateChangeManager mWifiDeviceStateChangeManager; 42 private final WifiSettingsConfigStore mWifiSettingsConfigStore; 43 private final WifiGlobals mWifiGlobals; 44 private final ActiveModeWarden mActiveModeWarden; 45 private final LocalLog mLocalLog; 46 private final FeatureFlags mFeatureFlags; 47 48 private boolean mVerboseLoggingEnabled; 49 private boolean mIsWepAllowedSettingEnabled; 50 private boolean mIsAdvancedProtectionModeEnabled; 51 WepNetworkUsageController( @onNull HandlerThread handlerThread, @NonNull WifiDeviceStateChangeManager wifiDeviceStateChangeManager, @NonNull WifiSettingsConfigStore wifiSettingsConfigStore, @NonNull WifiGlobals wifiGlobals, @NonNull ActiveModeWarden activeModeWarden, @NonNull FeatureFlags featureFlags)52 public WepNetworkUsageController( 53 @NonNull HandlerThread handlerThread, 54 @NonNull WifiDeviceStateChangeManager wifiDeviceStateChangeManager, 55 @NonNull WifiSettingsConfigStore wifiSettingsConfigStore, 56 @NonNull WifiGlobals wifiGlobals, 57 @NonNull ActiveModeWarden activeModeWarden, 58 @NonNull FeatureFlags featureFlags) { 59 mHandlerThread = handlerThread; 60 mWifiDeviceStateChangeManager = wifiDeviceStateChangeManager; 61 mWifiSettingsConfigStore = wifiSettingsConfigStore; 62 mWifiGlobals = wifiGlobals; 63 mActiveModeWarden = activeModeWarden; 64 mFeatureFlags = featureFlags; 65 if (!mFeatureFlags.wepDisabledInApm()) { 66 Log.wtf(TAG, "WepNetworkUsageController should work only" 67 + " after feature flag is enabled"); 68 } 69 mLocalLog = new LocalLog(32); 70 } 71 72 /** Handle the boot completed event. Start to monitor WEP network usage */ handleBootCompleted()73 public void handleBootCompleted() { 74 mIsWepAllowedSettingEnabled = mWifiSettingsConfigStore.get(WIFI_WEP_ALLOWED); 75 mWifiSettingsConfigStore.registerChangeListener(WIFI_WEP_ALLOWED, 76 (key, value) -> { 77 mIsWepAllowedSettingEnabled = value; 78 handleWepAllowedChanged(); 79 }, 80 new Handler(mHandlerThread.getLooper())); 81 mWifiDeviceStateChangeManager.registerStateChangeCallback( 82 new WifiDeviceStateChangeManager.StateChangeCallback() { 83 @Override 84 public void onAdvancedProtectionModeStateChanged(boolean apmOn) { 85 mIsAdvancedProtectionModeEnabled = apmOn; 86 handleWepAllowedChanged(); 87 } 88 }); 89 } 90 91 /** 92 * Enable verbose logging for WifiConnectivityManager. 93 */ enableVerboseLogging(boolean verbose)94 public void enableVerboseLogging(boolean verbose) { 95 mVerboseLoggingEnabled = verbose; 96 } 97 98 /** 99 * Handles WEP allowed changed either settings: WIFI_WEP_ALLOWED changed or APM changed. 100 */ handleWepAllowedChanged()101 private void handleWepAllowedChanged() { 102 final boolean isWepAllowed = mIsWepAllowedSettingEnabled 103 && !mIsAdvancedProtectionModeEnabled; 104 mLocalLog.log("handleWepAllowedChanged, mIsWepAllowedSettingEnabledByUser = " 105 + mIsWepAllowedSettingEnabled 106 + " and isAdvancedProtectionEnabled = " + mIsAdvancedProtectionModeEnabled); 107 if (isWepAllowed == mWifiGlobals.isWepAllowed()) { 108 return; // No changed. 109 } 110 mWifiGlobals.setWepAllowed(isWepAllowed); 111 if (!isWepAllowed) { 112 for (ClientModeManager clientModeManager 113 : mActiveModeWarden.getClientModeManagers()) { 114 if (!(clientModeManager instanceof ConcreteClientModeManager)) { 115 continue; 116 } 117 ConcreteClientModeManager cmm = (ConcreteClientModeManager) clientModeManager; 118 WifiInfo info = cmm.getConnectionInfo(); 119 if (info != null 120 && info.getCurrentSecurityType() == WifiInfo.SECURITY_TYPE_WEP) { 121 clientModeManager.disconnect(); 122 } 123 } 124 } 125 } 126 127 /** 128 * Dump output for debugging. 129 */ dump(FileDescriptor fd, PrintWriter pw, String[] args)130 public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 131 pw.println("Dump of WepNetworkUsageController:"); 132 if (mVerboseLoggingEnabled) { 133 mLocalLog.dump(fd, pw, args); 134 } 135 pw.println("mIsAdvancedProtectionModeEnabled=" + mIsAdvancedProtectionModeEnabled); 136 pw.println("mIsWepAllowedSettingEnabled=" + mIsWepAllowedSettingEnabled); 137 138 } 139 } 140