public RouteFilterLine(LineAction action, Prefix prefix, SubRange lengthRange) { _action = action; _ipWildcard = new IpWildcard(prefix); _lengthRange = lengthRange; }
boolean relevantPrefix(Prefix p) { if (_headerSpace.getDstIps() == null) { return true; } return new IpSpaceMayIntersectWildcard(new IpWildcard(p), ImmutableMap.of()) .visit(_headerSpace.getDstIps()); }
private static IpWildcard toIpWildcard(Wildcard_addressContext ctx) { Ip address = Ip.parse(ctx.ip_address.getText()); Ip mask = Ip.parse(ctx.wildcard_mask.getText()); // Mask needs to be inverted since 0's are don't-cares in this context return new IpWildcard(address, mask.inverted()); }
@VisibleForTesting IpSpace computeIpsAssignedToThisInterface(Interface iface) { Set<Ip> ips = _interfaceOwnedIps.get(iface.getOwner().getHostname()).get(iface.getName()); if (ips == null || ips.isEmpty()) { return EmptyIpSpace.INSTANCE; } IpWildcardSetIpSpace.Builder ipsAssignedToThisInterfaceBuilder = IpWildcardSetIpSpace.builder(); ips.forEach(ip -> ipsAssignedToThisInterfaceBuilder.including(new IpWildcard(ip))); IpWildcardSetIpSpace ipsAssignedToThisInterface = ipsAssignedToThisInterfaceBuilder.build(); return ipsAssignedToThisInterface; }
@Test public void testConstructors() { assertThat( new IpWildcard(Ip.parse("1.2.3.4")), equalTo(new IpWildcard(Ip.create(0x01020304L), Ip.ZERO))); assertThat(new IpWildcard("1.2.3.4"), equalTo(new IpWildcard(Ip.create(0x01020304L), Ip.ZERO))); assertThat(new IpWildcard("1.2.3.4/8"), equalTo(new IpWildcard("1.0.0.0/8"))); }
@Test public void testParseWildcards_two() { assertThat( parseWildcards("1.0.0.0/8, 2.0.0.0/8"), equalTo(ImmutableList.of(new IpWildcard("1.0.0.0/8"), new IpWildcard("2.0.0.0/8")))); } }
@Override public void exitCisprf_match(Cisprf_matchContext ctx) { _currentIsakmpProfile.setMatchIdentity( new IpWildcard(toIp(ctx.address), toIp(ctx.mask).inverted())); }
@Test public void testParseIpSpace_blacklist() { assertThat( parseIpSpace("1.0.0.0,2.0.0.0/8 - 3.0.0.0,4.0.0.0/32"), equalTo( IpWildcardSetIpSpace.builder() .including(ImmutableList.of(new IpWildcard("1.0.0.0"), new IpWildcard("2.0.0.0/8"))) .excluding( ImmutableList.of(new IpWildcard("3.0.0.0"), new IpWildcard("4.0.0.0/32"))) .build())); }
@Override public void applyTo(RouteFilterList rfl) { int prefixLength = _prefix.getPrefixLength(); org.batfish.datamodel.RouteFilterLine line = new org.batfish.datamodel.RouteFilterLine( LineAction.PERMIT, new IpWildcard( Prefix.create(_prefix.getStartIp(), prefixLength).getStartIp(), _addressMask), new SubRange(prefixLength, prefixLength)); rfl.addLine(line); }
private void excludeRoutableIps(IpWildcardSetIpSpace.Builder builder) { if (hasForwardingRoute()) { builder.excluding(new IpWildcard(_prefix)); } else { if (_left != null) { _left.excludeRoutableIps(builder); } if (_right != null) { _right.excludeRoutableIps(builder); } } }
@Override public void exitRe_network(Re_networkContext ctx) { if (_currentEigrpProcess == null) { _w.addWarning(ctx, getFullText(ctx), _parser, "No EIGRP process available"); return; } // In process context Ip address = toIp(ctx.address); Ip mask = (ctx.mask != null) ? toIp(ctx.mask) : address.getClassMask().inverted(); _currentEigrpProcess.getWildcardNetworks().add(new IpWildcard(address, mask)); }
@Test public void testSupersetOf() { IpWildcard wc1 = new IpWildcard("1.2.0.0/16"); IpWildcard wc2 = new IpWildcard("1.2.3.0/24"); assertThat("IpWildcard.supersetOf should not be strict", wc1.supersetOf(wc1)); assertThat("wc1 should be a superset of wc2", wc1.supersetOf(wc2)); assertThat("wc2 should not be a superset of wc1", !wc2.supersetOf(wc1)); wc1 = new IpWildcard(Ip.create(0x12005600L), Ip.create(0xFF00FF00L).inverted()); wc2 = new IpWildcard(Ip.create(0x12345600L), Ip.create(0xFFFFFF00L).inverted()); assertThat("wc1 should be a superset of wc2", wc1.supersetOf(wc2)); assertThat("wc2 should not be a superset of wc1", !wc2.supersetOf(wc1)); }
@Test public void testParseIpSpace_whitelist() { assertThat( parseIpSpace("1.0.0.0,2.0.0.0/8"), equalTo( IpWildcardSetIpSpace.builder() .including(ImmutableList.of(new IpWildcard("1.0.0.0"), new IpWildcard("2.0.0.0/8"))) .build())); }
@Test public void testConnectedTo() { assertThat( new FlexibleInterfaceSpecifierFactory().buildInterfaceSpecifier("connectedTo(1.2.3.4)"), equalTo(new InterfaceWithConnectedIpsSpecifier(new IpWildcard("1.2.3.4").toIpSpace()))); }
@Test public void testIntersects() { /* * The second Ip of an IpWildcard indicates which bits of the first Ip * are significant (i.e. not wild). In this example, since the significant bits of * wc1 and wc2 don't overlap, they should intersect (i.e. their bitwise OR is included in each). */ IpWildcard wc1 = new IpWildcard(Ip.create(0x00b0000aL), Ip.create(0x00FF00FFL).inverted()); IpWildcard wc2 = new IpWildcard(Ip.create(0x000cd000L), Ip.create(0x0000FF00L).inverted()); assertThat("wildcards should overlap", wc1.intersects(wc2)); }
@Test public void testVisitIpWildcardSetIpSpace_whitelistOne() { IpWildcard ipWildcard = new IpWildcard("1.2.3.4"); assertThat( SIMPLIFIER.simplify(IpWildcardSetIpSpace.builder().including(ipWildcard).build()), equalTo(ipWildcard.toIpSpace())); }
@Test public void testComplement() { IpSpace ipSpace = new IpWildcard(Ip.create(0x01010001L), Ip.create(0x0000FF00L)).toIpSpace().complement(); assertThat(ipSpace, not(containsIp(Ip.parse("1.1.1.1")))); assertThat(ipSpace, not(containsIp(Ip.parse("1.1.255.1")))); assertThat(ipSpace, containsIp(Ip.parse("1.1.0.0"))); }
@Override public void exitCkr_psk(Ckr_pskContext ctx) { Ip wildCardMask = ctx.wildcard_mask == null ? Ip.MAX : toIp(ctx.wildcard_mask); _currentKeyring.setKey( CommonUtil.sha256Digest(ctx.variable_permissive().getText() + CommonUtil.salt())); _currentKeyring.setRemoteIdentity( new IpWildcard(toIp(ctx.ip_address), wildCardMask.inverted())); }
@Test public void testSpecializeIpWildcardIpSpace() { IpSpace ipSpace = new IpWildcard(Ip.parse("255.0.255.0"), Ip.parse("0.255.0.255")).toIpSpace(); assertThat(specializer(ipSpace).visit(ipSpace), equalTo(UniverseIpSpace.INSTANCE)); assertThat( specializer(Prefix.parse("255.0.0.0/8").toIpSpace()).visit(ipSpace), equalTo(ipSpace)); assertThat( specializer(Ip.parse("1.2.3.4").toIpSpace()).visit(ipSpace), equalTo(EmptyIpSpace.INSTANCE)); }
@Test public void testIpWildcard_prefix() { IpSpace ipWildcardIpSpace = new IpWildcard(Ip.parse("123.0.0.0"), Ip.parse("0.255.255.255")).toIpSpace(); IpSpace prefixIpSpace = Prefix.parse("123.0.0.0/8").toIpSpace(); BDD bdd1 = ipWildcardIpSpace.accept(_ipSpaceToBdd); BDD bdd2 = prefixIpSpace.accept(_ipSpaceToBdd); assertThat(bdd1, equalTo(bdd2)); }