wifi: Migrate to DhcpResultsParcelable

Bug: 147303283
Test: atest com.android.server.wifi
Change-Id: I7c525c2db01e93b3511a2dd161fdb07551677d8a

4 files changed, 101 insertions, 75 deletions

diff --git a/service/java/com/android/server/wifi/ClientModeImpl.java b/service/java/com/android/server/wifi/ClientModeImpl.java
index 3d6d1b09b..e9a718dd1 100644
--- a/service/java/com/android/server/wifi/ClientModeImpl.java
+++ b/service/java/com/android/server/wifi/ClientModeImpl.java
@@ -35,7 +35,7 @@ import android.content.IntentFilter;
 import android.content.pm.PackageManager;
 import android.database.ContentObserver;
 import android.net.ConnectivityManager;
-import android.net.DhcpResults;
+import android.net.DhcpResultsParcelable;
 import android.net.InvalidPacketException;
 import android.net.IpConfiguration;
 import android.net.KeepalivePacketData;
@@ -325,8 +325,9 @@ public class ClientModeImpl extends StateMachine {
 
     private Context mContext;
 
-    private final Object mDhcpResultsLock = new Object();
-    private DhcpResults mDhcpResults;
+    private final Object mDhcpResultsParcelableLock = new Object();
+    @NonNull
+    private DhcpResultsParcelable mDhcpResultsParcelable = new DhcpResultsParcelable();
 
     // NOTE: Do not return to clients - see syncRequestConnectionInfo()
     private final ExtendedWifiInfo mWifiInfo;
@@ -955,7 +956,7 @@ public class ClientModeImpl extends StateMachine {
         }
 
         @Override
-        public void onNewDhcpResults(DhcpResults dhcpResults) {
+        public void onNewDhcpResults(DhcpResultsParcelable dhcpResults) {
             if (dhcpResults != null) {
                 sendMessage(CMD_IPV4_PROVISIONING_SUCCESS, dhcpResults);
             } else {
@@ -1426,11 +1427,12 @@ public class ClientModeImpl extends StateMachine {
     /**
      * Blocking call to get the current DHCP results
      *
-     * @return DhcpResults current results
+     * @return DhcpResultsParcelable current results
      */
-    public DhcpResults syncGetDhcpResults() {
-        synchronized (mDhcpResultsLock) {
-            return new DhcpResults(mDhcpResults);
+    @NonNull
+    public DhcpResultsParcelable syncGetDhcpResultsParcelable() {
+        synchronized (mDhcpResultsParcelableLock) {
+            return mDhcpResultsParcelable;
         }
     }
 
@@ -1709,13 +1711,25 @@ public class ClientModeImpl extends StateMachine {
         }
     }
 
+    private static String dhcpResultsParcelableToString(DhcpResultsParcelable dhcpResults) {
+        return new StringBuilder()
+                .append("baseConfiguration ").append(dhcpResults.baseConfiguration)
+                .append("leaseDuration ").append(dhcpResults.leaseDuration)
+                .append("mtu ").append(dhcpResults.mtu)
+                .append("serverAddress ").append(dhcpResults.serverAddress)
+                .append("serverHostName ").append(dhcpResults.serverHostName)
+                .append("vendorInfo ").append(dhcpResults.vendorInfo)
+                .toString();
+    }
+
     @Override
     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
         super.dump(fd, pw, args);
         mSupplicantStateTracker.dump(fd, pw, args);
         pw.println("mLinkProperties " + mLinkProperties);
         pw.println("mWifiInfo " + mWifiInfo);
-        pw.println("mDhcpResults " + mDhcpResults);
+        pw.println("mDhcpResultsParcelable "
+                + dhcpResultsParcelableToString(mDhcpResultsParcelable));
         pw.println("mNetworkInfo " + mNetworkInfo);
         pw.println("mLastSignalLevel " + mLastSignalLevel);
         pw.println("mLastBssid " + mLastBssid);
@@ -2057,7 +2071,7 @@ public class ClientModeImpl extends StateMachine {
                 break;
             case CMD_IPV4_PROVISIONING_SUCCESS:
                 sb.append(" ");
-                sb.append(/* DhcpResults */ msg.obj);
+                sb.append(/* DhcpResultsParcelable */ msg.obj);
                 break;
             case WifiMonitor.MBO_OCE_BSS_TM_HANDLING_DONE:
                 BtmFrameData frameData = (BtmFrameData) msg.obj;
@@ -2375,10 +2389,8 @@ public class ClientModeImpl extends StateMachine {
     private void clearLinkProperties() {
         // Clear the link properties obtained from DHCP. The only caller of this
         // function has already called IpClient#stop(), which clears its state.
-        synchronized (mDhcpResultsLock) {
-            if (mDhcpResults != null) {
-                mDhcpResults.clear();
-            }
+        synchronized (mDhcpResultsParcelableLock) {
+            mDhcpResultsParcelable = new DhcpResultsParcelable();
         }
 
         // Now clear the merged link properties.
@@ -2802,16 +2814,16 @@ public class ClientModeImpl extends StateMachine {
         }
     }
 
-    private void handleIPv4Success(DhcpResults dhcpResults) {
+    private void handleIPv4Success(DhcpResultsParcelable dhcpResults) {
         if (mVerboseLoggingEnabled) {
             logd("handleIPv4Success <" + dhcpResults.toString() + ">");
-            logd("link address " + dhcpResults.ipAddress);
+            logd("link address " + dhcpResults.baseConfiguration.ipAddress);
         }
 
         Inet4Address addr;
-        synchronized (mDhcpResultsLock) {
-            mDhcpResults = dhcpResults;
-            addr = (Inet4Address) dhcpResults.ipAddress.getAddress();
+        synchronized (mDhcpResultsParcelableLock) {
+            mDhcpResultsParcelable = dhcpResults;
+            addr = (Inet4Address) dhcpResults.baseConfiguration.ipAddress.getAddress();
         }
 
         if (mIsAutoRoaming) {
@@ -2829,13 +2841,12 @@ public class ClientModeImpl extends StateMachine {
         if (config != null) {
             mWifiInfo.setEphemeral(config.ephemeral);
             mWifiInfo.setTrusted(config.trusted);
-            mWifiConfigManager.updateRandomizedMacExpireTime(config,
-                    dhcpResults.getLeaseDuration());
+            mWifiConfigManager.updateRandomizedMacExpireTime(config, dhcpResults.leaseDuration);
             mBssidBlocklistMonitor.handleDhcpProvisioningSuccess(mLastBssid, mWifiInfo.getSSID());
         }
 
         // Set meteredHint if DHCP result says network is metered
-        if (dhcpResults.hasMeteredHint()) {
+        if (dhcpResults.vendorInfo != null && dhcpResults.vendorInfo.contains("ANDROID_METERED")) {
             mWifiInfo.setMeteredHint(true);
         }
 
@@ -2873,10 +2884,8 @@ public class ClientModeImpl extends StateMachine {
                 WifiMetrics.ConnectionEvent.FAILURE_DHCP,
                 WifiMetricsProto.ConnectionEvent.HLF_DHCP,
                 WifiMetricsProto.ConnectionEvent.FAILURE_REASON_UNKNOWN);
-        synchronized (mDhcpResultsLock) {
-            if (mDhcpResults != null) {
-                mDhcpResults.clear();
-            }
+        synchronized (mDhcpResultsParcelableLock) {
+            mDhcpResultsParcelable = new DhcpResultsParcelable();
         }
         if (mVerboseLoggingEnabled) {
             logd("handleIPv4Failure");
@@ -4373,7 +4382,7 @@ public class ClientModeImpl extends StateMachine {
                     // similarly--via messages sent back from IpClient.
                     break;
                 case CMD_IPV4_PROVISIONING_SUCCESS: {
-                    handleIPv4Success((DhcpResults) message.obj);
+                    handleIPv4Success((DhcpResultsParcelable) message.obj);
                     sendNetworkStateChangeBroadcast(mLastBssid);
                     break;
                 }
diff --git a/service/java/com/android/server/wifi/WifiServiceImpl.java b/service/java/com/android/server/wifi/WifiServiceImpl.java
index 90f9e8186..8326f2f4b 100644
--- a/service/java/com/android/server/wifi/WifiServiceImpl.java
+++ b/service/java/com/android/server/wifi/WifiServiceImpl.java
@@ -43,7 +43,8 @@ import android.content.pm.ParceledListSlice;
 import android.content.pm.ResolveInfo;
 import android.database.ContentObserver;
 import android.net.DhcpInfo;
-import android.net.DhcpResults;
+import android.net.DhcpResultsParcelable;
+import android.net.InetAddresses;
 import android.net.Network;
 import android.net.NetworkStack;
 import android.net.Uri;
@@ -2615,35 +2616,40 @@ public class WifiServiceImpl extends BaseWifiService {
         if (mVerboseLoggingEnabled) {
             mLog.info("getDhcpInfo uid=%").c(Binder.getCallingUid()).flush();
         }
-        DhcpResults dhcpResults = mClientModeImpl.syncGetDhcpResults();
+        DhcpResultsParcelable dhcpResults = mClientModeImpl.syncGetDhcpResultsParcelable();
 
         DhcpInfo info = new DhcpInfo();
 
-        if (dhcpResults.ipAddress != null &&
-                dhcpResults.ipAddress.getAddress() instanceof Inet4Address) {
-            info.ipAddress = Inet4AddressUtils.inet4AddressToIntHTL(
-                    (Inet4Address) dhcpResults.ipAddress.getAddress());
-        }
+        if (dhcpResults.baseConfiguration != null) {
+            if (dhcpResults.baseConfiguration.ipAddress != null
+                    && dhcpResults.baseConfiguration.ipAddress.getAddress()
+                    instanceof Inet4Address) {
+                info.ipAddress = Inet4AddressUtils.inet4AddressToIntHTL(
+                        (Inet4Address) dhcpResults.baseConfiguration.ipAddress.getAddress());
+            }
 
-        if (dhcpResults.gateway != null) {
-            info.gateway = Inet4AddressUtils.inet4AddressToIntHTL(
-                    (Inet4Address) dhcpResults.gateway);
-        }
+            if (dhcpResults.baseConfiguration.gateway != null) {
+                info.gateway = Inet4AddressUtils.inet4AddressToIntHTL(
+                        (Inet4Address) dhcpResults.baseConfiguration.gateway);
+            }
 
-        int dnsFound = 0;
-        for (InetAddress dns : dhcpResults.dnsServers) {
-            if (dns instanceof Inet4Address) {
-                if (dnsFound == 0) {
-                    info.dns1 = Inet4AddressUtils.inet4AddressToIntHTL((Inet4Address) dns);
-                } else {
-                    info.dns2 = Inet4AddressUtils.inet4AddressToIntHTL((Inet4Address) dns);
+            int dnsFound = 0;
+            for (InetAddress dns : dhcpResults.baseConfiguration.dnsServers) {
+                if (dns instanceof Inet4Address) {
+                    if (dnsFound == 0) {
+                        info.dns1 = Inet4AddressUtils.inet4AddressToIntHTL((Inet4Address) dns);
+                    } else {
+                        info.dns2 = Inet4AddressUtils.inet4AddressToIntHTL((Inet4Address) dns);
+                    }
+                    if (++dnsFound > 1) break;
                 }
-                if (++dnsFound > 1) break;
             }
         }
-        Inet4Address serverAddress = dhcpResults.serverAddress;
+        String serverAddress = dhcpResults.serverAddress;
         if (serverAddress != null) {
-            info.serverAddress = Inet4AddressUtils.inet4AddressToIntHTL(serverAddress);
+            InetAddress serverInetAddress = InetAddresses.parseNumericAddress(serverAddress);
+            info.serverAddress =
+                    Inet4AddressUtils.inet4AddressToIntHTL((Inet4Address) serverInetAddress);
         }
         info.leaseDuration = dhcpResults.leaseDuration;
 
diff --git a/service/java/com/android/server/wifi/p2p/WifiP2pServiceImpl.java b/service/java/com/android/server/wifi/p2p/WifiP2pServiceImpl.java
index 0eb16b1c2..98d73302f 100644
--- a/service/java/com/android/server/wifi/p2p/WifiP2pServiceImpl.java
+++ b/service/java/com/android/server/wifi/p2p/WifiP2pServiceImpl.java
@@ -30,7 +30,7 @@ import android.content.res.Resources;
 import android.database.ContentObserver;
 import android.location.LocationManager;
 import android.net.ConnectivityManager;
-import android.net.DhcpResults;
+import android.net.DhcpResultsParcelable;
 import android.net.InetAddresses;
 import android.net.LinkAddress;
 import android.net.LinkProperties;
@@ -125,7 +125,7 @@ public class WifiP2pServiceImpl extends IWifiP2pManager.Stub {
     NetdWrapper mNetdWrapper;
     private IIpClient mIpClient;
     private int mIpClientStartIndex = 0;
-    private DhcpResults mDhcpResults;
+    private DhcpResultsParcelable mDhcpResultsParcelable;
 
     private P2pStateMachine mP2pStateMachine;
     private AsyncChannel mReplyChannel = new WifiAsyncChannel(TAG);
@@ -532,7 +532,7 @@ public class WifiP2pServiceImpl extends IWifiP2pManager.Stub {
             }
             mIpClient = null;
         }
-        mDhcpResults = null;
+        mDhcpResultsParcelable = null;
     }
 
     private void startIpClient(String ifname, Handler smHandler) {
@@ -583,7 +583,7 @@ public class WifiP2pServiceImpl extends IWifiP2pManager.Stub {
             mP2pStateMachine.sendMessage(IPC_POST_DHCP_ACTION);
         }
         @Override
-        public void onNewDhcpResults(DhcpResults dhcpResults) {
+        public void onNewDhcpResults(DhcpResultsParcelable dhcpResults) {
             mP2pStateMachine.sendMessage(IPC_DHCP_RESULTS, dhcpResults);
         }
         @Override
@@ -2633,8 +2633,7 @@ public class WifiP2pServiceImpl extends IWifiP2pManager.Stub {
 
                 // DHCP server has already been started if I am a group owner
                 if (mGroup.isGroupOwner()) {
-                    setWifiP2pInfoOnGroupFormation(
-                            InetAddresses.parseNumericAddress(SERVER_ADDRESS));
+                    setWifiP2pInfoOnGroupFormation(SERVER_ADDRESS);
                 }
 
                 // In case of a negotiation group, connection changed is sent
@@ -2725,19 +2724,22 @@ public class WifiP2pServiceImpl extends IWifiP2pManager.Stub {
                         mWifiNative.setP2pPowerSave(mGroup.getInterface(), true);
                         break;
                     case IPC_DHCP_RESULTS:
-                        mDhcpResults = (DhcpResults) message.obj;
-                        if (mDhcpResults == null) {
+                        mDhcpResultsParcelable = (DhcpResultsParcelable) message.obj;
+                        if (mDhcpResultsParcelable == null) {
                             break;
                         }
 
-                        if (mVerboseLoggingEnabled) logd("mDhcpResults: " + mDhcpResults);
-                        setWifiP2pInfoOnGroupFormation(mDhcpResults.serverAddress);
+                        if (mVerboseLoggingEnabled) {
+                            logd("mDhcpResultsParcelable: " + mDhcpResultsParcelable);
+                        }
+                        setWifiP2pInfoOnGroupFormation(mDhcpResultsParcelable.serverAddress);
                         sendP2pConnectionChangedBroadcast();
                         try {
                             final String ifname = mGroup.getInterface();
-                            if (mDhcpResults != null) {
+                            if (mDhcpResultsParcelable != null) {
                                 mNetdWrapper.addInterfaceToLocalNetwork(
-                                        ifname, mDhcpResults.getRoutes(ifname));
+                                        ifname,
+                                        mDhcpResultsParcelable.baseConfiguration.getRoutes(ifname));
                             }
                         } catch (Exception e) {
                             loge("Failed to add iface to local network " + e);
@@ -3660,7 +3662,10 @@ public class WifiP2pServiceImpl extends IWifiP2pManager.Stub {
             return true;
         }
 
-        private void setWifiP2pInfoOnGroupFormation(InetAddress serverInetAddress) {
+        private void setWifiP2pInfoOnGroupFormation(String serverAddress) {
+            InetAddress serverInetAddress = serverAddress == null
+                    ? null
+                    : InetAddresses.parseNumericAddress(serverAddress);
             mWifiP2pInfo.groupFormed = true;
             mWifiP2pInfo.isGroupOwner = mGroup.isGroupOwner();
             mWifiP2pInfo.groupOwnerAddress = serverInetAddress;
diff --git a/tests/wifitests/src/com/android/server/wifi/ClientModeImplTest.java b/tests/wifitests/src/com/android/server/wifi/ClientModeImplTest.java
index f8d99a95d..6c2d4abd2 100644
--- a/tests/wifitests/src/com/android/server/wifi/ClientModeImplTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/ClientModeImplTest.java
@@ -38,7 +38,9 @@ import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.hardware.wifi.supplicant.V1_0.ISupplicantStaIfaceCallback;
 import android.net.ConnectivityManager;
-import android.net.DhcpResults;
+import android.net.DhcpResultsParcelable;
+import android.net.InetAddresses;
+import android.net.LinkAddress;
 import android.net.LinkProperties;
 import android.net.MacAddress;
 import android.net.NetworkAgent;
@@ -46,6 +48,7 @@ import android.net.NetworkCapabilities;
 import android.net.NetworkInfo;
 import android.net.NetworkMisc;
 import android.net.NetworkSpecifier;
+import android.net.StaticIpConfiguration;
 import android.net.ip.IIpClient;
 import android.net.ip.IpClientCallbacks;
 import android.net.wifi.IActionListener;
@@ -295,14 +298,13 @@ public class ClientModeImplTest extends WifiBaseTest {
         return list;
     }
 
-    private void injectDhcpSuccess(DhcpResults dhcpResults) {
+    private void injectDhcpSuccess(DhcpResultsParcelable dhcpResults) {
         mIpClientCallback.onNewDhcpResults(dhcpResults);
         mIpClientCallback.onProvisioningSuccess(new LinkProperties());
     }
 
     private void injectDhcpFailure() {
-        // TODO: Change argument type to DhcpResultsParcelable after migration.
-        mIpClientCallback.onNewDhcpResults((DhcpResults) null);
+        mIpClientCallback.onNewDhcpResults((DhcpResultsParcelable) null);
         mIpClientCallback.onProvisioningFailure(new LinkProperties());
     }
 
@@ -952,11 +954,13 @@ public class ClientModeImplTest extends WifiBaseTest {
 
         assertEquals("ObtainingIpState", getCurrentState().getName());
 
-        DhcpResults dhcpResults = new DhcpResults();
-        dhcpResults.setGateway("1.2.3.4");
-        dhcpResults.setIpAddress("192.168.1.100", 0);
-        dhcpResults.addDns("8.8.8.8");
-        dhcpResults.setLeaseDuration(3600);
+        DhcpResultsParcelable dhcpResults = new DhcpResultsParcelable();
+        dhcpResults.baseConfiguration = new StaticIpConfiguration();
+        dhcpResults.baseConfiguration.gateway = InetAddresses.parseNumericAddress("1.2.3.4");
+        dhcpResults.baseConfiguration.ipAddress =
+                new LinkAddress(InetAddresses.parseNumericAddress("192.168.1.100"), 0);
+        dhcpResults.baseConfiguration.dnsServers.add(InetAddresses.parseNumericAddress("8.8.8.8"));
+        dhcpResults.leaseDuration = 3600;
 
         injectDhcpSuccess(dhcpResults);
         mLooper.dispatchAll();
@@ -2092,11 +2096,13 @@ public class ClientModeImplTest extends WifiBaseTest {
 
         when(mWifiConfigManager.getConfiguredNetwork(FRAMEWORK_NETWORK_ID)).thenReturn(null);
 
-        DhcpResults dhcpResults = new DhcpResults();
-        dhcpResults.setGateway("1.2.3.4");
-        dhcpResults.setIpAddress("192.168.1.100", 0);
-        dhcpResults.addDns("8.8.8.8");
-        dhcpResults.setLeaseDuration(3600);
+        DhcpResultsParcelable dhcpResults = new DhcpResultsParcelable();
+        dhcpResults.baseConfiguration = new StaticIpConfiguration();
+        dhcpResults.baseConfiguration.gateway = InetAddresses.parseNumericAddress("1.2.3.4");
+        dhcpResults.baseConfiguration.ipAddress =
+                new LinkAddress(InetAddresses.parseNumericAddress("192.168.1.100"), 0);
+        dhcpResults.baseConfiguration.dnsServers.add(InetAddresses.parseNumericAddress("8.8.8.8"));
+        dhcpResults.leaseDuration = 3600;
 
         injectDhcpSuccess(dhcpResults);
         mLooper.dispatchAll();