Merge "follow up aosp/2600007"
diff --git a/Tethering/src/com/android/networkstack/tethering/Tethering.java b/Tethering/src/com/android/networkstack/tethering/Tethering.java
index e5f644e..b371178 100644
--- a/Tethering/src/com/android/networkstack/tethering/Tethering.java
+++ b/Tethering/src/com/android/networkstack/tethering/Tethering.java
@@ -157,6 +157,7 @@
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
+import java.util.Objects;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
@@ -1845,11 +1846,12 @@
setUpstreamNetwork(ns);
final Network newUpstream = (ns != null) ? ns.network : null;
- if (mTetherUpstream != newUpstream) {
+ if (!Objects.equals(mTetherUpstream, newUpstream)) {
mTetherUpstream = newUpstream;
reportUpstreamChanged(mTetherUpstream);
- // Need to notify capabilities change after upstream network changed because new
- // network's capabilities should be checked every time.
+ // Need to notify capabilities change after upstream network changed because
+ // upstream may switch to existing network which don't have
+ // UpstreamNetworkMonitor.EVENT_ON_CAPABILITIES callback.
mNotificationUpdater.onUpstreamCapabilitiesChanged(
(ns != null) ? ns.networkCapabilities : null);
}
diff --git a/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringTest.java b/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringTest.java
index bd8b325..9c6904d 100644
--- a/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringTest.java
+++ b/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringTest.java
@@ -240,6 +240,7 @@
private static final String TEST_RNDIS_IFNAME = "test_rndis0";
private static final String TEST_WIFI_IFNAME = "test_wlan0";
private static final String TEST_WLAN_IFNAME = "test_wlan1";
+ private static final String TEST_WLAN2_IFNAME = "test_wlan2";
private static final String TEST_P2P_IFNAME = "test_p2p-p2p0-0";
private static final String TEST_NCM_IFNAME = "test_ncm0";
private static final String TEST_ETH_IFNAME = "test_eth0";
@@ -392,6 +393,7 @@
assertTrue("Non-mocked interface " + ifName,
ifName.equals(TEST_RNDIS_IFNAME)
|| ifName.equals(TEST_WLAN_IFNAME)
+ || ifName.equals(TEST_WLAN2_IFNAME)
|| ifName.equals(TEST_WIFI_IFNAME)
|| ifName.equals(TEST_MOBILE_IFNAME)
|| ifName.equals(TEST_DUN_IFNAME)
@@ -400,8 +402,9 @@
|| ifName.equals(TEST_ETH_IFNAME)
|| ifName.equals(TEST_BT_IFNAME));
final String[] ifaces = new String[] {
- TEST_RNDIS_IFNAME, TEST_WLAN_IFNAME, TEST_WIFI_IFNAME, TEST_MOBILE_IFNAME,
- TEST_DUN_IFNAME, TEST_P2P_IFNAME, TEST_NCM_IFNAME, TEST_ETH_IFNAME};
+ TEST_RNDIS_IFNAME, TEST_WLAN_IFNAME, TEST_WLAN2_IFNAME, TEST_WIFI_IFNAME,
+ TEST_MOBILE_IFNAME, TEST_DUN_IFNAME, TEST_P2P_IFNAME, TEST_NCM_IFNAME,
+ TEST_ETH_IFNAME};
return new InterfaceParams(ifName,
CollectionUtils.indexOf(ifaces, ifName) + IFINDEX_OFFSET,
MacAddress.ALL_ZEROS_ADDRESS);
@@ -428,7 +431,7 @@
public class MockTetheringDependencies extends TetheringDependencies {
StateMachine mUpstreamNetworkMonitorSM;
- ArrayList<IpServer> mIpv6CoordinatorNotifyList;
+ ArrayList<IpServer> mAllDownstreams;
@Override
public BpfCoordinator getBpfCoordinator(
@@ -463,7 +466,7 @@
@Override
public IPv6TetheringCoordinator getIPv6TetheringCoordinator(
ArrayList<IpServer> notifyList, SharedLog log) {
- mIpv6CoordinatorNotifyList = notifyList;
+ mAllDownstreams = notifyList;
return mIPv6TetheringCoordinator;
}
@@ -642,8 +645,8 @@
false);
when(mNetd.interfaceGetList())
.thenReturn(new String[] {
- TEST_MOBILE_IFNAME, TEST_WLAN_IFNAME, TEST_RNDIS_IFNAME, TEST_P2P_IFNAME,
- TEST_NCM_IFNAME, TEST_ETH_IFNAME, TEST_BT_IFNAME});
+ TEST_MOBILE_IFNAME, TEST_WLAN_IFNAME, TEST_WLAN2_IFNAME, TEST_RNDIS_IFNAME,
+ TEST_P2P_IFNAME, TEST_NCM_IFNAME, TEST_ETH_IFNAME, TEST_BT_IFNAME});
when(mResources.getString(R.string.config_wifi_tether_enable)).thenReturn("");
mInterfaceConfiguration = new InterfaceConfigurationParcel();
mInterfaceConfiguration.flags = new String[0];
@@ -1026,7 +1029,7 @@
*/
private void sendIPv6TetherUpdates(UpstreamNetworkState upstreamState) {
// IPv6TetheringCoordinator must have been notified of downstream
- for (IpServer ipSrv : mTetheringDependencies.mIpv6CoordinatorNotifyList) {
+ for (IpServer ipSrv : mTetheringDependencies.mAllDownstreams) {
UpstreamNetworkState ipv6OnlyState = buildMobileUpstreamState(false, true, false);
ipSrv.sendMessage(IpServer.CMD_IPV6_TETHER_UPDATE, 0, 0,
upstreamState.linkProperties.isIpv6Provisioned()
@@ -2682,10 +2685,9 @@
final UpstreamNetworkState upstreamState2 = buildMobileIPv4UpstreamState();
initTetheringUpstream(upstreamState2);
stateMachine.chooseUpstreamType(true);
- // Bug: duplicated upstream change event.
- mTetheringEventCallback.expectUpstreamChanged(upstreamState2.network);
- inOrder.verify(mNotificationUpdater)
- .onUpstreamCapabilitiesChanged(upstreamState2.networkCapabilities);
+ // Expect that no upstream change event and capabilities changed event.
+ mTetheringEventCallback.assertNoUpstreamChangeCallback();
+ inOrder.verify(mNotificationUpdater, never()).onUpstreamCapabilitiesChanged(any());
// Set the upstream with the same network ID but different object and different capability.
final UpstreamNetworkState upstreamState3 = buildMobileIPv4UpstreamState();
@@ -2693,11 +2695,13 @@
upstreamState3.networkCapabilities.addCapability(NET_CAPABILITY_VALIDATED);
initTetheringUpstream(upstreamState3);
stateMachine.chooseUpstreamType(true);
- // Bug: duplicated upstream change event.
- mTetheringEventCallback.expectUpstreamChanged(upstreamState3.network);
+ // Expect that no upstream change event and capabilities changed event.
+ mTetheringEventCallback.assertNoUpstreamChangeCallback();
+ stateMachine.handleUpstreamNetworkMonitorCallback(EVENT_ON_CAPABILITIES, upstreamState3);
inOrder.verify(mNotificationUpdater)
.onUpstreamCapabilitiesChanged(upstreamState3.networkCapabilities);
+
// Lose upstream.
initTetheringUpstream(null);
stateMachine.chooseUpstreamType(true);
@@ -3046,6 +3050,58 @@
callback.expectTetheredClientChanged(Collections.emptyList());
}
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.S_V2)
+ public void testConnectedClientsForSapAndLohsConcurrency() throws Exception {
+ TestTetheringEventCallback callback = new TestTetheringEventCallback();
+ runAsShell(NETWORK_SETTINGS, () -> {
+ mTethering.registerTetheringEventCallback(callback);
+ mLooper.dispatchAll();
+ });
+ callback.expectTetheredClientChanged(Collections.emptyList());
+
+ mTethering.interfaceStatusChanged(TEST_WLAN_IFNAME, true);
+ sendWifiApStateChanged(WIFI_AP_STATE_ENABLED, TEST_WLAN_IFNAME, IFACE_IP_MODE_TETHERED);
+ final ArgumentCaptor<IDhcpEventCallbacks> dhcpEventCbsCaptor =
+ ArgumentCaptor.forClass(IDhcpEventCallbacks.class);
+ verify(mDhcpServer, timeout(DHCPSERVER_START_TIMEOUT_MS)).startWithCallbacks(
+ any(), dhcpEventCbsCaptor.capture());
+ IDhcpEventCallbacks eventCallbacks = dhcpEventCbsCaptor.getValue();
+ final List<TetheredClient> connectedClients = new ArrayList<>();
+ final MacAddress wifiMac = MacAddress.fromString("11:11:11:11:11:11");
+ final DhcpLeaseParcelable wifiLease = createDhcpLeaseParcelable("clientId", wifiMac,
+ "192.168.2.12", 24, Long.MAX_VALUE, "test");
+ verifyHotspotClientUpdate(false /* isLocalOnly */, wifiMac, wifiLease, connectedClients,
+ eventCallbacks, callback);
+ reset(mDhcpServer);
+
+ mTethering.interfaceStatusChanged(TEST_WLAN2_IFNAME, true);
+ sendWifiApStateChanged(WIFI_AP_STATE_ENABLED, TEST_WLAN2_IFNAME, IFACE_IP_MODE_LOCAL_ONLY);
+
+ verify(mDhcpServer, timeout(DHCPSERVER_START_TIMEOUT_MS)).startWithCallbacks(
+ any(), dhcpEventCbsCaptor.capture());
+ eventCallbacks = dhcpEventCbsCaptor.getValue();
+ final MacAddress localOnlyMac = MacAddress.fromString("22:22:22:22:22:22");
+ final DhcpLeaseParcelable localOnlyLease = createDhcpLeaseParcelable("clientId",
+ localOnlyMac, "192.168.43.24", 24, Long.MAX_VALUE, "test");
+ verifyHotspotClientUpdate(true /* isLocalOnly */, localOnlyMac, localOnlyLease,
+ connectedClients, eventCallbacks, callback);
+
+ assertTrue(isIpServerActive(TETHERING_WIFI, TEST_WLAN_IFNAME, IpServer.STATE_TETHERED));
+ assertTrue(isIpServerActive(TETHERING_WIFI, TEST_WLAN2_IFNAME, IpServer.STATE_LOCAL_ONLY));
+ }
+
+ private boolean isIpServerActive(int type, String ifName, int mode) {
+ for (IpServer ipSrv : mTetheringDependencies.mAllDownstreams) {
+ if (ipSrv.interfaceType() == type && ipSrv.interfaceName().equals(ifName)
+ && ipSrv.servingMode() == mode) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
private void verifyHotspotClientUpdate(final boolean isLocalOnly, final MacAddress testMac,
final DhcpLeaseParcelable dhcpLease, final List<TetheredClient> currentClients,
final IDhcpEventCallbacks dhcpCallback, final TestTetheringEventCallback callback)
@@ -3486,6 +3542,29 @@
assertEquals(expectedTypes.size() > 0, mTethering.isTetheringSupported());
callback.expectSupportedTetheringTypes(expectedTypes);
}
+
+ @Test
+ public void testIpv4AddressForSapAndLohsConcurrency() throws Exception {
+ mTethering.interfaceStatusChanged(TEST_WLAN_IFNAME, true);
+ sendWifiApStateChanged(WIFI_AP_STATE_ENABLED, TEST_WLAN_IFNAME, IFACE_IP_MODE_TETHERED);
+
+ ArgumentCaptor<InterfaceConfigurationParcel> ifaceConfigCaptor =
+ ArgumentCaptor.forClass(InterfaceConfigurationParcel.class);
+ verify(mNetd).interfaceSetCfg(ifaceConfigCaptor.capture());
+ InterfaceConfigurationParcel ifaceConfig = ifaceConfigCaptor.getValue();
+ final IpPrefix sapPrefix = new IpPrefix(
+ InetAddresses.parseNumericAddress(ifaceConfig.ipv4Addr), ifaceConfig.prefixLength);
+
+ mTethering.interfaceStatusChanged(TEST_WLAN2_IFNAME, true);
+ sendWifiApStateChanged(WIFI_AP_STATE_ENABLED, TEST_WLAN2_IFNAME, IFACE_IP_MODE_LOCAL_ONLY);
+
+ ifaceConfigCaptor = ArgumentCaptor.forClass(InterfaceConfigurationParcel.class);
+ verify(mNetd, times(2)).interfaceSetCfg(ifaceConfigCaptor.capture());
+ ifaceConfig = ifaceConfigCaptor.getValue();
+ final IpPrefix lohsPrefix = new IpPrefix(
+ InetAddresses.parseNumericAddress(ifaceConfig.ipv4Addr), ifaceConfig.prefixLength);
+ assertFalse(sapPrefix.equals(lohsPrefix));
+ }
// TODO: Test that a request for hotspot mode doesn't interfere with an
// already operating tethering mode interface.
}
diff --git a/common/Android.bp b/common/Android.bp
index 729ef32..ff4de11 100644
--- a/common/Android.bp
+++ b/common/Android.bp
@@ -25,7 +25,7 @@
"src/com/android/net/module/util/bpf/*.java",
],
sdk_version: "module_current",
- min_sdk_version: "29",
+ min_sdk_version: "30",
visibility: [
// Do not add any lib. This library is only shared inside connectivity module
// and its tests.
diff --git a/service-t/src/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java b/service-t/src/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java
index 84faf12..2d5bb00 100644
--- a/service-t/src/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java
+++ b/service-t/src/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java
@@ -29,7 +29,6 @@
import java.io.IOException;
import java.lang.ref.WeakReference;
import java.net.DatagramPacket;
-import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.Collection;
@@ -78,6 +77,7 @@
private final List<MdnsResponse> servicesToResolve;
@NonNull
private final MdnsResponseDecoder.Clock clock;
+ private final boolean onlyUseIpv6OnIpv6OnlyNetworks;
EnqueueMdnsQueryCallable(
@NonNull MdnsSocketClientBase requestSender,
@@ -87,6 +87,7 @@
boolean expectUnicastResponse,
int transactionId,
@Nullable Network network,
+ boolean onlyUseIpv6OnIpv6OnlyNetworks,
boolean sendDiscoveryQueries,
@NonNull Collection<MdnsResponse> servicesToResolve,
@NonNull MdnsResponseDecoder.Clock clock) {
@@ -97,6 +98,7 @@
this.expectUnicastResponse = expectUnicastResponse;
this.transactionId = transactionId;
this.network = network;
+ this.onlyUseIpv6OnIpv6OnlyNetworks = onlyUseIpv6OnIpv6OnlyNetworks;
this.sendDiscoveryQueries = sendDiscoveryQueries;
this.servicesToResolve = new ArrayList<>(servicesToResolve);
this.clock = clock;
@@ -128,24 +130,29 @@
for (MdnsResponse response : servicesToResolve) {
final String[] serviceName = response.getServiceName();
if (serviceName == null) continue;
- if (!response.hasTextRecord() || MdnsUtils.isRecordRenewalNeeded(
- response.getTextRecord(), now)) {
- missingKnownAnswerRecords.add(new Pair<>(serviceName, MdnsRecord.TYPE_TXT));
- }
- if (!response.hasServiceRecord() || MdnsUtils.isRecordRenewalNeeded(
- response.getServiceRecord(), now)) {
- missingKnownAnswerRecords.add(new Pair<>(serviceName, MdnsRecord.TYPE_SRV));
- // The hostname is not yet known, so queries for address records will be sent
- // the next time the EnqueueMdnsQueryCallable is enqueued if the reply does not
- // contain them. In practice, advertisers should include the address records
- // when queried for SRV, although it's not a MUST requirement (RFC6763 12.2).
- // TODO: Figure out how to renew the A/AAAA record. Usually A/AAAA record will
- // be included in the response to the SRV record so in high chances there is
- // no need to renew them individually.
- } else if (!response.hasInet4AddressRecord() && !response.hasInet6AddressRecord()) {
- final String[] host = response.getServiceRecord().getServiceHost();
- missingKnownAnswerRecords.add(new Pair<>(host, MdnsRecord.TYPE_A));
- missingKnownAnswerRecords.add(new Pair<>(host, MdnsRecord.TYPE_AAAA));
+ boolean renewTxt = !response.hasTextRecord() || MdnsUtils.isRecordRenewalNeeded(
+ response.getTextRecord(), now);
+ boolean renewSrv = !response.hasServiceRecord() || MdnsUtils.isRecordRenewalNeeded(
+ response.getServiceRecord(), now);
+ if (renewSrv && renewTxt) {
+ missingKnownAnswerRecords.add(new Pair<>(serviceName, MdnsRecord.TYPE_ANY));
+ } else {
+ if (renewTxt) {
+ missingKnownAnswerRecords.add(new Pair<>(serviceName, MdnsRecord.TYPE_TXT));
+ }
+ if (renewSrv) {
+ missingKnownAnswerRecords.add(new Pair<>(serviceName, MdnsRecord.TYPE_SRV));
+ // The hostname is not yet known, so queries for address records will be
+ // sent the next time the EnqueueMdnsQueryCallable is enqueued if the reply
+ // does not contain them. In practice, advertisers should include the
+ // address records when queried for SRV, although it's not a MUST
+ // requirement (RFC6763 12.2).
+ } else if (!response.hasInet4AddressRecord()
+ && !response.hasInet6AddressRecord()) {
+ final String[] host = response.getServiceRecord().getServiceHost();
+ missingKnownAnswerRecords.add(new Pair<>(host, MdnsRecord.TYPE_A));
+ missingKnownAnswerRecords.add(new Pair<>(host, MdnsRecord.TYPE_AAAA));
+ }
}
}
numQuestions += missingKnownAnswerRecords.size();
@@ -183,24 +190,9 @@
writeQuestion(serviceTypeLabels, MdnsRecord.TYPE_PTR);
}
- if (requestSender instanceof MdnsMultinetworkSocketClient) {
- sendPacketToIpv4AndIpv6(requestSender, MdnsConstants.MDNS_PORT, network);
- for (Integer emulatorPort : castShellEmulatorMdnsPorts) {
- sendPacketToIpv4AndIpv6(requestSender, emulatorPort, network);
- }
- } else if (requestSender instanceof MdnsSocketClient) {
- final MdnsSocketClient client = (MdnsSocketClient) requestSender;
- InetAddress mdnsAddress = MdnsConstants.getMdnsIPv4Address();
- if (client.isOnIPv6OnlyNetwork()) {
- mdnsAddress = MdnsConstants.getMdnsIPv6Address();
- }
-
- sendPacketTo(client, new InetSocketAddress(mdnsAddress, MdnsConstants.MDNS_PORT));
- for (Integer emulatorPort : castShellEmulatorMdnsPorts) {
- sendPacketTo(client, new InetSocketAddress(mdnsAddress, emulatorPort));
- }
- } else {
- throw new IOException("Unknown socket client type: " + requestSender.getClass());
+ sendPacketToIpv4AndIpv6(requestSender, MdnsConstants.MDNS_PORT);
+ for (Integer emulatorPort : castShellEmulatorMdnsPorts) {
+ sendPacketToIpv4AndIpv6(requestSender, emulatorPort);
}
return Pair.create(transactionId, subtypes);
} catch (IOException e) {
@@ -218,38 +210,39 @@
| (expectUnicastResponse ? MdnsConstants.QCLASS_UNICAST : 0));
}
- private void sendPacketTo(MdnsSocketClient requestSender, InetSocketAddress address)
+ private void sendPacket(MdnsSocketClientBase requestSender, InetSocketAddress address)
throws IOException {
DatagramPacket packet = packetWriter.getPacket(address);
if (expectUnicastResponse) {
- requestSender.sendUnicastPacket(packet);
+ if (requestSender instanceof MdnsMultinetworkSocketClient) {
+ ((MdnsMultinetworkSocketClient) requestSender).sendPacketRequestingUnicastResponse(
+ packet, network, onlyUseIpv6OnIpv6OnlyNetworks);
+ } else {
+ requestSender.sendPacketRequestingUnicastResponse(
+ packet, onlyUseIpv6OnIpv6OnlyNetworks);
+ }
} else {
- requestSender.sendMulticastPacket(packet);
+ if (requestSender instanceof MdnsMultinetworkSocketClient) {
+ ((MdnsMultinetworkSocketClient) requestSender)
+ .sendPacketRequestingMulticastResponse(
+ packet, network, onlyUseIpv6OnIpv6OnlyNetworks);
+ } else {
+ requestSender.sendPacketRequestingMulticastResponse(
+ packet, onlyUseIpv6OnIpv6OnlyNetworks);
+ }
}
}
- private void sendPacketFromNetwork(MdnsSocketClientBase requestSender,
- InetSocketAddress address, Network network)
- throws IOException {
- DatagramPacket packet = packetWriter.getPacket(address);
- if (expectUnicastResponse) {
- requestSender.sendUnicastPacket(packet, network);
- } else {
- requestSender.sendMulticastPacket(packet, network);
- }
- }
-
- private void sendPacketToIpv4AndIpv6(MdnsSocketClientBase requestSender, int port,
- Network network) {
+ private void sendPacketToIpv4AndIpv6(MdnsSocketClientBase requestSender, int port) {
try {
- sendPacketFromNetwork(requestSender,
- new InetSocketAddress(MdnsConstants.getMdnsIPv4Address(), port), network);
+ sendPacket(requestSender,
+ new InetSocketAddress(MdnsConstants.getMdnsIPv4Address(), port));
} catch (IOException e) {
Log.i(TAG, "Can't send packet to IPv4", e);
}
try {
- sendPacketFromNetwork(requestSender,
- new InetSocketAddress(MdnsConstants.getMdnsIPv6Address(), port), network);
+ sendPacket(requestSender,
+ new InetSocketAddress(MdnsConstants.getMdnsIPv6Address(), port));
} catch (IOException e) {
Log.i(TAG, "Can't send packet to IPv6", e);
}
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClient.java b/service-t/src/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClient.java
index d0ca20e..1253444 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClient.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClient.java
@@ -213,17 +213,21 @@
return true;
}
- private void sendMdnsPacket(@NonNull DatagramPacket packet, @Nullable Network targetNetwork) {
+ private void sendMdnsPacket(@NonNull DatagramPacket packet, @Nullable Network targetNetwork,
+ boolean onlyUseIpv6OnIpv6OnlyNetworks) {
final boolean isIpv6 = ((InetSocketAddress) packet.getSocketAddress()).getAddress()
instanceof Inet6Address;
final boolean isIpv4 = ((InetSocketAddress) packet.getSocketAddress()).getAddress()
instanceof Inet4Address;
final ArrayMap<MdnsInterfaceSocket, SocketKey> activeSockets = getActiveSockets();
+ boolean shouldQueryIpv6 = !onlyUseIpv6OnIpv6OnlyNetworks || isIpv6OnlyNetworks(
+ activeSockets, targetNetwork);
for (int i = 0; i < activeSockets.size(); i++) {
final MdnsInterfaceSocket socket = activeSockets.keyAt(i);
final Network network = activeSockets.valueAt(i).getNetwork();
// Check ip capability and network before sending packet
- if (((isIpv6 && socket.hasJoinedIpv6()) || (isIpv4 && socket.hasJoinedIpv4()))
+ if (((isIpv6 && socket.hasJoinedIpv6() && shouldQueryIpv6)
+ || (isIpv4 && socket.hasJoinedIpv4()))
// Contrary to MdnsUtils.isNetworkMatched, only send packets targeting
// the null network to interfaces that have the null network (tethering
// downstream interfaces).
@@ -237,6 +241,19 @@
}
}
+ private boolean isIpv6OnlyNetworks(
+ @NonNull ArrayMap<MdnsInterfaceSocket, SocketKey> activeSockets,
+ @Nullable Network targetNetwork) {
+ for (int i = 0; i < activeSockets.size(); i++) {
+ final MdnsInterfaceSocket socket = activeSockets.keyAt(i);
+ final Network network = activeSockets.valueAt(i).getNetwork();
+ if (Objects.equals(network, targetNetwork) && socket.hasJoinedIpv4()) {
+ return false;
+ }
+ }
+ return true;
+ }
+
private void processResponsePacket(byte[] recvbuf, int length, @NonNull SocketKey socketKey) {
int packetNumber = ++mReceivedPacketNumber;
@@ -259,21 +276,38 @@
}
/**
- * Sends a mDNS request packet via given network that asks for multicast response. Null network
- * means sending packet via all networks.
+ * Send a mDNS request packet via given network that asks for multicast response.
+ *
+ * <p>The socket client may use a null network to identify some or all interfaces, in which case
+ * passing null sends the packet to these.
*/
+ public void sendPacketRequestingMulticastResponse(@NonNull DatagramPacket packet,
+ @Nullable Network network, boolean onlyUseIpv6OnIpv6OnlyNetworks) {
+ mHandler.post(() -> sendMdnsPacket(packet, network, onlyUseIpv6OnIpv6OnlyNetworks));
+ }
+
@Override
- public void sendMulticastPacket(@NonNull DatagramPacket packet, @Nullable Network network) {
- mHandler.post(() -> sendMdnsPacket(packet, network));
+ public void sendPacketRequestingMulticastResponse(
+ @NonNull DatagramPacket packet, boolean onlyUseIpv6OnIpv6OnlyNetworks) {
+ sendPacketRequestingMulticastResponse(
+ packet, null /* network */, onlyUseIpv6OnIpv6OnlyNetworks);
}
/**
- * Sends a mDNS request packet via given network that asks for unicast response. Null network
- * means sending packet via all networks.
+ * Send a mDNS request packet via given network that asks for unicast response.
+ *
+ * <p>The socket client may use a null network to identify some or all interfaces, in which case
+ * passing null sends the packet to these.
*/
- @Override
- public void sendUnicastPacket(@NonNull DatagramPacket packet, @Nullable Network network) {
- // TODO: Separate unicast packet.
- mHandler.post(() -> sendMdnsPacket(packet, network));
+ public void sendPacketRequestingUnicastResponse(@NonNull DatagramPacket packet,
+ @Nullable Network network, boolean onlyUseIpv6OnIpv6OnlyNetworks) {
+ mHandler.post(() -> sendMdnsPacket(packet, network, onlyUseIpv6OnIpv6OnlyNetworks));
}
-}
+
+ @Override
+ public void sendPacketRequestingUnicastResponse(
+ @NonNull DatagramPacket packet, boolean onlyUseIpv6OnIpv6OnlyNetworks) {
+ sendPacketRequestingUnicastResponse(
+ packet, null /* network */, onlyUseIpv6OnIpv6OnlyNetworks);
+ }
+}
\ No newline at end of file
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsSearchOptions.java b/service-t/src/com/android/server/connectivity/mdns/MdnsSearchOptions.java
index 3da6bd0..98c80ee 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsSearchOptions.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsSearchOptions.java
@@ -44,10 +44,13 @@
new Parcelable.Creator<MdnsSearchOptions>() {
@Override
public MdnsSearchOptions createFromParcel(Parcel source) {
- return new MdnsSearchOptions(source.createStringArrayList(),
- source.readBoolean(), source.readBoolean(),
+ return new MdnsSearchOptions(
+ source.createStringArrayList(),
+ source.readBoolean(),
+ source.readBoolean(),
source.readParcelable(null),
- source.readString());
+ source.readString(),
+ (source.dataAvail() > 0) ? source.readBoolean() : false);
}
@Override
@@ -61,18 +64,25 @@
private final String resolveInstanceName;
private final boolean isPassiveMode;
+ private final boolean onlyUseIpv6OnIpv6OnlyNetworks;
private final boolean removeExpiredService;
// The target network for searching. Null network means search on all possible interfaces.
@Nullable private final Network mNetwork;
/** Parcelable constructs for a {@link MdnsSearchOptions}. */
- MdnsSearchOptions(List<String> subtypes, boolean isPassiveMode, boolean removeExpiredService,
- @Nullable Network network, @Nullable String resolveInstanceName) {
+ MdnsSearchOptions(
+ List<String> subtypes,
+ boolean isPassiveMode,
+ boolean removeExpiredService,
+ @Nullable Network network,
+ @Nullable String resolveInstanceName,
+ boolean onlyUseIpv6OnIpv6OnlyNetworks) {
this.subtypes = new ArrayList<>();
if (subtypes != null) {
this.subtypes.addAll(subtypes);
}
this.isPassiveMode = isPassiveMode;
+ this.onlyUseIpv6OnIpv6OnlyNetworks = onlyUseIpv6OnIpv6OnlyNetworks;
this.removeExpiredService = removeExpiredService;
mNetwork = network;
this.resolveInstanceName = resolveInstanceName;
@@ -104,6 +114,14 @@
return isPassiveMode;
}
+ /**
+ * @return {@code true} if only the IPv4 mDNS host should be queried on network that supports
+ * both IPv6 as well as IPv4. On an IPv6-only network, this is ignored.
+ */
+ public boolean onlyUseIpv6OnIpv6OnlyNetworks() {
+ return onlyUseIpv6OnIpv6OnlyNetworks;
+ }
+
/** Returns {@code true} if service will be removed after its TTL expires. */
public boolean removeExpiredService() {
return removeExpiredService;
@@ -140,12 +158,14 @@
out.writeBoolean(removeExpiredService);
out.writeParcelable(mNetwork, 0);
out.writeString(resolveInstanceName);
+ out.writeBoolean(onlyUseIpv6OnIpv6OnlyNetworks);
}
/** A builder to create {@link MdnsSearchOptions}. */
public static final class Builder {
private final Set<String> subtypes;
private boolean isPassiveMode = true;
+ private boolean onlyUseIpv6OnIpv6OnlyNetworks = false;
private boolean removeExpiredService;
private Network mNetwork;
private String resolveInstanceName;
@@ -190,6 +210,15 @@
}
/**
+ * Sets if only the IPv4 mDNS host should be queried on a network that is both IPv4 & IPv6.
+ * On an IPv6-only network, this is ignored.
+ */
+ public Builder setOnlyUseIpv6OnIpv6OnlyNetworks(boolean onlyUseIpv6OnIpv6OnlyNetworks) {
+ this.onlyUseIpv6OnIpv6OnlyNetworks = onlyUseIpv6OnIpv6OnlyNetworks;
+ return this;
+ }
+
+ /**
* Sets if the service should be removed after TTL.
*
* @param removeExpiredService If set to {@code true}, the service will be removed after TTL
@@ -223,8 +252,13 @@
/** Builds a {@link MdnsSearchOptions} with the arguments supplied to this builder. */
public MdnsSearchOptions build() {
- return new MdnsSearchOptions(new ArrayList<>(subtypes), isPassiveMode,
- removeExpiredService, mNetwork, resolveInstanceName);
+ return new MdnsSearchOptions(
+ new ArrayList<>(subtypes),
+ isPassiveMode,
+ removeExpiredService,
+ mNetwork,
+ resolveInstanceName,
+ onlyUseIpv6OnIpv6OnlyNetworks);
}
}
}
\ No newline at end of file
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java b/service-t/src/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java
index bdc673e..a36eb1b 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java
@@ -198,6 +198,7 @@
final QueryTaskConfig taskConfig = new QueryTaskConfig(
searchOptions.getSubtypes(),
searchOptions.isPassiveMode(),
+ searchOptions.onlyUseIpv6OnIpv6OnlyNetworks(),
currentSessionId,
socketKey);
if (hadReply) {
@@ -220,7 +221,7 @@
final boolean matchesInstanceName = options.getResolveInstanceName() == null
// DNS is case-insensitive, so ignore case in the comparison
|| MdnsUtils.equalsIgnoreDnsCase(options.getResolveInstanceName(),
- response.getServiceInstanceName());
+ response.getServiceInstanceName());
// If discovery is requiring some subtypes, the response must have one that matches a
// requested one.
@@ -427,6 +428,7 @@
private final boolean alwaysAskForUnicastResponse =
MdnsConfigs.alwaysAskForUnicastResponseInEachBurst();
private final boolean usePassiveMode;
+ private final boolean onlyUseIpv6OnIpv6OnlyNetworks;
private final long sessionId;
@VisibleForTesting
int transactionId;
@@ -439,9 +441,13 @@
private boolean isFirstBurst;
@NonNull private final SocketKey socketKey;
- QueryTaskConfig(@NonNull Collection<String> subtypes, boolean usePassiveMode,
- long sessionId, @NonNull SocketKey socketKey) {
+ QueryTaskConfig(@NonNull Collection<String> subtypes,
+ boolean usePassiveMode,
+ boolean onlyUseIpv6OnIpv6OnlyNetworks,
+ long sessionId,
+ @Nullable SocketKey socketKey) {
this.usePassiveMode = usePassiveMode;
+ this.onlyUseIpv6OnIpv6OnlyNetworks = onlyUseIpv6OnIpv6OnlyNetworks;
this.subtypes = new ArrayList<>(subtypes);
this.queriesPerBurst = QUERIES_PER_BURST;
this.burstCounter = 0;
@@ -559,6 +565,7 @@
config.expectUnicastResponse,
config.transactionId,
config.socketKey.getNetwork(),
+ config.onlyUseIpv6OnIpv6OnlyNetworks,
sendDiscoveryQueries,
servicesToResolve,
clock)
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsSocket.java b/service-t/src/com/android/server/connectivity/mdns/MdnsSocket.java
index 5fd1354..cdd9f76 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsSocket.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsSocket.java
@@ -93,6 +93,10 @@
}
for (NetworkInterfaceWrapper networkInterface : networkInterfaces) {
multicastSocket.joinGroup(multicastAddress, networkInterface.getNetworkInterface());
+ if (!isOnIPv6OnlyNetwork) {
+ multicastSocket.joinGroup(
+ MULTICAST_IPV6_ADDRESS, networkInterface.getNetworkInterface());
+ }
}
}
@@ -105,6 +109,10 @@
}
for (NetworkInterfaceWrapper networkInterface : networkInterfaces) {
multicastSocket.leaveGroup(multicastAddress, networkInterface.getNetworkInterface());
+ if (!isOnIPv6OnlyNetwork) {
+ multicastSocket.leaveGroup(
+ MULTICAST_IPV6_ADDRESS, networkInterface.getNetworkInterface());
+ }
}
}
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClient.java b/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClient.java
index 2b6e5d0..9c9812d 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClient.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClient.java
@@ -31,6 +31,9 @@
import java.io.IOException;
import java.net.DatagramPacket;
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.InetSocketAddress;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
@@ -194,39 +197,23 @@
}
}
- /** Sends a mDNS request packet that asks for multicast response. */
- public void sendMulticastPacket(@NonNull DatagramPacket packet) {
- sendMdnsPacket(packet, multicastPacketQueue);
+ @Override
+ public void sendPacketRequestingMulticastResponse(@NonNull DatagramPacket packet,
+ boolean onlyUseIpv6OnIpv6OnlyNetworks) {
+ sendMdnsPacket(packet, multicastPacketQueue, onlyUseIpv6OnIpv6OnlyNetworks);
}
- /** Sends a mDNS request packet that asks for unicast response. */
- public void sendUnicastPacket(DatagramPacket packet) {
+ @Override
+ public void sendPacketRequestingUnicastResponse(@NonNull DatagramPacket packet,
+ boolean onlyUseIpv6OnIpv6OnlyNetworks) {
if (useSeparateSocketForUnicast) {
- sendMdnsPacket(packet, unicastPacketQueue);
+ sendMdnsPacket(packet, unicastPacketQueue, onlyUseIpv6OnIpv6OnlyNetworks);
} else {
- sendMdnsPacket(packet, multicastPacketQueue);
+ sendMdnsPacket(packet, multicastPacketQueue, onlyUseIpv6OnIpv6OnlyNetworks);
}
}
@Override
- public void sendMulticastPacket(@NonNull DatagramPacket packet, @Nullable Network network) {
- if (network != null) {
- throw new IllegalArgumentException("This socket client does not support sending to "
- + "specific networks");
- }
- sendMulticastPacket(packet);
- }
-
- @Override
- public void sendUnicastPacket(@NonNull DatagramPacket packet, @Nullable Network network) {
- if (network != null) {
- throw new IllegalArgumentException("This socket client does not support sending to "
- + "specific networks");
- }
- sendUnicastPacket(packet);
- }
-
- @Override
public void notifyNetworkRequested(
@NonNull MdnsServiceBrowserListener listener,
@Nullable Network network,
@@ -243,11 +230,25 @@
return false;
}
- private void sendMdnsPacket(DatagramPacket packet, Queue<DatagramPacket> packetQueueToUse) {
+ private void sendMdnsPacket(DatagramPacket packet, Queue<DatagramPacket> packetQueueToUse,
+ boolean onlyUseIpv6OnIpv6OnlyNetworks) {
if (shouldStopSocketLoop && !MdnsConfigs.allowAddMdnsPacketAfterDiscoveryStops()) {
LOGGER.w("sendMdnsPacket() is called after discovery already stopped");
return;
}
+
+ final boolean isIpv4 = ((InetSocketAddress) packet.getSocketAddress()).getAddress()
+ instanceof Inet4Address;
+ final boolean isIpv6 = ((InetSocketAddress) packet.getSocketAddress()).getAddress()
+ instanceof Inet6Address;
+ final boolean ipv6Only = multicastSocket != null && multicastSocket.isOnIPv6OnlyNetwork();
+ if (isIpv4 && ipv6Only) {
+ return;
+ }
+ if (isIpv6 && !ipv6Only && onlyUseIpv6OnIpv6OnlyNetworks) {
+ return;
+ }
+
synchronized (packetQueueToUse) {
while (packetQueueToUse.size() >= MdnsConfigs.mdnsPacketQueueMaxSize()) {
packetQueueToUse.remove();
@@ -535,8 +536,4 @@
}
packets.clear();
}
-
- public boolean isOnIPv6OnlyNetwork() {
- return multicastSocket != null && multicastSocket.isOnIPv6OnlyNetwork();
- }
}
\ No newline at end of file
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClientBase.java b/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClientBase.java
index a35925a..5e4a8b5 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClientBase.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClientBase.java
@@ -41,19 +41,15 @@
/**
* Send a mDNS request packet via given network that asks for multicast response.
- *
- * <p>The socket client may use a null network to identify some or all interfaces, in which case
- * passing null sends the packet to these.
*/
- void sendMulticastPacket(@NonNull DatagramPacket packet, @Nullable Network network);
+ void sendPacketRequestingMulticastResponse(@NonNull DatagramPacket packet,
+ boolean onlyUseIpv6OnIpv6OnlyNetworks);
/**
* Send a mDNS request packet via given network that asks for unicast response.
- *
- * <p>The socket client may use a null network to identify some or all interfaces, in which case
- * passing null sends the packet to these.
*/
- void sendUnicastPacket(@NonNull DatagramPacket packet, @Nullable Network network);
+ void sendPacketRequestingUnicastResponse(@NonNull DatagramPacket packet,
+ boolean onlyUseIpv6OnIpv6OnlyNetworks);
/*** Notify that the given network is requested for mdns discovery / resolution */
void notifyNetworkRequested(@NonNull MdnsServiceBrowserListener listener,
@@ -88,4 +84,4 @@
/*** Notify requested socket is destroyed */
void onAllSocketsDestroyed(@NonNull SocketKey socketKey);
}
-}
+}
\ No newline at end of file
diff --git a/service/src/com/android/server/ConnectivityService.java b/service/src/com/android/server/ConnectivityService.java
index 39a500c..53127d1 100755
--- a/service/src/com/android/server/ConnectivityService.java
+++ b/service/src/com/android/server/ConnectivityService.java
@@ -1703,7 +1703,8 @@
mUserAllContext.registerReceiver(mPackageIntentReceiver, packageIntentFilter,
null /* broadcastPermission */, mHandler);
- mNetworkActivityTracker = new LegacyNetworkActivityTracker(mContext, mHandler, mNetd);
+ mNetworkActivityTracker =
+ new LegacyNetworkActivityTracker(mContext, mNetd, mHandler, mDeps.isAtLeastU());
final NetdCallback netdCallback = new NetdCallback();
try {
@@ -5879,7 +5880,8 @@
break;
}
case EVENT_REPORT_NETWORK_ACTIVITY:
- mNetworkActivityTracker.handleReportNetworkActivity();
+ final NetworkActivityParams arg = (NetworkActivityParams) msg.obj;
+ mNetworkActivityTracker.handleReportNetworkActivity(arg);
break;
case EVENT_MOBILE_DATA_PREFERRED_UIDS_CHANGED:
handleMobileDataPreferredUidsChanged();
@@ -11064,11 +11066,34 @@
notifyDataStallSuspected(p, network.getNetId());
}
+ /**
+ * Class to hold the information for network activity change event from idle timers
+ * {@link NetdCallback#onInterfaceClassActivityChanged(boolean, int, long, int)}
+ */
+ private static final class NetworkActivityParams {
+ public final boolean isActive;
+ // Label used for idle timer. Transport type is used as label.
+ // label is int since NMS was using the identifier as int, and it has not been changed
+ public final int label;
+ public final long timestampNs;
+ // Uid represents the uid that was responsible for waking the radio.
+ // -1 for no uid and uid is -1 if isActive is false.
+ public final int uid;
+
+ NetworkActivityParams(boolean isActive, int label, long timestampNs, int uid) {
+ this.isActive = isActive;
+ this.label = label;
+ this.timestampNs = timestampNs;
+ this.uid = uid;
+ }
+ }
+
private class NetdCallback extends BaseNetdUnsolicitedEventListener {
@Override
- public void onInterfaceClassActivityChanged(boolean isActive, int transportType,
+ public void onInterfaceClassActivityChanged(boolean isActive, int label,
long timestampNs, int uid) {
- mNetworkActivityTracker.setAndReportNetworkActive(isActive, transportType, timestampNs);
+ mHandler.sendMessage(mHandler.obtainMessage(EVENT_REPORT_NETWORK_ACTIVITY,
+ new NetworkActivityParams(isActive, label, timestampNs, uid)));
}
@Override
@@ -11096,14 +11121,14 @@
private static final int NO_UID = -1;
private final Context mContext;
private final INetd mNetd;
+ private final Handler mHandler;
private final RemoteCallbackList<INetworkActivityListener> mNetworkActivityListeners =
new RemoteCallbackList<>();
// Indicate the current system default network activity is active or not.
- @GuardedBy("mActiveIdleTimers")
- private boolean mNetworkActive;
- @GuardedBy("mActiveIdleTimers")
+ // This needs to be volatile to allow non handler threads to read this value without lock.
+ private volatile boolean mIsDefaultNetworkActive;
private final ArrayMap<String, IdleTimerParams> mActiveIdleTimers = new ArrayMap<>();
- private final Handler mHandler;
+ private final boolean mIsAtLeastU;
private static class IdleTimerParams {
public final int timeout;
@@ -11115,34 +11140,37 @@
}
}
- LegacyNetworkActivityTracker(@NonNull Context context, @NonNull Handler handler,
- @NonNull INetd netd) {
+ LegacyNetworkActivityTracker(@NonNull Context context, @NonNull INetd netd,
+ @NonNull Handler handler, boolean isAtLeastU) {
mContext = context;
mNetd = netd;
mHandler = handler;
+ mIsAtLeastU = isAtLeastU;
}
- public void setAndReportNetworkActive(boolean active, int transportType, long tsNanos) {
- sendDataActivityBroadcast(transportTypeToLegacyType(transportType), active, tsNanos);
- synchronized (mActiveIdleTimers) {
- mNetworkActive = active;
- // If there are no idle timers, it means that system is not monitoring
- // activity, so the system default network for those default network
- // unspecified apps is always considered active.
- //
- // TODO: If the mActiveIdleTimers is empty, netd will actually not send
- // any network activity change event. Whenever this event is received,
- // the mActiveIdleTimers should be always not empty. The legacy behavior
- // is no-op. Remove to refer to mNetworkActive only.
- if (mNetworkActive || mActiveIdleTimers.isEmpty()) {
- mHandler.sendMessage(mHandler.obtainMessage(EVENT_REPORT_NETWORK_ACTIVITY));
- }
+ private void ensureRunningOnConnectivityServiceThread() {
+ if (mHandler.getLooper().getThread() != Thread.currentThread()) {
+ throw new IllegalStateException("Not running on ConnectivityService thread: "
+ + Thread.currentThread().getName());
}
}
- // The network activity should only be updated from ConnectivityService handler thread
- // when mActiveIdleTimers lock is held.
- @GuardedBy("mActiveIdleTimers")
+ public void handleReportNetworkActivity(NetworkActivityParams activityParams) {
+ ensureRunningOnConnectivityServiceThread();
+ if (mActiveIdleTimers.isEmpty()) {
+ // This activity change is not for the current default network.
+ // This can happen if netd callback post activity change event message but
+ // the default network is lost before processing this message.
+ return;
+ }
+ sendDataActivityBroadcast(transportTypeToLegacyType(activityParams.label),
+ activityParams.isActive, activityParams.timestampNs);
+ mIsDefaultNetworkActive = activityParams.isActive;
+ if (mIsDefaultNetworkActive) {
+ reportNetworkActive();
+ }
+ }
+
private void reportNetworkActive() {
final int length = mNetworkActivityListeners.beginBroadcast();
if (DDBG) log("reportNetworkActive, notify " + length + " listeners");
@@ -11159,13 +11187,6 @@
}
}
- @GuardedBy("mActiveIdleTimers")
- public void handleReportNetworkActivity() {
- synchronized (mActiveIdleTimers) {
- reportNetworkActive();
- }
- }
-
// This is deprecated and only to support legacy use cases.
private int transportTypeToLegacyType(int type) {
switch (type) {
@@ -11207,8 +11228,10 @@
*
* Every {@code setupDataActivityTracking} should be paired with a
* {@link #removeDataActivityTracking} for cleanup.
+ *
+ * @return true if the idleTimer is added to the network, false otherwise
*/
- private void setupDataActivityTracking(NetworkAgentInfo networkAgent) {
+ private boolean setupDataActivityTracking(NetworkAgentInfo networkAgent) {
final String iface = networkAgent.linkProperties.getInterfaceName();
final int timeout;
@@ -11227,25 +11250,22 @@
15);
type = NetworkCapabilities.TRANSPORT_WIFI;
} else {
- return; // do not track any other networks
+ return false; // do not track any other networks
}
updateRadioPowerState(true /* isActive */, type);
if (timeout > 0 && iface != null) {
try {
- synchronized (mActiveIdleTimers) {
- // Networks start up.
- mNetworkActive = true;
- mActiveIdleTimers.put(iface, new IdleTimerParams(timeout, type));
- mNetd.idletimerAddInterface(iface, timeout, Integer.toString(type));
- reportNetworkActive();
- }
+ mActiveIdleTimers.put(iface, new IdleTimerParams(timeout, type));
+ mNetd.idletimerAddInterface(iface, timeout, Integer.toString(type));
+ return true;
} catch (Exception e) {
// You shall not crash!
loge("Exception in setupDataActivityTracking " + e);
}
}
+ return false;
}
/**
@@ -11268,26 +11288,45 @@
try {
updateRadioPowerState(false /* isActive */, type);
- synchronized (mActiveIdleTimers) {
- final IdleTimerParams params = mActiveIdleTimers.remove(iface);
- // The call fails silently if no idle timer setup for this interface
- mNetd.idletimerRemoveInterface(iface, params.timeout,
- Integer.toString(params.transportType));
+ final IdleTimerParams params = mActiveIdleTimers.remove(iface);
+ if (params == null) {
+ // IdleTimer is not added if the configured timeout is 0 or negative value
+ return;
}
+ // The call fails silently if no idle timer setup for this interface
+ mNetd.idletimerRemoveInterface(iface, params.timeout,
+ Integer.toString(params.transportType));
} catch (Exception e) {
// You shall not crash!
loge("Exception in removeDataActivityTracking " + e);
}
}
+ private void updateDefaultNetworkActivity(NetworkAgentInfo defaultNetwork,
+ boolean hasIdleTimer) {
+ if (defaultNetwork != null) {
+ mIsDefaultNetworkActive = true;
+ // On T-, callbacks are called only when the network has the idle timer.
+ if (mIsAtLeastU || hasIdleTimer) {
+ reportNetworkActive();
+ }
+ } else {
+ // If there is no default network, default network is considered inactive.
+ mIsDefaultNetworkActive = false;
+ }
+ }
+
/**
* Update data activity tracking when network state is updated.
*/
public void updateDataActivityTracking(NetworkAgentInfo newNetwork,
NetworkAgentInfo oldNetwork) {
+ ensureRunningOnConnectivityServiceThread();
+ boolean hasIdleTimer = false;
if (newNetwork != null) {
- setupDataActivityTracking(newNetwork);
+ hasIdleTimer = setupDataActivityTracking(newNetwork);
}
+ updateDefaultNetworkActivity(newNetwork, hasIdleTimer);
if (oldNetwork != null) {
removeDataActivityTracking(oldNetwork);
}
@@ -11308,15 +11347,7 @@
}
public boolean isDefaultNetworkActive() {
- synchronized (mActiveIdleTimers) {
- // If there are no idle timers, it means that system is not monitoring activity,
- // so the default network is always considered active.
- //
- // TODO : Distinguish between the cases where mActiveIdleTimers is empty because
- // tracking is disabled (negative idle timer value configured), or no active default
- // network. In the latter case, this reports active but it should report inactive.
- return mNetworkActive || mActiveIdleTimers.isEmpty();
- }
+ return mIsDefaultNetworkActive;
}
public void registerNetworkActivityListener(@NonNull INetworkActivityListener l) {
@@ -11328,15 +11359,22 @@
}
public void dump(IndentingPrintWriter pw) {
- synchronized (mActiveIdleTimers) {
- pw.print("mNetworkActive="); pw.println(mNetworkActive);
- pw.println("Idle timers:");
- for (HashMap.Entry<String, IdleTimerParams> ent : mActiveIdleTimers.entrySet()) {
+ pw.print("mIsDefaultNetworkActive="); pw.println(mIsDefaultNetworkActive);
+ pw.println("Idle timers:");
+ try {
+ for (Map.Entry<String, IdleTimerParams> ent : mActiveIdleTimers.entrySet()) {
pw.print(" "); pw.print(ent.getKey()); pw.println(":");
final IdleTimerParams params = ent.getValue();
pw.print(" timeout="); pw.print(params.timeout);
pw.print(" type="); pw.println(params.transportType);
}
+ } catch (Exception e) {
+ // mActiveIdleTimers should only be accessed from handler thread, except dump().
+ // As dump() is never called in normal usage, it would be needlessly expensive
+ // to lock the collection only for its benefit.
+ // Also, mActiveIdleTimers is not expected to be updated frequently.
+ // So catching the exception and logging.
+ pw.println("Failed to dump NetworkActivityTracker: " + e);
}
}
}
diff --git a/service/src/com/android/server/connectivity/ClatCoordinator.java b/service/src/com/android/server/connectivity/ClatCoordinator.java
index d87f250..eb3e7ce 100644
--- a/service/src/com/android/server/connectivity/ClatCoordinator.java
+++ b/service/src/com/android/server/connectivity/ClatCoordinator.java
@@ -37,9 +37,10 @@
import android.system.ErrnoException;
import android.util.Log;
+import androidx.annotation.RequiresApi;
+
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.IndentingPrintWriter;
-import com.android.modules.utils.build.SdkLevel;
import com.android.net.module.util.BpfMap;
import com.android.net.module.util.IBpfMap;
import com.android.net.module.util.InterfaceParams;
@@ -59,8 +60,6 @@
import java.nio.ByteBuffer;
import java.util.Objects;
-import androidx.annotation.RequiresApi;
-
/**
* This coordinator is responsible for providing clat relevant functionality.
*
diff --git a/service/src/com/android/server/connectivity/KeepaliveTracker.java b/service/src/com/android/server/connectivity/KeepaliveTracker.java
index 1378293..76e97e2 100644
--- a/service/src/com/android/server/connectivity/KeepaliveTracker.java
+++ b/service/src/com/android/server/connectivity/KeepaliveTracker.java
@@ -104,19 +104,21 @@
// Allowed unprivileged keepalive slots per uid. Caller's permission will be enforced if
// the number of remaining keepalive slots is less than or equal to the threshold.
private final int mAllowedUnprivilegedSlotsForUid;
-
+ private final Dependencies mDependencies;
public KeepaliveTracker(Context context, Handler handler) {
- this(context, handler, new TcpKeepaliveController(handler));
+ this(context, handler, new TcpKeepaliveController(handler), new Dependencies());
}
@VisibleForTesting
- KeepaliveTracker(Context context, Handler handler, TcpKeepaliveController tcpController) {
+ KeepaliveTracker(Context context, Handler handler, TcpKeepaliveController tcpController,
+ Dependencies deps) {
mTcpController = tcpController;
mContext = context;
+ mDependencies = deps;
- mSupportedKeepalives = KeepaliveResourceUtil.getSupportedKeepalives(context);
+ mSupportedKeepalives = mDependencies.getSupportedKeepalives(mContext);
- final ConnectivityResources res = new ConnectivityResources(mContext);
+ final ConnectivityResources res = mDependencies.createConnectivityResources(mContext);
mReservedPrivilegedSlots = res.get().getInteger(
R.integer.config_reservedPrivilegedKeepaliveSlots);
mAllowedUnprivilegedSlotsForUid = res.get().getInteger(
@@ -752,6 +754,7 @@
srcAddress = InetAddresses.parseNumericAddress(srcAddrString);
dstAddress = InetAddresses.parseNumericAddress(dstAddrString);
} catch (IllegalArgumentException e) {
+ Log.e(TAG, "Fail to construct address", e);
notifyErrorCallback(cb, ERROR_INVALID_IP_ADDRESS);
return null;
}
@@ -761,6 +764,7 @@
packet = NattKeepalivePacketData.nattKeepalivePacket(
srcAddress, srcPort, dstAddress, NATT_PORT);
} catch (InvalidPacketException e) {
+ Log.e(TAG, "Fail to construct keepalive packet", e);
notifyErrorCallback(cb, e.getError());
return null;
}
@@ -893,4 +897,31 @@
}
pw.decreaseIndent();
}
+
+ /**
+ * Dependencies class for testing.
+ */
+ @VisibleForTesting
+ public static class Dependencies {
+ /**
+ * Read supported keepalive count for each transport type from overlay resource. This should
+ * be used to create a local variable store of resource customization, and set as the
+ * input for {@link getSupportedKeepalivesForNetworkCapabilities}.
+ *
+ * @param context The context to read resource from.
+ * @return An array of supported keepalive count for each transport type.
+ */
+ @NonNull
+ public int[] getSupportedKeepalives(@NonNull Context context) {
+ return KeepaliveResourceUtil.getSupportedKeepalives(context);
+ }
+
+ /**
+ * Create a new {@link ConnectivityResources}.
+ */
+ @NonNull
+ public ConnectivityResources createConnectivityResources(@NonNull Context context) {
+ return new ConnectivityResources(context);
+ }
+ }
}
diff --git a/tests/cts/hostside/app/src/com/android/cts/net/hostside/VpnTest.java b/tests/cts/hostside/app/src/com/android/cts/net/hostside/VpnTest.java
index 73a6502..cd3b650 100755
--- a/tests/cts/hostside/app/src/com/android/cts/net/hostside/VpnTest.java
+++ b/tests/cts/hostside/app/src/com/android/cts/net/hostside/VpnTest.java
@@ -1175,8 +1175,8 @@
final String origMode = runWithShellPermissionIdentity(() -> {
final String mode = DeviceConfig.getProperty(
- DeviceConfig.NAMESPACE_CONNECTIVITY, AUTOMATIC_ON_OFF_KEEPALIVE_VERSION);
- DeviceConfig.setProperty(DeviceConfig.NAMESPACE_CONNECTIVITY,
+ DeviceConfig.NAMESPACE_TETHERING, AUTOMATIC_ON_OFF_KEEPALIVE_VERSION);
+ DeviceConfig.setProperty(DeviceConfig.NAMESPACE_TETHERING,
AUTOMATIC_ON_OFF_KEEPALIVE_VERSION,
AUTOMATIC_ON_OFF_KEEPALIVE_ENABLED, false /* makeDefault */);
return mode;
@@ -1216,7 +1216,7 @@
runWithShellPermissionIdentity(() -> {
DeviceConfig.setProperty(
- DeviceConfig.NAMESPACE_CONNECTIVITY,
+ DeviceConfig.NAMESPACE_TETHERING,
AUTOMATIC_ON_OFF_KEEPALIVE_VERSION,
origMode, false);
mCM.setTestLowTcpPollingTimerForKeepalive(0);
diff --git a/tests/cts/hostside/src/com/android/cts/net/ProcNetTest.java b/tests/cts/hostside/src/com/android/cts/net/ProcNetTest.java
index 1a528b1..ff06a90 100644
--- a/tests/cts/hostside/src/com/android/cts/net/ProcNetTest.java
+++ b/tests/cts/hostside/src/com/android/cts/net/ProcNetTest.java
@@ -157,13 +157,13 @@
for (String interfaceDir : mSysctlDirs) {
String path = IPV6_SYSCTL_DIR + "/" + interfaceDir + "/" + "router_solicitations";
int value = readIntFromPath(path);
- assertEquals(IPV6_WIFI_ROUTER_SOLICITATIONS, value);
+ assertEquals(path, IPV6_WIFI_ROUTER_SOLICITATIONS, value);
path = IPV6_SYSCTL_DIR + "/" + interfaceDir + "/" + "router_solicitation_max_interval";
int interval = readIntFromPath(path);
final int lowerBoundSec = 15 * 60;
final int upperBoundSec = 60 * 60;
- assertTrue(lowerBoundSec <= interval);
- assertTrue(interval <= upperBoundSec);
+ assertTrue(path, lowerBoundSec <= interval);
+ assertTrue(path, interval <= upperBoundSec);
}
}
diff --git a/tests/cts/net/Android.bp b/tests/cts/net/Android.bp
index 51ee074..1276d59 100644
--- a/tests/cts/net/Android.bp
+++ b/tests/cts/net/Android.bp
@@ -92,7 +92,7 @@
"NetworkStackApiStableShims",
],
jni_uses_sdk_apis: true,
- min_sdk_version: "29",
+ min_sdk_version: "30",
}
// Networking CTS tests that target the latest released SDK. These tests can be installed on release
diff --git a/tests/cts/net/jni/Android.bp b/tests/cts/net/jni/Android.bp
index 8f0d78f..a421349 100644
--- a/tests/cts/net/jni/Android.bp
+++ b/tests/cts/net/jni/Android.bp
@@ -31,9 +31,9 @@
"liblog",
],
stl: "libc++_static",
- // To be compatible with Q devices, the min_sdk_version must be 29.
+ // To be compatible with R devices, the min_sdk_version must be 30.
sdk_version: "current",
- min_sdk_version: "29",
+ min_sdk_version: "30",
}
cc_library_shared {
diff --git a/tests/cts/net/native/dns/Android.bp b/tests/cts/net/native/dns/Android.bp
index 49b9337..2469710 100644
--- a/tests/cts/net/native/dns/Android.bp
+++ b/tests/cts/net/native/dns/Android.bp
@@ -28,8 +28,8 @@
"libbase",
"libnetdutils",
],
- // To be compatible with Q devices, the min_sdk_version must be 29.
- min_sdk_version: "29",
+ // To be compatible with R devices, the min_sdk_version must be 30.
+ min_sdk_version: "30",
}
cc_test {
diff --git a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
index 1411a37..03e74e0 100644
--- a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
+++ b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
@@ -2560,9 +2560,10 @@
assertThrows(SecurityException.class, () -> mCm.factoryReset());
}
- @AppModeFull(reason = "Cannot get WifiManager in instant app mode")
- @Test
- public void testFactoryReset() throws Exception {
+ // @AppModeFull(reason = "Cannot get WifiManager in instant app mode")
+ // @Test
+ // Temporarily disable the unreliable test, which is blocked by b/254183718.
+ private void testFactoryReset() throws Exception {
assumeTrue(TestUtils.shouldTestSApis());
// Store current settings.
diff --git a/tests/mts/Android.bp b/tests/mts/Android.bp
index 74fee3d..6425223 100644
--- a/tests/mts/Android.bp
+++ b/tests/mts/Android.bp
@@ -38,5 +38,5 @@
"bpf_existence_test.cpp",
],
compile_multilib: "first",
- min_sdk_version: "29", // Ensure test runs on Q and above.
+ min_sdk_version: "30", // Ensure test runs on R and above.
}
diff --git a/tests/unit/java/com/android/server/ConnectivityServiceTest.java b/tests/unit/java/com/android/server/ConnectivityServiceTest.java
index 644910c..8de6a31 100755
--- a/tests/unit/java/com/android/server/ConnectivityServiceTest.java
+++ b/tests/unit/java/com/android/server/ConnectivityServiceTest.java
@@ -46,14 +46,18 @@
import static android.content.pm.PackageManager.PERMISSION_DENIED;
import static android.content.pm.PackageManager.PERMISSION_GRANTED;
import static android.net.ConnectivityManager.ACTION_CAPTIVE_PORTAL_SIGN_IN;
+import static android.net.ConnectivityManager.ACTION_DATA_ACTIVITY_CHANGE;
import static android.net.ConnectivityManager.BLOCKED_METERED_REASON_DATA_SAVER;
import static android.net.ConnectivityManager.BLOCKED_METERED_REASON_MASK;
import static android.net.ConnectivityManager.BLOCKED_METERED_REASON_USER_RESTRICTED;
import static android.net.ConnectivityManager.BLOCKED_REASON_BATTERY_SAVER;
import static android.net.ConnectivityManager.BLOCKED_REASON_NONE;
import static android.net.ConnectivityManager.CONNECTIVITY_ACTION;
+import static android.net.ConnectivityManager.EXTRA_DEVICE_TYPE;
+import static android.net.ConnectivityManager.EXTRA_IS_ACTIVE;
import static android.net.ConnectivityManager.EXTRA_NETWORK_INFO;
import static android.net.ConnectivityManager.EXTRA_NETWORK_TYPE;
+import static android.net.ConnectivityManager.EXTRA_REALTIME_NS;
import static android.net.ConnectivityManager.FIREWALL_CHAIN_DOZABLE;
import static android.net.ConnectivityManager.FIREWALL_CHAIN_LOW_POWER_STANDBY;
import static android.net.ConnectivityManager.FIREWALL_CHAIN_OEM_DENY_1;
@@ -161,6 +165,7 @@
import static com.android.server.ConnectivityServiceTestUtils.transportToLegacyType;
import static com.android.server.NetworkAgentWrapper.CallbackType.OnQosCallbackRegister;
import static com.android.server.NetworkAgentWrapper.CallbackType.OnQosCallbackUnregister;
+import static com.android.testutils.Cleanup.testAndCleanup;
import static com.android.testutils.ConcurrentUtils.await;
import static com.android.testutils.ConcurrentUtils.durationOf;
import static com.android.testutils.DevSdkIgnoreRule.IgnoreAfter;
@@ -379,6 +384,7 @@
import com.android.internal.util.test.BroadcastInterceptingContext;
import com.android.internal.util.test.FakeSettingsProvider;
import com.android.net.module.util.ArrayTrackRecord;
+import com.android.net.module.util.BaseNetdUnsolicitedEventListener;
import com.android.net.module.util.CollectionUtils;
import com.android.net.module.util.LocationPermissionChecker;
import com.android.net.module.util.NetworkMonitorUtils;
@@ -537,10 +543,12 @@
private static final String WIFI_IFNAME = "test_wlan0";
private static final String WIFI_WOL_IFNAME = "test_wlan_wol";
private static final String VPN_IFNAME = "tun10042";
+ private static final String ETHERNET_IFNAME = "eth0";
private static final String TEST_PACKAGE_NAME = "com.android.test.package";
private static final int TEST_PACKAGE_UID = 123;
private static final int TEST_PACKAGE_UID2 = 321;
private static final int TEST_PACKAGE_UID3 = 456;
+ private static final int NETWORK_ACTIVITY_NO_UID = -1;
private static final int PACKET_WAKEUP_MARK_MASK = 0x80000000;
@@ -888,6 +896,25 @@
}
super.sendStickyBroadcast(intent, options);
}
+
+ private final ArrayTrackRecord<Intent>.ReadHead mOrderedBroadcastAsUserHistory =
+ new ArrayTrackRecord<Intent>().newReadHead();
+
+ public void expectDataActivityBroadcast(int deviceType, boolean isActive, long tsNanos) {
+ assertNotNull(mOrderedBroadcastAsUserHistory.poll(BROADCAST_TIMEOUT_MS,
+ intent -> intent.getAction().equals(ACTION_DATA_ACTIVITY_CHANGE)
+ && intent.getIntExtra(EXTRA_DEVICE_TYPE, -1) == deviceType
+ && intent.getBooleanExtra(EXTRA_IS_ACTIVE, !isActive) == isActive
+ && intent.getLongExtra(EXTRA_REALTIME_NS, -1) == tsNanos
+ ));
+ }
+
+ @Override
+ public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user,
+ String receiverPermission, BroadcastReceiver resultReceiver,
+ Handler scheduler, int initialCode, String initialData, Bundle initialExtras) {
+ mOrderedBroadcastAsUserHistory.add(intent);
+ }
}
// This was only added in the T SDK, but this test needs to build against the R+S SDKs, too.
@@ -11186,6 +11213,127 @@
assertTrue("Nat464Xlat was not IDLE", !clat.isStarted());
}
+ final String transportToTestIfaceName(int transport) {
+ switch (transport) {
+ case TRANSPORT_WIFI:
+ return WIFI_IFNAME;
+ case TRANSPORT_CELLULAR:
+ return MOBILE_IFNAME;
+ case TRANSPORT_ETHERNET:
+ return ETHERNET_IFNAME;
+ default:
+ throw new AssertionError("Unsupported transport type");
+ }
+ }
+
+ private void doTestInterfaceClassActivityChanged(final int transportType) throws Exception {
+ final int legacyType = transportToLegacyType(transportType);
+ final LinkProperties lp = new LinkProperties();
+ lp.setInterfaceName(transportToTestIfaceName(transportType));
+ final TestNetworkAgentWrapper agent = new TestNetworkAgentWrapper(transportType, lp);
+
+ final ConditionVariable onNetworkActiveCv = new ConditionVariable();
+ final ConnectivityManager.OnNetworkActiveListener listener = onNetworkActiveCv::open;
+
+ testAndCleanup(() -> {
+ agent.connect(true);
+
+ // Network is considered active when the network becomes the default network.
+ assertTrue(mCm.isDefaultNetworkActive());
+
+ mCm.addDefaultNetworkActiveListener(listener);
+
+ ArgumentCaptor<BaseNetdUnsolicitedEventListener> netdCallbackCaptor =
+ ArgumentCaptor.forClass(BaseNetdUnsolicitedEventListener.class);
+ verify(mMockNetd).registerUnsolicitedEventListener(netdCallbackCaptor.capture());
+
+ // Interface goes to inactive state
+ netdCallbackCaptor.getValue().onInterfaceClassActivityChanged(false /* isActive */,
+ transportType, TIMESTAMP, NETWORK_ACTIVITY_NO_UID);
+ mServiceContext.expectDataActivityBroadcast(legacyType, false /* isActive */,
+ TIMESTAMP);
+ assertFalse(onNetworkActiveCv.block(TEST_CALLBACK_TIMEOUT_MS));
+ assertFalse(mCm.isDefaultNetworkActive());
+
+ // Interface goes to active state
+ netdCallbackCaptor.getValue().onInterfaceClassActivityChanged(true /* isActive */,
+ transportType, TIMESTAMP, TEST_PACKAGE_UID);
+ mServiceContext.expectDataActivityBroadcast(legacyType, true /* isActive */, TIMESTAMP);
+ assertTrue(onNetworkActiveCv.block(TEST_CALLBACK_TIMEOUT_MS));
+ assertTrue(mCm.isDefaultNetworkActive());
+ }, () -> { // Cleanup
+ mCm.removeDefaultNetworkActiveListener(listener);
+ }, () -> { // Cleanup
+ agent.disconnect();
+ });
+ }
+
+ @Test
+ public void testInterfaceClassActivityChangedWifi() throws Exception {
+ doTestInterfaceClassActivityChanged(TRANSPORT_WIFI);
+ }
+
+ @Test
+ public void testInterfaceClassActivityChangedCellular() throws Exception {
+ doTestInterfaceClassActivityChanged(TRANSPORT_CELLULAR);
+ }
+
+ private void doTestOnNetworkActive_NewNetworkConnects(int transportType, boolean expectCallback)
+ throws Exception {
+ final ConditionVariable onNetworkActiveCv = new ConditionVariable();
+ final ConnectivityManager.OnNetworkActiveListener listener = onNetworkActiveCv::open;
+
+ final LinkProperties lp = new LinkProperties();
+ lp.setInterfaceName(transportToTestIfaceName(transportType));
+ final TestNetworkAgentWrapper agent = new TestNetworkAgentWrapper(transportType, lp);
+
+ testAndCleanup(() -> {
+ mCm.addDefaultNetworkActiveListener(listener);
+ agent.connect(true);
+ if (expectCallback) {
+ assertTrue(onNetworkActiveCv.block(TEST_CALLBACK_TIMEOUT_MS));
+ } else {
+ assertFalse(onNetworkActiveCv.block(TEST_CALLBACK_TIMEOUT_MS));
+ }
+ assertTrue(mCm.isDefaultNetworkActive());
+ }, () -> { // Cleanup
+ mCm.removeDefaultNetworkActiveListener(listener);
+ }, () -> { // Cleanup
+ agent.disconnect();
+ });
+ }
+
+ @Test
+ public void testOnNetworkActive_NewCellConnects_CallbackCalled() throws Exception {
+ doTestOnNetworkActive_NewNetworkConnects(TRANSPORT_CELLULAR, true /* expectCallback */);
+ }
+
+ @Test
+ public void testOnNetworkActive_NewEthernetConnects_Callback() throws Exception {
+ // On T-, LegacyNetworkActivityTracker calls onNetworkActive callback only for networks that
+ // tracker adds the idle timer to. And the tracker does not set the idle timer for the
+ // ethernet network.
+ // So onNetworkActive is not called when the ethernet becomes the default network
+ doTestOnNetworkActive_NewNetworkConnects(TRANSPORT_ETHERNET, mDeps.isAtLeastU());
+ }
+
+ @Test
+ public void testIsDefaultNetworkActiveNoDefaultNetwork() throws Exception {
+ assertFalse(mCm.isDefaultNetworkActive());
+
+ final LinkProperties cellLp = new LinkProperties();
+ cellLp.setInterfaceName(MOBILE_IFNAME);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(true);
+ // Network is considered active when the network becomes the default network.
+ assertTrue(mCm.isDefaultNetworkActive());
+
+ mCellAgent.disconnect();
+ waitForIdle();
+
+ assertFalse(mCm.isDefaultNetworkActive());
+ }
+
@Test
public void testDataActivityTracking() throws Exception {
final TestNetworkCallback networkCallback = new TestNetworkCallback();
diff --git a/tests/unit/java/com/android/server/connectivity/AutomaticOnOffKeepaliveTrackerTest.java b/tests/unit/java/com/android/server/connectivity/AutomaticOnOffKeepaliveTrackerTest.java
index 0b20227..9e604e3 100644
--- a/tests/unit/java/com/android/server/connectivity/AutomaticOnOffKeepaliveTrackerTest.java
+++ b/tests/unit/java/com/android/server/connectivity/AutomaticOnOffKeepaliveTrackerTest.java
@@ -265,7 +265,7 @@
TestKeepaliveTracker(@NonNull final Context context, @NonNull final Handler handler,
@NonNull final TcpKeepaliveController tcpController) {
- super(context, handler, tcpController);
+ super(context, handler, tcpController, new Dependencies());
}
public void setReturnedKeepaliveInfo(@NonNull final KeepaliveInfo ki) {
diff --git a/tests/unit/java/com/android/server/connectivity/VpnTest.java b/tests/unit/java/com/android/server/connectivity/VpnTest.java
index 2d2819c..dc50773 100644
--- a/tests/unit/java/com/android/server/connectivity/VpnTest.java
+++ b/tests/unit/java/com/android/server/connectivity/VpnTest.java
@@ -80,6 +80,7 @@
import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
@@ -807,6 +808,32 @@
}
@Test
+ public void testPrepare_legacyVpnWithoutControlVpn()
+ throws Exception {
+ doThrow(new SecurityException("no CONTROL_VPN")).when(mContext)
+ .enforceCallingOrSelfPermission(eq(CONTROL_VPN), any());
+ final Vpn vpn = createVpn();
+ assertThrows(SecurityException.class,
+ () -> vpn.prepare(null, VpnConfig.LEGACY_VPN, VpnManager.TYPE_VPN_SERVICE));
+
+ // CONTROL_VPN can be held by the caller or another system server process - both are
+ // allowed. Just checking for `enforceCallingPermission` may not be sufficient.
+ verify(mContext, never()).enforceCallingPermission(eq(CONTROL_VPN), any());
+ }
+
+ @Test
+ public void testPrepare_legacyVpnWithControlVpn()
+ throws Exception {
+ doNothing().when(mContext).enforceCallingOrSelfPermission(eq(CONTROL_VPN), any());
+ final Vpn vpn = createVpn();
+ assertTrue(vpn.prepare(null, VpnConfig.LEGACY_VPN, VpnManager.TYPE_VPN_SERVICE));
+
+ // CONTROL_VPN can be held by the caller or another system server process - both are
+ // allowed. Just checking for `enforceCallingPermission` may not be sufficient.
+ verify(mContext, never()).enforceCallingPermission(eq(CONTROL_VPN), any());
+ }
+
+ @Test
public void testIsAlwaysOnPackageSupported() throws Exception {
final Vpn vpn = createVpn(PRIMARY_USER.id);
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClientTest.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClientTest.java
index f7ef077..b812fa6 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClientTest.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClientTest.java
@@ -138,18 +138,38 @@
verify(mSocketCreationCallback).onSocketCreated(tetherSocketKey2);
// Send packet to IPv4 with target network and verify sending has been called.
- mSocketClient.sendMulticastPacket(ipv4Packet, mNetwork);
+ mSocketClient.sendPacketRequestingMulticastResponse(ipv4Packet, mNetwork,
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
verify(mSocket).send(ipv4Packet);
verify(tetherIfaceSock1, never()).send(any());
verify(tetherIfaceSock2, never()).send(any());
+ // Send packet to IPv4 with onlyUseIpv6OnIpv6OnlyNetworks = true, the packet will be sent.
+ mSocketClient.sendPacketRequestingMulticastResponse(ipv4Packet, mNetwork,
+ true /* onlyUseIpv6OnIpv6OnlyNetworks */);
+ HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
+ verify(mSocket, times(2)).send(ipv4Packet);
+ verify(tetherIfaceSock1, never()).send(any());
+ verify(tetherIfaceSock2, never()).send(any());
+
// Send packet to IPv6 without target network and verify sending has been called.
- mSocketClient.sendMulticastPacket(ipv6Packet, null);
+ mSocketClient.sendPacketRequestingMulticastResponse(ipv6Packet, null,
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
verify(mSocket, never()).send(ipv6Packet);
verify(tetherIfaceSock1).send(ipv6Packet);
verify(tetherIfaceSock2).send(ipv6Packet);
+
+ // Send packet to IPv6 with onlyUseIpv6OnIpv6OnlyNetworks = true, the packet will not be
+ // sent. Therefore, the tetherIfaceSock1.send() and tetherIfaceSock2.send() are still be
+ // called once.
+ mSocketClient.sendPacketRequestingMulticastResponse(ipv6Packet, null,
+ true /* onlyUseIpv6OnIpv6OnlyNetworks */);
+ HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
+ verify(mSocket, never()).send(ipv6Packet);
+ verify(tetherIfaceSock1, times(1)).send(ipv6Packet);
+ verify(tetherIfaceSock2, times(1)).send(ipv6Packet);
}
@Test
@@ -230,7 +250,8 @@
verify(mSocketCreationCallback).onSocketCreated(socketKey3);
// Send IPv4 packet on the non-null Network and verify sending has been called.
- mSocketClient.sendMulticastPacket(ipv4Packet, mNetwork);
+ mSocketClient.sendPacketRequestingMulticastResponse(ipv4Packet, mNetwork,
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
verify(mSocket).send(ipv4Packet);
verify(socket2, never()).send(any());
@@ -258,7 +279,8 @@
verify(socketCreationCb2).onSocketCreated(socketKey3);
// Send IPv4 packet to null network and verify sending to the 2 tethered interface sockets.
- mSocketClient.sendMulticastPacket(ipv4Packet, null);
+ mSocketClient.sendPacketRequestingMulticastResponse(ipv4Packet, null,
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
// ipv4Packet still sent only once on mSocket: times(1) matches the packet sent earlier on
// mNetwork
@@ -271,7 +293,8 @@
verify(mProvider, timeout(DEFAULT_TIMEOUT)).unrequestSocket(callback2);
// Send IPv4 packet again and verify it's still sent a second time
- mSocketClient.sendMulticastPacket(ipv4Packet, null);
+ mSocketClient.sendPacketRequestingMulticastResponse(ipv4Packet, null,
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
verify(socket2, times(2)).send(ipv4Packet);
verify(socket3, times(2)).send(ipv4Packet);
@@ -281,7 +304,8 @@
verify(mProvider, timeout(DEFAULT_TIMEOUT)).unrequestSocket(callback);
// Send IPv4 packet and verify no more sending.
- mSocketClient.sendMulticastPacket(ipv4Packet, null);
+ mSocketClient.sendPacketRequestingMulticastResponse(ipv4Packet, null,
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
verify(mSocket, times(1)).send(ipv4Packet);
verify(socket2, times(2)).send(ipv4Packet);
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceTypeClientTests.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceTypeClientTests.java
index 635a1d4..9892e9f 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceTypeClientTests.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceTypeClientTests.java
@@ -327,7 +327,8 @@
MdnsSearchOptions searchOptions =
MdnsSearchOptions.newBuilder().addSubtype("12345").setIsPassiveMode(false).build();
QueryTaskConfig config = new QueryTaskConfig(
- searchOptions.getSubtypes(), searchOptions.isPassiveMode(), 1, socketKey);
+ searchOptions.getSubtypes(), searchOptions.isPassiveMode(),
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */, 1, socketKey);
// This is the first query. We will ask for unicast response.
assertTrue(config.expectUnicastResponse);
@@ -356,7 +357,8 @@
MdnsSearchOptions searchOptions =
MdnsSearchOptions.newBuilder().addSubtype("12345").setIsPassiveMode(false).build();
QueryTaskConfig config = new QueryTaskConfig(
- searchOptions.getSubtypes(), searchOptions.isPassiveMode(), 1, socketKey);
+ searchOptions.getSubtypes(), searchOptions.isPassiveMode(),
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */, 1, socketKey);
// This is the first query. We will ask for unicast response.
assertTrue(config.expectUnicastResponse);
@@ -928,16 +930,16 @@
ArgumentCaptor.forClass(DatagramPacket.class);
currentThreadExecutor.getAndClearLastScheduledRunnable().run();
// Send twice for IPv4 and IPv6
- inOrder.verify(mockSocketClient, times(2)).sendUnicastPacket(srvTxtQueryCaptor.capture(),
- eq(mockNetwork));
+ inOrder.verify(mockSocketClient, times(2)).sendPacketRequestingUnicastResponse(
+ srvTxtQueryCaptor.capture(),
+ eq(mockNetwork), eq(false));
final MdnsPacket srvTxtQueryPacket = MdnsPacket.parse(
new MdnsPacketReader(srvTxtQueryCaptor.getValue()));
final String[] serviceName = getTestServiceName(instanceName);
assertFalse(hasQuestion(srvTxtQueryPacket, MdnsRecord.TYPE_PTR));
- assertTrue(hasQuestion(srvTxtQueryPacket, MdnsRecord.TYPE_SRV, serviceName));
- assertTrue(hasQuestion(srvTxtQueryPacket, MdnsRecord.TYPE_TXT, serviceName));
+ assertTrue(hasQuestion(srvTxtQueryPacket, MdnsRecord.TYPE_ANY, serviceName));
// Process a response with SRV+TXT
final MdnsPacket srvTxtResponse = new MdnsPacket(
@@ -959,8 +961,9 @@
final ArgumentCaptor<DatagramPacket> addressQueryCaptor =
ArgumentCaptor.forClass(DatagramPacket.class);
currentThreadExecutor.getAndClearLastScheduledRunnable().run();
- inOrder.verify(mockSocketClient, times(2)).sendMulticastPacket(addressQueryCaptor.capture(),
- eq(mockNetwork));
+ inOrder.verify(mockSocketClient, times(2)).sendPacketRequestingMulticastResponse(
+ addressQueryCaptor.capture(),
+ eq(mockNetwork), eq(false));
final MdnsPacket addressQueryPacket = MdnsPacket.parse(
new MdnsPacketReader(addressQueryCaptor.getValue()));
@@ -1018,15 +1021,15 @@
ArgumentCaptor.forClass(DatagramPacket.class);
currentThreadExecutor.getAndClearLastScheduledRunnable().run();
// Send twice for IPv4 and IPv6
- inOrder.verify(mockSocketClient, times(2)).sendUnicastPacket(srvTxtQueryCaptor.capture(),
- eq(mockNetwork));
+ inOrder.verify(mockSocketClient, times(2)).sendPacketRequestingUnicastResponse(
+ srvTxtQueryCaptor.capture(),
+ eq(mockNetwork), eq(false));
final MdnsPacket srvTxtQueryPacket = MdnsPacket.parse(
new MdnsPacketReader(srvTxtQueryCaptor.getValue()));
final String[] serviceName = getTestServiceName(instanceName);
- assertTrue(hasQuestion(srvTxtQueryPacket, MdnsRecord.TYPE_SRV, serviceName));
- assertTrue(hasQuestion(srvTxtQueryPacket, MdnsRecord.TYPE_TXT, serviceName));
+ assertTrue(hasQuestion(srvTxtQueryPacket, MdnsRecord.TYPE_ANY, serviceName));
// Process a response with all records
final MdnsPacket srvTxtResponse = new MdnsPacket(
@@ -1064,13 +1067,13 @@
final ArgumentCaptor<DatagramPacket> renewalQueryCaptor =
ArgumentCaptor.forClass(DatagramPacket.class);
// Second and later sends are sent as "expect multicast response" queries
- inOrder.verify(mockSocketClient, times(2)).sendMulticastPacket(renewalQueryCaptor.capture(),
- eq(mockNetwork));
+ inOrder.verify(mockSocketClient, times(2)).sendPacketRequestingMulticastResponse(
+ renewalQueryCaptor.capture(),
+ eq(mockNetwork), eq(false));
inOrder.verify(mockListenerOne).onDiscoveryQuerySent(any(), anyInt());
final MdnsPacket renewalPacket = MdnsPacket.parse(
new MdnsPacketReader(renewalQueryCaptor.getValue()));
- assertTrue(hasQuestion(renewalPacket, MdnsRecord.TYPE_SRV, serviceName));
- assertTrue(hasQuestion(renewalPacket, MdnsRecord.TYPE_TXT, serviceName));
+ assertTrue(hasQuestion(renewalPacket, MdnsRecord.TYPE_ANY, serviceName));
inOrder.verifyNoMoreInteractions();
long updatedReceiptTime = TEST_ELAPSED_REALTIME + TEST_TTL;
@@ -1328,18 +1331,18 @@
assertEquals(currentThreadExecutor.getAndClearLastScheduledDelayInMs(), timeInMs);
currentThreadExecutor.getAndClearLastScheduledRunnable().run();
if (expectsUnicastResponse) {
- verify(mockSocketClient).sendUnicastPacket(
- expectedIPv4Packets[index], mockNetwork);
+ verify(mockSocketClient).sendPacketRequestingUnicastResponse(
+ expectedIPv4Packets[index], mockNetwork, false);
if (multipleSocketDiscovery) {
- verify(mockSocketClient).sendUnicastPacket(
- expectedIPv6Packets[index], mockNetwork);
+ verify(mockSocketClient).sendPacketRequestingUnicastResponse(
+ expectedIPv6Packets[index], mockNetwork, false);
}
} else {
- verify(mockSocketClient).sendMulticastPacket(
- expectedIPv4Packets[index], mockNetwork);
+ verify(mockSocketClient).sendPacketRequestingMulticastResponse(
+ expectedIPv4Packets[index], mockNetwork, false);
if (multipleSocketDiscovery) {
- verify(mockSocketClient).sendMulticastPacket(
- expectedIPv6Packets[index], mockNetwork);
+ verify(mockSocketClient).sendPacketRequestingMulticastResponse(
+ expectedIPv6Packets[index], mockNetwork, false);
}
}
}
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketClientTests.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketClientTests.java
index e30c249..69efc61 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketClientTests.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketClientTests.java
@@ -54,6 +54,7 @@
import java.io.IOException;
import java.net.DatagramPacket;
+import java.net.InetSocketAddress;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
@@ -221,15 +222,17 @@
assertTrue(unicastReceiverThread.isAlive());
// Sends a packet.
- DatagramPacket packet = new DatagramPacket(buf, 0, 5);
- mdnsClient.sendMulticastPacket(packet);
+ DatagramPacket packet = getTestDatagramPacket();
+ mdnsClient.sendPacketRequestingMulticastResponse(packet,
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
// mockMulticastSocket.send() will be called on another thread. If we verify it immediately,
// it may not be called yet. So timeout is added.
verify(mockMulticastSocket, timeout(TIMEOUT).times(1)).send(packet);
verify(mockUnicastSocket, timeout(TIMEOUT).times(0)).send(packet);
// Verify the packet is sent by the unicast socket.
- mdnsClient.sendUnicastPacket(packet);
+ mdnsClient.sendPacketRequestingUnicastResponse(packet,
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
verify(mockMulticastSocket, timeout(TIMEOUT).times(1)).send(packet);
verify(mockUnicastSocket, timeout(TIMEOUT).times(1)).send(packet);
@@ -272,15 +275,17 @@
assertNull(unicastReceiverThread);
// Sends a packet.
- DatagramPacket packet = new DatagramPacket(buf, 0, 5);
- mdnsClient.sendMulticastPacket(packet);
+ DatagramPacket packet = getTestDatagramPacket();
+ mdnsClient.sendPacketRequestingMulticastResponse(packet,
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
// mockMulticastSocket.send() will be called on another thread. If we verify it immediately,
// it may not be called yet. So timeout is added.
verify(mockMulticastSocket, timeout(TIMEOUT).times(1)).send(packet);
verify(mockUnicastSocket, timeout(TIMEOUT).times(0)).send(packet);
// Verify the packet is sent by the multicast socket as well.
- mdnsClient.sendUnicastPacket(packet);
+ mdnsClient.sendPacketRequestingUnicastResponse(packet,
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
verify(mockMulticastSocket, timeout(TIMEOUT).times(2)).send(packet);
verify(mockUnicastSocket, timeout(TIMEOUT).times(0)).send(packet);
@@ -332,7 +337,8 @@
public void testStopDiscovery_queueIsCleared() throws IOException {
mdnsClient.startDiscovery();
mdnsClient.stopDiscovery();
- mdnsClient.sendMulticastPacket(new DatagramPacket(buf, 0, 5));
+ mdnsClient.sendPacketRequestingMulticastResponse(getTestDatagramPacket(),
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
synchronized (mdnsClient.multicastPacketQueue) {
assertTrue(mdnsClient.multicastPacketQueue.isEmpty());
@@ -343,7 +349,8 @@
public void testSendPacket_afterDiscoveryStops() throws IOException {
mdnsClient.startDiscovery();
mdnsClient.stopDiscovery();
- mdnsClient.sendMulticastPacket(new DatagramPacket(buf, 0, 5));
+ mdnsClient.sendPacketRequestingMulticastResponse(getTestDatagramPacket(),
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
synchronized (mdnsClient.multicastPacketQueue) {
assertTrue(mdnsClient.multicastPacketQueue.isEmpty());
@@ -356,7 +363,8 @@
//MdnsConfigsFlagsImpl.mdnsPacketQueueMaxSize.override(2L);
mdnsClient.startDiscovery();
for (int i = 0; i < 100; i++) {
- mdnsClient.sendMulticastPacket(new DatagramPacket(buf, 0, 5));
+ mdnsClient.sendPacketRequestingMulticastResponse(getTestDatagramPacket(),
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
}
synchronized (mdnsClient.multicastPacketQueue) {
@@ -452,9 +460,11 @@
enableUnicastResponse.set(true);
mdnsClient.startDiscovery();
- DatagramPacket packet = new DatagramPacket(buf, 0, 5);
- mdnsClient.sendUnicastPacket(packet);
- mdnsClient.sendMulticastPacket(packet);
+ DatagramPacket packet = getTestDatagramPacket();
+ mdnsClient.sendPacketRequestingUnicastResponse(packet,
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
+ mdnsClient.sendPacketRequestingMulticastResponse(packet,
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
// Wait for the timer to be triggered.
Thread.sleep(MdnsConfigs.checkMulticastResponseIntervalMs() * 2);
@@ -484,8 +494,10 @@
assertFalse(mdnsClient.receivedUnicastResponse);
assertFalse(mdnsClient.cannotReceiveMulticastResponse.get());
- mdnsClient.sendUnicastPacket(packet);
- mdnsClient.sendMulticastPacket(packet);
+ mdnsClient.sendPacketRequestingUnicastResponse(packet,
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
+ mdnsClient.sendPacketRequestingMulticastResponse(packet,
+ false /* onlyUseIpv6OnIpv6OnlyNetworks */);
Thread.sleep(MdnsConfigs.checkMulticastResponseIntervalMs() * 2);
// Verify cannotReceiveMulticastResponse is not set the true because we didn't receive the
@@ -540,4 +552,9 @@
verify(mockCallback, timeout(TIMEOUT).atLeast(1))
.onResponseReceived(any(), argThat(key -> key.getInterfaceIndex() == -1));
}
+
+ private DatagramPacket getTestDatagramPacket() {
+ return new DatagramPacket(buf, 0, 5,
+ new InetSocketAddress(MdnsConstants.getMdnsIPv4Address(), 5353 /* port */));
+ }
}
\ No newline at end of file