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