/*
- * Copyright (c) 2014 Contextream, Inc. and others. All rights reserved.
+ * Copyright (c) 2014, 2017 Contextream, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
*/
package org.opendaylight.lispflowmapping.lisp.util;
+import com.google.common.base.Preconditions;
+import com.google.common.net.InetAddresses;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
-
-import org.apache.commons.lang3.exception.ExceptionUtils;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LcafSegmentAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LcafSourceDestAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispAFIAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispIpv4Address;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispIpv6Address;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsegmentaddress.AddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsegmentaddress.Address;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsourcedestaddress.DstAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsourcedestaddress.DstAddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsourcedestaddress.SrcAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsourcedestaddress.SrcAddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainerBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv4;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv4Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv6;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv6Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafSegmentBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafSourceDest;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafSourceDestBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4AddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv6.Ipv6Address;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv6.Ipv6AddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafsegment.LcafSegmentAddr;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafsegment.LcafSegmentAddrBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddr;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddrBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IetfInetUtil;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SimpleAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.InstanceId;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ServicePath;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKeyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv4Binary;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv4PrefixBinary;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv6Binary;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv6PrefixBinary;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
+import org.opendaylight.yangtools.yang.common.Uint8;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class MaskUtil {
+public final class MaskUtil {
private static final Logger LOG = LoggerFactory.getLogger(MaskUtil.class);
- public static boolean isMaskable(LispAFIAddress address) {
- if (address instanceof Ipv4Address || address instanceof Ipv6Address || address instanceof LcafSegmentAddr) {
+ public static final short IPV4_MAX_MASK = 32;
+ public static final Uint8 IPV4_MAX_MASK_UINT = Uint8.valueOf(IPV4_MAX_MASK);
+ public static final short IPV6_MAX_MASK = 128;
+ public static final Uint8 IPV6_MAX_MASK_UINT = Uint8.valueOf(IPV6_MAX_MASK);
+
+ // Utility class, should not be instantiated
+ private MaskUtil() {
+ }
+
+ public static boolean isMaskable(Address address) {
+ if (address instanceof Ipv4Prefix || address instanceof Ipv6Prefix
+ || address instanceof Ipv4PrefixBinary || address instanceof Ipv6PrefixBinary
+ || address instanceof SourceDestKey) {
return true;
+ } else if (address instanceof InstanceId) {
+ return isMaskable(((InstanceId)address).getInstanceId().getAddress());
}
return false;
}
- public static boolean isMaskable(LispAddressContainer address) {
- if (address.getAddress() instanceof Ipv4 || address.getAddress() instanceof Ipv6) {
+ public static boolean isMaskable(SimpleAddress address) {
+ if (address.getIpPrefix() != null) {
return true;
- } else if (address.getAddress() instanceof LcafSegmentAddress) {
- return isMaskable(LispAFIConvertor.toAFIfromPrimitive(((LcafSegmentAddress) address).getAddress()
- .getPrimitiveAddress()));
- } else if (address.getAddress() instanceof LcafSourceDestAddress) {
- LcafSourceDestAddr sd = ((LcafSourceDest) address.getAddress()).getLcafSourceDestAddr();
- return isMaskable(LispAFIConvertor.toAFIfromPrimitive(sd.getSrcAddress().getPrimitiveAddress()))
- && isMaskable(LispAFIConvertor.toAFIfromPrimitive(sd.getDstAddress().getPrimitiveAddress()));
}
return false;
}
- public static LispAFIAddress normalize(LispAFIAddress address, short mask) {
- try {
- if (address instanceof Ipv4Address) {
- return LispAFIConvertor.asIPAfiAddress(normalizeIP(
- Inet4Address.getByName(((Ipv4Address) address).getIpv4Address().getValue()),
- mask).getHostAddress());
- } else if (address instanceof Ipv6Address) {
- return LispAFIConvertor.asIPv6AfiAddress(normalizeIP(
- Inet6Address.getByName(((Ipv6Address) address).getIpv6Address().getValue()),
- mask).getHostAddress());
- } else if (address instanceof LcafSegmentAddr) {
- LcafSegmentAddr segAddr = (LcafSegmentAddr) address;
- LispAFIAddress afiAddr = LispAFIConvertor
- .toAFIfromPrimitive(segAddr.getAddress().getPrimitiveAddress());
- Address normalizedAddr = new AddressBuilder().setPrimitiveAddress(
- LispAFIConvertor.toPrimitive(normalize(afiAddr, mask))).build();
- return new LcafSegmentAddrBuilder(segAddr).setAddress(normalizedAddr).build();
- }
- } catch (UnknownHostException e) {
- LOG.trace("Failed to normalize " + address + ": " + ExceptionUtils.getStackTrace(e));
- }
- return address;
+ private static int slashPosition(final String prefix) {
+ final int slash = prefix.lastIndexOf('/');
+ Preconditions.checkArgument(slash >= 0, "Argument %s does not contain a slash", prefix);
+ return slash;
+ }
+
+ public static String getPrefixAddress(final String prefix) {
+ return prefix.substring(0, slashPosition(prefix));
+ }
+
+ public static String getPrefixMask(final String prefix) {
+ return prefix.substring(slashPosition(prefix) + 1);
+ }
+
+ private static String[] splitPrefix(final String prefix) {
+ final int slash = slashPosition(prefix);
+ return new String[] { prefix.substring(0, slash), prefix.substring(slash + 1) };
}
- public static LispAFIAddress normalize(LispAFIAddress address) {
- if (address instanceof Ipv4Address) {
- return normalize(address, ((Ipv4Address) address).getMask());
- } else if (address instanceof Ipv6Address) {
- return normalize(address, ((Ipv6Address) address).getMask());
- } else if (address instanceof LcafSegmentAddr) {
- LcafSegmentAddr segAddr = (LcafSegmentAddr) address;
- LispAFIAddress afiAddr = LispAFIConvertor.toAFIfromPrimitive(segAddr.getAddress().getPrimitiveAddress());
- short mask = getMaskForAfiAddress(afiAddr);
- if (mask == 0) {
- return address;
+ public static Eid normalize(Eid eid, short mask) {
+ Address address = eid.getAddress();
+ try {
+ if (address instanceof Ipv4PrefixBinary) {
+ byte[] addr = ((Ipv4PrefixBinary) address).getIpv4AddressBinary().getValue();
+ return LispAddressUtil.asIpv4PrefixBinaryEid(eid, normalizeByteArray(addr, mask), mask);
+ } else if (address instanceof Ipv6PrefixBinary) {
+ byte[] addr = ((Ipv6PrefixBinary) address).getIpv6AddressBinary().getValue();
+ return LispAddressUtil.asIpv6PrefixBinaryEid(eid, normalizeByteArray(addr, mask), mask);
+ } else if (address instanceof Ipv4Prefix) {
+ final String addr = getPrefixAddress(((Ipv4Prefix)address).getIpv4Prefix().getValue());
+ InetAddress normalized = normalizeIP(InetAddresses.forString(addr), mask);
+ return LispAddressUtil.asIpv4PrefixEid(eid, (Inet4Address)normalized, mask);
+ } else if (address instanceof Ipv6Prefix) {
+ final String addr = getPrefixAddress(((Ipv6Prefix)address).getIpv6Prefix().getValue());
+ InetAddress normalized = normalizeIP(InetAddresses.forString(addr), mask);
+ return LispAddressUtil.asIpv6PrefixEid(eid, (Inet6Address)normalized, mask);
+ } else if (address instanceof InstanceId) {
+ // TODO - not absolutely necessary, but should be implemented
+ return eid;
}
- Address normalizedAddr = new AddressBuilder().setPrimitiveAddress(
- LispAFIConvertor.toPrimitive(normalize(afiAddr, mask))).build();
- return new LcafSegmentAddrBuilder(segAddr).setAddress(normalizedAddr).build();
+ } catch (UnknownHostException e) {
+ LOG.warn("Failed to normalize EID {} with mask {}, returning original EID", eid, mask, e);
}
- return address;
+ return eid;
}
- public static LispAddressContainer normalize(LispAddressContainer address, short mask) {
+ public static Eid normalize(Eid eid) {
+ Address address = eid.getAddress();
try {
- if (address.getAddress() instanceof Ipv4) {
- return LispAFIConvertor.asIPv4Prefix(normalizeIP(
- Inet4Address.getByName(((Ipv4) address.getAddress()).getIpv4Address().getIpv4Address().getValue()),
- mask).getHostAddress(), mask);
- } else if (address.getAddress() instanceof Ipv6) {
- return LispAFIConvertor.asIPv6Prefix(normalizeIP(
- Inet6Address.getByName(((Ipv6) address.getAddress()).getIpv6Address().getIpv6Address().getValue()),
- mask).getHostAddress(), mask);
- } else if (address instanceof LcafSegmentAddress) {
- LcafSegmentAddress segAddr = (LcafSegmentAddress) address;
- LispAFIAddress afiAddr = LispAFIConvertor
- .toAFIfromPrimitive(segAddr.getAddress().getPrimitiveAddress());
- Address normalizedAddr = new AddressBuilder().setPrimitiveAddress(
- LispAFIConvertor.toPrimitive(normalize(afiAddr, mask))).build();
- return new LispAddressContainerBuilder().setAddress(
- new LcafSegmentBuilder().setLcafSegmentAddr(
- new LcafSegmentAddrBuilder(segAddr).setAddress(normalizedAddr).build()).build())
- .build();
+ if (address instanceof Ipv4PrefixBinary) {
+ byte[] addr = ((Ipv4PrefixBinary) address).getIpv4AddressBinary().getValue();
+ short mask = ((Ipv4PrefixBinary) address).getIpv4MaskLength().toJava();
+ return LispAddressUtil.asIpv4PrefixBinaryEid(eid, normalizeByteArray(addr, mask), mask);
+ } else if (address instanceof Ipv6PrefixBinary) {
+ byte[] addr = ((Ipv6PrefixBinary) address).getIpv6AddressBinary().getValue();
+ short mask = ((Ipv6PrefixBinary) address).getIpv6MaskLength().toJava();
+ return LispAddressUtil.asIpv6PrefixBinaryEid(eid, normalizeByteArray(addr, mask), mask);
+ } else if (address instanceof Ipv4Prefix) {
+ String[] v4prefix = splitPrefix(((Ipv4Prefix)address).getIpv4Prefix().getValue());
+ short mask = Short.parseShort(v4prefix[1]);
+ InetAddress normalized = normalizeIP(InetAddresses.forString(v4prefix[0]), mask);
+ return LispAddressUtil.asIpv4PrefixEid(eid, (Inet4Address) normalized, mask);
+ } else if (address instanceof Ipv6Prefix) {
+ String[] v6prefix = splitPrefix(((Ipv6Prefix)address).getIpv6Prefix().getValue());
+ short mask = Short.parseShort(v6prefix[1]);
+ InetAddress normalized = normalizeIP(InetAddresses.forString(v6prefix[0]), mask);
+ return LispAddressUtil.asIpv6PrefixEid(eid, (Inet6Address) normalized, mask);
+ } else if (address instanceof Ipv4) {
+ return LispAddressUtil.asIpv4PrefixEid(((Ipv4) address).getIpv4(), eid.getVirtualNetworkId());
+ } else if (address instanceof Ipv6) {
+ return LispAddressUtil.asIpv6PrefixEid(((Ipv6) address).getIpv6(), eid.getVirtualNetworkId());
+ } else if (address instanceof InstanceId) {
+ // TODO - not absolutely necessary, but should be implemented
+ return eid;
+ } else if (address instanceof SourceDestKey) {
+ return normalizeSrcDst(eid);
+ } else if (address instanceof ServicePath) {
+ // Build new Service Path eid with service index set to 0
+ long spi = ((ServicePath) address).getServicePath().getServicePathId().getValue().toJava();
+ long vni = eid.getVirtualNetworkId() != null ? eid.getVirtualNetworkId().getValue().toJava() : -1;
+ return LispAddressUtil.asServicePathEid(vni, spi, (short)0);
}
} catch (UnknownHostException e) {
- LOG.trace("Failed to normalize " + address + ": " + ExceptionUtils.getStackTrace(e));
+ LOG.warn("Failed to normalize EID {}, returning original", eid, e);
}
- return address;
+ return eid;
}
- public static LispAddressContainer normalize(LispAddressContainer address) {
- if (address.getAddress() instanceof Ipv4) {
- return normalize(address, ((Ipv4)address.getAddress()).getIpv4Address().getMask());
- } else if (address.getAddress() instanceof Ipv6) {
- return normalize(address, ((Ipv6)address.getAddress()).getIpv6Address().getMask());
- } else if (address instanceof LcafSegmentAddress) {
- LcafSegmentAddress segAddr = (LcafSegmentAddress) address;
- LispAFIAddress afiAddr = LispAFIConvertor
- .toAFIfromPrimitive(segAddr.getAddress().getPrimitiveAddress());
- short mask = getMaskForAfiAddress(afiAddr);
- if (mask == 0) {
- return address;
- }
- Address normalizedAddr = new AddressBuilder().setPrimitiveAddress(
- LispAFIConvertor.toPrimitive(normalize(afiAddr, mask))).build();
- return new LispAddressContainerBuilder().setAddress(
- new LcafSegmentBuilder().setLcafSegmentAddr(
- new LcafSegmentAddrBuilder(segAddr).setAddress(normalizedAddr).build()).build())
- .build();
+ private static Eid normalizeSrcDst(Eid eid) throws UnknownHostException {
+ final SimpleAddress normalizedSrc = normalizeSimpleAddress(
+ ((SourceDestKey) eid.getAddress()).getSourceDestKey().getSource());
+ final SimpleAddress normalizedDst = normalizeSimpleAddress(
+ ((SourceDestKey) eid.getAddress()).getSourceDestKey().getDest());
+ return LispAddressUtil.asSrcDstEid(new SourceDestKeyBuilder()
+ .setSource(normalizedSrc).setDest(normalizedDst).build(), eid.getVirtualNetworkId());
+ }
+
+ private static SimpleAddress normalizeSimpleAddress(SimpleAddress address) throws UnknownHostException {
+ if (address.getIpPrefix() == null) {
+ return address;
}
- return address;
+ return new SimpleAddress(normalizeIpPrefix(address.getIpPrefix()));
}
- private static InetAddress normalizeIP(InetAddress address, int mask) throws UnknownHostException {
- ByteBuffer byteRepresentation = ByteBuffer.wrap(address.getAddress());
- byte b = (byte) 0xff;
- for (int i = 0; i < byteRepresentation.array().length; i++) {
- if (mask >= 8)
- byteRepresentation.put(i, (byte) (b & byteRepresentation.get(i)));
+ private static IpPrefix normalizeIpPrefix(IpPrefix address) throws UnknownHostException {
+ String[] prefix = splitPrefix(address.stringValue());
+ short mask = Short.parseShort(prefix[1]);
- else if (mask > 0) {
- byteRepresentation.put(i, (byte) ((byte) (b << (8 - mask)) & byteRepresentation.get(i)));
- } else {
- byteRepresentation.put(i, (byte) (0 & byteRepresentation.get(i)));
- }
+ InetAddress normalizedAddress = normalizeIP(InetAddresses.forString(prefix[0]), mask);
+ return IetfInetUtil.ipPrefixFor(normalizedAddress.getAddress(), mask);
+ }
- mask -= 8;
- }
- return InetAddress.getByAddress(byteRepresentation.array());
+ private static InetAddress normalizeIP(InetAddress address, int maskLength) throws UnknownHostException {
+ return InetAddress.getByAddress(normalizeByteArray(address.getAddress(), (short) maskLength));
}
- public static String normalizeIPString(String addr, int mask) {
- short afi = getIpAfiForString(addr);
- try {
- if (afi == 1) {
- return normalizeIP(Inet4Address.getByName(addr), mask).getHostAddress();
- } else if (afi == 2) {
- return normalizeIP(Inet6Address.getByName(addr), mask).getHostAddress();
+ public static byte[] normalizeByteArray(byte[] address, short maskLength) {
+ ByteBuffer byteRepresentation = ByteBuffer.wrap(address);
+ byte byteMask = (byte) 0xff;
+ int mask = maskLength;
+ for (int i = 0; i < byteRepresentation.array().length; i++) {
+ if (mask >= 8) {
+ byteRepresentation.put(i, (byte) (byteMask & byteRepresentation.get(i)));
+ } else if (mask > 0) {
+ byteRepresentation.put(i, (byte) ((byte) (byteMask << 8 - mask) & byteRepresentation.get(i)));
} else {
- LOG.debug("The string {} is not a valid IP address!", addr);
- return null;
+ byteRepresentation.put(i, (byte) (0 & byteRepresentation.get(i)));
}
- } catch (Exception e){
- LOG.trace("Failed to normalize " + addr + ": " + ExceptionUtils.getStackTrace(e));
- }
- return null;
- }
- public static int getMaxMask(LispAFIAddress address) {
- if (address instanceof Ipv4Address) {
- return 32;
- }
- if (address instanceof Ipv6Address) {
- return 128;
+ mask -= 8;
}
- return -1;
+ return byteRepresentation.array();
}
- public static byte getMaxMaskForAfi(int afi) {
- if (afi == 1) {
- return (byte) 32;
- } else if (afi == 2) {
- return (byte) 128;
+ public static int getMaxMask(Address address) {
+ if (address instanceof Ipv4 || address instanceof Ipv4Prefix || address instanceof Ipv4Binary
+ || address instanceof Ipv4PrefixBinary) {
+ return IPV4_MAX_MASK;
+ } else if (address instanceof Ipv6 || address instanceof Ipv6Prefix || address instanceof Ipv4Binary
+ || address instanceof Ipv6PrefixBinary) {
+ return IPV6_MAX_MASK;
} else {
- return (byte) -1;
+ return -1;
}
}
- private static short getMaskForAfiAddress(LispAFIAddress addr) {
- if (addr instanceof Ipv4Address) {
- Short res = ((Ipv4Address) addr).getMask();
- return (res != null) ? res.shortValue() : 32;
- } else if (addr instanceof Ipv6Address) {
- Short res = ((Ipv6Address) addr).getMask();
- return (res != null) ? res.shortValue() : 128;
+ private static String getIpPrefixString(IpPrefix prefix) {
+ if (prefix.getIpv4Prefix() != null) {
+ return prefix.getIpv4Prefix().getValue();
+ } else if (prefix.getIpv6Prefix() != null) {
+ return prefix.getIpv6Prefix().getValue();
} else {
- return 0;
+ throw new IllegalArgumentException("Invalid prefix " + prefix);
}
}
- public static short getMaskForAddress(LispAddressContainer addr) {
- if (addr.getAddress() instanceof Ipv4) {
- Short res = ((Ipv4)addr.getAddress()).getIpv4Address().getMask();
- return (res != null) ? res.shortValue() : 32;
- } else if (addr.getAddress() instanceof Ipv6) {
- Short res = ((Ipv6)addr.getAddress()).getIpv6Address().getMask();
- return (res != null) ? res.shortValue() : 128;
- } else if (addr.getAddress() instanceof LcafSegmentAddress) {
- return getMaskForAfiAddress(LispAFIConvertor.toAFIfromPrimitive(((LcafSegmentAddress) addr.getAddress())
- .getAddress().getPrimitiveAddress()));
- }
- return 0;
+ public static short getMaskForIpPrefix(IpPrefix prefix) {
+ return Short.parseShort(getPrefixMask(getIpPrefixString(prefix)));
}
- private static short getIpAfiForString(String addr) {
- if(addr.matches("([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])") == true){
- return 1;
- }
- else if(addr.matches("([0-9a-f]+)\\:([0-9a-f]+)\\:([0-9a-f]+)\\:([0-9a-f]+)\\:([0-9a-f]+)\\:([0-9a-f]+)\\:([0-9a-f]+)\\:([0-9a-f]+)") == true){
- return 2;
- }
- return -1;
+ public static String getAddressStringForIpPrefix(IpPrefix prefix) {
+ return getPrefixAddress(getIpPrefixString(prefix));
}
- public static LispAddressContainer setMask(LispAddressContainer addr, int mask) {
- if (addr.getAddress() instanceof Ipv4) {
- return new LispAddressContainerBuilder().setAddress(
- new Ipv4Builder().setIpv4Address(
- new Ipv4AddressBuilder(((Ipv4) addr.getAddress()).getIpv4Address()).setMask((short) mask)
- .build()).build()).build();
-
- } else if (addr.getAddress() instanceof Ipv6) {
- return new LispAddressContainerBuilder().setAddress(
- new Ipv6Builder().setIpv6Address(
- new Ipv6AddressBuilder(((Ipv6) addr.getAddress()).getIpv6Address()).setMask((short) mask)
- .build()).build()).build();
- } else if (addr.getAddress() instanceof LcafSegmentAddress) {
- setMask(LispAFIConvertor.toAFIfromPrimitive(((LcafSegmentAddress) addr.getAddress()).getAddress()
- .getPrimitiveAddress()), mask);
- }
- return addr;
+ public static String getAddressStringForIpv4Prefix(Ipv4Prefix prefix) {
+ return getPrefixAddress(prefix.getIpv4Prefix().getValue());
}
- public static LispAFIAddress setMask(LispAFIAddress addr, int mask) {
- if (addr instanceof LispIpv4Address) {
- return new Ipv4AddressBuilder().setIpv4Address(((LispIpv4Address) addr).getIpv4Address())
- .setAfi(addr.getAfi()).setMask((short)mask).build();
- } else if (addr instanceof LispIpv6Address) {
- return new Ipv6AddressBuilder().setIpv6Address(((LispIpv6Address) addr).getIpv6Address())
- .setAfi(addr.getAfi()).setMask((short)mask).build();
- } else if (addr instanceof LcafSegmentAddress) {
- LispAFIAddress afiAddr = LispAFIConvertor.toAFIfromPrimitive(((LcafSegmentAddress) addr).getAddress()
- .getPrimitiveAddress());
- afiAddr = setMask(afiAddr, mask);
- return new LcafSegmentAddrBuilder((LcafSegmentAddress) addr).setAddress(
- new AddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(afiAddr)).build()).build();
- }
- return addr;
+ public static String getAddressStringForIpv6Prefix(Ipv6Prefix prefix) {
+ return getPrefixAddress(prefix.getIpv6Prefix().getValue());
}
- public static LispAFIAddress setMaskSourceDest(LispAFIAddress addr, int srcMask, int dstMask) {
- DstAddress dst = LcafSourceDestHelper.getDstAddress(addr);
- LispAFIAddress dstAfi = LispAFIConvertor.toAFIfromPrimitive(dst.getPrimitiveAddress());
- DstAddress newDst = new DstAddressBuilder(dst).setPrimitiveAddress(LispAFIConvertor.toPrimitive(setMask(dstAfi, dstMask))).build();
- SrcAddress src = LcafSourceDestHelper.getSrcAddress(addr);
- LispAFIAddress srcAfi = LispAFIConvertor.toAFIfromPrimitive(src.getPrimitiveAddress());
- SrcAddress newSrc = new SrcAddressBuilder(src).setPrimitiveAddress(LispAFIConvertor.toPrimitive(setMask(srcAfi, srcMask))).build();
- return new LcafSourceDestAddrBuilder((LcafSourceDestAddress)addr).setDstAddress(newDst).setSrcAddress(newSrc).build();
+ public static short getMaskForAddress(SimpleAddress address) {
+ if (address.getIpPrefix() == null) {
+ return -1;
+ }
+ return getMaskForIpPrefix(address.getIpPrefix());
}
- public static LispAddressContainer setMaskSourceDest(LispAddressContainer addr, int srcMask, int dstMask) {
- return new LispAddressContainerBuilder().setAddress(
- new LcafSourceDestBuilder((LcafSourceDest) addr.getAddress()).setLcafSourceDestAddr(
- (LcafSourceDestAddr) setMaskSourceDest(
- ((LcafSourceDest) addr.getAddress()).getLcafSourceDestAddr(), srcMask, dstMask))
- .build()).build();
+ public static short getMaskForAddress(Address address) {
+ if (address instanceof Ipv4) {
+ return IPV4_MAX_MASK;
+ } else if (address instanceof Ipv6) {
+ return IPV6_MAX_MASK;
+ } else if (address instanceof Ipv4Binary) {
+ return IPV4_MAX_MASK;
+ } else if (address instanceof Ipv6Binary) {
+ return IPV6_MAX_MASK;
+ } else if (address instanceof Ipv4Prefix) {
+ return Short.parseShort(getPrefixMask(((Ipv4Prefix) address).getIpv4Prefix().getValue()));
+ } else if (address instanceof Ipv6Prefix) {
+ return Short.parseShort(getPrefixMask(((Ipv6Prefix) address).getIpv6Prefix().getValue()));
+ } else if (address instanceof InstanceId) {
+ return getMaskForAddress(((InstanceId)address).getInstanceId().getAddress());
+ } else if (address instanceof Ipv4PrefixBinary) {
+ return ((Ipv4PrefixBinary) address).getIpv4MaskLength().toJava();
+ } else if (address instanceof Ipv6PrefixBinary) {
+ return ((Ipv6PrefixBinary) address).getIpv6MaskLength().toJava();
+ }
+ return -1;
}
}
Code Review / lispflowmapping.git / blobdiff