private static boolean rangesContain(Collection<SubRange> ranges, int num) { for (SubRange range : ranges) { if (range.getStart() <= num && num <= range.getEnd()) { return true; } } return false; }
public static RangeMatchExpr fromSubRanges(VarIntExpr var, int bits, Set<SubRange> range) { return new RangeMatchExpr( var, bits, range.stream() .map(subRange -> Range.closed((long) subRange.getStart(), (long) subRange.getEnd())) .collect(ImmutableSet.toImmutableSet())); }
/** * Returns true if the {@code other} subrange is <b>fully</b> contained within this subrange. An * empty {@code other} is trivially considered to be contained within any subrange. */ public boolean contains(@Nonnull SubRange other) { return other.isEmpty() || (_start <= other.getStart() && _end >= other.getEnd()); }
@Override @JsonValue public String toString() { int prefixLength = _prefix.getPrefixLength(); int low = _lengthRange.getStart(); int high = _lengthRange.getEnd(); if (prefixLength == low && prefixLength == high) { return _prefix.toString(); } else { return _prefix + ":" + low + "-" + high; } }
@Override @JsonValue public String toString() { int prefixLength = _first.getPrefixLength(); int low = _second.getStart(); int high = _second.getEnd(); if (prefixLength == low && prefixLength == high) { return _first.toString(); } else { return _first + ";" + low + "-" + high; } } }
/** Exclude a {@link SubRange} */ public Builder excluding(SubRange range) { if (!range.isEmpty()) { _excluding.add( Range.closed(range.getStart(), range.getEnd()).canonical(DiscreteDomain.integers())); } return this; }
/** Include a {@link SubRange} */ public Builder including(SubRange range) { if (!range.isEmpty()) { _including.add( Range.closed(range.getStart(), range.getEnd()).canonical(DiscreteDomain.integers())); } return this; }
public PrefixRange(Prefix prefix, SubRange lengthRange) { // Canonicalize the prefix by dropping extra bits in the address that are longer than any // relevant length. int realPrefixLength = Math.min(prefix.getPrefixLength(), lengthRange.getEnd()); Ip realPrefixAddress = prefix.getStartIp().getNetworkAddress(realPrefixLength); this._prefix = Prefix.create(realPrefixAddress, prefix.getPrefixLength()); this._lengthRange = lengthRange; }
@VisibleForTesting static BDD toBDD(SubRange range, BDDInteger var) { long start = range.getStart(); long end = range.getEnd(); return start == end ? var.value(start) : var.geq(start).and(var.leq(end)); }
private boolean evaluatePrefix(Prefix prefix) { boolean accept = false; for (RouteFilterLine line : _lines) { if (line.getIpWildcard().containsIp(prefix.getStartIp())) { int prefixLength = prefix.getPrefixLength(); SubRange range = line.getLengthRange(); if (prefixLength >= range.getStart() && prefixLength <= range.getEnd()) { accept = line.getAction() == LineAction.PERMIT; break; } } } if (accept) { _permittedCache.get().add(prefix); } else { _deniedCache.get().add(prefix); } return accept; }
private boolean newPermits(Prefix6 prefix) { boolean accept = false; for (Route6FilterLine line : _lines) { if (line.getIpWildcard().contains(prefix.getAddress())) { int prefixLength = prefix.getPrefixLength(); SubRange range = line.getLengthRange(); if (prefixLength >= range.getStart() && prefixLength <= range.getEnd()) { accept = line.getAction() == LineAction.PERMIT; break; } } } if (accept) { _permittedCache.get().add(prefix); } else { _deniedCache.get().add(prefix); } return accept; }
private static BDD toBDD(SubRange subRange, BDDInteger var) { return var.geq(subRange.getStart()).and(var.leq(subRange.getEnd())); } }
@Test public void testEmptyRange() { SubRange range = new SubRange(3, 1); assertThat(range.isEmpty(), equalTo(true)); assertThat(range.getStart(), equalTo(3)); assertThat(range.getEnd(), equalTo(1)); assertThat(range.includes(1), equalTo(false)); assertThat(range.includes(2), equalTo(false)); assertThat(range.includes(3), equalTo(false)); }
public boolean includesPrefix6Range(Prefix6Range argPrefixRange) { Prefix6 prefix6 = getPrefix6(); SubRange lengthRange = getLengthRange(); int prefixLength = prefix6.getPrefixLength(); BigInteger maskedPrefixAsBigInteger = prefix6.getAddress().getNetworkAddress(prefixLength).asBigInteger(); Prefix6 argPrefix = argPrefixRange.getPrefix6(); SubRange argLengthRange = argPrefixRange.getLengthRange(); BigInteger argMaskedPrefixAsBigInteger = argPrefix.getAddress().getNetworkAddress(prefixLength).asBigInteger(); return maskedPrefixAsBigInteger.equals(argMaskedPrefixAsBigInteger) && lengthRange.getStart() <= argLengthRange.getStart() && lengthRange.getEnd() >= argLengthRange.getEnd(); }
public boolean includesPrefixRange(PrefixRange argPrefixRange) { Prefix prefix = getPrefix(); SubRange lengthRange = getLengthRange(); int prefixLength = prefix.getPrefixLength(); long maskedPrefixAsLong = prefix.getStartIp().getNetworkAddress(prefixLength).asLong(); Prefix argPrefix = argPrefixRange.getPrefix(); SubRange argLengthRange = argPrefixRange.getLengthRange(); long argMaskedPrefixAsLong = argPrefix.getStartIp().getNetworkAddress(prefixLength).asLong(); return maskedPrefixAsLong == argMaskedPrefixAsLong && lengthRange.getStart() <= argLengthRange.getStart() && lengthRange.getEnd() >= argLengthRange.getEnd(); }
private BoolExpr toBoolExpr(SubRange range, ArithExpr var) { int start = range.getStart(); int end = range.getEnd(); ArithExpr startExpr = _context.mkInt(start); ArithExpr endExpr = _context.mkInt(end); return start == end ? _context.mkEq(var, startExpr) : _context.mkAnd(_context.mkGe(var, startExpr), _context.mkLe(var, endExpr)); }
public boolean includesPrefix6(Prefix6 argPrefix6) { Prefix6 prefix6 = getPrefix6(); SubRange lengthRange = getLengthRange(); int prefixLength = prefix6.getPrefixLength(); int minPrefixLength = lengthRange.getStart(); int maxPrefixLength = lengthRange.getEnd(); int argPrefixLength = argPrefix6.getPrefixLength(); if (minPrefixLength > argPrefixLength || maxPrefixLength < argPrefixLength) { return false; } BigInteger maskedPrefixAsBigInteger = prefix6.getAddress().getNetworkAddress(prefixLength).asBigInteger(); BigInteger argMaskedPrefixAsBigInteger = argPrefix6.getAddress().getNetworkAddress(prefixLength).asBigInteger(); return maskedPrefixAsBigInteger.equals(argMaskedPrefixAsBigInteger); }
public void addPrefixRange(PrefixRange prefixRange) { Prefix prefix = prefixRange.getPrefix(); BitSet bits = getAddressBits(prefix.getStartIp()); // The minimum length of the range may be shorter than the actual prefix length. // If so, we need to specially handle all shorter prefixes with a custom address and bitset. int minLength = prefixRange.getLengthRange().getStart(); int maxLength = Math.min(prefixRange.getLengthRange().getEnd(), prefix.getPrefixLength() - 1); for (int currentLength = minLength; currentLength <= maxLength; currentLength++) { Prefix currentPrefix = Prefix.create(prefix.getStartIp(), currentLength); PrefixRange currentPrefixRange = PrefixRange.fromPrefix(currentPrefix); BitSet currentBits = getAddressBits(currentPrefix.getStartIp()); _root.addPrefixRange(currentPrefixRange, currentBits, currentLength, 0); } // Otherwise, add the prefix range as-is. _root.addPrefixRange(prefixRange, bits, prefix.getPrefixLength(), 0); }
private BDD isRelevantFor(BDDRoute record, PrefixRange range) { Prefix p = range.getPrefix(); SubRange r = range.getLengthRange(); int len = p.getPrefixLength(); int lower = r.getStart(); int upper = r.getEnd(); BDD lowerBitsMatch = firstBitsEqual(record.getPrefix().getBitvec(), p, len); BDD acc = factory.zero(); if (lower == 0 && upper == 32) { acc = factory.one(); } else { for (int i = lower; i <= upper; i++) { BDD equalLen = record.getPrefixLength().value(i); acc = acc.or(equalLen); } } return acc.and(lowerBitsMatch); }
BoolExpr isRelevantFor(ArithExpr prefixLen, PrefixRange range) { Prefix p = range.getPrefix(); SubRange r = range.getLengthRange(); long pfx = p.getStartIp().asLong(); int len = p.getPrefixLength(); int lower = r.getStart(); int upper = r.getEnd(); // well formed prefix assert (p.getPrefixLength() <= lower && lower <= upper); BoolExpr lowerBitsMatch = firstBitsEqual(_symbolicPacket.getDstIp(), pfx, len); if (lower == upper) { BoolExpr equalLen = mkEq(prefixLen, mkInt(lower)); return mkAnd(equalLen, lowerBitsMatch); } else { BoolExpr lengthLowerBound = mkGe(prefixLen, mkInt(lower)); BoolExpr lengthUpperBound = mkLe(prefixLen, mkInt(upper)); return mkAnd(lengthLowerBound, lengthUpperBound, lowerBitsMatch); } }