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.net.InetAddress;
  12 import java.net.NetworkInterface;
  13 import java.net.SocketException;
  14 import java.util.ArrayList;
  15 import java.util.Enumeration;
  16 import java.util.Set;
  17
  18 import org.apache.commons.lang3.BooleanUtils;
  19 import org.apache.commons.lang3.exception.ExceptionUtils;
  20 import org.opendaylight.lispflowmapping.implementation.authentication.LispAuthenticationUtil;
  21 import org.opendaylight.lispflowmapping.implementation.config.ConfigIni;
  22 import org.opendaylight.lispflowmapping.implementation.mapcache.TopologyMapCache;
  23 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
  24 import org.opendaylight.lispflowmapping.interfaces.dao.SubscriberRLOC;
  25 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapNotifyHandler;
  26 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapServerAsync;
  27 import org.opendaylight.lispflowmapping.lisp.util.LcafSourceDestHelper;
  28 import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
  29 import org.opendaylight.lispflowmapping.lisp.util.MapNotifyBuilderHelper;
  30 import org.opendaylight.lispflowmapping.lisp.util.MapRequestUtil;
  31 import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapRegister;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidrecords.EidRecord;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidrecords.EidRecordBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecord;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecordBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafSourceDest;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.mapnotifymessage.MapNotifyBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.maprequestnotification.MapRequestBuilder;
  41 import org.slf4j.Logger;
  42 import org.slf4j.LoggerFactory;
  43
  44 public class MapServer extends AbstractLispComponent implements IMapServerAsync {
  45
  46     protected static final Logger LOG = LoggerFactory.getLogger(MapServer.class);
  47
  48     private static final ConfigIni configIni = new ConfigIni();
  49     private static final boolean overwriteConfig = configIni.mappingOverwriteIsSet();
  50     private boolean overwrite;
  51
  52     public MapServer(ILispDAO dao) {
  53         this(dao, overwriteConfig);
  54     }
  55
  56     public MapServer(ILispDAO dao, boolean overwrite) {
  57         this(dao, overwrite, true);
  58     }
  59
  60     public MapServer(ILispDAO dao, boolean overwrite, boolean authenticate) {
  61         this(dao, overwrite, authenticate, true);
  62     }
  63
  64     public MapServer(ILispDAO dao, boolean overwrite, boolean authenticate, boolean iterateAuthenticationMask) {
  65         super(dao, authenticate, iterateAuthenticationMask);
  66         this.overwrite = overwrite;
  67     }
  68
  69     private static InetAddress getLocalAddress() {
  70         try {
  71             Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
  72             while (interfaces.hasMoreElements()) {
  73                 NetworkInterface current = interfaces.nextElement();
  74                 LOG.debug("Interface " + current.toString());
  75                 if (!current.isUp() || current.isLoopback() || current.isVirtual())
  76                     continue;
  77                 Enumeration<InetAddress> addresses = current.getInetAddresses();
  78                 while (addresses.hasMoreElements()) {
  79                     InetAddress current_addr = addresses.nextElement();
  80                     // Skip loopback and link local addresses
  81                     if (current_addr.isLoopbackAddress() || current_addr.isLinkLocalAddress())
  82                         continue;
  83                     LOG.debug(current_addr.getHostAddress());
  84                     return current_addr;
  85                 }
  86             }
  87         } catch (SocketException se) {
  88         }
  89         return null;
  90     }
  91
  92     public void handleMapRegister(MapRegister mapRegister, boolean smr, IMapNotifyHandler callback) {
  93         if (dao == null) {
  94             LOG.warn("handleMapRegister called while dao is uninitialized");
  95             return;
  96         }
  97         boolean failed = false;
  98         String password = null;
  99         for (EidToLocatorRecord eidRecord : mapRegister.getEidToLocatorRecord()) {
 100             if (shouldAuthenticate()) {
 101                 password = TopologyMapCache.getAuthenticationKey(eidRecord.getLispAddressContainer(), dao, shouldIterateMask());
 102                 if (!LispAuthenticationUtil.validate(mapRegister, password)) {
 103                     LOG.warn("Authentication failed");
 104                     failed = true;
 105                     break;
 106                 }
 107             }
 108             boolean mappingChanged = TopologyMapCache.addMapping(eidRecord, smr, dao, shouldIterateMask(),
 109                     shouldOverwrite());
 110             if (smr && mappingChanged) {
 111                 Set<SubscriberRLOC> subscribers = TopologyMapCache.getSubscribers(
 112                         eidRecord.getLispAddressContainer(), dao);
 113                 sendSmrs(eidRecord, subscribers, callback);
 114             }
 115         }
 116         if (!failed) {
 117             MapNotifyBuilder builder = new MapNotifyBuilder();
 118             if (BooleanUtils.isTrue(mapRegister.isWantMapNotify())) {
 119                 LOG.trace("MapRegister wants MapNotify");
 120                 MapNotifyBuilderHelper.setFromMapRegister(builder, mapRegister);
 121                 if (shouldAuthenticate()) {
 122                     builder.setAuthenticationData(LispAuthenticationUtil.createAuthenticationData(builder.build(),
 123                             password));
 124                 }
 125                 callback.handleMapNotify(builder.build());
 126             }
 127         }
 128     }
 129
 130     public String getAuthenticationKey(LispAddressContainer address) {
 131         return TopologyMapCache.getAuthenticationKey(address, dao, shouldIterateMask());
 132     }
 133
 134     public void removeAuthenticationKey(LispAddressContainer address) {
 135         TopologyMapCache.removeAuthenticationKey(address, dao);
 136     }
 137
 138     public void removeMapping(LispAddressContainer address, boolean smr, IMapNotifyHandler callback) {
 139         if (smr) {
 140             // mapping is removed before first SMR is sent to avoid inconsistent replies
 141             TopologyMapCache.removeMapping(address, dao, shouldOverwrite());
 142             Set<SubscriberRLOC> subscribers = TopologyMapCache.getSubscribers(address, dao);
 143             sendSmrs(new EidToLocatorRecordBuilder().setLispAddressContainer(address).
 144                     setMaskLength(MaskUtil.getMaskForAddress(address)).build(), subscribers, callback);
 145             TopologyMapCache.removeSubscribers(address, dao, shouldOverwrite());
 146         } else {
 147             TopologyMapCache.removeMapping(address, dao, shouldOverwrite());
 148             TopologyMapCache.removeSubscribers(address, dao, shouldOverwrite());
 149         }
 150     }
 151
 152     private void sendSmrs(EidToLocatorRecord record, Set<SubscriberRLOC> subscribers, IMapNotifyHandler callback) {
 153         LispAddressContainer eid = record.getLispAddressContainer();
 154         handleSmr(record, subscribers, callback);
 155
 156         // For SrcDst LCAF also send SMRs to Dst prefix
 157         if (eid.getAddress() instanceof LcafSourceDest) {
 158             LispAddressContainer dstAddr = LispAFIConvertor.toContainer(LcafSourceDestHelper.getDstAfi(eid));
 159             short dstMask = LcafSourceDestHelper.getDstMask(eid);
 160             subscribers = TopologyMapCache.getSubscribers(dstAddr, dao);
 161             EidToLocatorRecord newRecord = new EidToLocatorRecordBuilder().setAction(record.getAction()).
 162                     setAuthoritative(record.isAuthoritative()).setLocatorRecord(record.getLocatorRecord()).
 163                     setMapVersion(record.getMapVersion()).setRecordTtl(record.getRecordTtl()).
 164                     setLispAddressContainer(dstAddr).setMaskLength(dstMask).build();
 165             handleSmr(newRecord, subscribers, callback);
 166         }
 167     }
 168
 169     private void handleSmr(EidToLocatorRecord record, Set<SubscriberRLOC> subscribers, IMapNotifyHandler callback) {
 170         if (subscribers == null) {
 171             return;
 172         }
 173         MapRequestBuilder mrb = MapRequestUtil.prepareSMR(record.getLispAddressContainer(),
 174                 LispAFIConvertor.toContainer(getLocalAddress()));
 175         LOG.trace("Built SMR packet: " + mrb.build().toString());
 176         for (SubscriberRLOC subscriber : subscribers) {
 177             if (subscriber.timedOut()) {
 178                 LOG.trace("Lazy removing expired subscriber entry " + subscriber.toString());
 179                 subscribers.remove(subscriber);
 180             } else {
 181                 try {
 182                     // The address stored in the SMR's EID record is used as Source EID in the SMR-invoked Map-Request.
 183                     // To ensure consistent behavior it is set to the value used to originally request a given mapping
 184                     mrb.setEidRecord(new ArrayList<EidRecord>());
 185                     mrb.getEidRecord().add(new EidRecordBuilder()
 186                                 .setMask((short)MaskUtil.getMaxMask(LispAFIConvertor.toAFI(subscriber.getSrcEid())))
 187                                 .setLispAddressContainer(subscriber.getSrcEid()).build());
 188                     callback.handleSMR(mrb.build(), subscriber.getSrcRloc());
 189                 } catch (Exception e) {
 190                     LOG.error("Errors encountered while handling SMR:" + ExceptionUtils.getStackTrace(e));
 191                 }
 192             }
 193         }
 194         TopologyMapCache.addSubscribers(record.getLispAddressContainer(), subscribers, dao);
 195     }
 196
 197     public boolean shouldOverwrite() {
 198         return overwrite;
 199     }
 200
 201     public void setOverwrite(boolean overwrite) {
 202         this.overwrite = overwrite;
 203     }
 204
 205     @Override
 206     public void addAuthenticationKey(LispAddressContainer address, String key) {
 207         TopologyMapCache.addAuthenticationKey(address, key, dao);
 208     }
 209
 210 }