mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServer.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
   9 package org.opendaylight.lispflowmapping.implementation.lisp;
  10
  11 import java.io.PrintWriter;
  12 import java.io.StringWriter;
  13 import java.net.InetAddress;
  14 import java.net.NetworkInterface;
  15 import java.net.SocketException;
  16 import java.util.ArrayList;
  17 import java.util.Enumeration;
  18 import java.util.HashMap;
  19 import java.util.HashSet;
  20 import java.util.List;
  21 import java.util.Map;
  22 import java.util.Random;
  23 import java.util.Map.Entry;
  24
  25 import org.apache.commons.lang3.BooleanUtils;
  26 import org.opendaylight.lispflowmapping.implementation.authentication.LispAuthenticationUtil;
  27 import org.opendaylight.lispflowmapping.implementation.config.ConfigIni;
  28 import org.opendaylight.lispflowmapping.implementation.dao.MappingServiceKeyUtil;
  29 import org.opendaylight.lispflowmapping.implementation.util.DAOMappingUtil;
  30 import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
  31 import org.opendaylight.lispflowmapping.implementation.util.MapNotifyBuilderHelper;
  32 import org.opendaylight.lispflowmapping.inmemorydb.HashMapDb;
  33 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
  34 import org.opendaylight.lispflowmapping.interfaces.dao.IMappingServiceKey;
  35 import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
  36 import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceRLOCGroup;
  37 import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceSubscriberRLOC;
  38 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapNotifyHandler;
  39 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapServerAsync;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRequest;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecordBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecordBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainer;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.Address;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafKeyValue;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafSourceDest;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.DistinguishedName;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecord;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapnotifymessage.MapNotifyBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRloc;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRlocBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.SourceEidBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequestnotification.MapRequestBuilder;
  57 import org.slf4j.Logger;
  58 import org.slf4j.LoggerFactory;
  59
  60 public class MapServer extends AbstractLispComponent implements IMapServerAsync {
  61
  62     protected static final Logger LOG = LoggerFactory.getLogger(MapServer.class);
  63
  64     private static final ConfigIni configIni = new ConfigIni();
  65     private static final boolean overwriteConfig = configIni.mappingOverwriteIsSet();
  66     private boolean overwrite;
  67
  68     public MapServer(ILispDAO dao) {
  69         this(dao, overwriteConfig);
  70     }
  71
  72     public MapServer(ILispDAO dao, boolean overwrite) {
  73         this(dao, overwrite, true);
  74     }
  75
  76     public MapServer(ILispDAO dao, boolean overwrite, boolean authenticate) {
  77         this(dao, overwrite, authenticate, true);
  78     }
  79
  80     public MapServer(ILispDAO dao, boolean overwrite, boolean authenticate, boolean iterateAuthenticationMask) {
  81         super(dao, authenticate, iterateAuthenticationMask);
  82         this.overwrite = overwrite;
  83     }
  84
  85     private static InetAddress getLocalAddress() {
  86         try {
  87             Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
  88             while (interfaces.hasMoreElements()) {
  89                 NetworkInterface current = interfaces.nextElement();
  90                 LOG.debug("Interface " + current.toString());
  91                 if (!current.isUp() || current.isLoopback() || current.isVirtual())
  92                     continue;
  93                 Enumeration<InetAddress> addresses = current.getInetAddresses();
  94                 while (addresses.hasMoreElements()) {
  95                     InetAddress current_addr = addresses.nextElement();
  96                     // Skip loopback and link local addresses
  97                     if (current_addr.isLoopbackAddress() || current_addr.isLinkLocalAddress())
  98                         continue;
  99                     LOG.debug(current_addr.getHostAddress());
 100                     return current_addr;
 101                 }
 102             }
 103         } catch (SocketException se) {
 104         }
 105         return null;
 106     }
 107
 108     private static MapRequest buildSMR(EidToLocatorRecord eidRecord) {
 109         MapRequestBuilder builder = new MapRequestBuilder();
 110         builder.setAuthoritative(false);
 111         builder.setMapDataPresent(false);
 112         builder.setPitr(false);
 113         builder.setProbe(false);
 114         builder.setSmr(true);
 115         builder.setSmrInvoked(false);
 116
 117         builder.setEidRecord(new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecord>());
 118         LispAddressContainer container = eidRecord.getLispAddressContainer();
 119         short mask = (short) eidRecord.getMaskLength();
 120         builder.getEidRecord().add(new EidRecordBuilder().setMask(mask).setLispAddressContainer(container).build());
 121
 122         builder.setItrRloc(new ArrayList<ItrRloc>());
 123         builder.getItrRloc().add(new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(getLocalAddress())).build());
 124
 125         builder.setMapReply(null);
 126         builder.setNonce(new Random().nextLong());
 127
 128         // XXX For now we set source EID to queried EID...
 129         builder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(container).build());
 130         return builder.build();
 131     }
 132
 133     public void handleMapRegister(MapRegister mapRegister, boolean smr, IMapNotifyHandler callback) {
 134         if (dao == null) {
 135             LOG.warn("handleMapRegister called while dao is uninitialized");
 136         } else {
 137             boolean failed = false;
 138             String password = null;
 139             for (EidToLocatorRecord eidRecord : mapRegister.getEidToLocatorRecord()) {
 140                 if (shouldAuthenticate()) {
 141                     password = getPassword(eidRecord.getLispAddressContainer(), eidRecord.getMaskLength());
 142                     if (!LispAuthenticationUtil.validate(mapRegister, password)) {
 143                         LOG.warn("Authentication failed");
 144                         failed = true;
 145                         break;
 146                     }
 147                 }
 148                 boolean mappingChanged = saveRlocs(eidRecord, smr);
 149                 if (smr && mappingChanged) {
 150                     sendSmrs(eidRecord, callback);
 151                 }
 152             }
 153             if (!failed) {
 154                 MapNotifyBuilder builder = new MapNotifyBuilder();
 155                 if (BooleanUtils.isTrue(mapRegister.isWantMapNotify())) {
 156                     LOG.trace("MapRegister wants MapNotify");
 157                     MapNotifyBuilderHelper.setFromMapRegister(builder, mapRegister);
 158                     if (shouldAuthenticate()) {
 159                         builder.setAuthenticationData(LispAuthenticationUtil.createAuthenticationData(builder.build(), password));
 160                     }
 161                     callback.handleMapNotify(builder.build());
 162                 }
 163             }
 164         }
 165     }
 166
 167     public boolean saveRlocs(EidToLocatorRecord eidRecord, boolean checkForChanges) {
 168         Map<String, MappingServiceRLOCGroup> rlocGroups = new HashMap<String, MappingServiceRLOCGroup>();
 169         if (eidRecord.getLocatorRecord() != null) {
 170             for (LocatorRecord locatorRecord : eidRecord.getLocatorRecord()) {
 171                 String subkey = getAddressKey(locatorRecord.getLispAddressContainer().getAddress());
 172                 if (!rlocGroups.containsKey(subkey)) {
 173                     rlocGroups.put(subkey, new MappingServiceRLOCGroup(eidRecord.getRecordTtl(), eidRecord.getAction(), eidRecord.isAuthoritative()));
 174                 }
 175                 rlocGroups.get(subkey).addRecord(locatorRecord);
 176             }
 177         }
 178         List<MappingEntry<MappingServiceRLOCGroup>> entries = new ArrayList<>();
 179         for (String subkey : rlocGroups.keySet()) {
 180             entries.add(new MappingEntry<>(subkey, rlocGroups.get(subkey)));
 181         }
 182
 183         if (eidRecord.getLispAddressContainer().getAddress() instanceof LcafSourceDest) {
 184             Entry<IMappingServiceKey, List<MappingServiceRLOCGroup>> oldMapping= null, newMapping = null;
 185             LispAFIAddress srcAddr = getSrcForLcafSrcDst(eidRecord.getLispAddressContainer());
 186             LispAFIAddress dstAddr = getDstForLcafSrcDst(eidRecord.getLispAddressContainer());
 187             short srcMask = getSrcMaskForLcafSrcDst(eidRecord.getLispAddressContainer());
 188             short dstMask = getDstMaskForLcafSrcDst(eidRecord.getLispAddressContainer());
 189
 190             if (checkForChanges) {
 191                 oldMapping = DAOMappingUtil.getMappingExact(srcAddr, dstAddr, srcMask, dstMask, dao);
 192             }
 193             IMappingServiceKey dstKey = MappingServiceKeyUtil.generateMappingServiceKey(dstAddr, dstMask);
 194             ILispDAO srcDstDao = (ILispDAO) dao.getSpecific(dstKey, LCAF_SRCDST_SUBKEY);
 195             if (srcDstDao == null) {
 196                 srcDstDao = new HashMapDb();
 197                 dao.put(dstKey, new MappingEntry<>(LCAF_SRCDST_SUBKEY, srcDstDao));
 198             }
 199             IMappingServiceKey srcKey = MappingServiceKeyUtil.generateMappingServiceKey(srcAddr, srcMask);
 200             srcDstDao.put(srcKey, entries.toArray(new MappingEntry[entries.size()]));
 201             if (checkForChanges) {
 202                 newMapping = DAOMappingUtil.getMappingExact(srcAddr, dstAddr, srcMask, dstMask, dao);
 203                 if (!newMapping.getValue().equals(oldMapping.getValue())) {
 204                     return true;
 205                 }
 206             }
 207         } else {
 208             List<MappingServiceRLOCGroup> oldLocators = null, newLocators = null;
 209             if (checkForChanges) {
 210                 oldLocators = DAOMappingUtil.getLocatorsByEidToLocatorRecord(eidRecord, dao, shouldIterateMask());
 211             }
 212             IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(eidRecord.getLispAddressContainer(),
 213                     eidRecord.getMaskLength());
 214             dao.put(key, entries.toArray(new MappingEntry[entries.size()]));
 215             if (checkForChanges) {
 216                 newLocators = DAOMappingUtil.getLocatorsByEidToLocatorRecord(eidRecord, dao, shouldIterateMask());
 217                 if (!newLocators.equals(oldLocators)) {
 218                     return true;
 219                 }
 220             }
 221         }
 222         return false;
 223     }
 224
 225     private String getAddressKey(Address address) {
 226         if (address instanceof LcafKeyValue) {
 227             LcafKeyValue keyVal = (LcafKeyValue) address;
 228             if (keyVal.getLcafKeyValueAddressAddr().getKey().getPrimitiveAddress() instanceof DistinguishedName) {
 229                 return ((DistinguishedName) keyVal.getLcafKeyValueAddressAddr().getKey().getPrimitiveAddress()).getDistinguishedNameAddress().getDistinguishedName();
 230             }
 231         }
 232         if (shouldOverwrite()) {
 233             return ADDRESS_SUBKEY;
 234         } else {
 235             return String.valueOf(address.hashCode());
 236         }
 237     }
 238
 239     public String getAuthenticationKey(LispAddressContainer address, int maskLen) {
 240         return getPassword(address, maskLen);
 241     }
 242
 243     public void removeAuthenticationKey(LispAddressContainer address, int maskLen) {
 244         if (address.getAddress() instanceof LcafSourceDest) {
 245             ILispDAO srcDstDao = getSrcDstInnerDao(address, maskLen);
 246             if (srcDstDao != null) {
 247                 IMappingServiceKey srcKey = MappingServiceKeyUtil.generateMappingServiceKey(getSrcForLcafSrcDst(address),
 248                         getSrcMaskForLcafSrcDst(address));
 249                 srcDstDao.removeSpecific(srcKey, PASSWORD_SUBKEY);
 250             }
 251         } else {
 252             IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(address, maskLen);
 253             dao.removeSpecific(key, PASSWORD_SUBKEY);
 254         }
 255     }
 256
 257     public void addAuthenticationKey(LispAddressContainer address, int maskLen, String key) {
 258         IMappingServiceKey mappingServiceKey = MappingServiceKeyUtil.generateMappingServiceKey(address, maskLen);
 259         if (address.getAddress() instanceof LcafSourceDest) {
 260             IMappingServiceKey srcKey = MappingServiceKeyUtil.generateMappingServiceKey(getSrcForLcafSrcDst(address),
 261                     getSrcMaskForLcafSrcDst(address));
 262             ILispDAO srcDstDao = getOrInstantiateSrcDstInnerDao(address, maskLen);
 263             srcDstDao.put(srcKey, new MappingEntry<String>(PASSWORD_SUBKEY, key));
 264         } else {
 265             dao.put(mappingServiceKey, new MappingEntry<String>(PASSWORD_SUBKEY, key));
 266         }
 267     }
 268
 269     public void removeMapping(LispAddressContainer address, int maskLen, boolean smr, IMapNotifyHandler callback) {
 270         Entry<IMappingServiceKey, List<MappingServiceRLOCGroup>> mapping;
 271         ILispDAO db;
 272         if (address.getAddress() instanceof LcafSourceDest) {
 273             db = getSrcDstInnerDao(address, maskLen);
 274             LispAFIAddress srcAddr = getSrcForLcafSrcDst(address);
 275             short srcMask = getSrcMaskForLcafSrcDst(address);
 276             mapping = DAOMappingUtil.getMappingForEid(srcAddr, srcMask, db);
 277         } else {
 278             db = dao;
 279             mapping = DAOMappingUtil.getMappingForEid(LispAFIConvertor.toAFI(address), maskLen, db);
 280         }
 281         if (smr) {
 282             HashSet<MappingServiceSubscriberRLOC> subscribers = getSubscribers(address, maskLen);
 283             // mapping is removed before first SMR is sent to avoid inconsistent replies
 284             removeMappingRlocs(mapping, db);
 285             handleSmr(new EidToLocatorRecordBuilder().setLispAddressContainer(address).
 286                     setMaskLength((short) maskLen).build(), subscribers, callback);
 287             db.removeSpecific(mapping.getKey(), SUBSCRIBERS_SUBKEY);
 288         } else {
 289             removeMappingRlocs(mapping, db);
 290             db.removeSpecific(mapping.getKey(), SUBSCRIBERS_SUBKEY);
 291         }
 292     }
 293
 294     private void removeMappingRlocs(Entry<IMappingServiceKey, List<MappingServiceRLOCGroup>> mapping, ILispDAO db) {
 295         for (MappingServiceRLOCGroup group : mapping.getValue()) {
 296             for (LocatorRecord record : group.getRecords()) {
 297                 db.removeSpecific(mapping.getKey(), getAddressKey(record.getLispAddressContainer().getAddress()));
 298             }
 299         }
 300     }
 301
 302     private void sendSmrs(EidToLocatorRecord record, IMapNotifyHandler callback) {
 303         LispAddressContainer eid = record.getLispAddressContainer();
 304         HashSet<MappingServiceSubscriberRLOC> subscribers;
 305
 306         subscribers = getSubscribers(eid, record.getMaskLength());
 307         handleSmr(record, subscribers, callback);
 308
 309         // For SrcDst LCAF also send SMRs to Dst prefix
 310         if (eid.getAddress() instanceof LcafSourceDest) {
 311             LispAddressContainer dstAddr = LispAFIConvertor.toContainer(getDstForLcafSrcDst(eid));
 312             short dstMask = getDstMaskForLcafSrcDst(eid);
 313             subscribers = getSubscribers(dstAddr, dstMask);
 314             EidToLocatorRecord newRecord = new EidToLocatorRecordBuilder().setAction(record.getAction()).
 315                     setAuthoritative(record.isAuthoritative()).setLocatorRecord(record.getLocatorRecord()).
 316                     setMapVersion(record.getMapVersion()).setRecordTtl(record.getRecordTtl()).
 317                     setLispAddressContainer(dstAddr).setMaskLength(dstMask).build();
 318             handleSmr(newRecord, subscribers, callback);
 319         }
 320     }
 321
 322     private void handleSmr(EidToLocatorRecord record, HashSet<MappingServiceSubscriberRLOC> subscribers,
 323             IMapNotifyHandler callback) {
 324         if (subscribers == null) {
 325             return;
 326         }
 327         MapRequest mapRequest = buildSMR(record);
 328         LOG.trace("Built SMR packet: " + mapRequest.toString());
 329         for (MappingServiceSubscriberRLOC rloc : subscribers) {
 330             if (rloc.timedOut()) {
 331                 LOG.trace("Lazy removing expired subscriber entry " + rloc.toString());
 332                 subscribers.remove(rloc);
 333             } else {
 334                 try {
 335                     callback.handleSMR(mapRequest, rloc.getSrcRloc());
 336                 } catch (Exception e) {
 337                     StringWriter sw = new StringWriter();
 338                     e.printStackTrace(new PrintWriter(sw));
 339                     LOG.error("Errors encountered while handling SMR:" + sw.toString());
 340                 }
 341             }
 342         }
 343         IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(record.getLispAddressContainer(),
 344                 record.getMaskLength());
 345         dao.put(key, new MappingEntry<HashSet<MappingServiceSubscriberRLOC>>(SUBSCRIBERS_SUBKEY, subscribers));
 346     }
 347
 348     public boolean shouldOverwrite() {
 349         return overwrite;
 350     }
 351
 352     public void setOverwrite(boolean overwrite) {
 353         this.overwrite = overwrite;
 354     }
 355
 356 }