/** * <p>validateIPMatch</p> * * @param ip a {@link java.lang.String} object. * @return a boolean. */ public boolean validateIPMatch(String ip){ if(IPLike.matches(m_address, ip)){ return m_isSupported; }else{ return false; } }
final AddressType addressType = classifyAddress(address); final AddressType patternType = classifyAddress(pattern); switch (addressType) { case IPv4: { addressFields = parseIPv4Address(address); patternFields = parseIPv4Address(pattern); expectedFieldCount = 4; matcher = new DecimalRangeMatcher(); final IPv6Address parsedAddress = parseIPv6Address(address); final IPv6Address parsedPattern = parseIPv6Address(pattern); } else { if (!matchNumericListOrRange(parsedAddress.scope, parsedPattern.scope, new DecimalRangeMatcher())) { return false; if (!matchNumericListOrRange(addressFields[i], patternFields[i], matcher)) { return false;
/** * Helper method in support of matchNumericListOrRange * * @param value a {@link java.lang.String} object. * @param pattern a {@link java.lang.String} object. * @return a boolean. */ public static boolean matchRange(final String value, final String pattern) { final int dashCount = countChar('-', pattern); if ("*".equals(pattern)) { return true; } else if (dashCount == 0) { return Long.parseLong(pattern, 10) == Long.parseLong(value, 10); } else if (dashCount > 1) { return false; } else if (dashCount == 1) { final String[] ar = pattern.split("-"); final long rangeBegin = Long.parseLong(ar[0]); final long rangeEnd = Long.parseLong(ar[1]); final long ip = Long.parseLong(value); return (ip >= rangeBegin && ip <= rangeEnd); } return false; }
public static boolean matchNumericListOrRange(final String value, final String patterns) { return matchNumericListOrRange(value, patterns, new DecimalRangeMatcher()); }
@Override public boolean match(final String value, final String range) { return matchRangeHex(value, range); } }
@Override public boolean match(final String value, final String range) { return matchRange(value, range); } }
private void determineServerInitialResponse() { int serverResponseValue = -1; if (m_currentLine != null) { if (m_currentLine.startsWith("HTTP/")) { serverResponseValue = parseHttpResponse(); if (IPLike.matchNumericListOrRange(String.valueOf(serverResponseValue), determineResponse(m_parameters))) { if (HttpMonitor.LOG.isDebugEnabled()) { HttpMonitor.LOG.debug("determineServerResponse: valid server response: "+serverResponseValue+" found."); } m_serviceStatus = PollStatus.SERVICE_AVAILABLE; } else { m_serviceStatus = PollStatus.SERVICE_UNAVAILABLE; final StringBuilder sb = new StringBuilder(); sb.append("HTTP response value: "); sb.append(serverResponseValue); sb.append(". Expecting: "); sb.append(determineResponse(m_parameters)); sb.append("."); m_reason = sb.toString(); } } } m_serverResponseCode = serverResponseValue; }
@Test public void testMatchRangeHex() { // Test a bunch of case-sensitivity cases assertTrue(IPLike.matchRangeHex("C0", "BF-C1")); assertTrue(IPLike.matchRangeHex("c0", "BF-C1")); assertTrue(IPLike.matchRangeHex("C0", "bf-C1")); assertTrue(IPLike.matchRangeHex("C0", "BF-c1")); assertTrue(IPLike.matchRangeHex("C0", "bF-c1")); assertTrue(IPLike.matchRangeHex("C0", "Bf-c1")); assertTrue(IPLike.matchRangeHex("C0", "bf-c1")); assertTrue(IPLike.matchRangeHex("c0", "bf-c1")); assertTrue(IPLike.matchRangeHex("C0", "C0")); assertTrue(IPLike.matchRangeHex("c0", "C0")); assertTrue(IPLike.matchRangeHex("C0", "c0")); assertTrue(IPLike.matchRangeHex("c0", "c0")); assertTrue(IPLike.matchRangeHex("C0", "C0-C8")); assertTrue(IPLike.matchRangeHex("C0", "B4-C0")); assertTrue(IPLike.matchRangeHex("c0", "01-FF")); assertTrue(IPLike.matchRangeHex("c0", "*")); assertFalse(IPLike.matchRangeHex("c0", "01-09")); assertFalse(IPLike.matchRangeHex("c0", "1-9")); assertTrue(IPLike.matchRangeHex("5", "1-9")); }
@Test public void testMatchRange() { assertTrue(IPLike.matchRange("192", "191-193")); assertTrue(IPLike.matchRange("192", "192")); assertTrue(IPLike.matchRange("192", "192-200")); assertTrue(IPLike.matchRange("192", "1-255")); assertTrue(IPLike.matchRange("192", "*")); assertFalse(IPLike.matchRange("192", "1-9")); }
private static void validateAddress(String errorContext, String address) { Objects.requireNonNull(errorContext); try { // Matches actually verifies the "pattern" before a match against a concrete ip address is performed // As we are only interesting in the validation, we just use "8.8.8.8". IPLike.matches("8.8.8.8", address); } catch (Exception ex) { throw new ClassificationException(errorContext, Errors.RULE_IP_ADDRESS_INVALID, address); } }
@Test public void testMatchOctet() { assertTrue(IPLike.matchNumericListOrRange("192", "191,192,193")); assertFalse(IPLike.matchNumericListOrRange("192", "190,191,194")); assertTrue(IPLike.matchNumericListOrRange("192", "10,172,190-193")); assertFalse(IPLike.matchNumericListOrRange("192", "10,172,193-199")); assertTrue(IPLike.matchNumericListOrRange("205", "200-300,400-500")); assertTrue(IPLike.matchNumericListOrRange("405", "200-300,400-500")); assertFalse(IPLike.matchNumericListOrRange("505", "200-300,400-500")); }
/** * Helper method in support of matchNumericListOrRange * * @param value a {@link java.lang.String} object. * @param pattern a {@link java.lang.String} object. * @return a boolean. */ public static boolean matchRangeHex(final String value, final String pattern) { final int dashCount = countChar('-', pattern); if ("*".equals(pattern)) { return true; } else if (dashCount == 0) { // Convert values to hex integers and compare return Long.parseLong(pattern, 16) == Long.parseLong(value, 16); } else if (dashCount > 1) { return false; } else if (dashCount == 1) { final String[] ar = pattern.split("-"); final long rangeBegin = Long.parseLong(ar[0], 16); final long rangeEnd = Long.parseLong(ar[1], 16); final long ip = Long.parseLong(value, 16); return (ip >= rangeBegin && ip <= rangeEnd); } return false; }
private static void validateAddress(String errorContext, String address) { Objects.requireNonNull(errorContext); try { // Matches actually verifies the "pattern" before a match against a concrete ip address is performed // As we are only interesting in the validation, we just use "8.8.8.8". IPLike.matches("8.8.8.8", address); } catch (Exception ex) { throw new ClassificationException(errorContext, Errors.RULE_IP_ADDRESS_INVALID, address); } }
public static boolean matches(final InetAddress address, final String pattern) { return matches(InetAddressUtils.str(address), pattern); }
@Override public void visitIpMatches(final List<String> ipMatches) { // if we've already matched a specific or range, don't bother with the ipmatches if (!shouldTryToMatch()) return; for (final String ipMatch : ipMatches) { if (IPLike.matches(m_address, ipMatch)) { handleMatch(); return; } } }
@Override public boolean matches(ClassificationRequest request) { if (value.isWildcard()) { return true; } final String currentAddressValue = valueExtractor.apply(request); if (value.hasWildcard()) { return IPLike.matches(currentAddressValue, value.getValue()); } return value.getValue().equals(currentAddressValue); } }
public boolean isProtocolSupported(InetAddress address, Map<String, Object> qualifiers) { if (qualifiers == null) { return false; } String ipMatch = getIpMatch(qualifiers); if (IPLike.matches(InetAddressUtils.str(address), ipMatch)) { return isSupported(qualifiers); } else { return false; } }
protected static void validateIpAddress(String errorContext, String ipAddressValue) throws InvalidRuleException { if (Strings.isNullOrEmpty(ipAddressValue)) { throw new InvalidRuleException(errorContext, Errors.RULE_IP_ADDRESS_INVALID, ipAddressValue); } try { StringValue value = new StringValue(ipAddressValue); if (!value.isWildcard()) { // The matches method parses the pattern (in this case the ipAddressValue) and validates // the address, as we don't care if it actually matches. We only want to know, if it considers the // "pattern" (in this case a concrete address) correct. IPLike.matches("8.8.8.8", ipAddressValue); } } catch (Exception ex) { throw new InvalidRuleException(errorContext, Errors.RULE_IP_ADDRESS_INVALID, ipAddressValue); } }
@Test public void testVerifyIpMatch() { assertTrue(IPLike.matches("192.168.0.1", "*.*.*.*")); assertTrue(IPLike.matches("192.168.0.1", "192.*.*.*")); assertTrue(IPLike.matches("192.168.0.1", "*.168.*.*")); assertTrue(IPLike.matches("192.168.0.1", "*.*.0.*")); assertTrue(IPLike.matches("192.168.0.1", "*.*.*.1")); assertTrue(IPLike.matches("192.168.0.1", "*.*.*.0-7")); assertTrue(IPLike.matches("192.168.0.1", "192.168.0.0-7")); assertTrue(IPLike.matches("192.168.0.1", "192.166,167,168.*.0,1,5-10")); assertFalse(IPLike.matches("192.168.0.1", "10.0.0.1")); assertFalse(IPLike.matches("192.168.0.1", "*.168.*.2")); assertFalse(IPLike.matches("192.168.0.1", "10.168.0.1")); assertTrue(IPLike.matches("10.1.1.1", "10.1.1.1")); assertTrue(IPLike.matches("fe80:0000:0000:0000:aaaa:bbbb:cccc:dddd", "*:*:*:*:*:*:*:*")); assertTrue(IPLike.matches("fe80:0000:0000:0000:aaaa:bbbb:cccc:dddd%4", "*:*:*:*:*:*:*:*")); assertTrue(IPLike.matches("fe80:0000:0000:0000:aaaa:bbbb:cccc:dddd%4", "*:*:*:*:*:*:*:*%4")); assertFalse(IPLike.matches("fe80:0000:0000:0000:aaaa:bbbb:cccc:dddd", "*:*:*:*:*:*:*:*%4")); assertTrue(IPLike.matches("fe80:0000:0000:0000:aaaa:bbbb:cccc:dddd", "fe80:*:*:*:*:*:*:*")); assertTrue(IPLike.matches("fe80:0000:0000:0000:aaaa:bbbb:cccc:dddd%4", "fe80:*:*:*:*:*:*:*")); assertTrue(IPLike.matches("fe80:0000:0000:0000:aaaa:bbbb:cccc:dddd%4", "fe80:*:*:*:*:*:*:*%4")); assertFalse(IPLike.matches("fe80:0000:0000:0000:aaaa:bbbb:cccc:dddd", "fe80:*:*:*:*:*:*:*%4")); assertTrue(IPLike.matches("fe80:0000:0000:0000:aaaa:bbbb:cccc:dddd", "*:*:*:0:*:*:*:*")); assertTrue(IPLike.matches("fe80:0000:0000:0000:aaaa:bbbb:cccc:dddd%4", "*:*:*:0:*:*:*:*")); assertTrue(IPLike.matches("fe80:0000:0000:0000:aaaa:bbbb:cccc:dddd%4", "*:*:*:0:*:*:*:*%4")); assertFalse(IPLike.matches("fe80:0000:0000:0000:aaaa:bbbb:cccc:dddd", "*:*:*:0:*:*:*:*%4"));