sendPacket(mapRegisterPacketWithoutNotify);
ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
- MapRequest smr = MapRequestSerializer.getInstance().deserialize(readBuf);
+ MapRequest smr = MapRequestSerializer.getInstance().deserialize(readBuf, null);
assertTrue(smr.isSmr());
Eid sourceEid = smr.getSourceEid().getEid();
assertTrue(LispAddressUtil.asIpv4Eid("153.16.254.1").equals(sourceEid));
private MapRequest receiveMapRequest(DatagramSocket datagramSocket) throws SocketTimeoutException {
return MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket(
- datagramSocket, 30000).getData()));
+ datagramSocket, 30000).getData()), null);
}
private MapNotify receiveMapNotify() throws SocketTimeoutException {
private List<MapRequest> translateBuffersToMapRequest(byte[][] buffers) {
final List<MapRequest> mapRequests = new ArrayList<>();
for (byte[] buffer : buffers) {
- final MapRequest mapRequest = MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(buffer));
+ final MapRequest mapRequest = MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(buffer), null);
assertNotNull(mapRequest);
mapRequests.add(mapRequest);
}
package org.opendaylight.lispflowmapping.implementation.lisp;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
-
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
import org.opendaylight.lispflowmapping.interfaces.dao.SubscriberRLOC;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4Afi;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4PrefixAfi;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6Afi;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6PrefixAfi;
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.SourceDestKeyLcaf;
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.ExplicitLocatorPath;
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.explicit.locator.path.explicit.locator.path.Hop;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv4BinaryAfi;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv4PrefixBinaryAfi;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv6BinaryAfi;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv6PrefixBinaryAfi;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItem;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapreplymessage.MapReplyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRloc;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Sets;
-
public class MapResolver implements IMapResolverAsync {
protected static final Logger LOG = LoggerFactory.getLogger(MapResolver.class);
replyBuilder.setProbe(false);
replyBuilder.setSecurityEnabled(false);
replyBuilder.setNonce(request.getNonce());
- replyBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
+ replyBuilder.setMappingRecordItem(new ArrayList<>());
+ List<ItrRloc> itrRlocs = request.getItrRloc();
+ final IpAddressBinary sourceRloc = request.getSourceRloc();
+
for (EidItem eidRecord : request.getEidItem()) {
MappingRecord mapping = (MappingRecord) mapService.getMapping(srcEid,
eidRecord.getEid());
if (mapping != null) {
- List<ItrRloc> itrRlocs = request.getItrRloc();
if (itrRlocs != null && itrRlocs.size() != 0) {
if (subscriptionService) {
- updateSubscribers(itrRlocs.get(0).getRloc(), eidRecord.getEid(), mapping.getEid(), srcEid);
+ final Rloc resolvedRloc = resolveRloc(itrRlocs, sourceRloc);
+ updateSubscribers(resolvedRloc, eidRecord.getEid(), mapping.getEid(), srcEid);
}
mapping = updateLocators(mapping, itrRlocs);
}
requestHandler.handleMapReply(replyBuilder.build());
}
+ private static boolean isEqualIpVersion(IpAddressBinary srcRloc, Rloc rloc) {
+ if (srcRloc.getIpv4AddressBinary() != null) {
+ if (rloc.getAddressType() == Ipv4Afi.class ||
+ rloc.getAddressType() == Ipv4BinaryAfi.class ||
+ rloc.getAddressType() == Ipv4PrefixAfi.class ||
+ rloc.getAddressType() == Ipv4PrefixBinaryAfi.class) {
+ return true;
+ }
+ } else if (rloc.getAddressType() == Ipv6Afi.class ||
+ rloc.getAddressType() == Ipv6BinaryAfi.class ||
+ rloc.getAddressType() == Ipv6PrefixAfi.class ||
+ rloc.getAddressType() == Ipv6PrefixBinaryAfi.class) {
+ return true;
+ }
+ return false;
+ }
+
+ private Rloc resolveRloc(List<ItrRloc> itrRlocList, IpAddressBinary srcRloc) {
+ if (srcRloc == null) {
+ return itrRlocList.get(0).getRloc();
+ }
+ byte[] srcRlocByte;
+ if (srcRloc.getIpv4AddressBinary() != null) {
+ srcRlocByte = srcRloc.getIpv4AddressBinary().getValue();
+ } else {
+ srcRlocByte = srcRloc.getIpv6AddressBinary().getValue();
+ }
+
+ Rloc equalIpvRloc = null;
+ for (ItrRloc itrRloc : itrRlocList) {
+ final Rloc rloc = itrRloc.getRloc();
+ final byte[] itrRlocByte = LispAddressUtil.ipAddressToByteArray(rloc.getAddress());
+
+ // return an Rloc equal to the source Rloc
+ if (itrRlocByte != null && LispAddressUtil.compareIpAddressByteArrays(srcRlocByte, itrRlocByte) == 0) {
+ return rloc;
+ }
+ // else lookup the first Rloc with identical Ip version
+ if (equalIpvRloc == null && isEqualIpVersion(srcRloc, rloc)) {
+ equalIpvRloc = rloc;
+ }
+ }
+ if (equalIpvRloc != null) {
+ return equalIpvRloc;
+ } else {
+ // if none of the above, return the first Rloc
+ return itrRlocList.get(0).getRloc();
+ }
+ }
+
private MappingRecord getNegativeMapping(Eid eid) {
MappingRecordBuilder recordBuilder = new MappingRecordBuilder();
recordBuilder.setAuthoritative(false);
*/
package org.opendaylight.lispflowmapping.implementation.lisp;
+import static org.junit.Assert.assertEquals;
+
+import com.google.common.collect.Lists;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import org.opendaylight.lispflowmapping.implementation.LispMappingService;
import org.opendaylight.lispflowmapping.implementation.MappingService;
import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list
- .MappingRecordItemBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4Afi;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6Afi;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.LispAddressFamily;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.MacAfi;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.NoAddressAfi;
+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.Ipv4Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Mac;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.MacBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.NoAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv6AddressBinary;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv4BinaryAfi;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItemBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkeyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container
- .MappingRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapreplymessage.MapReplyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRloc;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRlocBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequestBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.RlocBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container
- .MappingAuthkeyBuilder;
public class MapResolverTest {
private static final String IPV6_STRING = "0:0:0:0:0:0:0:1";
private static final String IPV6_PREFIX_STRING = "/128";
+ private static final byte[] IPV4_BINARY_BYTES_1 = new byte[]{1, 2, 3, 0};
+ private static final byte[] IPV4_BINARY_BYTES_2 = new byte[]{1, 2, 5, 0};
+ private static final byte[] IPV6_BINARY_BYTES_1 = new byte[]{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+
private static final LocatorRecordKey LOCATOR_RECORD_KEY = new LocatorRecordKey("key");
private static final int TTL_RLOC_TIMED_OUT = 1;
private static final IpAddress IPV4_ADDRESS_1 = new IpAddress(new Ipv4Address(IPV4_STRING_1));
private static final IpAddress IPV4_ADDRESS_2 = new IpAddress(new Ipv4Address(IPV4_STRING_2));
+ private static final IpAddressBinary IPV4_ADDRESS_BINARY_1 =
+ new IpAddressBinary(new Ipv4AddressBinary(IPV4_BINARY_BYTES_1));
+ private static final IpAddressBinary IPV4_ADDRESS_BINARY_2 =
+ new IpAddressBinary(new Ipv4AddressBinary(IPV4_BINARY_BYTES_2));
+ private static final IpAddressBinary IPV6_ADDRESS_BINARY =
+ new IpAddressBinary(new Ipv6AddressBinary(IPV6_BINARY_BYTES_1));
+
private static final Eid IPV4_PREFIX_EID_1 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_1 + IPV4_PREFIX_STRING);
private static final Eid IPV4_PREFIX_EID_2 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_2 + IPV4_PREFIX_STRING);
private static final Eid IPV6_PREFIX_EID = LispAddressUtil.asIpv6PrefixEid(IPV6_STRING + IPV6_PREFIX_STRING);
private static final Eid SOURCE_DEST_KEY_EID = LispAddressUtil.asSrcDstEid(IPV4_SOURCE, IPV4_STRING_2, 24, 24, 0);
+ private static final Address IPV4_ADDRESS = new Ipv4Builder().setIpv4(new Ipv4Address(IPV4_STRING_1)).build();
+ private static final Address IPV6_ADDRESS = new Ipv6Builder().setIpv6(new Ipv6Address(IPV6_STRING)).build();
+
private static final Rloc RLOC_1 = LispAddressUtil.asIpv4Rloc(IPV4_RLOC_STRING_1);
private static MapRequestBuilder mapRequestBuilder = getDefaultMapRequestBuilder();
private static final SubscriberRLOC SUBSCRIBER_RLOC_1 = new SubscriberRLOC(RLOC_1,
.setAction(MappingRecord.Action.NativelyForward)
.setRecordTtl(TTL_RLOC_TIMED_OUT);
-
Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
.thenReturn(null);
Mockito.when(mapServiceMock.getAuthenticationKey(IPV4_PREFIX_EID_1))
Mockito.verify(subscriberSetMock, Mockito.never()).remove(Mockito.any(SubscriberRLOC.class));
}
+ /**
+ * Tests {@link MapResolver#isEqualIpVersion} method.
+ */
+ @Test
+ public void isEqualIpVersionTest() {
+ // input mapping
+ final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
+ final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
+ mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
+
+ Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
+ .thenReturn(mappingRecordBuilder.build());
+ Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
+ .thenReturn(subscriberSetMock);
+ Mockito.when(subscriberSetMock.contains(Mockito.any(SubscriberRLOC.class))).thenReturn(false);
+
+ // ----------------------
+ // with sourceRloc = null
+ List<ItrRloc> itrRlocList = Lists.newArrayList(
+ newItrRloc(MacAfi.class, null),
+ newItrRloc(Ipv4BinaryAfi.class, IPV4_ADDRESS));
+
+ ArgumentCaptor<SubscriberRLOC> captor = ArgumentCaptor.forClass(SubscriberRLOC.class);
+ mapResolver.handleMapRequest(mapRequestBuilder.setSourceRloc(null).setItrRloc(itrRlocList).build());
+ Mockito.verify(subscriberSetMock).add(captor.capture());
+ // Since mapRequest's sourceRloc is null, first ItrRloc from the itrRlocList must be used.
+ assertEquals(MacAfi.class, captor.getValue().getSrcRloc().getAddressType());
+
+ // ----------------------
+ // with sourceRloc address = itrRloc address
+ itrRlocList = Lists.newArrayList(
+ newItrRloc(MacAfi.class, null),
+ newItrRloc(Ipv4BinaryAfi.class, IPV4_ADDRESS));
+
+ MapRequest mapRequest = mapRequestBuilder
+ .setSourceRloc(IPV4_ADDRESS_BINARY_1)
+ .setItrRloc(itrRlocList).build();
+
+ captor = ArgumentCaptor.forClass(SubscriberRLOC.class);
+ mapResolver.handleMapRequest(mapRequest);
+ Mockito.verify(subscriberSetMock, Mockito.times(2)).add(captor.capture());
+ assertEquals(IPV4_ADDRESS, captor.getValue().getSrcRloc().getAddress());
+
+ // ----------------------
+ // with sourceRloc address Afi = itrRloc address Afi (for Ipv4)
+ itrRlocList = Lists.newArrayList(
+ newItrRloc(MacAfi.class, null),
+ newItrRloc(Ipv6Afi.class, IPV6_ADDRESS),
+ newItrRloc(Ipv4Afi.class, IPV4_ADDRESS));
+
+ mapRequest = mapRequestBuilder
+ .setSourceRloc(IPV6_ADDRESS_BINARY)
+ .setItrRloc(itrRlocList).build();
+
+ captor = ArgumentCaptor.forClass(SubscriberRLOC.class);
+ mapResolver.handleMapRequest(mapRequest);
+ Mockito.verify(subscriberSetMock, Mockito.times(3)).add(captor.capture());
+ assertEquals(IPV6_ADDRESS, captor.getValue().getSrcRloc().getAddress());
+
+ // ----------------------
+ // with sourceRloc address Afi = itrRloc address Afi (for Ipv6)
+ itrRlocList = Lists.newArrayList(
+ newItrRloc(MacAfi.class, null),
+ newItrRloc(Ipv6Afi.class, IPV6_ADDRESS),
+ newItrRloc(Ipv4Afi.class, IPV4_ADDRESS));
+
+ mapRequest = mapRequestBuilder
+ .setSourceRloc(IPV4_ADDRESS_BINARY_2)
+ .setItrRloc(itrRlocList).build();
+
+ captor = ArgumentCaptor.forClass(SubscriberRLOC.class);
+ mapResolver.handleMapRequest(mapRequest);
+ Mockito.verify(subscriberSetMock, Mockito.times(4)).add(captor.capture());
+ assertEquals(IPV4_ADDRESS, captor.getValue().getSrcRloc().getAddress());
+
+ // ----------------------
+ // with no common ip address nor Afi
+ final Mac mac = new MacBuilder().setMac(new MacAddress("aa:bb:cc:dd:ee:ff")).build();
+ itrRlocList = Lists.newArrayList(
+ newItrRloc(MacAfi.class, mac),
+ newItrRloc(NoAddressAfi.class, Mockito.mock(NoAddress.class)));
+
+ mapRequest = mapRequestBuilder
+ .setSourceRloc(IPV4_ADDRESS_BINARY_1)
+ .setItrRloc(itrRlocList).build();
+
+ captor = ArgumentCaptor.forClass(SubscriberRLOC.class);
+ mapResolver.handleMapRequest(mapRequest);
+ Mockito.verify(subscriberSetMock, Mockito.times(5)).add(captor.capture());
+ assertEquals(mac, captor.getValue().getSrcRloc().getAddress());
+ }
+
/**
* Tests {@link MapResolver#handleMapRequest} method.
*/
Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
}
+ private static ItrRloc newItrRloc(Class<? extends LispAddressFamily> clazz, Address address) {
+ return new ItrRlocBuilder().setRloc(new RlocBuilder()
+ .setAddress(address)
+ .setAddressType(clazz).build()).build();
+ }
+
private static List<ItrRloc> getDefaultItrRlocList() {
final List<ItrRloc> itrRlocList = new ArrayList<>();
final ItrRloc itrRloc = new ItrRlocBuilder()
*/
package org.opendaylight.lispflowmapping.lisp.serializer;
-import java.net.Inet4Address;
-import java.net.Inet6Address;
import java.net.InetAddress;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import org.apache.commons.lang3.BooleanUtils;
import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.lisp.util.NumberUtil;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv6AddressBinary;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MessageType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.SiteId;
for (MappingRecordBuilder mrb : mrbs) {
mrb.setXtrId(xtrId);
mrb.setSiteId(siteId);
- mrb.setSourceRloc(getSourceRloc(sourceRloc));
+ mrb.setSourceRloc(LispAddressUtil.addressBinaryFromInet(sourceRloc));
builder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(
mrb.build()).build());
}
throw new LispSerializationException("Couldn't deserialize Map-Register (len="
+ registerBuffer.capacity() + ")", re);
}
-
- }
-
- private static IpAddressBinary getSourceRloc(InetAddress sourceRloc) {
- if (sourceRloc == null) {
- sourceRloc = Inet4Address.getLoopbackAddress();
- }
-
- if (sourceRloc instanceof Inet4Address) {
- return new IpAddressBinary(new Ipv4AddressBinary(sourceRloc.getAddress()));
- } else if (sourceRloc instanceof Inet6Address) {
- return new IpAddressBinary(new Ipv6AddressBinary(sourceRloc.getAddress()));
- }
-
- return null;
}
private interface Flags {
*/
package org.opendaylight.lispflowmapping.lisp.serializer;
+import java.net.InetAddress;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import org.apache.commons.lang3.BooleanUtils;
import org.opendaylight.lispflowmapping.lisp.serializer.address.LispAddressSerializerContext;
import org.opendaylight.lispflowmapping.lisp.serializer.exception.LispSerializationException;
import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
import org.opendaylight.lispflowmapping.lisp.util.NumberUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
}
@SuppressWarnings("checkstyle:IllegalCatch")
- public MapRequest deserialize(ByteBuffer requestBuffer) {
+ public MapRequest deserialize(ByteBuffer requestBuffer, InetAddress sourceRloc) {
try {
MapRequestBuilder builder = new MapRequestBuilder();
LOG.warn("Couldn't deserialize Map-Reply encapsulated in Map-Request", re);
}
}
+ builder.setSourceRloc(LispAddressUtil.addressBinaryFromInet(sourceRloc));
return builder.build();
} catch (RuntimeException re) {
throw new LispSerializationException("Couldn't deserialize Map-Request (len="
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.source.dest.key.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.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv6AddressBinary;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv4BinaryAfi;
return rb.build();
}
+ /**
+ * Converts the {@link InetAddress} into Ipv4 or Ipv6 {@link IpAddressBinary}. If null parameter is passed, method
+ * returns the Ipv4 loopback address (127.0.0.1).
+ *
+ * @param inetAddress Any Ipv4 or Ipv6 InetAddress.
+ * @return The converted Ipv4 or Ipv6 IpAddressBinary, or Ipv4 loopback address (127.0.0.1) if null is passed.
+ */
+ public static IpAddressBinary addressBinaryFromInet(InetAddress inetAddress) {
+ if (inetAddress == null) {
+ inetAddress = Inet4Address.getLoopbackAddress();
+ }
+
+ if (inetAddress instanceof Inet4Address) {
+ return new IpAddressBinary(new Ipv4AddressBinary(inetAddress.getAddress()));
+ } else if (inetAddress instanceof Inet6Address) {
+ return new IpAddressBinary(new Ipv6AddressBinary(inetAddress.getAddress()));
+ }
+ return null;
+ }
+
private static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
.lisp.address.address.Ipv4Prefix convertFromBinary(Ipv4PrefixBinary prefix) {
return new Ipv4PrefixBuilder().setIpv4Prefix(IetfInetUtil.INSTANCE.ipv4PrefixFor(
}
}
+ grouping map-request-metadata {
+ leaf source-rloc {
+ type inet-bin:ip-address-binary;
+ description
+ "The Source IP address used for sending the enclosing control
+ packet in RLOC space.";
+ }
+ description
+ "This is a collection of fields which are not present in the actual
+ mapping record defined in RFC 6830, but are used internally in
+ OpenDaylight";
+ }
+
grouping mapping-record-metadata {
leaf xtr-id {
type xtr-id;
container MapReply {
uses mapping-record-container;
}
+ uses map-request-metadata;
}
grouping MapReply {
public void deserialize__FlagsInFirstByte() throws Exception {
MapRequest mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("16 00 00 01 3d 8d "
+ "2a cd 39 c8 d6 08 00 00 00 01 c0 a8 88 0a 00 20 "
- + "00 01 01 02 03 04"));
+ + "00 01 01 02 03 04"), null);
assertFalse(mr.isAuthoritative());
assertTrue(mr.isMapDataPresent());
assertTrue(mr.isProbe());
mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("19 00 00 01 3d 8d "
+ "2a cd 39 c8 d6 08 00 00 00 01 c0 a8 88 0a 00 20 "
- + "00 01 01 02 03 04"));
+ + "00 01 01 02 03 04"), null);
assertTrue(mr.isAuthoritative());
assertFalse(mr.isMapDataPresent());
assertFalse(mr.isProbe());
mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("1C 00 00 01 3d 8d "
+ "2a cd 39 c8 d6 08 00 00 00 01 c0 a8 88 0a 00 20 "
- + "00 01 01 02 03 04"));
+ + "00 01 01 02 03 04"), null);
assertTrue(mr.isAuthoritative());
assertTrue(mr.isMapDataPresent());
assertFalse(mr.isProbe());
+ "7f 5b 41 7c 77 3c 00 01 01 01 01 01 00 01 c0 a8 "
+ "38 66 00 20 00 01 01 02 03 04 00 00 00 0a 01 20 "
+ "10 00 00 00 00 01 01 01 01 01 01 64 ff 00 00 05 "
- + "00 01 c0 a8 38 66"));
+ + "00 01 c0 a8 38 66"), null);
assertArrayEquals(new byte[] {1, 1, 1, 1},
((Ipv4Binary) mr.getSourceEid().getEid().getAddress()).getIpv4Binary().getValue());
assertEquals(LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32"), mr.getEidItem().get(0).getEid());
public void deserialize__FlagsInSecondByte() throws Exception {
MapRequest mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("16 80 00 01 3d 8d "
+ "2a cd 39 c8 d6 08 00 00 00 01 c0 a8 88 0a 00 20 "
- + "00 01 01 02 03 04"));
+ + "00 01 01 02 03 04"), null);
assertTrue(mr.isPitr());
assertFalse(mr.isSmrInvoked());
mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("19 40 00 01 3d 8d "
+ "2a cd 39 c8 d6 08 00 00 00 01 c0 a8 88 0a 00 20 "
- + "00 01 01 02 03 04"));
+ + "00 01 01 02 03 04"), null);
assertFalse(mr.isPitr());
assertTrue(mr.isSmrInvoked());
}
MapRequest mr = MapRequestSerializer.getInstance().deserialize(hexToByteBuffer("16 80 00 "
+ "01 " // single record
+ "3d 8d 2a cd 39 c8 d6 08 00 00 00 01 c0 a8 88 0a "
- + "00 20 00 01 01 02 03 04"));
+ + "00 20 00 01 01 02 03 04"), null);
assertEquals(1, mr.getEidItem().size());
assertEquals(LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32"), mr.getEidItem().get(0).getEid());
+ "03 04 00 06 00 01 0a 0a "
+ "0a 0a"
- ));
+ ), null);
assertEquals(1, mr.getEidItem().size());
assertEquals(LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32"), mr.getEidItem().get(0).getEid());
+ "02 " // 2 records
+ "3d 8d 2a cd 39 c8 d6 08 00 00 00 01 c0 a8 88 0a " //
+ "00 20 00 01 01 02 03 04 " //
- + "00 80 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 05"));
+ + "00 80 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 05"), null);
assertEquals(2, mr.getEidItem().size());
assertEquals(LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32"), mr.getEidItem().get(0).getEid());
+ "00 " // This means 1 ITR-RLOC
+ "01 3d 8d 2a cd 39 c8 d6 08 00 00 " //
+ "00 01 c0 a8 88 0a " // IPv4 (ITR-RLOC #1 of 1)
- + "00 20 00 01 01 02 03 04"));
+ + "00 20 00 01 01 02 03 04"), null);
assertEquals(1, mr.getItrRloc().size());
assertArrayEquals(new byte[] {(byte) 192, (byte) 168, (byte) 136, (byte) 10},
// IPv6 (ITR-RLOC #2 of 3)
+ "00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 " //
+ "00 01 11 22 34 56 " // IPv4 (ITR-RLOC #3 of 3)
- + "00 20 00 01 01 02 03 04"));
+ + "00 20 00 01 01 02 03 04"), null);
assertEquals(3, mr.getItrRloc().size());
assertArrayEquals(new byte[] {(byte) 192, (byte) 168, (byte) 136, (byte) 10},
handleEncapsulatedControlMessage(inBuffer, msg.sender().getAddress());
} else if (lispType == MessageType.MapRequest) {
LOG.trace("Received packet of type Map-Request");
- handleMapRequest(inBuffer, msg.sender().getPort());
+ handleMapRequest(inBuffer, msg.sender().getAddress(), msg.sender().getPort());
} else if (lispType == MessageType.MapRegister) {
LOG.trace("Received packet of type Map-Register");
handleMapRegister(inBuffer, msg.sender().getAddress(), msg.sender().getPort());
private void handleEncapsulatedControlMessage(ByteBuffer inBuffer, InetAddress sourceAddress) {
try {
- handleMapRequest(inBuffer, extractEncapsulatedSourcePort(inBuffer));
+ handleMapRequest(inBuffer, sourceAddress, extractEncapsulatedSourcePort(inBuffer));
} catch (RuntimeException re) {
throw new LispMalformedPacketException("Couldn't deserialize Map-Request (len="
+ inBuffer.capacity() + ")", re);
}
}
- private void handleMapRequest(ByteBuffer inBuffer, int port) {
+ private void handleMapRequest(ByteBuffer inBuffer, InetAddress sourceAddress, int port) {
try {
- MapRequest request = MapRequestSerializer.getInstance().deserialize(inBuffer);
+ MapRequest request = MapRequestSerializer.getInstance().deserialize(inBuffer, sourceAddress);
InetAddress finalSourceAddress = MapRequestUtil.selectItrRloc(request);
if (finalSourceAddress == null) {
throw new LispMalformedPacketException("Couldn't deserialize Map-Request, no ITR Rloc found!");
Object lispType = MessageType.forValue((int) (ByteUtil.getUnsignedByte(inBuffer, LispMessage.Pos.TYPE) >> 4));
if (lispType == MessageType.MapRequest) {
LOG.trace("Received packet of type MapRequest for xTR");
- handleMapRequest(inBuffer);
+ handleMapRequest(inBuffer, packet.sender().getAddress());
} else if (lispType == MessageType.MapReply){
LOG.trace("Received packet of type MapReply for xTR");
handleMapReply(inBuffer);
}
}
- private void handleMapRequest(ByteBuffer inBuffer) {
+ private void handleMapRequest(ByteBuffer inBuffer, InetAddress sourceAddress) {
try {
- MapRequest request = MapRequestSerializer.getInstance().deserialize(inBuffer);
+ MapRequest request = MapRequestSerializer.getInstance().deserialize(inBuffer, sourceAddress);
InetAddress finalSourceAddress = MapRequestUtil.selectItrRloc(request);
if (finalSourceAddress == null) {
throw new LispMalformedPacketException("Couldn't deserialize Map-Request, no ITR Rloc found!");
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.socket.DatagramPacket;
+import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.util.Arrays;
byte[] result = Arrays.copyOfRange(buffer.array(),
headerLength, headerLength + lispPacketLength);
- final InetSocketAddress address = new InetSocketAddress(PORT);
- return new DatagramPacket(Unpooled.copiedBuffer(result), address);
+ final InetAddress inetAddress = null;
+ final InetSocketAddress recipient = new InetSocketAddress(PORT);
+ final InetSocketAddress sender = new InetSocketAddress(inetAddress, PORT);
+ return new DatagramPacket(Unpooled.copiedBuffer(result), recipient, sender);
}
private static MapRequestBuilder getDefaultMapRequestBuilder() {
Code Review / lispflowmapping.git / commitdiff