[AWARE] Verify IPv6 address before declaring network fullfilled

The Aware interface is configured using network utilities - but the
network stack may not be ready immediately. There is currently no
mechanism to get a callback when configuration is done (TBD) so
looping internally trying to bind to the interface until validated
or timed out.

Bug: 123096306
Test: atest com.android.server.wifi.aware
Test: ACTS DataPathTest
Test: ACTS DataPathStressTest
Test: ACTS ThroughputTest
Change-Id: Iae7294c88c2842848f113b122d4de6c4f7fd5900

6 files changed, 188 insertions, 37 deletions

diff --git a/service/java/com/android/server/wifi/aware/WifiAwareDataPathStateManager.java b/service/java/com/android/server/wifi/aware/WifiAwareDataPathStateManager.java
index e641106a7..1ac73aef8 100644
--- a/service/java/com/android/server/wifi/aware/WifiAwareDataPathStateManager.java
+++ b/service/java/com/android/server/wifi/aware/WifiAwareDataPathStateManager.java
@@ -42,17 +42,18 @@ import android.net.wifi.aware.WifiAwareNetworkInfo;
 import android.net.wifi.aware.WifiAwareNetworkSpecifier;
 import android.net.wifi.aware.WifiAwareUtils;
 import android.os.Build;
+import android.os.Handler;
 import android.os.IBinder;
 import android.os.INetworkManagementService;
 import android.os.Looper;
 import android.os.ServiceManager;
-import android.os.SystemClock;
 import android.text.TextUtils;
 import android.util.ArrayMap;
 import android.util.Log;
 import android.util.Pair;
 
 import com.android.internal.annotations.VisibleForTesting;
+import com.android.server.wifi.Clock;
 import com.android.server.wifi.util.WifiPermissionsUtil;
 import com.android.server.wifi.util.WifiPermissionsWrapper;
 
@@ -60,6 +61,7 @@ import libcore.util.HexEncoding;
 
 import java.io.FileDescriptor;
 import java.io.PrintWriter;
+import java.net.DatagramSocket;
 import java.net.Inet6Address;
 import java.net.InetAddress;
 import java.net.NetworkInterface;
@@ -97,7 +99,13 @@ public class WifiAwareDataPathStateManager {
     private static final int NETWORK_FACTORY_BANDWIDTH_AVAIL = 1;
     private static final int NETWORK_FACTORY_SIGNAL_STRENGTH_AVAIL = 1;
 
+    @VisibleForTesting
+    public static final int ADDRESS_VALIDATION_RETRY_INTERVAL_MS = 1_000; // 1 second
+    @VisibleForTesting
+    public static final int ADDRESS_VALIDATION_TIMEOUT_MS = 5_000; // 5 seconds
+
     private final WifiAwareStateManager mMgr;
+    private final Clock mClock;
     public NetworkInterfaceWrapper mNiWrapper = new NetworkInterfaceWrapper();
     private static final NetworkCapabilities sNetworkCapabilitiesFilter = new NetworkCapabilities();
     private final Set<String> mInterfaces = new HashSet<>();
@@ -108,14 +116,16 @@ public class WifiAwareDataPathStateManager {
     private WifiPermissionsUtil mWifiPermissionsUtil;
     private WifiPermissionsWrapper mPermissionsWrapper;
     private Looper mLooper;
+    private Handler mHandler;
     private WifiAwareNetworkFactory mNetworkFactory;
     public INetworkManagementService mNwService;
 
     // internal debug flag to override API check
     /* package */ boolean mAllowNdpResponderFromAnyOverride = false;
 
-    public WifiAwareDataPathStateManager(WifiAwareStateManager mgr) {
+    public WifiAwareDataPathStateManager(WifiAwareStateManager mgr, Clock clock) {
         mMgr = mgr;
+        mClock = clock;
     }
 
     /**
@@ -131,6 +141,7 @@ public class WifiAwareDataPathStateManager {
         mWifiPermissionsUtil = wifiPermissionsUtil;
         mPermissionsWrapper = permissionsWrapper;
         mLooper = looper;
+        mHandler = new Handler(mLooper);
 
         sNetworkCapabilitiesFilter.clearAll();
         sNetworkCapabilitiesFilter.addTransportType(NetworkCapabilities.TRANSPORT_WIFI_AWARE);
@@ -282,8 +293,7 @@ public class WifiAwareDataPathStateManager {
             Log.w(TAG, "onDataPathInitiateSuccess: network request in incorrect state: state="
                     + nnri.state);
             mNetworkRequestsCache.remove(networkSpecifier);
-            mNetworkFactory.letAppKnowThatRequestsAreUnavailable(nnri);
-            mMgr.endDataPath(ndpId);
+            declareUnfullfillableAndEndDp(nnri, ndpId);
             return;
         }
 
@@ -428,7 +438,7 @@ public class WifiAwareDataPathStateManager {
 
         nnri.state = AwareNetworkRequestInformation.STATE_RESPONDER_WAIT_FOR_RESPOND_RESPONSE;
         nnri.ndpId = ndpId;
-        nnri.startTimestamp = SystemClock.elapsedRealtime();
+        nnri.startTimestamp = mClock.getElapsedSinceBootMillis();
         mMgr.respondToDataPathRequest(true, ndpId, nnri.interfaceName, nnri.networkSpecifier.pmk,
                 nnri.networkSpecifier.passphrase,
                 NetworkInformationData.buildTlv(nnri.networkSpecifier.port,
@@ -565,8 +575,7 @@ public class WifiAwareDataPathStateManager {
                     Log.e(TAG, "onDataPathConfirm: ACCEPT nnri=" + nnri
                             + ": can't configure network - "
                             + e);
-                    mMgr.endDataPath(ndpId);
-                    nnri.state = AwareNetworkRequestInformation.STATE_TERMINATING;
+                    declareUnfullfillableAndEndDp(nnri, ndpId);
                     return networkSpecifier;
                 }
             } else {
@@ -633,6 +642,7 @@ public class WifiAwareDataPathStateManager {
 
             if (!mNiWrapper.configureAgentProperties(nnri, nnri.equivalentRequests, ndpId,
                     networkInfo, networkCapabilities, linkProperties)) {
+                declareUnfullfillableAndEndDp(nnri, ndpId);
                 return networkSpecifier;
             }
 
@@ -641,12 +651,9 @@ public class WifiAwareDataPathStateManager {
                     new NetworkInfo(ConnectivityManager.TYPE_NONE, 0, NETWORK_TAG, ""),
                     networkCapabilities, linkProperties, NETWORK_FACTORY_SCORE_AVAIL,
                     nnri);
-            nnri.networkAgent.sendNetworkInfo(networkInfo);
-
-            mAwareMetrics.recordNdpStatus(NanStatusType.SUCCESS, networkSpecifier.isOutOfBand(),
-                    nnri.startTimestamp);
-            nnri.startTimestamp = SystemClock.elapsedRealtime(); // update time-stamp for duration
-            mAwareMetrics.recordNdpCreation(nnri.uid, mNetworkRequestsCache);
+            nnri.startValidationTimestamp = mClock.getElapsedSinceBootMillis();
+            handleAddressValidation(nnri, linkProperties, networkInfo, ndpId,
+                    networkSpecifier.isOutOfBand());
         } else {
             if (VDBG) {
                 Log.v(TAG, "onDataPathConfirm: data-path for networkSpecifier=" + networkSpecifier
@@ -661,6 +668,38 @@ public class WifiAwareDataPathStateManager {
         return networkSpecifier;
     }
 
+    private void handleAddressValidation(AwareNetworkRequestInformation nnri,
+            LinkProperties linkProperties, NetworkInfo networkInfo, int ndpId,
+            boolean isOutOfBand) {
+        if (mNiWrapper.isAddressUsable(linkProperties)) {
+            mNiWrapper.sendAgentNetworkInfo(nnri.networkAgent, networkInfo);
+
+            mAwareMetrics.recordNdpStatus(NanStatusType.SUCCESS, isOutOfBand, nnri.startTimestamp);
+            nnri.startTimestamp = mClock.getElapsedSinceBootMillis(); // update time-stamp
+            mAwareMetrics.recordNdpCreation(nnri.uid, mNetworkRequestsCache);
+        } else {
+            if (mClock.getElapsedSinceBootMillis() - nnri.startValidationTimestamp
+                    > ADDRESS_VALIDATION_TIMEOUT_MS) {
+                Log.e(TAG, "Timed-out while waiting for IPv6 address to be usable");
+
+                declareUnfullfillableAndEndDp(nnri, ndpId);
+                return;
+            }
+            if (mDbg) {
+                Log.d(TAG, "Failed address validation");
+            }
+            mHandler.postDelayed(() -> {
+                handleAddressValidation(nnri, linkProperties, networkInfo, ndpId, isOutOfBand);
+            }, ADDRESS_VALIDATION_RETRY_INTERVAL_MS);
+        }
+    }
+
+    private void declareUnfullfillableAndEndDp(AwareNetworkRequestInformation nnri, int ndpId) {
+        mNetworkFactory.letAppKnowThatRequestsAreUnavailable(nnri);
+        mMgr.endDataPath(ndpId);
+        nnri.state = AwareNetworkRequestInformation.STATE_TERMINATING;
+    }
+
     /**
      * Notification (unsolicited/asynchronous) from the firmware that the specified data-path has
      * been terminated.
@@ -906,7 +945,7 @@ public class WifiAwareDataPathStateManager {
                         null);
                 nnri.state =
                         AwareNetworkRequestInformation.STATE_INITIATOR_WAIT_FOR_REQUEST_RESPONSE;
-                nnri.startTimestamp = SystemClock.elapsedRealtime();
+                nnri.startTimestamp = mClock.getElapsedSinceBootMillis();
             } else {
                 nnri.state = AwareNetworkRequestInformation.STATE_RESPONDER_WAIT_FOR_REQUEST;
             }
@@ -979,7 +1018,11 @@ public class WifiAwareDataPathStateManager {
         }
     }
 
-    private class WifiAwareNetworkAgent extends NetworkAgent {
+    /**
+     * Network agent for Wi-Fi Aware.
+     */
+    @VisibleForTesting
+    public class WifiAwareNetworkAgent extends NetworkAgent {
         private NetworkInfo mNetworkInfo;
         private AwareNetworkRequestInformation mAwareNetworkRequestInfo;
 
@@ -1140,6 +1183,7 @@ public class WifiAwareDataPathStateManager {
         public WifiAwareNetworkSpecifier networkSpecifier;
         public List<NanDataPathChannelInfo> channelInfo;
         public long startTimestamp = 0; // request is made (initiator) / get request (responder)
+        public long startValidationTimestamp = 0; // NDP created and starting to validate IPv6 addr
 
         public WifiAwareNetworkAgent networkAgent;
 
@@ -1492,6 +1536,36 @@ public class WifiAwareDataPathStateManager {
 
             return true;
         }
+
+        /**
+         * Tries binding to the input address to check whether it is configured (and therefore
+         * usable).
+         */
+        public boolean isAddressUsable(LinkProperties linkProperties) {
+            InetAddress address = linkProperties.getLinkAddresses().get(0).getAddress();
+            DatagramSocket testDatagramSocket = null;
+            try {
+                testDatagramSocket = new DatagramSocket(0, address);
+            } catch (SocketException e) {
+                if (mDbg) {
+                    Log.d(TAG, "Can't create socket on address " + address + " -- " + e);
+                }
+                return false;
+            } finally {
+                if (testDatagramSocket != null) {
+                    testDatagramSocket.close();
+                }
+            }
+            return true;
+        }
+
+        /**
+         * Send updated network information to the agent.
+         */
+        public void sendAgentNetworkInfo(WifiAwareNetworkAgent networkAgent,
+                NetworkInfo networkInfo) {
+            networkAgent.sendNetworkInfo(networkInfo);
+        }
     }
 
     /**
diff --git a/service/java/com/android/server/wifi/aware/WifiAwareServiceImpl.java b/service/java/com/android/server/wifi/aware/WifiAwareServiceImpl.java
index 23ecc755b..e6e961d69 100644
--- a/service/java/com/android/server/wifi/aware/WifiAwareServiceImpl.java
+++ b/service/java/com/android/server/wifi/aware/WifiAwareServiceImpl.java
@@ -43,6 +43,7 @@ import android.util.Log;
 import android.util.SparseArray;
 import android.util.SparseIntArray;
 
+import com.android.server.wifi.Clock;
 import com.android.server.wifi.FrameworkFacade;
 import com.android.server.wifi.WifiInjector;
 import com.android.server.wifi.util.WifiPermissionsUtil;
@@ -104,7 +105,7 @@ public class WifiAwareServiceImpl extends IWifiAwareManager.Stub {
         mStateManager = awareStateManager;
         mShellCommand = awareShellCommand;
         mStateManager.start(mContext, handlerThread.getLooper(), awareMetrics, wifiPermissionsUtil,
-                permissionsWrapper);
+                permissionsWrapper, new Clock());
 
         frameworkFacade.registerContentObserver(mContext,
                 Settings.Global.getUriFor(Settings.Global.WIFI_VERBOSE_LOGGING_ENABLED), true,
diff --git a/service/java/com/android/server/wifi/aware/WifiAwareStateManager.java b/service/java/com/android/server/wifi/aware/WifiAwareStateManager.java
index ac1ed6a36..36cabd646 100644
--- a/service/java/com/android/server/wifi/aware/WifiAwareStateManager.java
+++ b/service/java/com/android/server/wifi/aware/WifiAwareStateManager.java
@@ -52,6 +52,7 @@ import com.android.internal.util.MessageUtils;
 import com.android.internal.util.State;
 import com.android.internal.util.StateMachine;
 import com.android.internal.util.WakeupMessage;
+import com.android.server.wifi.Clock;
 import com.android.server.wifi.util.WifiPermissionsUtil;
 import com.android.server.wifi.util.WifiPermissionsWrapper;
 
@@ -378,7 +379,8 @@ public class WifiAwareStateManager implements WifiAwareShellCommand.DelegatedShe
      * @param looper Thread looper on which to run the handler.
      */
     public void start(Context context, Looper looper, WifiAwareMetrics awareMetrics,
-            WifiPermissionsUtil wifiPermissionsUtil, WifiPermissionsWrapper permissionsWrapper) {
+            WifiPermissionsUtil wifiPermissionsUtil, WifiPermissionsWrapper permissionsWrapper,
+            Clock clock) {
         Log.i(TAG, "start()");
 
         mContext = context;
@@ -388,7 +390,7 @@ public class WifiAwareStateManager implements WifiAwareShellCommand.DelegatedShe
         mSm.setDbg(VVDBG);
         mSm.start();
 
-        mDataPathMgr = new WifiAwareDataPathStateManager(this);
+        mDataPathMgr = new WifiAwareDataPathStateManager(this, clock);
         mDataPathMgr.start(mContext, mSm.getHandler().getLooper(), awareMetrics,
                 wifiPermissionsUtil, permissionsWrapper);
 
diff --git a/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareDataPathStateManagerTest.java b/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareDataPathStateManagerTest.java
index e7a61e575..f2cc45fef 100644
--- a/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareDataPathStateManagerTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareDataPathStateManagerTest.java
@@ -80,6 +80,7 @@ import android.util.Pair;
 import androidx.test.filters.SmallTest;
 
 import com.android.internal.util.AsyncChannel;
+import com.android.server.wifi.Clock;
 import com.android.server.wifi.util.WifiPermissionsUtil;
 import com.android.server.wifi.util.WifiPermissionsWrapper;
 
@@ -101,6 +102,7 @@ import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
 
+
 /**
  * Unit test harness for WifiAwareDataPathStateManager class.
  */
@@ -111,6 +113,7 @@ public class WifiAwareDataPathStateManagerTest {
     private TestLooper mMockLooper;
     private Handler mMockLooperHandler;
     private WifiAwareStateManager mDut;
+    @Mock private Clock mClock;
     @Mock private WifiAwareNativeManager mMockNativeManager;
     @Spy private TestUtils.MonitoredWifiAwareNativeApi mMockNative =
             new TestUtils.MonitoredWifiAwareNativeApi();
@@ -164,12 +167,13 @@ public class WifiAwareDataPathStateManagerTest {
         mDut = new WifiAwareStateManager();
         mDut.setNative(mMockNativeManager, mMockNative);
         mDut.start(mMockContext, mMockLooper.getLooper(), mAwareMetricsMock,
-                mWifiPermissionsUtil, mPermissionsWrapperMock);
+                mWifiPermissionsUtil, mPermissionsWrapperMock, mClock);
         mDut.startLate();
         mMockLooper.dispatchAll();
 
         when(mMockNetworkInterface.configureAgentProperties(any(), any(), anyInt(), any(), any(),
                 any())).thenReturn(true);
+        when(mMockNetworkInterface.isAddressUsable(any())).thenReturn(true);
 
         when(mMockPowerManager.isDeviceIdleMode()).thenReturn(false);
         when(mMockPowerManager.isInteractive()).thenReturn(true);
@@ -867,7 +871,7 @@ public class WifiAwareDataPathStateManagerTest {
 
         testDataPathInitiatorUtilityMore(false, true, true, false, true, false, peerDataPathMac,
                 buildTlv((1 << 16) - 1, (1 << 8) - 1, true), (1 << 16) - 1, (1 << 8) - 1,
-                linkLocalIpv6Address);
+                linkLocalIpv6Address, 0);
     }
 
     /**
@@ -880,7 +884,7 @@ public class WifiAwareDataPathStateManagerTest {
                 peerDataPathMac).getLinkLocalIpv6FromEui48Mac().getHostAddress();
 
         testDataPathInitiatorUtilityMore(false, true, true, false, true, false, peerDataPathMac,
-                buildTlv(1 << 15, 1 << 7, true), 1 << 15, 1 << 7, linkLocalIpv6Address);
+                buildTlv(1 << 15, 1 << 7, true), 1 << 15, 1 << 7, linkLocalIpv6Address, 0);
     }
 
     /**
@@ -894,7 +898,7 @@ public class WifiAwareDataPathStateManagerTest {
 
         testDataPathInitiatorUtilityMore(false, true, true, false, true, false, peerDataPathMac,
                 buildTlv((1 << 15) - 1, (1 << 7) - 1, true), (1 << 15) - 1, (1 << 7) - 1,
-                linkLocalIpv6Address);
+                linkLocalIpv6Address, 0);
     }
 
     /**
@@ -908,7 +912,38 @@ public class WifiAwareDataPathStateManagerTest {
                         (byte) 0xfe, 0x7a, 0x2f, (byte) 0xa2};
 
         testDataPathInitiatorUtilityMore(false, true, true, false, true, false, peerDataPathMac,
-                testVector, 0, -1, "fe80::b3:e1ff:fe7a:2fa2");
+                testVector, 0, -1, "fe80::b3:e1ff:fe7a:2fa2", 0);
+    }
+
+    /**
+     * Verify that retrying address validation a 'small' number of times results in successful
+     * NDP setup.
+     */
+    @Test
+    public void testDataPathInitiatorAddressValidationRetrySuccess() throws Exception {
+        final byte[] peerDataPathMac = HexEncoding.decode("0A0B0C0D0E0F".toCharArray(), false);
+        String linkLocalIpv6Address = MacAddress.fromBytes(
+                peerDataPathMac).getLinkLocalIpv6FromEui48Mac().getHostAddress();
+
+        testDataPathInitiatorUtilityMore(false, true, true, false, true, false, peerDataPathMac,
+                null, 0, -1, linkLocalIpv6Address,
+                WifiAwareDataPathStateManager.ADDRESS_VALIDATION_TIMEOUT_MS
+                        / WifiAwareDataPathStateManager.ADDRESS_VALIDATION_RETRY_INTERVAL_MS - 1);
+    }
+
+    /**
+     * Verify that retrying address validation a 'large' number of times results in failure.
+     */
+    @Test
+    public void testDataPathInitiatorAddressValidationRetryFail() throws Exception {
+        final byte[] peerDataPathMac = HexEncoding.decode("0A0B0C0D0E0F".toCharArray(), false);
+        String linkLocalIpv6Address = MacAddress.fromBytes(
+                peerDataPathMac).getLinkLocalIpv6FromEui48Mac().getHostAddress();
+
+        testDataPathInitiatorUtilityMore(false, true, true, false, true, false, peerDataPathMac,
+                null, 0, -1, linkLocalIpv6Address,
+                WifiAwareDataPathStateManager.ADDRESS_VALIDATION_TIMEOUT_MS
+                        / WifiAwareDataPathStateManager.ADDRESS_VALIDATION_RETRY_INTERVAL_MS + 10);
     }
 
     /**
@@ -1254,13 +1289,13 @@ public class WifiAwareDataPathStateManagerTest {
 
         testDataPathInitiatorUtilityMore(useDirect, provideMac, providePmk, providePassphrase,
                 getConfirmation, immediateHalFailure, peerDataPathMac, null, 0, -1,
-                linkLocalIpv6Address);
+                linkLocalIpv6Address, 0);
     }
 
     private void testDataPathInitiatorUtilityMore(boolean useDirect, boolean provideMac,
             boolean providePmk, boolean providePassphrase, boolean getConfirmation,
             boolean immediateHalFailure, byte[] peerDataPathMac, byte[] peerToken, int port,
-            int transportProtocol, String ipv6Address)
+            int transportProtocol, String ipv6Address, int numAddrValidationRetries)
             throws Exception {
         final int clientId = 123;
         final byte pubSubId = 58;
@@ -1275,7 +1310,7 @@ public class WifiAwareDataPathStateManagerTest {
         ArgumentCaptor<NetworkCapabilities> netCapCaptor = ArgumentCaptor.forClass(
                 NetworkCapabilities.class);
         InOrder inOrder = inOrder(mMockNative, mMockCm, mMockCallback, mMockSessionCallback,
-                mMockNwMgt);
+                mMockNwMgt, mMockNetworkInterface);
         InOrder inOrderM = inOrder(mAwareMetricsMock);
 
         if (!providePmk) {
@@ -1332,20 +1367,56 @@ public class WifiAwareDataPathStateManagerTest {
 
         // (2) get confirmation OR timeout
         if (getConfirmation) {
+            if (numAddrValidationRetries > 0) {
+                when(mMockNetworkInterface.isAddressUsable(any())).thenReturn(false);
+            }
+            when(mClock.getElapsedSinceBootMillis()).thenReturn(0L);
+
             mDut.onDataPathConfirmNotification(ndpId, peerDataPathMac, true, 0, peerToken, null);
             mMockLooper.dispatchAll();
             inOrder.verify(mMockNwMgt).setInterfaceUp(anyString());
             inOrder.verify(mMockNwMgt).enableIpv6(anyString());
+            inOrder.verify(mMockNetworkInterface).configureAgentProperties(any(), any(), anyInt(),
+                    any(), any(), any());
             inOrder.verify(mMockCm).registerNetworkAgent(messengerCaptor.capture(), any(), any(),
                     netCapCaptor.capture(), anyInt(), any(), anyInt());
-            inOrderM.verify(mAwareMetricsMock).recordNdpStatus(eq(NanStatusType.SUCCESS),
-                    eq(useDirect), anyLong());
-            inOrderM.verify(mAwareMetricsMock).recordNdpCreation(anyInt(), any());
-            WifiAwareNetworkInfo netInfo =
-                    (WifiAwareNetworkInfo) netCapCaptor.getValue().getTransportInfo();
-            assertEquals(ipv6Address, netInfo.getPeerIpv6Addr().getHostAddress());
-            assertEquals(port, netInfo.getPort());
-            assertEquals(transportProtocol, netInfo.getTransportProtocol());
+
+            inOrder.verify(mMockNetworkInterface).isAddressUsable(any());
+            boolean timedout = false;
+            for (int i = 0; i < numAddrValidationRetries; ++i) {
+                if (i == numAddrValidationRetries - 1) {
+                    when(mMockNetworkInterface.isAddressUsable(any())).thenReturn(true);
+                }
+
+                long currentTime = (i + 1L)
+                        * WifiAwareDataPathStateManager.ADDRESS_VALIDATION_RETRY_INTERVAL_MS;
+                when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTime);
+                mMockLooper.moveTimeForward(
+                        WifiAwareDataPathStateManager.ADDRESS_VALIDATION_RETRY_INTERVAL_MS + 1);
+                mMockLooper.dispatchAll();
+                inOrder.verify(mMockNetworkInterface).isAddressUsable(any());
+
+                if (currentTime > WifiAwareDataPathStateManager.ADDRESS_VALIDATION_TIMEOUT_MS) {
+                    timedout = true;
+                    break;
+                }
+            }
+
+            if (timedout) {
+                verifyUnfullfillableDispatched(res.mReverseMessenger);
+                inOrder.verify(mMockNative).endDataPath(transactionId.capture(), eq(ndpId));
+                mDut.onEndDataPathResponse(transactionId.getValue(), true, 0);
+            } else {
+                inOrder.verify(mMockNetworkInterface).sendAgentNetworkInfo(any(), any());
+                inOrderM.verify(mAwareMetricsMock).recordNdpStatus(eq(NanStatusType.SUCCESS),
+                        eq(useDirect), anyLong());
+                inOrderM.verify(mAwareMetricsMock).recordNdpCreation(anyInt(), any());
+                WifiAwareNetworkInfo netInfo =
+                        (WifiAwareNetworkInfo) netCapCaptor.getValue().getTransportInfo();
+                assertEquals(ipv6Address, netInfo.getPeerIpv6Addr().getHostAddress());
+                assertEquals(port, netInfo.getPort());
+                assertEquals(transportProtocol, netInfo.getTransportProtocol());
+            }
         } else {
             assertTrue(mAlarmManager.dispatch(
                     WifiAwareStateManager.HAL_DATA_PATH_CONFIRM_TIMEOUT_TAG));
@@ -1377,7 +1448,8 @@ public class WifiAwareDataPathStateManagerTest {
             inOrderM.verify(mAwareMetricsMock).recordNdpSessionDuration(anyLong());
         }
 
-        verifyNoMoreInteractions(mMockNative, mMockCm, mAwareMetricsMock, mMockNwMgt);
+        verifyNoMoreInteractions(mMockNative, mMockCm, mAwareMetricsMock, mMockNwMgt,
+                mMockNetworkInterface);
     }
 
     private void testDataPathResponderUtility(boolean useDirect, boolean provideMac,
diff --git a/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareServiceImplTest.java b/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareServiceImplTest.java
index 8fd38cc5c..1204c4f81 100644
--- a/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareServiceImplTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareServiceImplTest.java
@@ -66,6 +66,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
+
 /**
  * Unit test harness for WifiAwareStateManager.
  */
@@ -151,7 +152,7 @@ public class WifiAwareServiceImplTest {
                 mock(WifiAwareNativeManager.class), mock(WifiAwareNativeApi.class),
                 mock(WifiAwareNativeCallback.class));
         verify(mAwareStateManagerMock).start(eq(mContextMock), any(), eq(mAwareMetricsMock),
-                eq(mWifiPermissionsUtil), eq(mPermissionsWrapperMock));
+                eq(mWifiPermissionsUtil), eq(mPermissionsWrapperMock), any());
     }
 
     /**
diff --git a/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareStateManagerTest.java b/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareStateManagerTest.java
index 920341db0..b4f93c123 100644
--- a/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareStateManagerTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareStateManagerTest.java
@@ -73,6 +73,7 @@ import android.util.SparseArray;
 
 import androidx.test.filters.SmallTest;
 
+import com.android.server.wifi.Clock;
 import com.android.server.wifi.util.WifiPermissionsUtil;
 import com.android.server.wifi.util.WifiPermissionsWrapper;
 
@@ -170,7 +171,7 @@ public class WifiAwareStateManagerTest {
         mDut = new WifiAwareStateManager();
         mDut.setNative(mMockNativeManager, mMockNative);
         mDut.start(mMockContext, mMockLooper.getLooper(), mAwareMetricsMock,
-                mWifiPermissionsUtil, mPermissionsWrapperMock);
+                mWifiPermissionsUtil, mPermissionsWrapperMock, new Clock());
         mDut.startLate();
         mMockLooper.dispatchAll();
         verify(mMockContext, times(3)).registerReceiver(bcastRxCaptor.capture(),