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