Wifi: add support for Fast Session Transfer (FST)

In case FST is enabled (controlled by system property
persist.fst.rate.upgrade.en), data interface (bond0) is different than
control interface (wlan0 by default).
In case FST is disabled, control and data interfaces are the same and
there is no change in functionality.

WifiStateMachine now has separation between control and data interfaces.
Control interface is used for WifiNative (scan, connect, startap, etc.)
and FirmwareReload.
Data interface is used for DHCP (inc. routes), IP Addresses,
IpManager, FrameworkFacade (for traffic stats).

In fast-session-transfer feature, two wlan adapters exist but only one of
them (wlan0) is monitored by wifi monitor. The events from supplicant
from the other adapter (e.g. wlan1) need to be filtered out.

Change-Id: Ib9a562459ba9033e66e8347f382d882bd495dcb1

2 files changed, 52 insertions, 12 deletions

diff --git a/service/java/com/android/server/wifi/WifiMonitor.java b/service/java/com/android/server/wifi/WifiMonitor.java
index 2c1bde10d..07a32852e 100644
--- a/service/java/com/android/server/wifi/WifiMonitor.java
+++ b/service/java/com/android/server/wifi/WifiMonitor.java
@@ -762,11 +762,17 @@ public class WifiMonitor {
             int space = eventStr.indexOf(' ');
             if (space != -1) {
                 iface = eventStr.substring(7, space);
-                if (!mHandlerMap.containsKey(iface) && iface.startsWith("p2p-")) {
-                    // p2p interfaces are created dynamically, but we have
-                    // only one P2p state machine monitoring all of them; look
-                    // for it explicitly, and send messages there ..
-                    iface = "p2p0";
+                if (!mHandlerMap.containsKey(iface)) {
+                        if (iface.startsWith("p2p-")) {
+                            // p2p interfaces are created dynamically, but we have
+                            // only one P2p state machine monitoring all of them; look
+                            // for it explicitly, and send messages there ..
+                            iface = "p2p0";
+                        } else {
+                            Log.i(TAG, "Ignoring event from unexpected interface: "
+                                  + eventStr);
+                            return false;
+                        }
                 }
                 eventStr = eventStr.substring(space + 1);
             } else {
diff --git a/service/java/com/android/server/wifi/WifiStateMachine.java b/service/java/com/android/server/wifi/WifiStateMachine.java
index 402cbe54c..262c9fcd5 100644
--- a/service/java/com/android/server/wifi/WifiStateMachine.java
+++ b/service/java/com/android/server/wifi/WifiStateMachine.java
@@ -94,6 +94,7 @@ import android.telephony.TelephonyManager;
 import android.text.TextUtils;
 import android.util.Log;
 import android.util.SparseArray;
+import android.os.SystemProperties;
 
 import com.android.internal.R;
 import com.android.internal.annotations.VisibleForTesting;
@@ -216,6 +217,8 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiRss
     private final boolean mBackgroundScanSupported;
 
     private final String mInterfaceName;
+    /* The interface for ipManager */
+    private String mDataInterfaceName;
     /* Tethering interface could be separate from wlan interface */
     private String mTetherInterfaceName;
 
@@ -525,7 +528,7 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiRss
         }
     }
 
-    private final IpManager mIpManager;
+    private IpManager mIpManager;
 
     private AlarmManager mAlarmManager;
     private PendingIntent mScanIntent;
@@ -1011,6 +1014,9 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiRss
         // TODO refactor WifiNative use of context out into it's own class
         mWifiNative.initContext(mContext);
         mInterfaceName = mWifiNative.getInterfaceName();
+
+        updateDataInterface();
+
         mNetworkInfo = new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0, NETWORKTYPE, "");
         mBatteryStats = IBatteryStats.Stub.asInterface(mFacade.getService(
                 BatteryStats.SERVICE_NAME));
@@ -1051,7 +1057,7 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiRss
         mLastNetworkId = WifiConfiguration.INVALID_NETWORK_ID;
         mLastSignalLevel = -1;
 
-        mIpManager = mFacade.makeIpManager(mContext, mInterfaceName, new IpManagerCallback());
+        mIpManager = mFacade.makeIpManager(mContext, mDataInterfaceName, new IpManagerCallback());
         mIpManager.setMulticastFilter(true);
 
         mAlarmManager = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
@@ -1378,6 +1384,32 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiRss
         return mWifiConfigManager.getEnableAutoJoinWhenAssociated();
     }
 
+    private void updateDataInterface() {
+        String defaultRateUpgradeInterfaceName = "bond0"; // interface used for fst
+        int fstEnabled = SystemProperties.getInt("persist.fst.rate.upgrade.en", 0);
+        String prevDataInterfaceName = mDataInterfaceName;
+        String rateUpgradeDataInterfaceName = SystemProperties.get("persist.fst.data.interface",
+                defaultRateUpgradeInterfaceName);
+
+        // When fst is not enabled, data interface is the same as the wlan interface
+        mDataInterfaceName = (fstEnabled == 1) ? rateUpgradeDataInterfaceName : mInterfaceName;
+
+        // as long as we did not change from fst enabled to disabled state
+        // and vise-versa data interface does not change
+        if (mDataInterfaceName.equals(prevDataInterfaceName)) {
+            return;
+        }
+
+        logd("fst " + ((fstEnabled == 1) ? "enabled" : "disabled"));
+
+        if (mIpManager != null) {
+            mIpManager.shutdown();
+            mIpManager = mFacade.makeIpManager(mContext, mDataInterfaceName,
+                                               new IpManagerCallback());
+            mIpManager.setMulticastFilter(true);
+        }
+    }
+
     private boolean setRandomMacOui() {
         String oui = mContext.getResources().getString(R.string.config_wifi_random_mac_oui);
         if (TextUtils.isEmpty(oui)) {
@@ -1554,8 +1586,8 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiRss
             }
         }
         if (stats == null || mWifiLinkLayerStatsSupported <= 0) {
-            long mTxPkts = mFacade.getTxPackets(mInterfaceName);
-            long mRxPkts = mFacade.getRxPackets(mInterfaceName);
+            long mTxPkts = mFacade.getTxPackets(mDataInterfaceName);
+            long mRxPkts = mFacade.getRxPackets(mDataInterfaceName);
             mWifiInfo.updatePacketRates(mTxPkts, mRxPkts);
         } else {
             mWifiInfo.updatePacketRates(stats);
@@ -4249,16 +4281,16 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiRss
                             // Ensure interface is down and we have no IP
                             // addresses before a supplicant start.
                             mNwService.setInterfaceDown(mInterfaceName);
-                            mNwService.clearInterfaceAddresses(mInterfaceName);
+                            mNwService.clearInterfaceAddresses(mDataInterfaceName);
 
                             // Set privacy extensions
-                            mNwService.setInterfaceIpv6PrivacyExtensions(mInterfaceName, true);
+                            mNwService.setInterfaceIpv6PrivacyExtensions(mDataInterfaceName, true);
 
                             // IPv6 is enabled only as long as access point is connected since:
                             // - IPv6 addresses and routes stick around after disconnection
                             // - kernel is unaware when connected and fails to start IPv6 negotiation
                             // - kernel can start autoconfiguration when 802.1x is not complete
-                            mNwService.disableIpv6(mInterfaceName);
+                            mNwService.disableIpv6(mDataInterfaceName);
                         } catch (RemoteException re) {
                             loge("Unable to change interface settings: " + re);
                         } catch (IllegalStateException ie) {
@@ -4276,6 +4308,8 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiRss
                             loge("Failed to start HAL");
                         }
 
+                        updateDataInterface();
+
                         if (mWifiNative.startSupplicant(mP2pSupported)) {
                             setWifiState(WIFI_STATE_ENABLING);
                             if (DBG) log("Supplicant start successful");