mappingservice/integrationtest/src/test/java/org/opendaylight/lispflowmapping/integrationtest/MappingServiceIntegrationTest.java

   1 /*
   2  * Copyright (c) 2014 Contextream, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.lispflowmapping.integrationtest;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertTrue;
  13 import static org.junit.Assert.fail;
  14 import static org.ops4j.pax.exam.CoreOptions.options;
  15
  16 import java.io.BufferedReader;
  17 import java.io.IOException;
  18 import java.io.InputStream;
  19 import java.io.InputStreamReader;
  20 import java.io.OutputStreamWriter;
  21 import java.net.DatagramPacket;
  22 import java.net.DatagramSocket;
  23 import java.net.HttpURLConnection;
  24 import java.net.InetAddress;
  25 import java.net.InetSocketAddress;
  26 import java.net.MalformedURLException;
  27 import java.net.SocketException;
  28 import java.net.SocketTimeoutException;
  29 import java.net.URL;
  30 import java.net.UnknownHostException;
  31 import java.nio.ByteBuffer;
  32 import java.nio.charset.Charset;
  33 import java.util.ArrayList;
  34 import java.util.Arrays;
  35
  36 import javax.inject.Inject;
  37
  38 import org.apache.commons.codec.binary.Base64;
  39 import org.codehaus.jettison.json.JSONException;
  40 import org.codehaus.jettison.json.JSONObject;
  41 import org.codehaus.jettison.json.JSONTokener;
  42 import org.junit.After;
  43 import org.junit.Before;
  44 import org.junit.Test;
  45 import org.junit.runner.RunWith;
  46 import org.opendaylight.controller.sal.binding.api.NotificationListener;
  47 import org.opendaylight.lispflowmapping.implementation.LispMappingService;
  48 import org.opendaylight.lispflowmapping.implementation.serializer.LispMessage;
  49 import org.opendaylight.lispflowmapping.implementation.serializer.MapNotifySerializer;
  50 import org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer;
  51 import org.opendaylight.lispflowmapping.implementation.serializer.MapReplySerializer;
  52 import org.opendaylight.lispflowmapping.implementation.serializer.MapRequestSerializer;
  53 import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
  54 import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
  55 import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
  56 import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
  57 import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafApplicationDataAddress;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafListAddress;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafSegmentAddress;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafTrafficEngineeringAddress;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispIpv4Address;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispMacAddress;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapNotify;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapReply;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRequest;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.ReencapHop;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.XtrRequestMapping;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecord;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecordBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecordBuilder;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafkeyvalueaddress.KeyBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafkeyvalueaddress.ValueBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaflistaddress.Addresses;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaflistaddress.AddressesBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsegmentaddress.AddressBuilder;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsourcedestaddress.DstAddressBuilder;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsourcedestaddress.SrcAddressBuilder;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaftrafficengineeringaddress.Hops;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaftrafficengineeringaddress.HopsBuilder;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainer;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafKeyValue;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafSourceDest;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddr;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddrBuilder;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafkeyvalue.LcafKeyValueAddressAddrBuilder;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcaflist.LcafListAddrBuilder;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsegment.LcafSegmentAddrBuilder;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddr;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddrBuilder;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcaftrafficengineering.LcafTrafficEngineeringAddrBuilder;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecord;
  99 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecordBuilder;
 100 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapregisternotification.MapRegisterBuilder;
 101 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRloc;
 102 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRlocBuilder;
 103 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.SourceEidBuilder;
 104 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequestnotification.MapRequestBuilder;
 105 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.reencaphop.Hop;
 106 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.reencaphop.HopBuilder;
 107 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
 108 import org.ops4j.pax.exam.Configuration;
 109 import org.ops4j.pax.exam.Option;
 110 import org.ops4j.pax.exam.junit.PaxExam;
 111 import org.ops4j.pax.exam.util.Filter;
 112 import org.osgi.framework.Bundle;
 113 import org.osgi.framework.BundleContext;
 114 import org.osgi.framework.InvalidSyntaxException;
 115 import org.osgi.framework.ServiceReference;
 116 import org.slf4j.Logger;
 117 import org.slf4j.LoggerFactory;
 118
 119 @RunWith(PaxExam.class)
 120 public class MappingServiceIntegrationTest {
 121
 122     private IFlowMapping lms;
 123     protected static final Logger LOG = LoggerFactory.getLogger(MappingServiceIntegrationTest.class);
 124     private byte[] mapRequestPacket;
 125     private byte[] mapRegisterPacketWithNotify;
 126     private byte[] mapRegisterPacketWithoutNotify;
 127     String lispBindAddress = "127.0.0.1";
 128     String ourAddress = "127.0.0.2";
 129     private LispAFIAddress locatorEid;
 130     private DatagramSocket socket;
 131     private byte[] mapRegisterPacketWithAuthenticationAndMapNotify;
 132
 133     public static final String ODL = "org.opendaylight.controller";
 134     public static final String YANG = "org.opendaylight.yangtools";
 135     public static final String JERSEY = "com.sun.jersey";
 136     private static final int MAX_SERVICE_LOAD_RETRIES = 45;
 137     private static final int MAX_NOTIFICATION_RETRYS = 20;
 138
 139     @After
 140     public void after() {
 141         if (socket != null) {
 142             socket.close();
 143         }
 144         if (connection != null) {
 145             connection.disconnect();
 146         }
 147     }
 148
 149     @Before
 150     public void before() throws Exception {
 151         areWeReady();
 152         locatorEid = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
 153         socket = initSocket(socket, LispMessage.PORT_NUM);
 154
 155         // SRC: 127.0.0.1:58560 to 127.0.0.1:4342
 156         // LISP(Type = 8 - Encapsulated)
 157         // IP: 192.168.136.10 -> 153.16.254.1
 158         // UDP: 56756
 159         // LISP(Type = 1 Map-Request
 160         // Record Count: 1
 161         // ITR-RLOC count: 0
 162         // Source EID AFI: 0
 163         // Source EID not present
 164         // Nonce: 0x3d8d2acd39c8d608
 165         // ITR-RLOC AFI=1 Address=192.168.136.10
 166         // Record 1: 153.16.254.1/32
 167         mapRequestPacket = extractWSUdpByteArray(new String("0000   00 00 00 00 00 00 00 00 00 00 00 00 08 00 45 00 " //
 168                 + "0010   00 58 00 00 40 00 40 11 3c 93 7f 00 00 01 7f 00 "
 169                 + "0020   00 01 e4 c0 10 f6 00 44 fe 57 80 00 00 00 45 00 "
 170                 + "0030   00 3c d4 31 00 00 ff 11 56 f3 7f 00 00 02 99 10 "
 171                 + "0040   fe 01 dd b4 10 f6 00 28 ef 3a 10 00 00 01 3d 8d "
 172                 + "0050   2a cd 39 c8 d6 08 00 01 01 02 03 04 00 01 7f 00 00 02 00 20 " //
 173                 + "0060   00 01 99 10 fe 01"));
 174
 175         // IP: 192.168.136.10 -> 128.223.156.35
 176         // UDP: 49289 -> 4342
 177         // LISP(Type = 3 Map-Register, P=1, M=1
 178         // Record Counter: 1
 179         // Nonce: 0
 180         // Key ID: 0x0001
 181         // AuthDataLength: 20 Data:
 182         // e8:f5:0b:c5:c5:f2:b0:21:27:a8:21:41:04:f3:46:5a:a5:68:89:ec
 183         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 184         // No-Action
 185         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 186         // Priority/Weight: 1/100, Multicast Priority/Weight:
 187         // 255/0
 188         //
 189
 190         mapRegisterPacketWithAuthenticationAndMapNotify = extractWSUdpByteArray(new String("0000   00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
 191                 + "0010   00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
 192                 + "0020   9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
 193                 + "0030   00 00 00 00 00 00 00 01 00 14 0e a4 c6 d8 a4 06 "
 194                 + "0040   71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
 195                 + "0050   00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 196                 + "0060   ff 00 00 05 00 01 c0 a8 88 0a"));
 197
 198         // IP: 192.168.136.10 -> 128.223.156.35
 199         // UDP: 49289 -> 4342
 200         // LISP(Type = 3 Map-Register, P=1, M=1
 201         // Record Counter: 1
 202         // Nonce: 7
 203         // Key ID: 0x0000 NO AUTHENTICATION!!
 204         // AuthDataLength: 00 Data:
 205         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 206         // No-Action
 207         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 208         // Priority/Weight: 1/100, Multicast Priority/Weight:
 209         // 255/0
 210         //
 211
 212         mapRegisterPacketWithNotify = extractWSUdpByteArray(new String("0000   00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
 213                 + "0010   00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
 214                 + "0020   9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
 215                 + "0030   00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
 216                 + "0040   71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
 217                 + "0050   00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 218                 + "0060   ff 00 00 05 00 01 c0 a8 88 0a"));
 219
 220         // IP: 192.168.136.10 -> 128.223.156.35
 221         // UDP: 49289 -> 4342
 222         // LISP(Type = 3 Map-Register, P=1, M=1
 223         // Record Counter: 1
 224         // Nonce: 7
 225         // Key ID: 0x0000 NO AUTHENTICATION!!
 226         // AuthDataLength: 00 Data:
 227         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 228         // No-Action
 229         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 230         // Priority/Weight: 1/100, Multicast Priority/Weight:
 231         // 255/0
 232         //
 233
 234         mapRegisterPacketWithoutNotify = extractWSUdpByteArray(new String("0000   00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
 235                 + "0010   00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
 236                 + "0020   9c 23 d6 40 10 f6 00 48 59 a4 38 00 00 01 00 00 "
 237                 + "0030   00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
 238                 + "0040   71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
 239                 + "0050   00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 240                 + "0060   ff 00 00 05 00 01 c0 a8 88 0a"));
 241     }
 242
 243     @Inject
 244     private BundleContext bc;
 245     private HttpURLConnection connection;
 246     protected static boolean notificationCalled;
 247     @Inject @Filter(timeout=10000)
 248     private IConfigLispSouthboundPlugin configLispPlugin;
 249
 250
 251     // Configure the OSGi container
 252     @Configuration
 253     public Option[] config() {
 254         return options(MappingServiceTestHelper.mappingServiceBundlesWithClusterDAO());
 255     }
 256
 257     @Test
 258     public void testSimpleUsage() throws Exception {
 259         mapRequestSimple();
 260         mapRegisterWithMapNotify();
 261         mapRegisterWithMapNotifyAndMapRequest();
 262         registerAndQuery__MAC();
 263         mapRequestMapRegisterAndMapRequest();
 264         mapRegisterWithAuthenticationWithoutConfiguringAKey();
 265         mapRegisterWithoutMapNotify();
 266     }
 267
 268     @Test
 269     public void testLCAFs() throws Exception {
 270         registerAndQuery__SrcDestLCAF();
 271         registerAndQuery__SrcDestLCAFOverlap();
 272         registerAndQuery__KeyValueLCAF();
 273         registerAndQuery__ListLCAF();
 274         registerAndQuery__ApplicationData();
 275         registerAndQuery__TrafficEngineering();
 276         registerAndQuery__SegmentLCAF();
 277     }
 278
 279     @Test
 280     public void testMask() throws Exception {
 281         //testPasswordExactMatch();                     TODO commented because it needs NB
 282         //testPasswordMaskMatch();                      TODO commented because it needs NB
 283         eidPrefixLookupIPv4();
 284         eidPrefixLookupIPv6();
 285     }
 286 /*
 287     @Test
 288     public void testNorthbound() throws Exception {
 289         northboundAddKey();
 290         northboundAddMapping();
 291         northboundDeleteMapping();
 292         northboundRetrieveKey();
 293         northboundRetrieveMapping();
 294         northboundRetrieveSourceDestKey();
 295         northboundRetrieveSourceDestMapping();
 296     }
 297 */
 298     @Test
 299     public void testOverWriting() throws Exception {
 300         //testMapRegisterDosntOverwritesOtherSubKeys(); TODO weird failure, needs debug
 301         testMapRegisterOverwritesSameSubkey();
 302         testMapRegisterOverwritesNoSubkey();
 303         testMapRegisterDoesntOverwritesNoSubkey();
 304     }
 305
 306     @Test
 307     public void testTimeOuts() throws Exception {
 308         mapRequestMapRegisterAndMapRequestTestTimeout();
 309         //mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse();   TODO commented because it needs NB
 310     }
 311
 312     @Test
 313     public void testNonProxy() throws Throwable {
 314         testSimpleNonProxy();
 315         testNonProxyOtherPort();
 316         testRecievingNonProxyOnXtrPort();
 317     }
 318
 319     @Test
 320     public void testSmr() throws Exception {
 321         registerQueryRegisterWithSmr();
 322     }
 323
 324     // ------------------------------- Simple Tests ---------------------------
 325
 326     public void mapRequestSimple() throws SocketTimeoutException {
 327         cleanUP();
 328
 329         // This Map-Request is sent from a source port different from 4342
 330         // We close and bind the socket on the correct port
 331         if (socket != null) {
 332             socket.close();
 333         }
 334         socket = initSocket(socket, 56756);
 335
 336         sendPacket(mapRequestPacket);
 337         ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
 338         MapReply reply = MapReplySerializer.getInstance().deserialize(readBuf);
 339         assertEquals(4435248268955932168L, reply.getNonce().longValue());
 340
 341     }
 342
 343     public void mapRegisterWithMapNotify() throws SocketTimeoutException {
 344         cleanUP();
 345         sendPacket(mapRegisterPacketWithNotify);
 346         MapNotify reply = receiveMapNotify();
 347         assertEquals(7, reply.getNonce().longValue());
 348     }
 349
 350     public void mapRegisterWithMapNotifyAndMapRequest() throws SocketTimeoutException {
 351         cleanUP();
 352         LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
 353
 354         MapReply mapReply = registerAddressAndQuery(eid, 32);
 355
 356         assertEquals(4, mapReply.getNonce().longValue());
 357         assertEquals(LispAFIConvertor.toContainer(locatorEid), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
 358                 .getLispAddressContainer());
 359
 360     }
 361
 362     public void registerAndQuery__MAC() throws SocketTimeoutException {
 363         cleanUP();
 364         String macAddress = "01:02:03:04:05:06";
 365
 366         MapReply reply = registerAddressAndQuery(LispAFIConvertor.asMacAfiAddress(macAddress));
 367
 368         assertTrue(true);
 369         LispAFIAddress addressFromNetwork = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
 370         assertTrue(addressFromNetwork instanceof LispMacAddress);
 371         String macAddressFromReply = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.mac.MacAddress) addressFromNetwork).getMacAddress().getValue();
 372
 373         assertEquals(macAddress, macAddressFromReply);
 374     }
 375
 376     public void mapRequestMapRegisterAndMapRequest() throws SocketTimeoutException {
 377         cleanUP();
 378         LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
 379         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
 380         mapRequestBuilder.setNonce((long) 4);
 381         mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
 382                 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
 383         mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
 384         mapRequestBuilder.getEidRecord().add(
 385                 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
 386         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
 387         mapRequestBuilder.getItrRloc().add(
 388                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
 389         sendMapRequest(mapRequestBuilder.build());
 390         MapReply mapReply = receiveMapReply();
 391         assertEquals(4, mapReply.getNonce().longValue());
 392         assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
 393         MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
 394         mapRegisterbuilder.setWantMapNotify(true);
 395         mapRegisterbuilder.setNonce((long) 8);
 396         EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
 397         etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
 398         etlrBuilder.setMaskLength((short) 32);
 399         etlrBuilder.setRecordTtl(254);
 400         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
 401         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
 402         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
 403         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
 404         mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
 405         mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
 406         sendMapRegister(mapRegisterbuilder.build());
 407         MapNotify mapNotify = receiveMapNotify();
 408         assertEquals(8, mapNotify.getNonce().longValue());
 409         sendMapRequest(mapRequestBuilder.build());
 410         mapReply = receiveMapReply();
 411         assertEquals(4, mapReply.getNonce().longValue());
 412         assertEquals(recordBuilder.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
 413                 .getLispAddressContainer());
 414
 415     }
 416
 417     public void testMapRegisterDosntOverwritesOtherSubKeys() throws SocketTimeoutException {
 418         cleanUP();
 419         LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
 420         LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
 421         LispAFIAddress rloc1 = LispAFIConvertor.asKeyValue("subkey1", LispAFIConvertor.toPrimitive(rloc1Value));
 422         LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
 423         LispAFIAddress rloc2 = LispAFIConvertor.asKeyValue("subkey2", LispAFIConvertor.toPrimitive(rloc2Value));
 424         MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
 425         assertEquals(2, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
 426         assertEquals(LispAFIConvertor.toContainer(rloc2), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
 427         assertEquals(LispAFIConvertor.toContainer(rloc1), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(1).getLispAddressContainer());
 428     }
 429
 430     public void testMapRegisterOverwritesSameSubkey() throws SocketTimeoutException {
 431         cleanUP();
 432         LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
 433         LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
 434         LispAFIAddress rloc1 = LispAFIConvertor.asKeyValue("subkey", LispAFIConvertor.toPrimitive(rloc1Value));
 435         LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
 436         LispAFIAddress rloc2 = LispAFIConvertor.asKeyValue("subkey", LispAFIConvertor.toPrimitive(rloc2Value));
 437         MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
 438         assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
 439         assertEquals(LispAFIConvertor.toContainer(rloc2), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
 440     }
 441
 442     public void testMapRegisterOverwritesNoSubkey() throws SocketTimeoutException {
 443         cleanUP();
 444         lms.setOverwrite(true);
 445         LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
 446         LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
 447         LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
 448         MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
 449         assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
 450         assertEquals(LispAFIConvertor.toContainer(rloc2Value), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
 451                 .getLispAddressContainer());
 452     }
 453
 454     public void testMapRegisterDoesntOverwritesNoSubkey() throws SocketTimeoutException {
 455         cleanUP();
 456         lms.setOverwrite(false);
 457         LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
 458         LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
 459         LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
 460         MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
 461         assertEquals(2, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
 462         LispAddressContainer rloc1ReturnValueContainer = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer();
 463         LispAddressContainer rloc2ReturnValueContainer = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(1).getLispAddressContainer();
 464         assertTrue((LispAFIConvertor.toContainer(rloc1Value).equals(rloc1ReturnValueContainer) && LispAFIConvertor.toContainer(rloc2Value).equals(
 465                 rloc2ReturnValueContainer))
 466                 || (LispAFIConvertor.toContainer(rloc1Value).equals(rloc2ReturnValueContainer) && LispAFIConvertor.toContainer(rloc2Value).equals(
 467                         rloc1ReturnValueContainer)));
 468     }
 469
 470     private MapReply sendMapRegisterTwiceWithDiffrentValues(LispAFIAddress eid, LispAFIAddress rloc1, LispAFIAddress rloc2)
 471             throws SocketTimeoutException {
 472         MapRegister mb = createMapRegister(eid, rloc1);
 473         MapNotify mapNotify = lms.handleMapRegister(mb, false);
 474         MapRequest mr = createMapRequest(eid);
 475         MapReply mapReply = lms.handleMapRequest(mr);
 476         assertEquals(mb.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0)
 477                 .getLocatorRecord().get(0).getLispAddressContainer());
 478         mb = createMapRegister(eid, rloc2);
 479         mapNotify = lms.handleMapRegister(mb, false);
 480         assertEquals(8, mapNotify.getNonce().longValue());
 481         mr = createMapRequest(eid);
 482         sendMapRequest(mr);
 483         mapReply = lms.handleMapRequest(mr);
 484         return mapReply;
 485     }
 486
 487     public void mapRegisterWithAuthenticationWithoutConfiguringAKey() throws SocketTimeoutException {
 488         cleanUP();
 489         sendPacket(mapRegisterPacketWithAuthenticationAndMapNotify);
 490         try {
 491             receivePacket(3000);
 492             // If didn't timeout then fail:
 493             fail();
 494         } catch (SocketTimeoutException ste) {
 495         }
 496     }
 497
 498     public void mapRegisterWithoutMapNotify() {
 499         cleanUP();
 500         sendPacket(mapRegisterPacketWithoutNotify);
 501         try {
 502             receivePacket(3000);
 503             // If didn't timeout then fail:
 504             fail();
 505         } catch (SocketTimeoutException ste) {
 506         }
 507     }
 508
 509     public void registerQueryRegisterWithSmr() throws SocketTimeoutException {
 510         cleanUP();
 511         lms.setShouldUseSmr(true);
 512
 513         sendPacket(mapRegisterPacketWithNotify);
 514         receiveMapNotify();
 515
 516         sendPacket(mapRequestPacket);
 517         try {
 518             Thread.sleep(1000);
 519         } catch (InterruptedException e) {
 520         }
 521
 522         mapRegisterPacketWithoutNotify[mapRegisterPacketWithoutNotify.length - 1] += 1;
 523         sendPacket(mapRegisterPacketWithoutNotify);
 524
 525         ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
 526         MapRequest smr = MapRequestSerializer.getInstance().deserialize(readBuf);
 527         assertTrue(smr.isSmr());
 528         LispAddressContainer smrEid = smr.getEidRecord().get(0).getLispAddressContainer();
 529         assertTrue(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("153.16.254.1")).equals(smrEid));
 530     }
 531
 532     // --------------------- Northbound Tests ---------------------------
 533
 534     private void northboundAddKey() throws Exception {
 535         cleanUP();
 536         LispIpv4Address address = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
 537         int mask = 32;
 538         String pass = "asdf";
 539
 540         URL url = createPutURL("key");
 541         String authKeyJSON = createAuthKeyJSON(pass, address, mask);
 542         callURL("PUT", "application/json", "text/plain", authKeyJSON, url);
 543
 544         String retrievedKey = lms.getAuthenticationKey(LispAFIConvertor.toContainer(address), mask);
 545
 546         // Check stored password matches the one sent
 547         assertEquals(pass, retrievedKey);
 548
 549     }
 550
 551     private void northboundRetrieveSourceDestKey() throws Exception {
 552         cleanUP();
 553         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
 554                 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.1"));
 555         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
 556                 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.2"));
 557         int mask1 = 32;
 558         int mask2 = 32;
 559         LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
 560                 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
 561                 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build()).setSrcMaskLength((short) mask1)
 562                 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build()).setDstMaskLength((short) mask2).build();
 563         String pass = "asdf";
 564
 565         lms.addAuthenticationKey(LispAFIConvertor.toContainer(sourceDestAddress), mask1, pass);
 566
 567         // URL url = createGetKeyIPv4URL(address1, mask1);
 568         URL url = createGetKeySourceDestURL(address1.getIpv4Address().getAfi(),
 569                 ((LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(sourceDestAddress.getSrcAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getSrcMaskLength(),
 570                 ((LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(sourceDestAddress.getDstAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getDstMaskLength());
 571         String reply = callURL("GET", null, "application/json", null, url);
 572         JSONTokener jt = new JSONTokener(reply);
 573         JSONObject json = new JSONObject(jt);
 574
 575         // test that the password matches what was we expected.
 576         assertEquals(pass, json.get("key"));
 577
 578     }
 579
 580     private void northboundRetrieveKey() throws Exception {
 581         cleanUP();
 582         LispIpv4Address address = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
 583         int mask = 32;
 584         String pass = "asdf";
 585
 586         lms.addAuthenticationKey(LispAFIConvertor.toContainer(address), mask, pass);
 587
 588         URL url = createGetKeyIPv4URL(address, mask);
 589         String reply = callURL("GET", null, "application/json", null, url);
 590         JSONTokener jt = new JSONTokener(reply);
 591         JSONObject json = new JSONObject(jt);
 592
 593         // test that the password matches what was we expected.
 594         assertEquals(pass, json.get("key"));
 595
 596     }
 597
 598     private String createAuthKeyJSON(String key, LispIpv4Address address, int mask) {
 599         return "{\"key\" : \"" + key + "\",\"maskLength\" : " + mask + ",\"address\" : " + "{\"ipAddress\" : \""
 600                 + address.getIpv4Address().getValue() + "\",\"afi\" : " + address.getAfi().shortValue() + "}}";
 601     }
 602
 603     private void northboundAddMapping() throws Exception {
 604         cleanUP();
 605         String pass = "asdf";
 606         LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
 607         int mask = 32;
 608         LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
 609
 610         // NB add mapping always checks the key
 611         lms.addAuthenticationKey(LispAFIConvertor.toContainer(eid), mask, pass);
 612
 613         URL url = createPutURL("mapping");
 614         String mapRegisterJSON = createMapRegisterJSON(pass, eid, mask, rloc);
 615         callURL("PUT", "application/json", "text/plain", mapRegisterJSON, url);
 616
 617         // Retrieve the RLOC from the database
 618         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
 619         mapRequestBuilder.setPitr(false);
 620         mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
 621         mapRequestBuilder.getEidRecord().add(
 622                 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
 623         MapReply mapReply = lms.handleMapRequest(mapRequestBuilder.build());
 624
 625         LispIpv4Address retrievedRloc = (LispIpv4Address) LispAFIConvertor.toAFI(
 626                 mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
 627
 628         assertEquals(rloc.getIpv4Address().getValue(), retrievedRloc.getIpv4Address().getValue());
 629
 630     }
 631
 632     private String createMapRegisterJSON(String key, LispIpv4Address eid, int mask, LispIpv4Address rloc) {
 633         String jsonString = "{ " + "\"key\" : \"" + key + "\"," + "\"mapregister\" : " + "{ " + "\"proxyMapReply\" : false, "
 634                 + "\"eidToLocatorRecords\" : " + "[ " + "{ " + "\"authoritative\" : true," + "\"prefixGeneric\" : " + "{ " + "\"ipAddress\" : \""
 635                 + eid.getIpv4Address().getValue() + "\"," + "\"afi\" : " + eid.getAfi().shortValue() + "}," + "\"mapVersion\" : 0,"
 636                 + "\"maskLength\" : " + mask + ", " + "\"action\" : \"NoAction\"," + "\"locators\" : " + "[ " + "{ " + "\"multicastPriority\" : 1,"
 637                 + "\"locatorGeneric\" : " + "{ " + "\"ipAddress\" : \"" + rloc.getIpv4Address().getValue() + "\"," + "\"afi\" : "
 638                 + rloc.getAfi().shortValue() + "}, " + "\"routed\" : true," + "\"multicastWeight\" : 50," + "\"rlocProbed\" : false, "
 639                 + "\"localLocator\" : false, " + "\"priority\" : 1, " + "\"weight\" : 50 " + "} " + "], " + "\"recordTtl\" : 100" + "} " + "], "
 640                 + "\"nonce\" : 3," + "\"keyId\" : 0 " + "} " + "}";
 641
 642         return jsonString;
 643     }
 644
 645     private void northboundRetrieveMapping() throws Exception {
 646         cleanUP();
 647         LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
 648         int mask = 32;
 649         LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
 650         // Insert mapping in the database
 651         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
 652         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
 653         etlr.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
 654         etlr.setMaskLength((short) mask);
 655         etlr.setRecordTtl(254);
 656         etlr.setAuthoritative(false);
 657         etlr.setAction(Action.NoAction);
 658         LocatorRecordBuilder record = new LocatorRecordBuilder();
 659         record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 660         record.setRouted(true);
 661         record.setRlocProbed(false);
 662         record.setLocalLocator(false);
 663         record.setPriority((short) 1);
 664         record.setWeight((short) 50);
 665         record.setMulticastPriority((short) 1);
 666         record.setMulticastWeight((short) 1);
 667         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
 668         etlr.getLocatorRecord().add(record.build());
 669         mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
 670         mapRegister.getEidToLocatorRecord().add(etlr.build());
 671         lms.handleMapRegister(mapRegister.build(), false);
 672
 673         // Get mapping using NB interface. No IID used
 674         URL url = createGetMappingIPv4URL(0, eid, mask);
 675         String reply = callURL("GET", null, "application/json", null, url);
 676         JSONTokener jt = new JSONTokener(reply);
 677         JSONObject json = new JSONObject(jt);
 678
 679         // With just one locator, locators is not a JSONArray
 680         String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric").getString("ipAddress");
 681
 682         assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
 683
 684     }
 685
 686     private void northboundDeleteMapping() throws Exception {
 687         cleanUP();
 688         LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
 689         int mask = 32;
 690         LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
 691         // Insert mapping in the database
 692         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
 693         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
 694         etlr.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
 695         etlr.setMaskLength((short) mask);
 696         etlr.setRecordTtl(254);
 697         etlr.setAuthoritative(false);
 698         etlr.setAction(Action.NoAction);
 699         LocatorRecordBuilder record = new LocatorRecordBuilder();
 700         record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 701         record.setRouted(true);
 702         record.setRlocProbed(false);
 703         record.setLocalLocator(false);
 704         record.setPriority((short) 1);
 705         record.setWeight((short) 50);
 706         record.setMulticastPriority((short) 1);
 707         record.setMulticastWeight((short) 1);
 708         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
 709         etlr.getLocatorRecord().add(record.build());
 710         mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
 711         mapRegister.getEidToLocatorRecord().add(etlr.build());
 712         lms.handleMapRegister(mapRegister.build(), false);
 713
 714         // Delete mapping using NB interface. No IID used
 715         URL url = createDeleteMappingIPv4URL(0, eid, mask);
 716         String reply = callURL("DELETE", null, "application/json", null, url);
 717
 718         // Get mapping using NB interface. No IID used
 719         url = createGetMappingIPv4URL(0, eid, mask);
 720         reply = callURL("GET", null, "application/json", null, url);
 721         JSONTokener jt = new JSONTokener(reply);
 722         JSONObject json = new JSONObject(jt);
 723
 724         // With just one locator, locators is not a JSONArray
 725         assertEquals(json.getJSONArray("locators").length(), 0);
 726     }
 727
 728     private void northboundRetrieveSourceDestMapping() throws Exception {
 729         cleanUP();
 730         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
 731                 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.1"));
 732         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
 733                 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.2"));
 734         int mask1 = 32;
 735         int mask2 = 32;
 736         LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
 737                 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
 738                 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build()).setSrcMaskLength((short) mask1)
 739                 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build()).setDstMaskLength((short) mask2).build();
 740         LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
 741
 742         // Insert mapping in the database
 743         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
 744         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
 745         etlr.setLispAddressContainer(LispAFIConvertor.toContainer(sourceDestAddress));
 746         etlr.setMaskLength((short) mask1);
 747         etlr.setRecordTtl(254);
 748         etlr.setAuthoritative(false);
 749         etlr.setAction(Action.NoAction);
 750         LocatorRecordBuilder record = new LocatorRecordBuilder();
 751         record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 752         record.setRouted(true);
 753         record.setRlocProbed(false);
 754         record.setLocalLocator(false);
 755         record.setPriority((short) 1);
 756         record.setWeight((short) 50);
 757         record.setMulticastPriority((short) 1);
 758         record.setMulticastWeight((short) 1);
 759         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
 760         etlr.getLocatorRecord().add(record.build());
 761         mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
 762         mapRegister.getEidToLocatorRecord().add(etlr.build());
 763         lms.handleMapRegister(mapRegister.build(), false);
 764
 765         // Get mapping using NB interface. No IID used
 766         URL url = createGetMappingSourceDestURL(address1.getIpv4Address().getAfi(),
 767                 address1.getIpv4Address().getIpv4Address().getValue(),
 768                 mask1,
 769                 address2.getIpv4Address().getIpv4Address().getValue(),
 770                 mask2);
 771         String reply = callURL("GET", null, "application/json", null, url);
 772         JSONTokener jt = new JSONTokener(reply);
 773         JSONObject json = new JSONObject(jt);
 774
 775         // With just one locator, locators is not a JSONArray
 776         String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric").getString("ipAddress");
 777
 778         assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
 779
 780     }
 781
 782     private URL createGetKeyIPv4URL(LispIpv4Address address, int mask) throws MalformedURLException {
 783         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d", "key", address.getAfi().shortValue(),
 784                 address.getIpv4Address().getValue(), mask);
 785         URL url = new URL(restUrl);
 786         return url;
 787     }
 788
 789     private URL createGetKeySourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask) throws MalformedURLException {
 790         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d", "key", afi, srcAddress, srcMask,
 791                 dstAddress, dstMask);
 792         URL url = new URL(restUrl);
 793         return url;
 794     }
 795
 796     private URL createGetMappingSourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask) throws MalformedURLException {
 797         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d", "mapping", afi, srcAddress,
 798                 srcMask, dstAddress, dstMask);
 799         URL url = new URL(restUrl);
 800         return url;
 801     }
 802
 803     private URL createGetMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
 804         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping", iid, address.getAfi()
 805                 .shortValue(), address.getIpv4Address().getValue(), mask);
 806         URL url = new URL(restUrl);
 807         return url;
 808     }
 809
 810     private URL createDeleteMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
 811         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping", iid, address.getAfi()
 812                 .shortValue(), address.getIpv4Address().getValue(), mask);
 813         URL url = new URL(restUrl);
 814         return url;
 815     }
 816
 817     private URL createPutURL(String resource) throws MalformedURLException {
 818
 819         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s", resource);
 820
 821         URL url = new URL(restUrl);
 822         return url;
 823     }
 824
 825     private String createAuthenticationString() {
 826         String authString = "admin:admin";
 827         byte[] authEncBytes = Base64.encodeBase64(authString.getBytes());
 828         String authStringEnc = new String(authEncBytes);
 829         return authStringEnc;
 830     }
 831
 832     private String callURL(String method, String content, String accept, String body, URL url) throws IOException, JSONException {
 833         String authStringEnc = createAuthenticationString();
 834         connection = (HttpURLConnection) url.openConnection();
 835         connection.setRequestMethod(method);
 836         connection.setRequestProperty("Authorization", "Basic " + authStringEnc);
 837         if (content != null) {
 838             connection.setRequestProperty("Content-Type", content);
 839         }
 840         if (accept != null) {
 841             connection.setRequestProperty("Accept", accept);
 842         }
 843         if (body != null) {
 844             // now add the request body
 845             connection.setDoOutput(true);
 846             OutputStreamWriter wr = new OutputStreamWriter(connection.getOutputStream());
 847             wr.write(body);
 848             wr.flush();
 849         }
 850         connection.connect();
 851
 852         // getting the result, first check response code
 853         Integer httpResponseCode = connection.getResponseCode();
 854
 855         if (httpResponseCode > 299) {
 856             LOG.trace("HTTP Address: " + url);
 857             LOG.trace("HTTP Response Code: " + httpResponseCode);
 858             fail();
 859         }
 860
 861         InputStream is = connection.getInputStream();
 862         BufferedReader rd = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
 863         StringBuilder sb = new StringBuilder();
 864         int cp;
 865         while ((cp = rd.read()) != -1) {
 866             sb.append((char) cp);
 867         }
 868         is.close();
 869         connection.disconnect();
 870         return (sb.toString());
 871     }
 872
 873     // timePeriod - in ms
 874     public void assertNoPacketReceived(int timePeriod) {
 875         try {
 876             receivePacket(timePeriod);
 877             // If didn't timeout then fail:
 878             fail();
 879         } catch (SocketTimeoutException ste) {
 880         }
 881     }
 882
 883     // ------------------------------- Mask Tests ---------------------------
 884
 885     public void eidPrefixLookupIPv4() throws SocketTimeoutException {
 886         cleanUP();
 887         runPrefixTest(LispAFIConvertor.asIPAfiAddress("1.2.3.4"), 16, LispAFIConvertor.asIPAfiAddress("1.2.3.2"),
 888                 LispAFIConvertor.asIPAfiAddress("1.1.1.1"), (byte) 32);
 889     }
 890
 891     public void eidPrefixLookupIPv6() throws SocketTimeoutException {
 892         cleanUP();
 893         runPrefixTest(LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:6:7:8"), 64, LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:1:2:3"),
 894                 LispAFIConvertor.asIPv6AfiAddress("1:2:3:1:2:3:1:2"), 128);
 895     }
 896
 897     private void runPrefixTest(LispAFIAddress registerEID, int registerdMask, LispAFIAddress matchedAddress, LispAFIAddress unMatchedAddress, int mask)
 898             throws SocketTimeoutException {
 899
 900         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
 901         mapRegister.setWantMapNotify(true);
 902         mapRegister.setNonce((long) 8);
 903         mapRegister.setWantMapNotify(true);
 904         mapRegister.setKeyId((short) 0);
 905         mapRegister.setAuthenticationData(new byte[0]);
 906         mapRegister.setNonce((long) 8);
 907         mapRegister.setProxyMapReply(false);
 908         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
 909         etlr.setRecordTtl(254);
 910         etlr.setAction(Action.NoAction);
 911         etlr.setAuthoritative(false);
 912         etlr.setMapVersion((short) 0);
 913         etlr.setLispAddressContainer(LispAFIConvertor.toContainer(registerEID));
 914         etlr.setMaskLength((short) registerdMask);
 915         etlr.setRecordTtl(254);
 916         LocatorRecordBuilder record = new LocatorRecordBuilder();
 917         record.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
 918         record.setLocalLocator(false);
 919         record.setRlocProbed(false);
 920         record.setRouted(true);
 921         record.setMulticastPriority((short) 0);
 922         record.setMulticastWeight((short) 0);
 923         record.setPriority((short) 0);
 924         record.setWeight((short) 0);
 925         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
 926         etlr.getLocatorRecord().add(record.build());
 927         mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
 928         mapRegister.getEidToLocatorRecord().add(etlr.build());
 929         sendMapRegister(mapRegister.build());
 930         MapNotify mapNotify = receiveMapNotify();
 931         assertEquals(8, mapNotify.getNonce().longValue());
 932         MapRequestBuilder mapRequest = new MapRequestBuilder();
 933         mapRequest.setNonce((long) 4);
 934         mapRequest.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
 935         mapRequest.setEidRecord(new ArrayList<EidRecord>());
 936         mapRequest.setAuthoritative(false);
 937         mapRequest.setMapDataPresent(false);
 938         mapRequest.setPitr(false);
 939         mapRequest.setProbe(false);
 940         mapRequest.setSmr(false);
 941         mapRequest.setSmrInvoked(false);
 942         mapRequest.getEidRecord().add(
 943                 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(matchedAddress)).build());
 944         mapRequest.setItrRloc(new ArrayList<ItrRloc>());
 945         mapRequest.getItrRloc().add(
 946                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
 947         sendMapRequest(mapRequest.build());
 948         MapReply mapReply = receiveMapReply();
 949         assertEquals(4, mapReply.getNonce().longValue());
 950         assertEquals(record.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
 951         mapRequest.setEidRecord(new ArrayList<EidRecord>());
 952         mapRequest.getEidRecord().add(
 953                 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(unMatchedAddress)).build());
 954         sendMapRequest(mapRequest.build());
 955         mapReply = receiveMapReply();
 956         assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
 957     }
 958
 959     // This registers an IP with a MapRegister, then adds a password via the
 960     // northbound REST API
 961     // and checks that the password works
 962     public void testPasswordExactMatch() throws Exception {
 963         cleanUP();
 964         String ipString = "10.0.0.1";
 965         LispIpv4Address address = LispAFIConvertor.asIPAfiAddress(ipString);
 966         int mask = 32;
 967         String pass = "pass";
 968
 969         URL url = createPutURL("key");
 970
 971         String jsonAuthData = createAuthKeyJSON(pass, address, mask);
 972
 973         LOG.trace("Sending this JSON to LISP server: \n" + jsonAuthData);
 974         LOG.trace("Address: " + address);
 975
 976         byte[] expectedSha = new byte[] { (byte) 146, (byte) 234, (byte) 52, (byte) 247, (byte) 186, (byte) 232, (byte) 31, (byte) 249, (byte) 87,
 977                 (byte) 73, (byte) 234, (byte) 54, (byte) 225, (byte) 160, (byte) 129, (byte) 251, (byte) 73, (byte) 53, (byte) 196, (byte) 62 };
 978
 979         byte[] zeros = new byte[20];
 980
 981         callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
 982
 983         // build a MapRegister
 984         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
 985         mapRegister.setWantMapNotify(true);
 986         mapRegister.setNonce((long) 8);
 987         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
 988         etlr.setLispAddressContainer(LispAFIConvertor.toContainer(address));
 989         etlr.setMaskLength((short) mask);
 990         etlr.setRecordTtl(254);
 991         LocatorRecordBuilder record = new LocatorRecordBuilder();
 992         record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
 993         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
 994         etlr.getLocatorRecord().add(record.build());
 995         mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
 996         mapRegister.getEidToLocatorRecord().add(etlr.build());
 997
 998         mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
 999         mapRegister.setAuthenticationData(zeros);
1000
1001         sendMapRegister(mapRegister.build());
1002         assertNoPacketReceived(3000);
1003
1004         mapRegister.setAuthenticationData(expectedSha);
1005
1006         sendMapRegister(mapRegister.build());
1007
1008         assertMapNotifyRecieved();
1009     }
1010
1011     public void testPasswordMaskMatch() throws Exception {
1012         cleanUP();
1013         LispIpv4Address addressInRange = LispAFIConvertor.asIPAfiAddress("10.20.30.40");
1014         LispIpv4Address addressOutOfRange = LispAFIConvertor.asIPAfiAddress("20.40.30.40");
1015         LispIpv4Address range = LispAFIConvertor.asIPAfiAddress("10.20.30.0");
1016
1017         int mask = 32;
1018         String pass = "pass";
1019
1020         URL url = createPutURL("key");
1021         String jsonAuthData = createAuthKeyJSON(pass, range, 8);
1022
1023         callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
1024         // build a MapRegister
1025         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1026
1027         mapRegister.setWantMapNotify(true);
1028         mapRegister.setNonce((long) 8);
1029         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1030         etlr.setLispAddressContainer(LispAFIConvertor.toContainer(addressInRange));
1031         etlr.setMaskLength((short) mask);
1032         etlr.setRecordTtl(254);
1033         LocatorRecordBuilder record = new LocatorRecordBuilder();
1034         record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1035         record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1036         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1037         etlr.getLocatorRecord().add(record.build());
1038         mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1039         mapRegister.getEidToLocatorRecord().add(etlr.build());
1040
1041         mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
1042         mapRegister
1043                 .setAuthenticationData(new byte[] { -15, -52, 38, -94, 125, -111, -68, -79, 68, 6, 101, 45, -1, 47, -4, -67, -113, 104, -110, -71 });
1044
1045         sendMapRegister(mapRegister.build());
1046
1047         assertMapNotifyRecieved();
1048
1049         etlr.setLispAddressContainer(LispAFIConvertor.toContainer(addressOutOfRange));
1050         mapRegister
1051                 .setAuthenticationData(new byte[] { -54, 68, -58, -91, -23, 22, -88, -31, 113, 39, 115, 78, -68, -123, -71, -14, -99, 67, -23, -73 });
1052
1053         sendMapRegister(mapRegister.build());
1054         assertNoPacketReceived(3000);
1055     }
1056
1057     private MapReply registerAddressAndQuery(LispAFIAddress eid) throws SocketTimeoutException {
1058         return registerAddressAndQuery(eid, -1);
1059     }
1060
1061     // takes an address, packs it in a MapRegister and sends it
1062     private void registerAddress(LispAFIAddress eid, int maskLength) throws SocketTimeoutException {
1063         MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1064         mapRegisterBuilder.setWantMapNotify(true);
1065         mapRegisterBuilder.setKeyId((short) 0);
1066         mapRegisterBuilder.setAuthenticationData(new byte[0]);
1067         mapRegisterBuilder.setNonce((long) 8);
1068         mapRegisterBuilder.setProxyMapReply(false);
1069         EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1070         etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1071         if (maskLength != -1) {
1072             etlrBuilder.setMaskLength((short) maskLength);
1073         } else {
1074             etlrBuilder.setMaskLength((short) 0);
1075         }
1076         etlrBuilder.setRecordTtl(254);
1077         etlrBuilder.setAction(Action.NoAction);
1078         etlrBuilder.setAuthoritative(false);
1079         etlrBuilder.setMapVersion((short) 0);
1080         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1081         recordBuilder.setLocalLocator(false);
1082         recordBuilder.setRlocProbed(false);
1083         recordBuilder.setRouted(true);
1084         recordBuilder.setMulticastPriority((short) 0);
1085         recordBuilder.setMulticastWeight((short) 0);
1086         recordBuilder.setPriority((short) 0);
1087         recordBuilder.setWeight((short) 0);
1088         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1089         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1090         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1091         mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1092         mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1093         sendMapRegister(mapRegisterBuilder.build());
1094         MapNotify mapNotify = receiveMapNotify();
1095         assertEquals(8, mapNotify.getNonce().longValue());
1096     }
1097
1098     private MapReply queryForAddress(LispAFIAddress eid, String srcEid) throws SocketTimeoutException {
1099         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1100         mapRequestBuilder.setNonce((long) 4);
1101         mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1102         mapRequestBuilder.getEidRecord().add(
1103                 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1104         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1105         if (srcEid != null) {
1106             mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.
1107                     toContainer(LispAFIConvertor.asIPAfiAddress(srcEid))).build());
1108         } else {
1109             mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.
1110                     toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1111         }
1112         mapRequestBuilder.getItrRloc().add(
1113                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1114         mapRequestBuilder.setAuthoritative(false);
1115         mapRequestBuilder.setMapDataPresent(false);
1116         mapRequestBuilder.setPitr(false);
1117         mapRequestBuilder.setProbe(false);
1118         mapRequestBuilder.setSmr(false);
1119         mapRequestBuilder.setSmrInvoked(false);
1120         sendMapRequest(mapRequestBuilder.build());
1121         return receiveMapReply();
1122     }
1123
1124     // takes an address, packs it in a MapRegister, sends it, returns the
1125     // MapReply
1126     private MapReply registerAddressAndQuery(LispAFIAddress eid, int maskLength) throws SocketTimeoutException {
1127         MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1128         mapRegisterBuilder.setWantMapNotify(true);
1129         mapRegisterBuilder.setKeyId((short) 0);
1130         mapRegisterBuilder.setAuthenticationData(new byte[0]);
1131         mapRegisterBuilder.setNonce((long) 8);
1132         mapRegisterBuilder.setProxyMapReply(false);
1133         EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1134         etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1135         if (maskLength != -1) {
1136             etlrBuilder.setMaskLength((short) maskLength);
1137         } else {
1138             etlrBuilder.setMaskLength((short) 0);
1139         }
1140         etlrBuilder.setRecordTtl(254);
1141         etlrBuilder.setAction(Action.NoAction);
1142         etlrBuilder.setAuthoritative(false);
1143         etlrBuilder.setMapVersion((short) 0);
1144         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1145         recordBuilder.setLocalLocator(false);
1146         recordBuilder.setRlocProbed(false);
1147         recordBuilder.setRouted(true);
1148         recordBuilder.setMulticastPriority((short) 0);
1149         recordBuilder.setMulticastWeight((short) 0);
1150         recordBuilder.setPriority((short) 0);
1151         recordBuilder.setWeight((short) 0);
1152         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1153         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1154         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1155         mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1156         mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1157         sendMapRegister(mapRegisterBuilder.build());
1158         MapNotify mapNotify = receiveMapNotify();
1159         assertEquals(8, mapNotify.getNonce().longValue());
1160         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1161         mapRequestBuilder.setNonce((long) 4);
1162         mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1163         mapRequestBuilder.getEidRecord().add(
1164                 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1165         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1166         mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress)))
1167                 .build());
1168         mapRequestBuilder.getItrRloc().add(
1169                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1170         mapRequestBuilder.setAuthoritative(false);
1171         mapRequestBuilder.setMapDataPresent(false);
1172         mapRequestBuilder.setPitr(false);
1173         mapRequestBuilder.setProbe(false);
1174         mapRequestBuilder.setSmr(false);
1175         mapRequestBuilder.setSmrInvoked(false);
1176         sendMapRequest(mapRequestBuilder.build());
1177         return receiveMapReply();
1178     }
1179
1180     // ------------------------------- LCAF Tests ---------------------------
1181
1182     @Test
1183     public void registerAndQuery__SrcDestLCAF() throws SocketTimeoutException {
1184         cleanUP();
1185         String ipString = "10.20.30.200";
1186         String macString = "01:02:03:04:05:06";
1187         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString);
1188         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAFIConvertor.asPrimitiveMacAfiAddress(macString);
1189         LcafSourceDestAddrBuilder builder = new LcafSourceDestAddrBuilder();
1190         builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1191         builder.setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode());
1192         builder.setSrcMaskLength((short) 32);
1193         builder.setDstMaskLength((short) 0);
1194         builder.setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(addrToSend1).build());
1195         builder.setDstAddress(new DstAddressBuilder().setPrimitiveAddress(addrToSend2).build());
1196
1197         MapReply reply = registerAddressAndQuery(builder.build());
1198
1199         LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1200         assertTrue(fromNetwork.getAddress() instanceof LcafSourceDest);
1201         LcafSourceDest sourceDestFromNetwork = (LcafSourceDest) fromNetwork.getAddress();
1202
1203         LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getSrcAddress().getPrimitiveAddress());
1204         LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getDstAddress().getPrimitiveAddress());
1205
1206         assertTrue(receivedAddr1 instanceof LispIpv4Address);
1207         assertTrue(receivedAddr2 instanceof LispMacAddress);
1208
1209         LispIpv4Address receivedIP = (LispIpv4Address) receivedAddr1;
1210         LispMacAddress receivedMAC = (LispMacAddress) receivedAddr2;
1211
1212         assertEquals(ipString, receivedIP.getIpv4Address().getValue());
1213         assertEquals(macString, receivedMAC.getMacAddress().getValue());
1214     }
1215
1216     @Test
1217     public void registerAndQuery__SrcDestLCAFOverlap() throws SocketTimeoutException {
1218         cleanUP();
1219         String ipString1 = "10.10.10.0";
1220         String ipString2 = "20.20.20.0";
1221         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString1);
1222         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend2 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString2);
1223         LcafSourceDestAddrBuilder builder = new LcafSourceDestAddrBuilder();
1224         builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1225         builder.setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode());
1226         builder.setSrcMaskLength((short) 24);
1227         builder.setDstMaskLength((short) 24);
1228         builder.setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(addrToSend1).build());
1229         builder.setDstAddress(new DstAddressBuilder().setPrimitiveAddress(addrToSend2).build());
1230
1231         LcafSourceDestAddr srcDst = builder.build();
1232         registerAddress(LispAFIConvertor.asIPAfiAddress(ipString2), 24);
1233         registerAddress(srcDst, -1);
1234
1235         // exact match
1236         MapReply reply = queryForAddress(srcDst, null);
1237
1238         LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1239         assertTrue(fromNetwork.getAddress() instanceof LcafSourceDest);
1240         LcafSourceDest sourceDestFromNetwork = (LcafSourceDest) fromNetwork.getAddress();
1241
1242         LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getSrcAddress().getPrimitiveAddress());
1243         LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getDstAddress().getPrimitiveAddress());
1244
1245         assertTrue(receivedAddr1 instanceof LispIpv4Address);
1246         assertTrue(receivedAddr2 instanceof LispIpv4Address);
1247
1248         LispIpv4Address receivedIP1 = (LispIpv4Address) receivedAddr1;
1249         LispIpv4Address receivedIP2 = (LispIpv4Address) receivedAddr2;
1250
1251         assertEquals(ipString1, receivedIP1.getIpv4Address().getValue());
1252         assertEquals(ipString2, receivedIP2.getIpv4Address().getValue());
1253
1254         // srcEid/dstEid match
1255         reply = queryForAddress(LispAFIConvertor.asIPAfiAddress("20.20.20.1"), "10.10.10.1");
1256         fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1257         assertTrue(fromNetwork.getAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4);
1258
1259         Ipv4Address ipAddr2 = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4) fromNetwork.getAddress()).getIpv4Address();
1260         assertEquals(ipString2, ipAddr2.getIpv4Address().getValue());
1261
1262         // dstEid match only
1263         reply = queryForAddress(LispAFIConvertor.asIPAfiAddress("20.20.20.1"), "1.2.3.4");
1264         fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1265         assertTrue(fromNetwork.getAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4);
1266
1267         ipAddr2 = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4) fromNetwork.getAddress()).getIpv4Address();
1268         assertEquals(ipString2, ipAddr2.getIpv4Address().getValue());
1269     }
1270
1271     @Test
1272     public void registerAndQuery__KeyValueLCAF() throws SocketTimeoutException {
1273         cleanUP();
1274         String ipString = "10.20.30.200";
1275         String macString = "01:02:03:04:05:06";
1276         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString);
1277         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAFIConvertor.asPrimitiveMacAfiAddress(macString);
1278         LcafKeyValueAddressAddrBuilder builder = new LcafKeyValueAddressAddrBuilder();
1279         builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1280         builder.setLcafType((short) LispCanonicalAddressFormatEnum.KEY_VALUE.getLispCode());
1281         builder.setKey(new KeyBuilder().setPrimitiveAddress(addrToSend1).build());
1282         builder.setValue(new ValueBuilder().setPrimitiveAddress(addrToSend2).build());
1283
1284         MapReply reply = registerAddressAndQuery(builder.build());
1285
1286         LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1287         assertTrue(fromNetwork.getAddress() instanceof LcafKeyValue);
1288         LcafKeyValue keyValueFromNetwork = (LcafKeyValue) fromNetwork.getAddress();
1289
1290         LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(keyValueFromNetwork.getLcafKeyValueAddressAddr().getKey().getPrimitiveAddress());
1291         LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(keyValueFromNetwork.getLcafKeyValueAddressAddr().getValue().getPrimitiveAddress());
1292
1293         assertTrue(receivedAddr1 instanceof LispIpv4Address);
1294         assertTrue(receivedAddr2 instanceof LispMacAddress);
1295
1296         LispIpv4Address receivedIP = (LispIpv4Address) receivedAddr1;
1297         LispMacAddress receivedMAC = (LispMacAddress) receivedAddr2;
1298
1299         assertEquals(ipString, receivedIP.getIpv4Address().getValue());
1300         assertEquals(macString, receivedMAC.getMacAddress().getValue());
1301     }
1302
1303     public void registerAndQuery__ListLCAF() throws SocketTimeoutException {
1304         cleanUP();
1305         String macString = "01:02:03:04:05:06";
1306         String ipString = "10.20.255.30";
1307         LcafListAddrBuilder listbuilder = new LcafListAddrBuilder();
1308         listbuilder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.LIST.getLispCode());
1309         listbuilder.setAddresses(new ArrayList<Addresses>());
1310         listbuilder.getAddresses().add(new AddressesBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1311         listbuilder.getAddresses().add(new AddressesBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asMacAfiAddress(macString))).build());
1312
1313         MapReply reply = registerAddressAndQuery(listbuilder.build());
1314
1315         LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1316
1317         assertTrue(receivedAddress instanceof LcafListAddress);
1318
1319         LcafListAddress listAddrFromNetwork = (LcafListAddress) receivedAddress;
1320         LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(listAddrFromNetwork.getAddresses().get(0).getPrimitiveAddress());
1321         LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(listAddrFromNetwork.getAddresses().get(1).getPrimitiveAddress());
1322
1323         assertTrue(receivedAddr1 instanceof LispIpv4Address);
1324         assertTrue(receivedAddr2 instanceof LispMacAddress);
1325
1326         assertEquals(macString, ((LispMacAddress) receivedAddr2).getMacAddress().getValue());
1327         assertEquals(ipString, ((LispIpv4Address) receivedAddr1).getIpv4Address().getValue());
1328     }
1329
1330     public void registerAndQuery__SegmentLCAF() throws SocketTimeoutException {
1331         cleanUP();
1332         String ipString = "10.20.255.30";
1333         int instanceId = 6;
1334         LcafSegmentAddrBuilder builder = new LcafSegmentAddrBuilder();
1335         builder.setInstanceId((long) instanceId);
1336         builder.setIidMaskLength((short) 32);
1337         builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.SEGMENT.getLispCode());
1338         builder.setAddress(new AddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1339
1340         MapReply reply = registerAddressAndQuery(builder.build());
1341
1342         LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1343         assertTrue(receivedAddress instanceof LcafSegmentAddress);
1344
1345         LcafSegmentAddress segmentfromNetwork = (LcafSegmentAddress) receivedAddress;
1346         LispAFIAddress addrFromSegment = LispAFIConvertor.toAFIfromPrimitive(segmentfromNetwork.getAddress().getPrimitiveAddress());
1347         assertTrue(addrFromSegment instanceof LispIpv4Address);
1348         assertEquals(ipString, ((LispIpv4Address) addrFromSegment).getIpv4Address().getValue());
1349
1350         assertEquals(instanceId, segmentfromNetwork.getInstanceId().intValue());
1351     }
1352
1353     public void registerAndQuery__TrafficEngineering() throws SocketTimeoutException {
1354         cleanUP();
1355         String macString = "01:02:03:04:05:06";
1356         String ipString = "10.20.255.30";
1357         HopBuilder hopBuilder = new HopBuilder();
1358         hopBuilder.setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString)));
1359         Hop hop1 = hopBuilder.build();
1360         hopBuilder.setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asMacAfiAddress(macString)));
1361         Hop hop2 = hopBuilder.build();
1362         HopsBuilder hb = new HopsBuilder();
1363         hb.setHop(hop1);
1364         hb.setLookup(true);
1365         hb.setRLOCProbe(false);
1366         hb.setStrict(true);
1367         HopsBuilder hb2 = new HopsBuilder();
1368         hb2.setHop(hop2);
1369         hb2.setLookup(false);
1370         hb2.setRLOCProbe(true);
1371         hb2.setStrict(false);
1372         Hops hops1 = hb.build();
1373         Hops hops2 = hb2.build();
1374         LcafTrafficEngineeringAddrBuilder trafficBuilder = new LcafTrafficEngineeringAddrBuilder();
1375         trafficBuilder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType(
1376                 (short) LispCanonicalAddressFormatEnum.TRAFFIC_ENGINEERING.getLispCode());
1377         trafficBuilder.setHops(new ArrayList<Hops>());
1378         trafficBuilder.getHops().add(hb.build());
1379         trafficBuilder.getHops().add(hb2.build());
1380
1381         MapReply reply = registerAddressAndQuery(trafficBuilder.build());
1382
1383         assertTrue(LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer()) instanceof LcafTrafficEngineeringAddress);
1384
1385         LcafTrafficEngineeringAddress receivedAddress = (LcafTrafficEngineeringAddress) LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0)
1386                 .getLispAddressContainer());
1387
1388         ReencapHop receivedHop1 = receivedAddress.getHops().get(0);
1389         ReencapHop receivedHop2 = receivedAddress.getHops().get(1);
1390
1391         assertEquals(true, hops1.isLookup());
1392         assertEquals(false, hops1.isRLOCProbe());
1393         assertEquals(true, hops1.isStrict());
1394
1395         assertEquals(false, hops2.isLookup());
1396         assertEquals(true, hops2.isRLOCProbe());
1397         assertEquals(false, hops2.isStrict());
1398
1399         assertTrue(receivedHop1.getHop().getPrimitiveAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4);
1400         assertTrue(receivedHop2.getHop().getPrimitiveAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac);
1401
1402         assertEquals(ipString, ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) receivedHop1.getHop().getPrimitiveAddress()).getIpv4Address().getIpv4Address().getValue());
1403         assertEquals(macString, ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac) receivedHop2.getHop().getPrimitiveAddress()).getMacAddress().getMacAddress().getValue());
1404     }
1405
1406     public void registerAndQuery__ApplicationData() throws SocketTimeoutException {
1407         cleanUP();
1408         String ipString = "1.2.3.4";
1409         short protocol = 1;
1410         int ipTOs = 2;
1411         int localPort = 3;
1412         int remotePort = 4;
1413
1414         LcafApplicationDataAddrBuilder builder = new LcafApplicationDataAddrBuilder();
1415         builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode());
1416         builder.setIpTos(ipTOs);
1417         builder.setProtocol(protocol);
1418         builder.setLocalPort(new PortNumber(localPort));
1419         builder.setRemotePort(new PortNumber(remotePort));
1420         builder.setAddress(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder()
1421                 .setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1422
1423         LcafApplicationDataAddress addressToSend = builder.build();
1424
1425         MapReply reply = registerAddressAndQuery(addressToSend);
1426
1427         LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1428
1429         assertTrue(receivedAddress instanceof LcafApplicationDataAddress);
1430
1431         LcafApplicationDataAddress receivedApplicationDataAddress = (LcafApplicationDataAddress) receivedAddress;
1432         assertEquals(protocol, receivedApplicationDataAddress.getProtocol().intValue());
1433         assertEquals(ipTOs, receivedApplicationDataAddress.getIpTos().intValue());
1434         assertEquals(localPort, receivedApplicationDataAddress.getLocalPort().getValue().intValue());
1435         assertEquals(remotePort, receivedApplicationDataAddress.getRemotePort().getValue().intValue());
1436
1437         LispIpv4Address ipAddressReceived = (LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(receivedApplicationDataAddress.getAddress().getPrimitiveAddress());
1438         assertEquals(ipString, ipAddressReceived.getIpv4Address().getValue());
1439     }
1440
1441     // ------------------- TimeOut Tests -----------
1442
1443     public void mapRequestMapRegisterAndMapRequestTestTimeout() throws SocketTimeoutException {
1444         cleanUP();
1445         LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
1446         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1447         mapRequestBuilder.setNonce((long) 4);
1448         mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
1449                 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
1450         mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1451         mapRequestBuilder.getEidRecord().add(
1452                 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1453         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1454         mapRequestBuilder.getItrRloc().add(
1455                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1456         sendMapRequest(mapRequestBuilder.build());
1457         MapReply mapReply = receiveMapReply();
1458         assertEquals(4, mapReply.getNonce().longValue());
1459         assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
1460         MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1461         mapRegisterbuilder.setWantMapNotify(true);
1462         mapRegisterbuilder.setNonce((long) 8);
1463         EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1464         etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1465         etlrBuilder.setMaskLength((short) 32);
1466         etlrBuilder.setRecordTtl(254);
1467         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1468         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
1469         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1470         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1471         mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1472         mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1473         sendMapRegister(mapRegisterbuilder.build());
1474         MapNotify mapNotify = receiveMapNotify();
1475         assertEquals(8, mapNotify.getNonce().longValue());
1476         sendMapRequest(mapRequestBuilder.build());
1477         mapReply = receiveMapReply();
1478         assertEquals(4, mapReply.getNonce().longValue());
1479         assertEquals(recordBuilder.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
1480                 .getLispAddressContainer());
1481         causeEntryToBeCleaned();
1482         sendMapRequest(mapRequestBuilder.build());
1483         mapReply = receiveMapReply();
1484         assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
1485     }
1486
1487     public void mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse() throws Exception {
1488         cleanUP();
1489         LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
1490         MapRequest mapRequest = createMapRequest(eid);
1491
1492         testTTLBeforeRegister(mapRequest);
1493
1494         registerForTTL(eid);
1495
1496         testTTLAfterRegister(mapRequest);
1497
1498         causeEntryToBeCleaned();
1499         testTTLAfterClean(mapRequest);
1500
1501         northboundAddKey();
1502         testTTLAfterAutherize(mapRequest);
1503
1504     }
1505
1506     private void testTTLAfterClean(MapRequest mapRequest) throws SocketTimeoutException {
1507         MapReply mapReply;
1508         sendMapRequest(mapRequest);
1509         mapReply = receiveMapReply();
1510         assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1511     }
1512
1513     private void causeEntryToBeCleaned() {
1514         // TODO for the time being, to keep master and stable/lithium in sync, we need to remove the forceful
1515         // expiration of DAO entries. Once we're past this, we'll have to expose methods to setTimeUnit(TimeUnit)
1516         // and cleanOld() (expired) entries in IFlowMapping (and perhaps ILispDAO) and use them here.
1517         this.lms.clean();
1518     }
1519
1520     private void testTTLAfterRegister(MapRequest mapRequest) throws SocketTimeoutException {
1521         MapReply mapReply;
1522         sendMapRequest(mapRequest);
1523         mapReply = receiveMapReply();
1524         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
1525                 .getLispAddressContainer());
1526         assertCorrectMapReplyTTLAndAction(mapReply, 254, Action.NoAction);
1527     }
1528
1529     private void registerForTTL(LispIpv4Address eid) throws SocketTimeoutException {
1530         MapRegister mapRegister = createMapRegister(eid);
1531         sendMapRegister(mapRegister);
1532         assertMapNotifyRecieved();
1533     }
1534
1535     private void testTTLBeforeRegister(MapRequest mapRequest) throws SocketTimeoutException {
1536         MapReply mapReply;
1537         sendMapRequest(mapRequest);
1538         mapReply = receiveMapReply();
1539         assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1540     }
1541
1542     private void testTTLAfterAutherize(MapRequest mapRequest) throws SocketTimeoutException {
1543         MapReply mapReply;
1544         sendMapRequest(mapRequest);
1545         mapReply = receiveMapReply();
1546         assertCorrectMapReplyTTLAndAction(mapReply, 1, Action.NativelyForward);
1547     }
1548
1549     private void assertCorrectMapReplyTTLAndAction(MapReply mapReply, int expectedTTL, Action expectedAction) {
1550         assertEquals(expectedTTL, mapReply.getEidToLocatorRecord().get(0).getRecordTtl().intValue());
1551         assertEquals(expectedAction, mapReply.getEidToLocatorRecord().get(0).getAction());
1552     }
1553
1554     private MapRegister createMapRegister(LispAFIAddress eid, LispAFIAddress rloc) {
1555         MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1556         mapRegisterbuilder.setWantMapNotify(true);
1557         mapRegisterbuilder.setNonce((long) 8);
1558         mapRegisterbuilder.setKeyId((short) 0);
1559         EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1560         etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1561         etlrBuilder.setMaskLength((short) 24);
1562         etlrBuilder.setRecordTtl(254);
1563         etlrBuilder.setAuthoritative(false);
1564         etlrBuilder.setAction(Action.NoAction);
1565         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1566         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
1567         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1568         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1569         mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1570         mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1571         MapRegister mapRegister = mapRegisterbuilder.build();
1572         return mapRegister;
1573     }
1574
1575     private MapRegister createMapRegister(LispIpv4Address eid) {
1576         return createMapRegister(eid, LispAFIConvertor.asIPAfiAddress("4.3.2.1"));
1577     }
1578
1579     private MapRequest createMapRequest(LispAFIAddress eid) {
1580         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1581         mapRequestBuilder.setNonce((long) 4);
1582         mapRequestBuilder.setPitr(false);
1583         mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
1584                 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
1585         mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1586         mapRequestBuilder.getEidRecord().add(
1587                 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1588         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1589         mapRequestBuilder.getItrRloc().add(
1590                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1591         MapRequest mr = mapRequestBuilder.build();
1592         return mr;
1593     }
1594
1595     public void testSimpleNonProxy() throws SocketTimeoutException, SocketException {
1596         cleanUP();
1597         String rloc = "127.0.0.3";
1598         int port = LispMessage.PORT_NUM;
1599         LispAFIAddress ipRloc = LispAFIConvertor.asIPAfiAddress(rloc);
1600         sendProxyMapRequest(rloc, port, ipRloc);
1601
1602     }
1603
1604     public void testNonProxyOtherPort() throws SocketTimeoutException, SocketException {
1605         cleanUP();
1606         String rloc = "127.0.0.3";
1607         int port = 4350;
1608         LcafApplicationDataAddr adLcaf = new LcafApplicationDataAddrBuilder()
1609                 .setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
1610                 .setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode())
1611                 .setAddress(
1612                         new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder().setPrimitiveAddress(
1613                                 LispAFIConvertor.asPrimitiveIPAfiAddress(rloc)).build()).setLocalPort(new PortNumber(port)).build();
1614         LOG.info("testNonProxyOtherPort:" + adLcaf.toString());
1615         sendProxyMapRequest(rloc, port, adLcaf);
1616
1617     }
1618
1619     public void testRecievingNonProxyOnXtrPort() throws SocketTimeoutException, SocketException, Throwable {
1620         cleanUP();
1621         configLispPlugin.shouldListenOnXtrPort(true);
1622         notificationCalled = false;
1623         final String eid = "10.10.10.10";
1624         String rloc = "127.0.0.3";
1625         int port = LispMessage.XTR_PORT_NUM;
1626         LcafApplicationDataAddr adLcaf = new LcafApplicationDataAddrBuilder()
1627                 .setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
1628                 .setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode())
1629                 .setAddress(
1630                         new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder().setPrimitiveAddress(
1631                                 LispAFIConvertor.asPrimitiveIPAfiAddress(rloc)).build()).setLocalPort(new PortNumber(port)).build();
1632         final MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
1633         ((LispMappingService) lms).registerNotificationListener(XtrRequestMapping.class, new NotificationListener<XtrRequestMapping>() {
1634
1635             @Override
1636             public void onNotification(XtrRequestMapping notification) {
1637                 assertEquals(((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4) mapRequest.getEidRecord().get(0).getLispAddressContainer().getAddress()).getIpv4Address().getIpv4Address().getValue(),
1638                         eid);
1639                 notificationCalled = true;
1640                 LOG.warn("notification arrived");
1641             }
1642         });
1643         sendMapRequest(mapRequest, port);
1644         for (int i = 0; i < MAX_NOTIFICATION_RETRYS; i++) {
1645             if (notificationCalled) {
1646                 return;
1647             } else {
1648                 LOG.warn("notification hasn't arrived, sleeping...");
1649                 Thread.sleep(500);
1650             }
1651         }
1652
1653         fail("Notification hasn't arrived");
1654
1655     }
1656
1657     private void sendProxyMapRequest(String rloc, int port, LispAFIAddress adLcaf) throws SocketTimeoutException, SocketException {
1658         String eid = "10.1.0.1";
1659         MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
1660         sendMapRequest(mapRequest);
1661         DatagramSocket nonProxySocket = new DatagramSocket(new InetSocketAddress(rloc, port));
1662         MapRequest recievedMapRequest = receiveMapRequest(nonProxySocket);
1663         assertEquals(mapRequest.getNonce(), recievedMapRequest.getNonce());
1664         assertEquals(mapRequest.getSourceEid(), recievedMapRequest.getSourceEid());
1665         assertEquals(mapRequest.getItrRloc(), recievedMapRequest.getItrRloc());
1666         assertEquals(mapRequest.getEidRecord(), recievedMapRequest.getEidRecord());
1667         nonProxySocket.close();
1668     }
1669
1670     private MapRequest createNonProxyMapRequest(String eid, LispAFIAddress adLcaf) throws SocketTimeoutException {
1671         MapRegister mr = createMapRegister(LispAFIConvertor.asIPAfiAddress(eid));
1672         LocatorRecord record = new LocatorRecordBuilder(mr.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)).setLispAddressContainer(
1673                 LispAFIConvertor.toContainer(adLcaf)).build();
1674         mr.getEidToLocatorRecord().get(0).getLocatorRecord().set(0, record);
1675         sendMapRegister(mr);
1676         assertMapNotifyRecieved();
1677         MapRequest mapRequest = createMapRequest(LispAFIConvertor.asIPAfiAddress(eid));
1678         MapRequestBuilder builder = new MapRequestBuilder(mapRequest);
1679         builder.setPitr(true);
1680         mapRequest = builder.build();
1681         return mapRequest;
1682     }
1683
1684     private void assertMapNotifyRecieved() throws SocketTimeoutException {
1685         receiveMapNotify();
1686     }
1687
1688     private MapReply receiveMapReply() throws SocketTimeoutException {
1689         return MapReplySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
1690     }
1691
1692     private MapRequest receiveMapRequest(DatagramSocket datagramSocket) throws SocketTimeoutException {
1693         return MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket(datagramSocket, 30000).getData()));
1694     }
1695
1696     private MapNotify receiveMapNotify() throws SocketTimeoutException {
1697         return MapNotifySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
1698     }
1699
1700     private void sendMapRequest(MapRequest mapRequest) {
1701         sendMapRequest(mapRequest, LispMessage.PORT_NUM);
1702     }
1703
1704     private void sendMapRequest(MapRequest mapRequest, int port) {
1705         sendPacket(MapRequestSerializer.getInstance().serialize(mapRequest).array(), port);
1706     }
1707
1708     private void sendMapRegister(MapRegister mapRegister) {
1709         sendPacket(MapRegisterSerializer.getInstance().serialize(mapRegister).array());
1710     }
1711
1712     private void sendPacket(byte[] bytesToSend) {
1713         sendPacket(bytesToSend, LispMessage.PORT_NUM);
1714     }
1715
1716     private void sendPacket(byte[] bytesToSend, int port) {
1717         try {
1718             DatagramPacket packet = new DatagramPacket(bytesToSend, bytesToSend.length);
1719             initPacketAddress(packet, port);
1720             LOG.trace("Sending packet to LispPlugin on socket, port {}", port);
1721             socket.send(packet);
1722         } catch (Throwable t) {
1723             fail();
1724         }
1725     }
1726
1727     private DatagramPacket receivePacket() throws SocketTimeoutException {
1728         return receivePacket(6000);
1729     }
1730
1731     private DatagramPacket receivePacket(int timeout) throws SocketTimeoutException {
1732         return receivePacket(socket, timeout);
1733     }
1734
1735     private DatagramPacket receivePacket(DatagramSocket receivedSocket, int timeout) throws SocketTimeoutException {
1736         try {
1737             byte[] buffer = new byte[4096];
1738             DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
1739             LOG.trace("Waiting for packet from socket...");
1740             receivedSocket.setSoTimeout(timeout);
1741             receivedSocket.receive(receivePacket);
1742             LOG.trace("Recieved packet from socket!");
1743             return receivePacket;
1744         } catch (SocketTimeoutException ste) {
1745             throw ste;
1746         } catch (Throwable t) {
1747             fail();
1748             return null;
1749         }
1750     }
1751
1752     private void initPacketAddress(DatagramPacket packet, int port) throws UnknownHostException {
1753         packet.setAddress(InetAddress.getByName(lispBindAddress));
1754         packet.setPort(port);
1755     }
1756
1757     private DatagramSocket initSocket(DatagramSocket socket, int port) {
1758         try {
1759             socket = new DatagramSocket(new InetSocketAddress(ourAddress, port));
1760         } catch (SocketException e) {
1761             e.printStackTrace();
1762             fail();
1763         }
1764         return socket;
1765     }
1766
1767     private byte[] extractWSUdpByteArray(String wiresharkHex) {
1768         final int HEADER_LEN = 42;
1769         byte[] res = new byte[1000];
1770         String[] split = wiresharkHex.split(" ");
1771         int counter = 0;
1772         for (String cur : split) {
1773             cur = cur.trim();
1774             if (cur.length() == 2) {
1775                 ++counter;
1776                 if (counter > HEADER_LEN) {
1777                     res[counter - HEADER_LEN - 1] = (byte) Integer.parseInt(cur, 16);
1778                 }
1779
1780             }
1781         }
1782         return Arrays.copyOf(res, counter - HEADER_LEN);
1783     }
1784
1785     private String stateToString(int state) {
1786         switch (state) {
1787         case Bundle.ACTIVE:
1788             return "ACTIVE";
1789         case Bundle.INSTALLED:
1790             return "INSTALLED";
1791         case Bundle.RESOLVED:
1792             return "RESOLVED";
1793         case Bundle.UNINSTALLED:
1794             return "UNINSTALLED";
1795         default:
1796             return "Not CONVERTED";
1797         }
1798     }
1799
1800     @SuppressWarnings({ "rawtypes", "unchecked" })
1801     private void areWeReady() throws InvalidSyntaxException {
1802         assertNotNull(bc);
1803         boolean debugit = false;
1804         Bundle b[] = bc.getBundles();
1805         for (Bundle element : b) {
1806             int state = element.getState();
1807             LOG.trace("Bundle[" + element.getBundleId() + "]:" + element.getSymbolicName() + ",v" + element.getVersion() + ", state:"
1808                     + stateToString(state));
1809             if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
1810                 LOG.debug("Bundle:" + element.getSymbolicName() + " state:" + stateToString(state));
1811
1812                 // try {
1813                 // String host = element.getHeaders().get("FRAGMENT-HOST");
1814                 // if (host != null) {
1815                 // LOG.warn("Bundle " + element.getSymbolicName() +
1816                 // " is a fragment which is part of: " + host);
1817                 // LOG.warn("Required imports are: " +
1818                 // element.getHeaders().get("IMPORT-PACKAGE"));
1819                 // } else {
1820                 // element.start();
1821                 // }
1822                 // } catch (BundleException e) {
1823                 // LOG.error("BundleException:", e);
1824                 // fail();
1825                 // }
1826
1827                 debugit = true;
1828
1829             }
1830         }
1831         if (debugit) {
1832             LOG.warn(("Do some debugging because some bundle is unresolved"));
1833         }
1834         // assertNotNull(broker);
1835
1836         int retry = 0;
1837         ServiceReference r = null;
1838         while (this.lms == null && retry < MAX_SERVICE_LOAD_RETRIES) {
1839
1840             r = bc.getServiceReference(IFlowMapping.class.getName());
1841             // r.getPropertyKeys();
1842             if (r != null) {
1843                 this.lms = (IFlowMapping) bc.getService(r);
1844             } else {
1845                 try {
1846                     Thread.sleep(1000);
1847                 } catch (InterruptedException e) {
1848                 }
1849             }
1850             retry += 1;
1851         }
1852
1853         assertNotNull(IFlowMapping.class.getName() + " service wasn't found in bundle context ", this.lms);
1854
1855         configLispPlugin.setLispAddress(lispBindAddress);
1856
1857         // Uncomment this code to Know which services were actually loaded to
1858         // BundleContext
1859         /*
1860          * for (ServiceReference sr : bc.getAllServiceReferences(null, null)) {
1861          * LOG.trace(sr.getBundle().getSymbolicName());
1862          * LOG.trace(sr.toString()); }
1863          */
1864         try {
1865             Thread.sleep(1000);
1866         } catch (InterruptedException e) {
1867         }
1868     }
1869
1870     private void cleanUP() {
1871         after();
1872         lms.clean();
1873         configLispPlugin.shouldListenOnXtrPort(false);
1874         socket = initSocket(socket, LispMessage.PORT_NUM);
1875
1876     }
1877
1878 }