1 /* 2 * Copyright (C) 2010 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 android.net; 18 19 import android.net.IpPrefix; 20 import android.net.LinkAddress; 21 import android.net.LinkProperties; 22 import android.net.LinkProperties.ProvisioningChange; 23 import android.net.RouteInfo; 24 import android.system.OsConstants; 25 import android.test.suitebuilder.annotation.SmallTest; 26 import android.test.suitebuilder.annotation.Suppress; 27 import junit.framework.TestCase; 28 29 import java.net.InetAddress; 30 import java.util.ArrayList; 31 32 33 public class LinkPropertiesTest extends TestCase { 34 private static InetAddress ADDRV4 = NetworkUtils.numericToInetAddress("75.208.6.1"); 35 private static InetAddress ADDRV6 = NetworkUtils.numericToInetAddress( 36 "2001:0db8:85a3:0000:0000:8a2e:0370:7334"); 37 private static InetAddress DNS1 = NetworkUtils.numericToInetAddress("75.208.7.1"); 38 private static InetAddress DNS2 = NetworkUtils.numericToInetAddress("69.78.7.1"); 39 private static InetAddress DNS6 = NetworkUtils.numericToInetAddress("2001:4860:4860::8888"); 40 private static InetAddress GATEWAY1 = NetworkUtils.numericToInetAddress("75.208.8.1"); 41 private static InetAddress GATEWAY2 = NetworkUtils.numericToInetAddress("69.78.8.1"); 42 private static InetAddress GATEWAY61 = NetworkUtils.numericToInetAddress("fe80::6:0000:613"); 43 private static InetAddress GATEWAY62 = NetworkUtils.numericToInetAddress("fe80::6:2222"); 44 private static String NAME = "qmi0"; 45 private static int MTU = 1500; 46 47 private static LinkAddress LINKADDRV4 = new LinkAddress(ADDRV4, 32); 48 private static LinkAddress LINKADDRV6 = new LinkAddress(ADDRV6, 128); 49 private static LinkAddress LINKADDRV6LINKLOCAL = new LinkAddress("fe80::1/64"); 50 51 // TODO: replace all calls to NetworkUtils.numericToInetAddress with calls to this method. 52 private InetAddress Address(String addrString) { 53 return NetworkUtils.numericToInetAddress(addrString); 54 } 55 56 public void assertLinkPropertiesEqual(LinkProperties source, LinkProperties target) { 57 // Check implementation of equals(), element by element. 58 assertTrue(source.isIdenticalInterfaceName(target)); 59 assertTrue(target.isIdenticalInterfaceName(source)); 60 61 assertTrue(source.isIdenticalAddresses(target)); 62 assertTrue(target.isIdenticalAddresses(source)); 63 64 assertTrue(source.isIdenticalDnses(target)); 65 assertTrue(target.isIdenticalDnses(source)); 66 67 assertTrue(source.isIdenticalRoutes(target)); 68 assertTrue(target.isIdenticalRoutes(source)); 69 70 assertTrue(source.isIdenticalHttpProxy(target)); 71 assertTrue(target.isIdenticalHttpProxy(source)); 72 73 assertTrue(source.isIdenticalStackedLinks(target)); 74 assertTrue(target.isIdenticalStackedLinks(source)); 75 76 assertTrue(source.isIdenticalMtu(target)); 77 assertTrue(target.isIdenticalMtu(source)); 78 79 // Check result of equals(). 80 assertTrue(source.equals(target)); 81 assertTrue(target.equals(source)); 82 83 // Check hashCode. 84 assertEquals(source.hashCode(), target.hashCode()); 85 } 86 87 @SmallTest 88 public void testEqualsNull() { 89 LinkProperties source = new LinkProperties(); 90 LinkProperties target = new LinkProperties(); 91 92 assertFalse(source == target); 93 assertLinkPropertiesEqual(source, target); 94 } 95 96 @SmallTest 97 public void testEqualsSameOrder() { 98 try { 99 LinkProperties source = new LinkProperties(); 100 source.setInterfaceName(NAME); 101 // set 2 link addresses 102 source.addLinkAddress(LINKADDRV4); 103 source.addLinkAddress(LINKADDRV6); 104 // set 2 dnses 105 source.addDnsServer(DNS1); 106 source.addDnsServer(DNS2); 107 // set 2 gateways 108 source.addRoute(new RouteInfo(GATEWAY1)); 109 source.addRoute(new RouteInfo(GATEWAY2)); 110 source.setMtu(MTU); 111 112 LinkProperties target = new LinkProperties(); 113 114 // All fields are same 115 target.setInterfaceName(NAME); 116 target.addLinkAddress(LINKADDRV4); 117 target.addLinkAddress(LINKADDRV6); 118 target.addDnsServer(DNS1); 119 target.addDnsServer(DNS2); 120 target.addRoute(new RouteInfo(GATEWAY1)); 121 target.addRoute(new RouteInfo(GATEWAY2)); 122 target.setMtu(MTU); 123 124 assertLinkPropertiesEqual(source, target); 125 126 target.clear(); 127 // change Interface Name 128 target.setInterfaceName("qmi1"); 129 target.addLinkAddress(LINKADDRV4); 130 target.addLinkAddress(LINKADDRV6); 131 target.addDnsServer(DNS1); 132 target.addDnsServer(DNS2); 133 target.addRoute(new RouteInfo(GATEWAY1)); 134 target.addRoute(new RouteInfo(GATEWAY2)); 135 target.setMtu(MTU); 136 assertFalse(source.equals(target)); 137 138 target.clear(); 139 target.setInterfaceName(NAME); 140 // change link addresses 141 target.addLinkAddress(new LinkAddress( 142 NetworkUtils.numericToInetAddress("75.208.6.2"), 32)); 143 target.addLinkAddress(LINKADDRV6); 144 target.addDnsServer(DNS1); 145 target.addDnsServer(DNS2); 146 target.addRoute(new RouteInfo(GATEWAY1)); 147 target.addRoute(new RouteInfo(GATEWAY2)); 148 target.setMtu(MTU); 149 assertFalse(source.equals(target)); 150 151 target.clear(); 152 target.setInterfaceName(NAME); 153 target.addLinkAddress(LINKADDRV4); 154 target.addLinkAddress(LINKADDRV6); 155 // change dnses 156 target.addDnsServer(NetworkUtils.numericToInetAddress("75.208.7.2")); 157 target.addDnsServer(DNS2); 158 target.addRoute(new RouteInfo(GATEWAY1)); 159 target.addRoute(new RouteInfo(GATEWAY2)); 160 target.setMtu(MTU); 161 assertFalse(source.equals(target)); 162 163 target.clear(); 164 target.setInterfaceName(NAME); 165 target.addLinkAddress(LINKADDRV4); 166 target.addLinkAddress(LINKADDRV6); 167 target.addDnsServer(DNS1); 168 target.addDnsServer(DNS2); 169 // change gateway 170 target.addRoute(new RouteInfo(NetworkUtils.numericToInetAddress("75.208.8.2"))); 171 target.addRoute(new RouteInfo(GATEWAY2)); 172 target.setMtu(MTU); 173 assertFalse(source.equals(target)); 174 175 target.clear(); 176 target.setInterfaceName(NAME); 177 target.addLinkAddress(LINKADDRV4); 178 target.addLinkAddress(LINKADDRV6); 179 target.addDnsServer(DNS1); 180 target.addDnsServer(DNS2); 181 target.addRoute(new RouteInfo(GATEWAY1)); 182 target.addRoute(new RouteInfo(GATEWAY2)); 183 // change mtu 184 target.setMtu(1440); 185 assertFalse(source.equals(target)); 186 187 } catch (Exception e) { 188 throw new RuntimeException(e.toString()); 189 //fail(); 190 } 191 } 192 193 @SmallTest 194 public void testEqualsDifferentOrder() { 195 try { 196 LinkProperties source = new LinkProperties(); 197 source.setInterfaceName(NAME); 198 // set 2 link addresses 199 source.addLinkAddress(LINKADDRV4); 200 source.addLinkAddress(LINKADDRV6); 201 // set 2 dnses 202 source.addDnsServer(DNS1); 203 source.addDnsServer(DNS2); 204 // set 2 gateways 205 source.addRoute(new RouteInfo(GATEWAY1)); 206 source.addRoute(new RouteInfo(GATEWAY2)); 207 source.setMtu(MTU); 208 209 LinkProperties target = new LinkProperties(); 210 // Exchange order 211 target.setInterfaceName(NAME); 212 target.addLinkAddress(LINKADDRV6); 213 target.addLinkAddress(LINKADDRV4); 214 target.addDnsServer(DNS2); 215 target.addDnsServer(DNS1); 216 target.addRoute(new RouteInfo(GATEWAY2)); 217 target.addRoute(new RouteInfo(GATEWAY1)); 218 target.setMtu(MTU); 219 220 assertLinkPropertiesEqual(source, target); 221 } catch (Exception e) { 222 fail(); 223 } 224 } 225 226 @SmallTest 227 public void testEqualsDuplicated() { 228 try { 229 LinkProperties source = new LinkProperties(); 230 // set 3 link addresses, eg, [A, A, B] 231 source.addLinkAddress(LINKADDRV4); 232 source.addLinkAddress(LINKADDRV4); 233 source.addLinkAddress(LINKADDRV6); 234 235 LinkProperties target = new LinkProperties(); 236 // set 3 link addresses, eg, [A, B, B] 237 target.addLinkAddress(LINKADDRV4); 238 target.addLinkAddress(LINKADDRV6); 239 target.addLinkAddress(LINKADDRV6); 240 241 assertLinkPropertiesEqual(source, target); 242 } catch (Exception e) { 243 fail(); 244 } 245 } 246 247 private void assertAllRoutesHaveInterface(String iface, LinkProperties lp) { 248 for (RouteInfo r : lp.getRoutes()) { 249 assertEquals(iface, r.getInterface()); 250 } 251 } 252 253 @SmallTest 254 public void testRouteInterfaces() { 255 LinkAddress prefix = new LinkAddress( 256 NetworkUtils.numericToInetAddress("2001:db8::"), 32); 257 InetAddress address = ADDRV6; 258 259 // Add a route with no interface to a LinkProperties with no interface. No errors. 260 LinkProperties lp = new LinkProperties(); 261 RouteInfo r = new RouteInfo(prefix, address, null); 262 assertTrue(lp.addRoute(r)); 263 assertEquals(1, lp.getRoutes().size()); 264 assertAllRoutesHaveInterface(null, lp); 265 266 // Adding the same route twice has no effect. 267 assertFalse(lp.addRoute(r)); 268 assertEquals(1, lp.getRoutes().size()); 269 270 // Add a route with an interface. Expect an exception. 271 r = new RouteInfo(prefix, address, "wlan0"); 272 try { 273 lp.addRoute(r); 274 fail("Adding wlan0 route to LP with no interface, expect exception"); 275 } catch (IllegalArgumentException expected) {} 276 277 // Change the interface name. All the routes should change their interface name too. 278 lp.setInterfaceName("rmnet0"); 279 assertAllRoutesHaveInterface("rmnet0", lp); 280 281 // Now add a route with the wrong interface. This causes an exception too. 282 try { 283 lp.addRoute(r); 284 fail("Adding wlan0 route to rmnet0 LP, expect exception"); 285 } catch (IllegalArgumentException expected) {} 286 287 // If the interface name matches, the route is added. 288 r = new RouteInfo(prefix, null, "wlan0"); 289 lp.setInterfaceName("wlan0"); 290 lp.addRoute(r); 291 assertEquals(2, lp.getRoutes().size()); 292 assertAllRoutesHaveInterface("wlan0", lp); 293 294 // Routes with null interfaces are converted to wlan0. 295 r = RouteInfo.makeHostRoute(ADDRV6, null); 296 lp.addRoute(r); 297 assertEquals(3, lp.getRoutes().size()); 298 assertAllRoutesHaveInterface("wlan0", lp); 299 300 // Check comparisons work. 301 LinkProperties lp2 = new LinkProperties(lp); 302 assertAllRoutesHaveInterface("wlan0", lp); 303 assertEquals(0, lp.compareAllRoutes(lp2).added.size()); 304 assertEquals(0, lp.compareAllRoutes(lp2).removed.size()); 305 306 lp2.setInterfaceName("p2p0"); 307 assertAllRoutesHaveInterface("p2p0", lp2); 308 assertEquals(3, lp.compareAllRoutes(lp2).added.size()); 309 assertEquals(3, lp.compareAllRoutes(lp2).removed.size()); 310 } 311 312 @SmallTest 313 public void testStackedInterfaces() { 314 LinkProperties rmnet0 = new LinkProperties(); 315 rmnet0.setInterfaceName("rmnet0"); 316 rmnet0.addLinkAddress(LINKADDRV6); 317 318 LinkProperties clat4 = new LinkProperties(); 319 clat4.setInterfaceName("clat4"); 320 clat4.addLinkAddress(LINKADDRV4); 321 322 assertEquals(0, rmnet0.getStackedLinks().size()); 323 assertEquals(1, rmnet0.getAddresses().size()); 324 assertEquals(1, rmnet0.getLinkAddresses().size()); 325 assertEquals(1, rmnet0.getAllAddresses().size()); 326 assertEquals(1, rmnet0.getAllLinkAddresses().size()); 327 328 rmnet0.addStackedLink(clat4); 329 assertEquals(1, rmnet0.getStackedLinks().size()); 330 assertEquals(1, rmnet0.getAddresses().size()); 331 assertEquals(1, rmnet0.getLinkAddresses().size()); 332 assertEquals(2, rmnet0.getAllAddresses().size()); 333 assertEquals(2, rmnet0.getAllLinkAddresses().size()); 334 335 rmnet0.addStackedLink(clat4); 336 assertEquals(1, rmnet0.getStackedLinks().size()); 337 assertEquals(1, rmnet0.getAddresses().size()); 338 assertEquals(1, rmnet0.getLinkAddresses().size()); 339 assertEquals(2, rmnet0.getAllAddresses().size()); 340 assertEquals(2, rmnet0.getAllLinkAddresses().size()); 341 342 assertEquals(0, clat4.getStackedLinks().size()); 343 344 // Modify an item in the returned collection to see what happens. 345 for (LinkProperties link : rmnet0.getStackedLinks()) { 346 if (link.getInterfaceName().equals("clat4")) { 347 link.setInterfaceName("newname"); 348 } 349 } 350 for (LinkProperties link : rmnet0.getStackedLinks()) { 351 assertFalse("newname".equals(link.getInterfaceName())); 352 } 353 354 assertTrue(rmnet0.removeStackedLink("clat4")); 355 assertEquals(0, rmnet0.getStackedLinks().size()); 356 assertEquals(1, rmnet0.getAddresses().size()); 357 assertEquals(1, rmnet0.getLinkAddresses().size()); 358 assertEquals(1, rmnet0.getAllAddresses().size()); 359 assertEquals(1, rmnet0.getAllLinkAddresses().size()); 360 361 assertFalse(rmnet0.removeStackedLink("clat4")); 362 } 363 364 private LinkAddress getFirstLinkAddress(LinkProperties lp) { 365 return lp.getLinkAddresses().iterator().next(); 366 } 367 368 @SmallTest 369 public void testAddressMethods() { 370 LinkProperties lp = new LinkProperties(); 371 372 // No addresses. 373 assertFalse(lp.hasIPv4Address()); 374 assertFalse(lp.hasGlobalIPv6Address()); 375 376 // Addresses on stacked links don't count. 377 LinkProperties stacked = new LinkProperties(); 378 stacked.setInterfaceName("stacked"); 379 lp.addStackedLink(stacked); 380 stacked.addLinkAddress(LINKADDRV4); 381 stacked.addLinkAddress(LINKADDRV6); 382 assertTrue(stacked.hasIPv4Address()); 383 assertTrue(stacked.hasGlobalIPv6Address()); 384 assertFalse(lp.hasIPv4Address()); 385 assertFalse(lp.hasGlobalIPv6Address()); 386 lp.removeStackedLink("stacked"); 387 assertFalse(lp.hasIPv4Address()); 388 assertFalse(lp.hasGlobalIPv6Address()); 389 390 // Addresses on the base link. 391 // Check the return values of hasIPvXAddress and ensure the add/remove methods return true 392 // iff something changes. 393 assertEquals(0, lp.getLinkAddresses().size()); 394 assertTrue(lp.addLinkAddress(LINKADDRV6)); 395 assertEquals(1, lp.getLinkAddresses().size()); 396 assertFalse(lp.hasIPv4Address()); 397 assertTrue(lp.hasGlobalIPv6Address()); 398 399 assertTrue(lp.removeLinkAddress(LINKADDRV6)); 400 assertEquals(0, lp.getLinkAddresses().size()); 401 402 assertTrue(lp.addLinkAddress(LINKADDRV6LINKLOCAL)); 403 assertEquals(1, lp.getLinkAddresses().size()); 404 assertFalse(lp.hasGlobalIPv6Address()); 405 406 assertTrue(lp.addLinkAddress(LINKADDRV4)); 407 assertEquals(2, lp.getLinkAddresses().size()); 408 assertTrue(lp.hasIPv4Address()); 409 assertFalse(lp.hasGlobalIPv6Address()); 410 411 assertTrue(lp.addLinkAddress(LINKADDRV6)); 412 assertEquals(3, lp.getLinkAddresses().size()); 413 assertTrue(lp.hasIPv4Address()); 414 assertTrue(lp.hasGlobalIPv6Address()); 415 416 assertTrue(lp.removeLinkAddress(LINKADDRV6LINKLOCAL)); 417 assertEquals(2, lp.getLinkAddresses().size()); 418 assertTrue(lp.hasIPv4Address()); 419 assertTrue(lp.hasGlobalIPv6Address()); 420 421 // Adding an address twice has no effect. 422 // Removing an address that's not present has no effect. 423 assertFalse(lp.addLinkAddress(LINKADDRV4)); 424 assertEquals(2, lp.getLinkAddresses().size()); 425 assertTrue(lp.hasIPv4Address()); 426 assertTrue(lp.removeLinkAddress(LINKADDRV4)); 427 assertEquals(1, lp.getLinkAddresses().size()); 428 assertFalse(lp.hasIPv4Address()); 429 assertFalse(lp.removeLinkAddress(LINKADDRV4)); 430 assertEquals(1, lp.getLinkAddresses().size()); 431 432 // Adding an address that's already present but with different properties causes the 433 // existing address to be updated and returns true. 434 // Start with only LINKADDRV6. 435 assertEquals(1, lp.getLinkAddresses().size()); 436 assertEquals(LINKADDRV6, getFirstLinkAddress(lp)); 437 438 // Create a LinkAddress object for the same address, but with different flags. 439 LinkAddress deprecated = new LinkAddress(ADDRV6, 128, 440 OsConstants.IFA_F_DEPRECATED, OsConstants.RT_SCOPE_UNIVERSE); 441 assertTrue(deprecated.isSameAddressAs(LINKADDRV6)); 442 assertFalse(deprecated.equals(LINKADDRV6)); 443 444 // Check that adding it updates the existing address instead of adding a new one. 445 assertTrue(lp.addLinkAddress(deprecated)); 446 assertEquals(1, lp.getLinkAddresses().size()); 447 assertEquals(deprecated, getFirstLinkAddress(lp)); 448 assertFalse(LINKADDRV6.equals(getFirstLinkAddress(lp))); 449 450 // Removing LINKADDRV6 removes deprecated, because removing addresses ignores properties. 451 assertTrue(lp.removeLinkAddress(LINKADDRV6)); 452 assertEquals(0, lp.getLinkAddresses().size()); 453 } 454 455 @SmallTest 456 public void testSetLinkAddresses() { 457 LinkProperties lp = new LinkProperties(); 458 lp.addLinkAddress(LINKADDRV4); 459 lp.addLinkAddress(LINKADDRV6); 460 461 LinkProperties lp2 = new LinkProperties(); 462 lp2.addLinkAddress(LINKADDRV6); 463 464 assertFalse(lp.equals(lp2)); 465 466 lp2.setLinkAddresses(lp.getLinkAddresses()); 467 assertTrue(lp.equals(lp)); 468 } 469 470 @SmallTest 471 public void testIsProvisioned() { 472 LinkProperties lp4 = new LinkProperties(); 473 assertFalse("v4only:empty", lp4.isProvisioned()); 474 lp4.addLinkAddress(LINKADDRV4); 475 assertFalse("v4only:addr-only", lp4.isProvisioned()); 476 lp4.addDnsServer(DNS1); 477 assertFalse("v4only:addr+dns", lp4.isProvisioned()); 478 lp4.addRoute(new RouteInfo(GATEWAY1)); 479 assertTrue("v4only:addr+dns+route", lp4.isProvisioned()); 480 assertTrue("v4only:addr+dns+route", lp4.isIPv4Provisioned()); 481 assertFalse("v4only:addr+dns+route", lp4.isIPv6Provisioned()); 482 483 LinkProperties lp6 = new LinkProperties(); 484 assertFalse("v6only:empty", lp6.isProvisioned()); 485 lp6.addLinkAddress(LINKADDRV6LINKLOCAL); 486 assertFalse("v6only:fe80-only", lp6.isProvisioned()); 487 lp6.addDnsServer(DNS6); 488 assertFalse("v6only:fe80+dns", lp6.isProvisioned()); 489 lp6.addRoute(new RouteInfo(GATEWAY61)); 490 assertFalse("v6only:fe80+dns+route", lp6.isProvisioned()); 491 lp6.addLinkAddress(LINKADDRV6); 492 assertTrue("v6only:fe80+global+dns+route", lp6.isIPv6Provisioned()); 493 assertTrue("v6only:fe80+global+dns+route", lp6.isProvisioned()); 494 lp6.removeLinkAddress(LINKADDRV6LINKLOCAL); 495 assertFalse("v6only:global+dns+route", lp6.isIPv4Provisioned()); 496 assertTrue("v6only:global+dns+route", lp6.isIPv6Provisioned()); 497 assertTrue("v6only:global+dns+route", lp6.isProvisioned()); 498 499 LinkProperties lp46 = new LinkProperties(); 500 lp46.addLinkAddress(LINKADDRV4); 501 lp46.addLinkAddress(LINKADDRV6); 502 lp46.addDnsServer(DNS1); 503 lp46.addDnsServer(DNS6); 504 assertFalse("dualstack:missing-routes", lp46.isProvisioned()); 505 lp46.addRoute(new RouteInfo(GATEWAY1)); 506 assertTrue("dualstack:v4-provisioned", lp46.isIPv4Provisioned()); 507 assertFalse("dualstack:v4-provisioned", lp46.isIPv6Provisioned()); 508 assertTrue("dualstack:v4-provisioned", lp46.isProvisioned()); 509 lp46.addRoute(new RouteInfo(GATEWAY61)); 510 assertTrue("dualstack:both-provisioned", lp46.isIPv4Provisioned()); 511 assertTrue("dualstack:both-provisioned", lp46.isIPv6Provisioned()); 512 assertTrue("dualstack:both-provisioned", lp46.isProvisioned()); 513 514 // A link with an IPv6 address and default route, but IPv4 DNS server. 515 LinkProperties mixed = new LinkProperties(); 516 mixed.addLinkAddress(LINKADDRV6); 517 mixed.addDnsServer(DNS1); 518 mixed.addRoute(new RouteInfo(GATEWAY61)); 519 assertFalse("mixed:addr6+route6+dns4", mixed.isIPv4Provisioned()); 520 assertFalse("mixed:addr6+route6+dns4", mixed.isIPv6Provisioned()); 521 assertFalse("mixed:addr6+route6+dns4", mixed.isProvisioned()); 522 } 523 524 @SmallTest 525 public void testCompareProvisioning() { 526 LinkProperties v4lp = new LinkProperties(); 527 v4lp.addLinkAddress(LINKADDRV4); 528 v4lp.addRoute(new RouteInfo(GATEWAY1)); 529 v4lp.addDnsServer(DNS1); 530 assertTrue(v4lp.isProvisioned()); 531 532 LinkProperties v4r = new LinkProperties(v4lp); 533 v4r.removeDnsServer(DNS1); 534 assertFalse(v4r.isProvisioned()); 535 536 assertEquals(ProvisioningChange.STILL_NOT_PROVISIONED, 537 LinkProperties.compareProvisioning(v4r, v4r)); 538 assertEquals(ProvisioningChange.LOST_PROVISIONING, 539 LinkProperties.compareProvisioning(v4lp, v4r)); 540 assertEquals(ProvisioningChange.GAINED_PROVISIONING, 541 LinkProperties.compareProvisioning(v4r, v4lp)); 542 assertEquals(ProvisioningChange.STILL_PROVISIONED, 543 LinkProperties.compareProvisioning(v4lp, v4lp)); 544 545 // Check that losing IPv4 provisioning on a dualstack network is 546 // seen as a total loss of provisioning. 547 LinkProperties v6lp = new LinkProperties(); 548 v6lp.addLinkAddress(LINKADDRV6); 549 v6lp.addRoute(new RouteInfo(GATEWAY61)); 550 v6lp.addDnsServer(DNS6); 551 assertFalse(v6lp.isIPv4Provisioned()); 552 assertTrue(v6lp.isIPv6Provisioned()); 553 assertTrue(v6lp.isProvisioned()); 554 555 LinkProperties v46lp = new LinkProperties(v6lp); 556 v46lp.addLinkAddress(LINKADDRV4); 557 v46lp.addRoute(new RouteInfo(GATEWAY1)); 558 v46lp.addDnsServer(DNS1); 559 assertTrue(v46lp.isIPv4Provisioned()); 560 assertTrue(v46lp.isIPv6Provisioned()); 561 assertTrue(v46lp.isProvisioned()); 562 563 assertEquals(ProvisioningChange.STILL_PROVISIONED, 564 LinkProperties.compareProvisioning(v4lp, v46lp)); 565 assertEquals(ProvisioningChange.STILL_PROVISIONED, 566 LinkProperties.compareProvisioning(v6lp, v46lp)); 567 assertEquals(ProvisioningChange.LOST_PROVISIONING, 568 LinkProperties.compareProvisioning(v46lp, v6lp)); 569 assertEquals(ProvisioningChange.LOST_PROVISIONING, 570 LinkProperties.compareProvisioning(v46lp, v4lp)); 571 572 // Check that losing and gaining a secondary router does not change 573 // the provisioning status. 574 LinkProperties v6lp2 = new LinkProperties(v6lp); 575 v6lp2.addRoute(new RouteInfo(GATEWAY62)); 576 assertTrue(v6lp2.isProvisioned()); 577 578 assertEquals(ProvisioningChange.STILL_PROVISIONED, 579 LinkProperties.compareProvisioning(v6lp2, v6lp)); 580 assertEquals(ProvisioningChange.STILL_PROVISIONED, 581 LinkProperties.compareProvisioning(v6lp, v6lp2)); 582 } 583 584 @SmallTest 585 @Suppress // Failing. 586 public void testIsReachable() { 587 final LinkProperties v4lp = new LinkProperties(); 588 assertFalse(v4lp.isReachable(DNS1)); 589 assertFalse(v4lp.isReachable(DNS2)); 590 591 // Add an on-link route, making the on-link DNS server reachable, 592 // but there is still no IPv4 address. 593 assertTrue(v4lp.addRoute(new RouteInfo( 594 new IpPrefix(NetworkUtils.numericToInetAddress("75.208.0.0"), 16)))); 595 assertFalse(v4lp.isReachable(DNS1)); 596 assertFalse(v4lp.isReachable(DNS2)); 597 598 // Adding an IPv4 address (right now, any IPv4 address) means we use 599 // the routes to compute likely reachability. 600 assertTrue(v4lp.addLinkAddress(new LinkAddress(ADDRV4, 16))); 601 assertTrue(v4lp.isReachable(DNS1)); 602 assertFalse(v4lp.isReachable(DNS2)); 603 604 // Adding a default route makes the off-link DNS server reachable. 605 assertTrue(v4lp.addRoute(new RouteInfo(GATEWAY1))); 606 assertTrue(v4lp.isReachable(DNS1)); 607 assertTrue(v4lp.isReachable(DNS2)); 608 609 final LinkProperties v6lp = new LinkProperties(); 610 final InetAddress kLinkLocalDns = NetworkUtils.numericToInetAddress("fe80::6:1"); 611 final InetAddress kLinkLocalDnsWithScope = NetworkUtils.numericToInetAddress("fe80::6:2%43"); 612 final InetAddress kOnLinkDns = NetworkUtils.numericToInetAddress("2001:db8:85a3::53"); 613 assertFalse(v6lp.isReachable(kLinkLocalDns)); 614 assertFalse(v6lp.isReachable(kLinkLocalDnsWithScope)); 615 assertFalse(v6lp.isReachable(kOnLinkDns)); 616 assertFalse(v6lp.isReachable(DNS6)); 617 618 // Add a link-local route, making the link-local DNS servers reachable. Because 619 // we assume the presence of an IPv6 link-local address, link-local DNS servers 620 // are considered reachable, but only those with a non-zero scope identifier. 621 assertTrue(v6lp.addRoute(new RouteInfo( 622 new IpPrefix(NetworkUtils.numericToInetAddress("fe80::"), 64)))); 623 assertFalse(v6lp.isReachable(kLinkLocalDns)); 624 assertTrue(v6lp.isReachable(kLinkLocalDnsWithScope)); 625 assertFalse(v6lp.isReachable(kOnLinkDns)); 626 assertFalse(v6lp.isReachable(DNS6)); 627 628 // Add a link-local address--nothing changes. 629 assertTrue(v6lp.addLinkAddress(LINKADDRV6LINKLOCAL)); 630 assertFalse(v6lp.isReachable(kLinkLocalDns)); 631 assertTrue(v6lp.isReachable(kLinkLocalDnsWithScope)); 632 assertFalse(v6lp.isReachable(kOnLinkDns)); 633 assertFalse(v6lp.isReachable(DNS6)); 634 635 // Add a global route on link, but no global address yet. DNS servers reachable 636 // via a route that doesn't require a gateway: give them the benefit of the 637 // doubt and hope the link-local source address suffices for communication. 638 assertTrue(v6lp.addRoute(new RouteInfo( 639 new IpPrefix(NetworkUtils.numericToInetAddress("2001:db8:85a3::"), 64)))); 640 assertFalse(v6lp.isReachable(kLinkLocalDns)); 641 assertTrue(v6lp.isReachable(kLinkLocalDnsWithScope)); 642 assertTrue(v6lp.isReachable(kOnLinkDns)); 643 assertFalse(v6lp.isReachable(DNS6)); 644 645 // Add a global address; the on-link global address DNS server is (still) 646 // presumed reachable. 647 assertTrue(v6lp.addLinkAddress(new LinkAddress(ADDRV6, 64))); 648 assertFalse(v6lp.isReachable(kLinkLocalDns)); 649 assertTrue(v6lp.isReachable(kLinkLocalDnsWithScope)); 650 assertTrue(v6lp.isReachable(kOnLinkDns)); 651 assertFalse(v6lp.isReachable(DNS6)); 652 653 // Adding a default route makes the off-link DNS server reachable. 654 assertTrue(v6lp.addRoute(new RouteInfo(GATEWAY62))); 655 assertFalse(v6lp.isReachable(kLinkLocalDns)); 656 assertTrue(v6lp.isReachable(kLinkLocalDnsWithScope)); 657 assertTrue(v6lp.isReachable(kOnLinkDns)); 658 assertTrue(v6lp.isReachable(DNS6)); 659 660 // Check isReachable on stacked links. This requires that the source IP address be assigned 661 // on the interface returned by the route lookup. 662 LinkProperties stacked = new LinkProperties(); 663 664 // Can't add a stacked link without an interface name. 665 stacked.setInterfaceName("v4-test0"); 666 v6lp.addStackedLink(stacked); 667 668 InetAddress stackedAddress = Address("192.0.0.4"); 669 LinkAddress stackedLinkAddress = new LinkAddress(stackedAddress, 32); 670 assertFalse(v6lp.isReachable(stackedAddress)); 671 stacked.addLinkAddress(stackedLinkAddress); 672 assertFalse(v6lp.isReachable(stackedAddress)); 673 stacked.addRoute(new RouteInfo(stackedLinkAddress)); 674 assertTrue(stacked.isReachable(stackedAddress)); 675 assertTrue(v6lp.isReachable(stackedAddress)); 676 677 assertFalse(v6lp.isReachable(DNS1)); 678 stacked.addRoute(new RouteInfo((IpPrefix) null, stackedAddress)); 679 assertTrue(v6lp.isReachable(DNS1)); 680 } 681 } 682
