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