Merge "Use IDnsResolverUnsolicitedEventListener" (a476ef4d) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/ConnectivityService.java

+30 −43

Original line number	Original line	Diff line number	Diff line
	@@ -142,10 +142,13 @@ import android.net.UnderlyingNetworkInfo;
	import android.net.Uri;		import android.net.Uri;
	import android.net.VpnManager;		import android.net.VpnManager;
	import android.net.VpnTransportInfo;		import android.net.VpnTransportInfo;
	import android.net.metrics.INetdEventListener;
	import android.net.metrics.IpConnectivityLog;		import android.net.metrics.IpConnectivityLog;
	import android.net.metrics.NetworkEvent;		import android.net.metrics.NetworkEvent;
	import android.net.netlink.InetDiagMessage;		import android.net.netlink.InetDiagMessage;
			import android.net.resolv.aidl.DnsHealthEventParcel;
			import android.net.resolv.aidl.IDnsResolverUnsolicitedEventListener;
			import android.net.resolv.aidl.Nat64PrefixEventParcel;
			import android.net.resolv.aidl.PrivateDnsValidationEventParcel;
	import android.net.shared.PrivateDnsConfig;		import android.net.shared.PrivateDnsConfig;
	import android.net.util.MultinetworkPolicyTracker;		import android.net.util.MultinetworkPolicyTracker;
	import android.net.util.NetdService;		import android.net.util.NetdService;
	@@ -2037,25 +2040,24 @@ public class ConnectivityService extends IConnectivityManager.Stub
	return true;		return true;
	}		}

	private class NetdEventCallback extends INetdEventListener.Stub {		class DnsResolverUnsolicitedEventCallback extends
			IDnsResolverUnsolicitedEventListener.Stub {
	@Override		@Override
	public void onPrivateDnsValidationEvent(int netId, String ipAddress,		public void onPrivateDnsValidationEvent(final PrivateDnsValidationEventParcel event) {
	String hostname, boolean validated) {
	try {		try {
	mHandler.sendMessage(mHandler.obtainMessage(		mHandler.sendMessage(mHandler.obtainMessage(
	EVENT_PRIVATE_DNS_VALIDATION_UPDATE,		EVENT_PRIVATE_DNS_VALIDATION_UPDATE,
	new PrivateDnsValidationUpdate(netId,		new PrivateDnsValidationUpdate(event.netId,
	InetAddresses.parseNumericAddress(ipAddress),		InetAddresses.parseNumericAddress(event.ipAddress),
	hostname, validated)));		event.hostname, event.validation)));
	} catch (IllegalArgumentException e) {		} catch (IllegalArgumentException e) {
	loge("Error parsing ip address in validation event");		loge("Error parsing ip address in validation event");
	}		}
	}		}

	@Override		@Override
	public void onDnsEvent(int netId, int eventType, int returnCode, int latencyMs,		public void onDnsHealthEvent(final DnsHealthEventParcel event) {
	String hostname, String[] ipAddresses, int ipAddressesCount, int uid) {		NetworkAgentInfo nai = getNetworkAgentInfoForNetId(event.netId);
	NetworkAgentInfo nai = getNetworkAgentInfoForNetId(netId);
	// Netd event only allow registrants from system. Each NetworkMonitor thread is under		// Netd event only allow registrants from system. Each NetworkMonitor thread is under
	// the caller thread of registerNetworkAgent. Thus, it's not allowed to register netd		// the caller thread of registerNetworkAgent. Thus, it's not allowed to register netd
	// event callback for certain nai. e.g. cellular. Register here to pass to		// event callback for certain nai. e.g. cellular. Register here to pass to
	@@ -2064,34 +2066,18 @@ public class ConnectivityService extends IConnectivityManager.Stub
	// callback from each caller type. Need to re-factor NetdEventListenerService to allow		// callback from each caller type. Need to re-factor NetdEventListenerService to allow
	// multiple NetworkMonitor registrants.		// multiple NetworkMonitor registrants.
	if (nai != null && nai.satisfies(mDefaultRequest.mRequests.get(0))) {		if (nai != null && nai.satisfies(mDefaultRequest.mRequests.get(0))) {
	nai.networkMonitor().notifyDnsResponse(returnCode);		nai.networkMonitor().notifyDnsResponse(event.healthResult);
	}		}
	}		}

	@Override		@Override
	public void onNat64PrefixEvent(int netId, boolean added,		public void onNat64PrefixEvent(final Nat64PrefixEventParcel event) {
	String prefixString, int prefixLength) {		mHandler.post(() -> handleNat64PrefixEvent(event.netId, event.prefixOperation,
	mHandler.post(() -> handleNat64PrefixEvent(netId, added, prefixString, prefixLength));		event.prefixAddress, event.prefixLength));
	}		}

	@Override		@Override
	public void onConnectEvent(int netId, int error, int latencyMs, String ipAddr, int port,		public int getInterfaceVersion() {
	int uid) {
	}

	@Override
	public void onWakeupEvent(String prefix, int uid, int ethertype, int ipNextHeader,
	byte[] dstHw, String srcIp, String dstIp, int srcPort, int dstPort,
	long timestampNs) {
	}

	@Override
	public void onTcpSocketStatsEvent(int[] networkIds, int[] sentPackets, int[] lostPackets,
	int[] rttsUs, int[] sentAckDiffsMs) {
	}

	@Override
	public int getInterfaceVersion() throws RemoteException {
	return this.VERSION;		return this.VERSION;
	}		}

	@@ -2099,16 +2085,17 @@ public class ConnectivityService extends IConnectivityManager.Stub
	public String getInterfaceHash() {		public String getInterfaceHash() {
	return this.HASH;		return this.HASH;
	}		}
	};		}

	@VisibleForTesting		@VisibleForTesting
	protected final INetdEventListener mNetdEventCallback = new NetdEventCallback();		protected final DnsResolverUnsolicitedEventCallback mResolverUnsolEventCallback =
			new DnsResolverUnsolicitedEventCallback();

	private void registerNetdEventCallback() {		private void registerDnsResolverUnsolicitedEventListener() {
	try {		try {
	mDnsResolver.registerEventListener(mNetdEventCallback);		mDnsResolver.registerUnsolicitedEventListener(mResolverUnsolEventCallback);
	} catch (Exception e) {		} catch (Exception e) {
	loge("Error registering DnsResolver callback: " + e);		loge("Error registering DnsResolver unsolicited event callback: " + e);
	}		}
	}		}

	@@ -2439,7 +2426,7 @@ public class ConnectivityService extends IConnectivityManager.Stub
	// to ensure the tracking will be initialized correctly.		// to ensure the tracking will be initialized correctly.
	mPermissionMonitor.startMonitoring();		mPermissionMonitor.startMonitoring();
	mProxyTracker.loadGlobalProxy();		mProxyTracker.loadGlobalProxy();
	registerNetdEventCallback();		registerDnsResolverUnsolicitedEventListener();

	synchronized (this) {		synchronized (this) {
	mSystemReady = true;		mSystemReady = true;
	@@ -3370,21 +3357,21 @@ public class ConnectivityService extends IConnectivityManager.Stub
	handleUpdateLinkProperties(nai, new LinkProperties(nai.linkProperties));		handleUpdateLinkProperties(nai, new LinkProperties(nai.linkProperties));
	}		}

	private void handleNat64PrefixEvent(int netId, boolean added, String prefixString,		private void handleNat64PrefixEvent(int netId, int operation, String prefixAddress,
	int prefixLength) {		int prefixLength) {
	NetworkAgentInfo nai = mNetworkForNetId.get(netId);		NetworkAgentInfo nai = mNetworkForNetId.get(netId);
	if (nai == null) return;		if (nai == null) return;

	log(String.format("NAT64 prefix %s on netId %d: %s/%d",		log(String.format("NAT64 prefix changed on netId %d: operation=%d, %s/%d",
	(added ? "added" : "removed"), netId, prefixString, prefixLength));		netId, operation, prefixAddress, prefixLength));

	IpPrefix prefix = null;		IpPrefix prefix = null;
	if (added) {		if (operation == IDnsResolverUnsolicitedEventListener.PREFIX_OPERATION_ADDED) {
	try {		try {
	prefix = new IpPrefix(InetAddresses.parseNumericAddress(prefixString),		prefix = new IpPrefix(InetAddresses.parseNumericAddress(prefixAddress),
	prefixLength);		prefixLength);
	} catch (IllegalArgumentException e) {		} catch (IllegalArgumentException e) {
	loge("Invalid NAT64 prefix " + prefixString + "/" + prefixLength);		loge("Invalid NAT64 prefix " + prefixAddress + "/" + prefixLength);
	return;		return;
	}		}
	}		}

services/core/java/com/android/server/connectivity/DnsManager.java

+14 −8

Original line number	Original line	Diff line number	Diff line
	@@ -19,6 +19,8 @@ package com.android.server.connectivity;
	import static android.net.ConnectivityManager.PRIVATE_DNS_DEFAULT_MODE_FALLBACK;		import static android.net.ConnectivityManager.PRIVATE_DNS_DEFAULT_MODE_FALLBACK;
	import static android.net.ConnectivityManager.PRIVATE_DNS_MODE_OFF;		import static android.net.ConnectivityManager.PRIVATE_DNS_MODE_OFF;
	import static android.net.ConnectivityManager.PRIVATE_DNS_MODE_PROVIDER_HOSTNAME;		import static android.net.ConnectivityManager.PRIVATE_DNS_MODE_PROVIDER_HOSTNAME;
			import static android.net.resolv.aidl.IDnsResolverUnsolicitedEventListener.VALIDATION_RESULT_FAILURE;
			import static android.net.resolv.aidl.IDnsResolverUnsolicitedEventListener.VALIDATION_RESULT_SUCCESS;
	import static android.provider.Settings.Global.DNS_RESOLVER_MAX_SAMPLES;		import static android.provider.Settings.Global.DNS_RESOLVER_MAX_SAMPLES;
	import static android.provider.Settings.Global.DNS_RESOLVER_MIN_SAMPLES;		import static android.provider.Settings.Global.DNS_RESOLVER_MIN_SAMPLES;
	import static android.provider.Settings.Global.DNS_RESOLVER_SAMPLE_VALIDITY_SECONDS;		import static android.provider.Settings.Global.DNS_RESOLVER_SAMPLE_VALIDITY_SECONDS;
	@@ -147,17 +149,18 @@ public class DnsManager {
	}		}

	public static class PrivateDnsValidationUpdate {		public static class PrivateDnsValidationUpdate {
	final public int netId;		public final int netId;
	final public InetAddress ipAddress;		public final InetAddress ipAddress;
	final public String hostname;		public final String hostname;
	final public boolean validated;		// Refer to IDnsResolverUnsolicitedEventListener.VALIDATION_RESULT_*.
			public final int validationResult;

	public PrivateDnsValidationUpdate(int netId, InetAddress ipAddress,		public PrivateDnsValidationUpdate(int netId, InetAddress ipAddress,
	String hostname, boolean validated) {		String hostname, int validationResult) {
	this.netId = netId;		this.netId = netId;
	this.ipAddress = ipAddress;		this.ipAddress = ipAddress;
	this.hostname = hostname;		this.hostname = hostname;
	this.validated = validated;		this.validationResult = validationResult;
	}		}
	}		}

	@@ -216,10 +219,13 @@ public class DnsManager {
	if (!mValidationMap.containsKey(p)) {		if (!mValidationMap.containsKey(p)) {
	return;		return;
	}		}
	if (update.validated) {		if (update.validationResult == VALIDATION_RESULT_SUCCESS) {
	mValidationMap.put(p, ValidationStatus.SUCCEEDED);		mValidationMap.put(p, ValidationStatus.SUCCEEDED);
	} else {		} else if (update.validationResult == VALIDATION_RESULT_FAILURE) {
	mValidationMap.put(p, ValidationStatus.FAILED);		mValidationMap.put(p, ValidationStatus.FAILED);
			} else {
			Log.e(TAG, "Unknown private dns validation operation="
			+ update.validationResult);
	}		}
	}		}

tests/net/java/com/android/server/ConnectivityServiceTest.java

+54 −24

Original line number	Original line	Diff line number	Diff line
	@@ -90,6 +90,10 @@ import static android.net.OemNetworkPreferences.OEM_NETWORK_PREFERENCE_OEM_PAID_
	import static android.net.OemNetworkPreferences.OEM_NETWORK_PREFERENCE_OEM_PRIVATE_ONLY;		import static android.net.OemNetworkPreferences.OEM_NETWORK_PREFERENCE_OEM_PRIVATE_ONLY;
	import static android.net.OemNetworkPreferences.OEM_NETWORK_PREFERENCE_UNINITIALIZED;		import static android.net.OemNetworkPreferences.OEM_NETWORK_PREFERENCE_UNINITIALIZED;
	import static android.net.RouteInfo.RTN_UNREACHABLE;		import static android.net.RouteInfo.RTN_UNREACHABLE;
			import static android.net.resolv.aidl.IDnsResolverUnsolicitedEventListener.PREFIX_OPERATION_ADDED;
			import static android.net.resolv.aidl.IDnsResolverUnsolicitedEventListener.PREFIX_OPERATION_REMOVED;
			import static android.net.resolv.aidl.IDnsResolverUnsolicitedEventListener.VALIDATION_RESULT_FAILURE;
			import static android.net.resolv.aidl.IDnsResolverUnsolicitedEventListener.VALIDATION_RESULT_SUCCESS;
	import static android.os.Process.INVALID_UID;		import static android.os.Process.INVALID_UID;
	import static android.system.OsConstants.IPPROTO_TCP;		import static android.system.OsConstants.IPPROTO_TCP;

	@@ -217,6 +221,8 @@ import android.net.Uri;
	import android.net.VpnManager;		import android.net.VpnManager;
	import android.net.VpnTransportInfo;		import android.net.VpnTransportInfo;
	import android.net.metrics.IpConnectivityLog;		import android.net.metrics.IpConnectivityLog;
			import android.net.resolv.aidl.Nat64PrefixEventParcel;
			import android.net.resolv.aidl.PrivateDnsValidationEventParcel;
	import android.net.shared.NetworkMonitorUtils;		import android.net.shared.NetworkMonitorUtils;
	import android.net.shared.PrivateDnsConfig;		import android.net.shared.PrivateDnsConfig;
	import android.net.util.MultinetworkPolicyTracker;		import android.net.util.MultinetworkPolicyTracker;
	@@ -5919,6 +5925,16 @@ public class ConnectivityServiceTest {
	assertEquals("strict.example.com", cbi.getLp().getPrivateDnsServerName());		assertEquals("strict.example.com", cbi.getLp().getPrivateDnsServerName());
	}		}

			private PrivateDnsValidationEventParcel makePrivateDnsValidationEvent(
			final int netId, final String ipAddress, final String hostname, final int validation) {
			final PrivateDnsValidationEventParcel event = new PrivateDnsValidationEventParcel();
			event.netId = netId;
			event.ipAddress = ipAddress;
			event.hostname = hostname;
			event.validation = validation;
			return event;
			}

	@Test		@Test
	public void testLinkPropertiesWithPrivateDnsValidationEvents() throws Exception {		public void testLinkPropertiesWithPrivateDnsValidationEvents() throws Exception {
	// The default on Android is opportunistic mode ("Automatic").		// The default on Android is opportunistic mode ("Automatic").
	@@ -5949,8 +5965,9 @@ public class ConnectivityServiceTest {

	// Send a validation event for a server that is not part of the current		// Send a validation event for a server that is not part of the current
	// resolver config. The validation event should be ignored.		// resolver config. The validation event should be ignored.
	mService.mNetdEventCallback.onPrivateDnsValidationEvent(		mService.mResolverUnsolEventCallback.onPrivateDnsValidationEvent(
	mCellNetworkAgent.getNetwork().netId, "", "145.100.185.18", true);		makePrivateDnsValidationEvent(mCellNetworkAgent.getNetwork().netId, "",
			"145.100.185.18", VALIDATION_RESULT_SUCCESS));
	cellNetworkCallback.assertNoCallback();		cellNetworkCallback.assertNoCallback();

	// Add a dns server to the LinkProperties.		// Add a dns server to the LinkProperties.
	@@ -5967,20 +5984,23 @@ public class ConnectivityServiceTest {

	// Send a validation event containing a hostname that is not part of		// Send a validation event containing a hostname that is not part of
	// the current resolver config. The validation event should be ignored.		// the current resolver config. The validation event should be ignored.
	mService.mNetdEventCallback.onPrivateDnsValidationEvent(		mService.mResolverUnsolEventCallback.onPrivateDnsValidationEvent(
	mCellNetworkAgent.getNetwork().netId, "145.100.185.16", "hostname", true);		makePrivateDnsValidationEvent(mCellNetworkAgent.getNetwork().netId,
			"145.100.185.16", "hostname", VALIDATION_RESULT_SUCCESS));
	cellNetworkCallback.assertNoCallback();		cellNetworkCallback.assertNoCallback();

	// Send a validation event where validation failed.		// Send a validation event where validation failed.
	mService.mNetdEventCallback.onPrivateDnsValidationEvent(		mService.mResolverUnsolEventCallback.onPrivateDnsValidationEvent(
	mCellNetworkAgent.getNetwork().netId, "145.100.185.16", "", false);		makePrivateDnsValidationEvent(mCellNetworkAgent.getNetwork().netId,
			"145.100.185.16", "", VALIDATION_RESULT_FAILURE));
	cellNetworkCallback.assertNoCallback();		cellNetworkCallback.assertNoCallback();

	// Send a validation event where validation succeeded for a server in		// Send a validation event where validation succeeded for a server in
	// the current resolver config. A LinkProperties callback with updated		// the current resolver config. A LinkProperties callback with updated
	// private dns fields should be sent.		// private dns fields should be sent.
	mService.mNetdEventCallback.onPrivateDnsValidationEvent(		mService.mResolverUnsolEventCallback.onPrivateDnsValidationEvent(
	mCellNetworkAgent.getNetwork().netId, "145.100.185.16", "", true);		makePrivateDnsValidationEvent(mCellNetworkAgent.getNetwork().netId,
			"145.100.185.16", "", VALIDATION_RESULT_SUCCESS));
	cbi = cellNetworkCallback.expectCallback(CallbackEntry.LINK_PROPERTIES_CHANGED,		cbi = cellNetworkCallback.expectCallback(CallbackEntry.LINK_PROPERTIES_CHANGED,
	mCellNetworkAgent);		mCellNetworkAgent);
	cellNetworkCallback.assertNoCallback();		cellNetworkCallback.assertNoCallback();
	@@ -7824,6 +7844,16 @@ public class ConnectivityServiceTest {
	return stacked;		return stacked;
	}		}

			private Nat64PrefixEventParcel makeNat64PrefixEvent(final int netId, final int prefixOperation,
			final String prefixAddress, final int prefixLength) {
			final Nat64PrefixEventParcel event = new Nat64PrefixEventParcel();
			event.netId = netId;
			event.prefixOperation = prefixOperation;
			event.prefixAddress = prefixAddress;
			event.prefixLength = prefixLength;
			return event;
			}

	@Test		@Test
	public void testStackedLinkProperties() throws Exception {		public void testStackedLinkProperties() throws Exception {
	final LinkAddress myIpv4 = new LinkAddress("1.2.3.4/24");		final LinkAddress myIpv4 = new LinkAddress("1.2.3.4/24");
	@@ -7908,8 +7938,8 @@ public class ConnectivityServiceTest {
	// When NAT64 prefix discovery succeeds, LinkProperties are updated and clatd is started.		// When NAT64 prefix discovery succeeds, LinkProperties are updated and clatd is started.
	Nat464Xlat clat = getNat464Xlat(mCellNetworkAgent);		Nat464Xlat clat = getNat464Xlat(mCellNetworkAgent);
	assertNull(mCm.getLinkProperties(mCellNetworkAgent.getNetwork()).getNat64Prefix());		assertNull(mCm.getLinkProperties(mCellNetworkAgent.getNetwork()).getNat64Prefix());
	mService.mNetdEventCallback.onNat64PrefixEvent(cellNetId, true /* added */,		mService.mResolverUnsolEventCallback.onNat64PrefixEvent(
	kNat64PrefixString, 96);		makeNat64PrefixEvent(cellNetId, PREFIX_OPERATION_ADDED, kNat64PrefixString, 96));
	LinkProperties lpBeforeClat = networkCallback.expectCallback(		LinkProperties lpBeforeClat = networkCallback.expectCallback(
	CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent).getLp();		CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent).getLp();
	assertEquals(0, lpBeforeClat.getStackedLinks().size());		assertEquals(0, lpBeforeClat.getStackedLinks().size());
	@@ -7949,8 +7979,8 @@ public class ConnectivityServiceTest {
	.thenReturn(getClatInterfaceConfigParcel(myIpv4));		.thenReturn(getClatInterfaceConfigParcel(myIpv4));
	// Change the NAT64 prefix without first removing it.		// Change the NAT64 prefix without first removing it.
	// Expect clatd to be stopped and started with the new prefix.		// Expect clatd to be stopped and started with the new prefix.
	mService.mNetdEventCallback.onNat64PrefixEvent(cellNetId, true /* added */,		mService.mResolverUnsolEventCallback.onNat64PrefixEvent(makeNat64PrefixEvent(
	kOtherNat64PrefixString, 96);		cellNetId, PREFIX_OPERATION_ADDED, kOtherNat64PrefixString, 96));
	networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,		networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
	(lp) -> lp.getStackedLinks().size() == 0);		(lp) -> lp.getStackedLinks().size() == 0);
	verify(mMockNetd, times(1)).clatdStop(MOBILE_IFNAME);		verify(mMockNetd, times(1)).clatdStop(MOBILE_IFNAME);
	@@ -7998,8 +8028,8 @@ public class ConnectivityServiceTest {
	.thenReturn(getClatInterfaceConfigParcel(myIpv4));		.thenReturn(getClatInterfaceConfigParcel(myIpv4));

	// Stopping prefix discovery causes netd to tell us that the NAT64 prefix is gone.		// Stopping prefix discovery causes netd to tell us that the NAT64 prefix is gone.
	mService.mNetdEventCallback.onNat64PrefixEvent(cellNetId, false /* added */,		mService.mResolverUnsolEventCallback.onNat64PrefixEvent(makeNat64PrefixEvent(
	kOtherNat64PrefixString, 96);		cellNetId, PREFIX_OPERATION_REMOVED, kOtherNat64PrefixString, 96));
	networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,		networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
	(lp) -> lp.getNat64Prefix() == null);		(lp) -> lp.getNat64Prefix() == null);

	@@ -8011,8 +8041,8 @@ public class ConnectivityServiceTest {
	networkCallback.expectCallback(CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);		networkCallback.expectCallback(CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
	assertRoutesRemoved(cellNetId, ipv4Subnet); // Directly-connected routes auto-added.		assertRoutesRemoved(cellNetId, ipv4Subnet); // Directly-connected routes auto-added.
	verify(mMockDnsResolver, times(1)).startPrefix64Discovery(cellNetId);		verify(mMockDnsResolver, times(1)).startPrefix64Discovery(cellNetId);
	mService.mNetdEventCallback.onNat64PrefixEvent(cellNetId, true /* added */,		mService.mResolverUnsolEventCallback.onNat64PrefixEvent(makeNat64PrefixEvent(
	kNat64PrefixString, 96);		cellNetId, PREFIX_OPERATION_ADDED, kNat64PrefixString, 96));
	networkCallback.expectCallback(CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);		networkCallback.expectCallback(CallbackEntry.LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
	verify(mMockNetd, times(1)).clatdStart(MOBILE_IFNAME, kNat64Prefix.toString());		verify(mMockNetd, times(1)).clatdStart(MOBILE_IFNAME, kNat64Prefix.toString());

	@@ -8024,8 +8054,8 @@ public class ConnectivityServiceTest {
	verify(mMockNetd, times(1)).networkAddInterface(cellNetId, CLAT_PREFIX + MOBILE_IFNAME);		verify(mMockNetd, times(1)).networkAddInterface(cellNetId, CLAT_PREFIX + MOBILE_IFNAME);

	// NAT64 prefix is removed. Expect that clat is stopped.		// NAT64 prefix is removed. Expect that clat is stopped.
	mService.mNetdEventCallback.onNat64PrefixEvent(cellNetId, false /* added */,		mService.mResolverUnsolEventCallback.onNat64PrefixEvent(makeNat64PrefixEvent(
	kNat64PrefixString, 96);		cellNetId, PREFIX_OPERATION_REMOVED, kNat64PrefixString, 96));
	networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,		networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
	(lp) -> lp.getStackedLinks().size() == 0 && lp.getNat64Prefix() == null);		(lp) -> lp.getStackedLinks().size() == 0 && lp.getNat64Prefix() == null);
	assertRoutesRemoved(cellNetId, ipv4Subnet, stackedDefault);		assertRoutesRemoved(cellNetId, ipv4Subnet, stackedDefault);
	@@ -8113,8 +8143,8 @@ public class ConnectivityServiceTest {
	inOrder.verify(mMockDnsResolver).setPrefix64(netId, "");		inOrder.verify(mMockDnsResolver).setPrefix64(netId, "");
	inOrder.verify(mMockDnsResolver).startPrefix64Discovery(netId);		inOrder.verify(mMockDnsResolver).startPrefix64Discovery(netId);

	mService.mNetdEventCallback.onNat64PrefixEvent(netId, true /* added */,		mService.mResolverUnsolEventCallback.onNat64PrefixEvent(
	pref64FromDnsStr, 96);		makeNat64PrefixEvent(netId, PREFIX_OPERATION_ADDED, pref64FromDnsStr, 96));
	expectNat64PrefixChange(callback, mWiFiNetworkAgent, pref64FromDns);		expectNat64PrefixChange(callback, mWiFiNetworkAgent, pref64FromDns);
	inOrder.verify(mMockNetd).clatdStart(iface, pref64FromDns.toString());		inOrder.verify(mMockNetd).clatdStart(iface, pref64FromDns.toString());

	@@ -8147,8 +8177,8 @@ public class ConnectivityServiceTest {
	inOrder.verify(mMockDnsResolver).stopPrefix64Discovery(netId);		inOrder.verify(mMockDnsResolver).stopPrefix64Discovery(netId);

	// Stopping prefix discovery results in a prefix removed notification.		// Stopping prefix discovery results in a prefix removed notification.
	mService.mNetdEventCallback.onNat64PrefixEvent(netId, false /* added */,		mService.mResolverUnsolEventCallback.onNat64PrefixEvent(
	pref64FromDnsStr, 96);		makeNat64PrefixEvent(netId, PREFIX_OPERATION_REMOVED, pref64FromDnsStr, 96));

	inOrder.verify(mMockNetd).clatdStart(iface, pref64FromRa.toString());		inOrder.verify(mMockNetd).clatdStart(iface, pref64FromRa.toString());
	inOrder.verify(mMockDnsResolver).setPrefix64(netId, pref64FromRa.toString());		inOrder.verify(mMockDnsResolver).setPrefix64(netId, pref64FromRa.toString());
	@@ -8186,8 +8216,8 @@ public class ConnectivityServiceTest {
	inOrder.verify(mMockNetd).clatdStop(iface);		inOrder.verify(mMockNetd).clatdStop(iface);
	inOrder.verify(mMockDnsResolver).setPrefix64(netId, "");		inOrder.verify(mMockDnsResolver).setPrefix64(netId, "");
	inOrder.verify(mMockDnsResolver).startPrefix64Discovery(netId);		inOrder.verify(mMockDnsResolver).startPrefix64Discovery(netId);
	mService.mNetdEventCallback.onNat64PrefixEvent(netId, true /* added */,		mService.mResolverUnsolEventCallback.onNat64PrefixEvent(
	pref64FromDnsStr, 96);		makeNat64PrefixEvent(netId, PREFIX_OPERATION_ADDED, pref64FromDnsStr, 96));
	expectNat64PrefixChange(callback, mWiFiNetworkAgent, pref64FromDns);		expectNat64PrefixChange(callback, mWiFiNetworkAgent, pref64FromDns);
	inOrder.verify(mMockNetd).clatdStart(iface, pref64FromDns.toString());		inOrder.verify(mMockNetd).clatdStart(iface, pref64FromDns.toString());
	inOrder.verify(mMockDnsResolver, never()).setPrefix64(eq(netId), any());		inOrder.verify(mMockDnsResolver, never()).setPrefix64(eq(netId), any());

tests/net/java/com/android/server/connectivity/DnsManagerTest.java

+23 −12

File changed.

Preview size limit exceeded, changes collapsed.