1 /* 2 * Copyright (C) 2018, The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.server.connectivity; 18 19 import static android.net.ConnectivitySettingsManager.PRIVATE_DNS_DEFAULT_MODE; 20 import static android.net.ConnectivitySettingsManager.PRIVATE_DNS_MODE; 21 import static android.net.ConnectivitySettingsManager.PRIVATE_DNS_MODE_OFF; 22 import static android.net.ConnectivitySettingsManager.PRIVATE_DNS_MODE_PROVIDER_HOSTNAME; 23 import static android.net.ConnectivitySettingsManager.PRIVATE_DNS_SPECIFIER; 24 import static android.net.NetworkCapabilities.MAX_TRANSPORT; 25 import static android.net.NetworkCapabilities.MIN_TRANSPORT; 26 import static android.net.NetworkCapabilities.TRANSPORT_VPN; 27 import static android.net.NetworkCapabilities.TRANSPORT_WIFI; 28 import static android.net.resolv.aidl.IDnsResolverUnsolicitedEventListener.VALIDATION_RESULT_FAILURE; 29 import static android.net.resolv.aidl.IDnsResolverUnsolicitedEventListener.VALIDATION_RESULT_SUCCESS; 30 31 import static com.android.testutils.MiscAsserts.assertContainsExactly; 32 import static com.android.testutils.MiscAsserts.assertContainsStringsExactly; 33 import static com.android.testutils.MiscAsserts.assertFieldCountEquals; 34 35 import static org.junit.Assert.assertEquals; 36 import static org.junit.Assert.assertFalse; 37 import static org.junit.Assert.assertNotNull; 38 import static org.junit.Assert.assertNull; 39 import static org.junit.Assert.assertTrue; 40 import static org.mockito.Mockito.reset; 41 import static org.mockito.Mockito.times; 42 import static org.mockito.Mockito.verify; 43 import static org.mockito.Mockito.when; 44 45 import android.annotation.NonNull; 46 import android.annotation.Nullable; 47 import android.content.Context; 48 import android.net.ConnectivitySettingsManager; 49 import android.net.IDnsResolver; 50 import android.net.IpPrefix; 51 import android.net.LinkAddress; 52 import android.net.LinkProperties; 53 import android.net.Network; 54 import android.net.NetworkCapabilities; 55 import android.net.ResolverOptionsParcel; 56 import android.net.ResolverParamsParcel; 57 import android.net.RouteInfo; 58 import android.net.shared.PrivateDnsConfig; 59 import android.os.Build; 60 import android.provider.Settings; 61 import android.test.mock.MockContentResolver; 62 import android.util.SparseArray; 63 64 import androidx.test.filters.SmallTest; 65 66 import com.android.internal.util.MessageUtils; 67 import com.android.internal.util.test.FakeSettingsProvider; 68 import com.android.testutils.DevSdkIgnoreRule; 69 import com.android.testutils.DevSdkIgnoreRunner; 70 71 import libcore.net.InetAddressUtils; 72 73 import org.junit.Before; 74 import org.junit.Test; 75 import org.junit.runner.RunWith; 76 import org.mockito.ArgumentCaptor; 77 import org.mockito.Mock; 78 import org.mockito.MockitoAnnotations; 79 80 import java.net.InetAddress; 81 import java.util.Arrays; 82 83 /** 84 * Tests for {@link DnsManager}. 85 * 86 * Build, install and run with: 87 * runtest frameworks-net -c com.android.server.connectivity.DnsManagerTest 88 */ 89 @RunWith(DevSdkIgnoreRunner.class) 90 @SmallTest 91 @DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R) 92 public class DnsManagerTest { 93 static final String TEST_IFACENAME = "test_wlan0"; 94 static final int TEST_NETID = 100; 95 static final int TEST_NETID_ALTERNATE = 101; 96 static final int TEST_NETID_UNTRACKED = 102; 97 static final int TEST_DEFAULT_SAMPLE_VALIDITY_SECONDS = 1800; 98 static final int TEST_DEFAULT_SUCCESS_THRESHOLD_PERCENT = 25; 99 static final int TEST_DEFAULT_MIN_SAMPLES = 8; 100 static final int TEST_DEFAULT_MAX_SAMPLES = 64; 101 static final int[] TEST_TRANSPORT_TYPES = {TRANSPORT_WIFI, TRANSPORT_VPN}; 102 103 DnsManager mDnsManager; 104 MockContentResolver mContentResolver; 105 106 @Mock Context mCtx; 107 @Mock IDnsResolver mMockDnsResolver; 108 assertResolverOptionsEquals( @ullable ResolverOptionsParcel actual, @Nullable ResolverOptionsParcel expected)109 private void assertResolverOptionsEquals( 110 @Nullable ResolverOptionsParcel actual, 111 @Nullable ResolverOptionsParcel expected) { 112 if (actual == null) { 113 assertNull(expected); 114 return; 115 } else { 116 assertNotNull(expected); 117 } 118 assertEquals(actual.hosts, expected.hosts); 119 assertEquals(actual.tcMode, expected.tcMode); 120 assertEquals(actual.enforceDnsUid, expected.enforceDnsUid); 121 assertFieldCountEquals(3, ResolverOptionsParcel.class); 122 } 123 assertResolverParamsEquals(@onNull ResolverParamsParcel actual, @NonNull ResolverParamsParcel expected)124 private void assertResolverParamsEquals(@NonNull ResolverParamsParcel actual, 125 @NonNull ResolverParamsParcel expected) { 126 assertEquals(actual.netId, expected.netId); 127 assertEquals(actual.sampleValiditySeconds, expected.sampleValiditySeconds); 128 assertEquals(actual.successThreshold, expected.successThreshold); 129 assertEquals(actual.minSamples, expected.minSamples); 130 assertEquals(actual.maxSamples, expected.maxSamples); 131 assertEquals(actual.baseTimeoutMsec, expected.baseTimeoutMsec); 132 assertEquals(actual.retryCount, expected.retryCount); 133 assertContainsStringsExactly(actual.servers, expected.servers); 134 assertContainsStringsExactly(actual.domains, expected.domains); 135 assertEquals(actual.tlsName, expected.tlsName); 136 assertContainsStringsExactly(actual.tlsServers, expected.tlsServers); 137 assertContainsStringsExactly(actual.tlsFingerprints, expected.tlsFingerprints); 138 assertEquals(actual.caCertificate, expected.caCertificate); 139 assertEquals(actual.tlsConnectTimeoutMs, expected.tlsConnectTimeoutMs); 140 assertResolverOptionsEquals(actual.resolverOptions, expected.resolverOptions); 141 assertContainsExactly(actual.transportTypes, expected.transportTypes); 142 assertFieldCountEquals(16, ResolverParamsParcel.class); 143 } 144 145 @Before setUp()146 public void setUp() throws Exception { 147 MockitoAnnotations.initMocks(this); 148 mContentResolver = new MockContentResolver(); 149 mContentResolver.addProvider(Settings.AUTHORITY, 150 new FakeSettingsProvider()); 151 when(mCtx.getContentResolver()).thenReturn(mContentResolver); 152 mDnsManager = new DnsManager(mCtx, mMockDnsResolver); 153 154 // Clear the private DNS settings 155 Settings.Global.putString(mContentResolver, PRIVATE_DNS_DEFAULT_MODE, ""); 156 Settings.Global.putString(mContentResolver, PRIVATE_DNS_MODE, ""); 157 Settings.Global.putString(mContentResolver, PRIVATE_DNS_SPECIFIER, ""); 158 } 159 160 @Test testTrackedValidationUpdates()161 public void testTrackedValidationUpdates() throws Exception { 162 mDnsManager.updatePrivateDns(new Network(TEST_NETID), 163 mDnsManager.getPrivateDnsConfig()); 164 mDnsManager.updatePrivateDns(new Network(TEST_NETID_ALTERNATE), 165 mDnsManager.getPrivateDnsConfig()); 166 LinkProperties lp = new LinkProperties(); 167 lp.setInterfaceName(TEST_IFACENAME); 168 lp.addDnsServer(InetAddress.getByName("3.3.3.3")); 169 lp.addDnsServer(InetAddress.getByName("4.4.4.4")); 170 171 // Send a validation event that is tracked on the alternate netId 172 mDnsManager.updateTransportsForNetwork(TEST_NETID, TEST_TRANSPORT_TYPES); 173 mDnsManager.noteDnsServersForNetwork(TEST_NETID, lp); 174 mDnsManager.flushVmDnsCache(); 175 mDnsManager.updateTransportsForNetwork(TEST_NETID_ALTERNATE, TEST_TRANSPORT_TYPES); 176 mDnsManager.noteDnsServersForNetwork(TEST_NETID_ALTERNATE, lp); 177 mDnsManager.flushVmDnsCache(); 178 mDnsManager.updatePrivateDnsValidation( 179 new DnsManager.PrivateDnsValidationUpdate(TEST_NETID_ALTERNATE, 180 InetAddress.parseNumericAddress("4.4.4.4"), "", 181 VALIDATION_RESULT_SUCCESS)); 182 LinkProperties fixedLp = new LinkProperties(lp); 183 mDnsManager.updatePrivateDnsStatus(TEST_NETID, fixedLp); 184 assertFalse(fixedLp.isPrivateDnsActive()); 185 assertNull(fixedLp.getPrivateDnsServerName()); 186 fixedLp = new LinkProperties(lp); 187 mDnsManager.updatePrivateDnsStatus(TEST_NETID_ALTERNATE, fixedLp); 188 assertTrue(fixedLp.isPrivateDnsActive()); 189 assertNull(fixedLp.getPrivateDnsServerName()); 190 assertEquals(Arrays.asList(InetAddress.getByName("4.4.4.4")), 191 fixedLp.getValidatedPrivateDnsServers()); 192 193 // Set up addresses for strict mode and switch to it. 194 lp.addLinkAddress(new LinkAddress("192.0.2.4/24")); 195 lp.addRoute(new RouteInfo((IpPrefix) null, InetAddress.getByName("192.0.2.4"), 196 TEST_IFACENAME)); 197 lp.addLinkAddress(new LinkAddress("2001:db8:1::1/64")); 198 lp.addRoute(new RouteInfo((IpPrefix) null, InetAddress.getByName("2001:db8:1::1"), 199 TEST_IFACENAME)); 200 201 ConnectivitySettingsManager.setPrivateDnsMode(mCtx, PRIVATE_DNS_MODE_PROVIDER_HOSTNAME); 202 ConnectivitySettingsManager.setPrivateDnsHostname(mCtx, "strictmode.com"); 203 mDnsManager.updatePrivateDns(new Network(TEST_NETID), 204 new PrivateDnsConfig("strictmode.com", new InetAddress[] { 205 InetAddress.parseNumericAddress("6.6.6.6"), 206 InetAddress.parseNumericAddress("2001:db8:66:66::1") 207 })); 208 mDnsManager.updateTransportsForNetwork(TEST_NETID, TEST_TRANSPORT_TYPES); 209 mDnsManager.noteDnsServersForNetwork(TEST_NETID, lp); 210 mDnsManager.flushVmDnsCache(); 211 fixedLp = new LinkProperties(lp); 212 mDnsManager.updatePrivateDnsStatus(TEST_NETID, fixedLp); 213 assertTrue(fixedLp.isPrivateDnsActive()); 214 assertEquals("strictmode.com", fixedLp.getPrivateDnsServerName()); 215 // No validation events yet. 216 assertEquals(Arrays.asList(new InetAddress[0]), fixedLp.getValidatedPrivateDnsServers()); 217 // Validate one. 218 mDnsManager.updatePrivateDnsValidation( 219 new DnsManager.PrivateDnsValidationUpdate(TEST_NETID, 220 InetAddress.parseNumericAddress("6.6.6.6"), "strictmode.com", 221 VALIDATION_RESULT_SUCCESS)); 222 fixedLp = new LinkProperties(lp); 223 mDnsManager.updatePrivateDnsStatus(TEST_NETID, fixedLp); 224 assertEquals(Arrays.asList(InetAddress.parseNumericAddress("6.6.6.6")), 225 fixedLp.getValidatedPrivateDnsServers()); 226 // Validate the 2nd one. 227 mDnsManager.updatePrivateDnsValidation( 228 new DnsManager.PrivateDnsValidationUpdate(TEST_NETID, 229 InetAddress.parseNumericAddress("2001:db8:66:66::1"), "strictmode.com", 230 VALIDATION_RESULT_SUCCESS)); 231 fixedLp = new LinkProperties(lp); 232 mDnsManager.updatePrivateDnsStatus(TEST_NETID, fixedLp); 233 assertEquals(Arrays.asList( 234 InetAddress.parseNumericAddress("2001:db8:66:66::1"), 235 InetAddress.parseNumericAddress("6.6.6.6")), 236 fixedLp.getValidatedPrivateDnsServers()); 237 } 238 239 @Test testIgnoreUntrackedValidationUpdates()240 public void testIgnoreUntrackedValidationUpdates() throws Exception { 241 // The PrivateDnsConfig map is empty, so no validation events will 242 // be tracked. 243 LinkProperties lp = new LinkProperties(); 244 lp.addDnsServer(InetAddress.getByName("3.3.3.3")); 245 mDnsManager.updateTransportsForNetwork(TEST_NETID, TEST_TRANSPORT_TYPES); 246 mDnsManager.noteDnsServersForNetwork(TEST_NETID, lp); 247 mDnsManager.flushVmDnsCache(); 248 mDnsManager.updatePrivateDnsValidation( 249 new DnsManager.PrivateDnsValidationUpdate(TEST_NETID, 250 InetAddress.parseNumericAddress("3.3.3.3"), "", 251 VALIDATION_RESULT_SUCCESS)); 252 mDnsManager.updatePrivateDnsStatus(TEST_NETID, lp); 253 assertFalse(lp.isPrivateDnsActive()); 254 assertNull(lp.getPrivateDnsServerName()); 255 256 // Validation event has untracked netId 257 mDnsManager.updatePrivateDns(new Network(TEST_NETID), 258 mDnsManager.getPrivateDnsConfig()); 259 mDnsManager.updateTransportsForNetwork(TEST_NETID, TEST_TRANSPORT_TYPES); 260 mDnsManager.noteDnsServersForNetwork(TEST_NETID, lp); 261 mDnsManager.flushVmDnsCache(); 262 mDnsManager.updatePrivateDnsValidation( 263 new DnsManager.PrivateDnsValidationUpdate(TEST_NETID_UNTRACKED, 264 InetAddress.parseNumericAddress("3.3.3.3"), "", 265 VALIDATION_RESULT_SUCCESS)); 266 mDnsManager.updatePrivateDnsStatus(TEST_NETID, lp); 267 assertFalse(lp.isPrivateDnsActive()); 268 assertNull(lp.getPrivateDnsServerName()); 269 270 // Validation event has untracked ipAddress 271 mDnsManager.updatePrivateDnsValidation( 272 new DnsManager.PrivateDnsValidationUpdate(TEST_NETID, 273 InetAddress.parseNumericAddress("4.4.4.4"), "", 274 VALIDATION_RESULT_SUCCESS)); 275 mDnsManager.updatePrivateDnsStatus(TEST_NETID, lp); 276 assertFalse(lp.isPrivateDnsActive()); 277 assertNull(lp.getPrivateDnsServerName()); 278 279 // Validation event has untracked hostname 280 mDnsManager.updatePrivateDnsValidation( 281 new DnsManager.PrivateDnsValidationUpdate(TEST_NETID, 282 InetAddress.parseNumericAddress("3.3.3.3"), "hostname", 283 VALIDATION_RESULT_SUCCESS)); 284 mDnsManager.updatePrivateDnsStatus(TEST_NETID, lp); 285 assertFalse(lp.isPrivateDnsActive()); 286 assertNull(lp.getPrivateDnsServerName()); 287 288 // Validation event failed 289 mDnsManager.updatePrivateDnsValidation( 290 new DnsManager.PrivateDnsValidationUpdate(TEST_NETID, 291 InetAddress.parseNumericAddress("3.3.3.3"), "", 292 VALIDATION_RESULT_FAILURE)); 293 mDnsManager.updatePrivateDnsStatus(TEST_NETID, lp); 294 assertFalse(lp.isPrivateDnsActive()); 295 assertNull(lp.getPrivateDnsServerName()); 296 297 // Network removed 298 mDnsManager.removeNetwork(new Network(TEST_NETID)); 299 mDnsManager.updatePrivateDnsValidation( 300 new DnsManager.PrivateDnsValidationUpdate(TEST_NETID, 301 InetAddress.parseNumericAddress("3.3.3.3"), "", VALIDATION_RESULT_SUCCESS)); 302 mDnsManager.updatePrivateDnsStatus(TEST_NETID, lp); 303 assertFalse(lp.isPrivateDnsActive()); 304 assertNull(lp.getPrivateDnsServerName()); 305 306 // Turn private DNS mode off 307 ConnectivitySettingsManager.setPrivateDnsMode(mCtx, PRIVATE_DNS_MODE_OFF); 308 mDnsManager.updatePrivateDns(new Network(TEST_NETID), 309 mDnsManager.getPrivateDnsConfig()); 310 mDnsManager.updateTransportsForNetwork(TEST_NETID, TEST_TRANSPORT_TYPES); 311 mDnsManager.noteDnsServersForNetwork(TEST_NETID, lp); 312 mDnsManager.flushVmDnsCache(); 313 mDnsManager.updatePrivateDnsValidation( 314 new DnsManager.PrivateDnsValidationUpdate(TEST_NETID, 315 InetAddress.parseNumericAddress("3.3.3.3"), "", 316 VALIDATION_RESULT_SUCCESS)); 317 mDnsManager.updatePrivateDnsStatus(TEST_NETID, lp); 318 assertFalse(lp.isPrivateDnsActive()); 319 assertNull(lp.getPrivateDnsServerName()); 320 } 321 322 @Test testOverrideDefaultMode()323 public void testOverrideDefaultMode() throws Exception { 324 // Hard-coded default is opportunistic mode. 325 final PrivateDnsConfig cfgAuto = DnsManager.getPrivateDnsConfig(mCtx); 326 assertTrue(cfgAuto.useTls); 327 assertEquals("", cfgAuto.hostname); 328 assertEquals(new InetAddress[0], cfgAuto.ips); 329 330 // Pretend a gservices push sets the default to "off". 331 ConnectivitySettingsManager.setPrivateDnsDefaultMode(mCtx, PRIVATE_DNS_MODE_OFF); 332 final PrivateDnsConfig cfgOff = DnsManager.getPrivateDnsConfig(mCtx); 333 assertFalse(cfgOff.useTls); 334 assertEquals("", cfgOff.hostname); 335 assertEquals(new InetAddress[0], cfgOff.ips); 336 337 // Strict mode still works. 338 ConnectivitySettingsManager.setPrivateDnsMode(mCtx, PRIVATE_DNS_MODE_PROVIDER_HOSTNAME); 339 ConnectivitySettingsManager.setPrivateDnsHostname(mCtx, "strictmode.com"); 340 final PrivateDnsConfig cfgStrict = DnsManager.getPrivateDnsConfig(mCtx); 341 assertTrue(cfgStrict.useTls); 342 assertEquals("strictmode.com", cfgStrict.hostname); 343 assertEquals(new InetAddress[0], cfgStrict.ips); 344 } 345 346 @Test testSendDnsConfiguration()347 public void testSendDnsConfiguration() throws Exception { 348 reset(mMockDnsResolver); 349 mDnsManager.updatePrivateDns(new Network(TEST_NETID), 350 mDnsManager.getPrivateDnsConfig()); 351 final LinkProperties lp = new LinkProperties(); 352 lp.setInterfaceName(TEST_IFACENAME); 353 lp.addDnsServer(InetAddress.getByName("3.3.3.3")); 354 lp.addDnsServer(InetAddress.getByName("4.4.4.4")); 355 mDnsManager.updateTransportsForNetwork(TEST_NETID, TEST_TRANSPORT_TYPES); 356 mDnsManager.noteDnsServersForNetwork(TEST_NETID, lp); 357 mDnsManager.flushVmDnsCache(); 358 359 final ArgumentCaptor<ResolverParamsParcel> resolverParamsParcelCaptor = 360 ArgumentCaptor.forClass(ResolverParamsParcel.class); 361 verify(mMockDnsResolver, times(1)).setResolverConfiguration( 362 resolverParamsParcelCaptor.capture()); 363 final ResolverParamsParcel actualParams = resolverParamsParcelCaptor.getValue(); 364 final ResolverParamsParcel expectedParams = new ResolverParamsParcel(); 365 expectedParams.netId = TEST_NETID; 366 expectedParams.sampleValiditySeconds = TEST_DEFAULT_SAMPLE_VALIDITY_SECONDS; 367 expectedParams.successThreshold = TEST_DEFAULT_SUCCESS_THRESHOLD_PERCENT; 368 expectedParams.minSamples = TEST_DEFAULT_MIN_SAMPLES; 369 expectedParams.maxSamples = TEST_DEFAULT_MAX_SAMPLES; 370 expectedParams.servers = new String[]{"3.3.3.3", "4.4.4.4"}; 371 expectedParams.domains = new String[]{}; 372 expectedParams.tlsName = ""; 373 expectedParams.tlsServers = new String[]{"3.3.3.3", "4.4.4.4"}; 374 expectedParams.transportTypes = TEST_TRANSPORT_TYPES; 375 expectedParams.resolverOptions = null; 376 assertResolverParamsEquals(actualParams, expectedParams); 377 } 378 379 @Test testTransportTypesEqual()380 public void testTransportTypesEqual() throws Exception { 381 SparseArray<String> ncTransTypes = MessageUtils.findMessageNames( 382 new Class[] { NetworkCapabilities.class }, new String[]{ "TRANSPORT_" }); 383 SparseArray<String> dnsTransTypes = MessageUtils.findMessageNames( 384 new Class[] { IDnsResolver.class }, new String[]{ "TRANSPORT_" }); 385 assertEquals(0, MIN_TRANSPORT); 386 assertEquals(MAX_TRANSPORT + 1, ncTransTypes.size()); 387 // TRANSPORT_UNKNOWN in IDnsResolver is defined to -1 and only for resolver. 388 assertEquals("TRANSPORT_UNKNOWN", dnsTransTypes.get(-1)); 389 assertEquals(ncTransTypes.size(), dnsTransTypes.size() - 1); 390 for (int i = MIN_TRANSPORT; i < MAX_TRANSPORT; i++) { 391 String name = ncTransTypes.get(i, null); 392 assertNotNull("Could not find NetworkCapabilies.TRANSPORT_* constant equal to " 393 + i, name); 394 assertEquals(name, dnsTransTypes.get(i)); 395 } 396 } 397 398 @Test testGetPrivateDnsConfigForNetwork()399 public void testGetPrivateDnsConfigForNetwork() throws Exception { 400 final Network network = new Network(TEST_NETID); 401 final InetAddress dnsAddr = InetAddressUtils.parseNumericAddress("3.3.3.3"); 402 final InetAddress[] tlsAddrs = new InetAddress[]{ 403 InetAddressUtils.parseNumericAddress("6.6.6.6"), 404 InetAddressUtils.parseNumericAddress("2001:db8:66:66::1") 405 }; 406 final String tlsName = "strictmode.com"; 407 LinkProperties lp = new LinkProperties(); 408 lp.addDnsServer(dnsAddr); 409 410 // The PrivateDnsConfig map is empty, so the default PRIVATE_DNS_OFF is returned. 411 PrivateDnsConfig privateDnsCfg = mDnsManager.getPrivateDnsConfig(network); 412 assertFalse(privateDnsCfg.useTls); 413 assertEquals("", privateDnsCfg.hostname); 414 assertEquals(new InetAddress[0], privateDnsCfg.ips); 415 416 // An entry with default PrivateDnsConfig is added to the PrivateDnsConfig map. 417 mDnsManager.updatePrivateDns(network, mDnsManager.getPrivateDnsConfig()); 418 mDnsManager.noteDnsServersForNetwork(TEST_NETID, lp); 419 mDnsManager.updatePrivateDnsValidation( 420 new DnsManager.PrivateDnsValidationUpdate(TEST_NETID, dnsAddr, "", 421 VALIDATION_RESULT_SUCCESS)); 422 mDnsManager.updatePrivateDnsStatus(TEST_NETID, lp); 423 privateDnsCfg = mDnsManager.getPrivateDnsConfig(network); 424 assertTrue(privateDnsCfg.useTls); 425 assertEquals("", privateDnsCfg.hostname); 426 assertEquals(new InetAddress[0], privateDnsCfg.ips); 427 428 // The original entry is overwritten by a new PrivateDnsConfig. 429 mDnsManager.updatePrivateDns(network, new PrivateDnsConfig(tlsName, tlsAddrs)); 430 mDnsManager.updatePrivateDnsStatus(TEST_NETID, lp); 431 privateDnsCfg = mDnsManager.getPrivateDnsConfig(network); 432 assertTrue(privateDnsCfg.useTls); 433 assertEquals(tlsName, privateDnsCfg.hostname); 434 assertEquals(tlsAddrs, privateDnsCfg.ips); 435 436 // The network is removed, so the PrivateDnsConfig map becomes empty again. 437 mDnsManager.removeNetwork(network); 438 privateDnsCfg = mDnsManager.getPrivateDnsConfig(network); 439 assertFalse(privateDnsCfg.useTls); 440 assertEquals("", privateDnsCfg.hostname); 441 assertEquals(new InetAddress[0], privateDnsCfg.ips); 442 } 443 } 444