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.util.DAOMappingUtil;
  23 import org.opendaylight.lispflowmapping.implementation.util.MaskUtil;
  24 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
  25 import org.opendaylight.lispflowmapping.interfaces.dao.SubscriberRLOC;
  26 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapNotifyHandler;
  27 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapServerAsync;
  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.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecord;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecordBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecordBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainer;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafSourceDest;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapnotifymessage.MapNotifyBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequestnotification.MapRequestBuilder;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42
  43 public class MapServer extends AbstractLispComponent implements IMapServerAsync {
  44
  45     protected static final Logger LOG = LoggerFactory.getLogger(MapServer.class);
  46
  47     private static final ConfigIni configIni = new ConfigIni();
  48     private static final boolean overwriteConfig = configIni.mappingOverwriteIsSet();
  49     private boolean overwrite;
  50
  51     public MapServer(ILispDAO dao) {
  52         this(dao, overwriteConfig);
  53     }
  54
  55     public MapServer(ILispDAO dao, boolean overwrite) {
  56         this(dao, overwrite, true);
  57     }
  58
  59     public MapServer(ILispDAO dao, boolean overwrite, boolean authenticate) {
  60         this(dao, overwrite, authenticate, true);
  61     }
  62
  63     public MapServer(ILispDAO dao, boolean overwrite, boolean authenticate, boolean iterateAuthenticationMask) {
  64         super(dao, authenticate, iterateAuthenticationMask);
  65         this.overwrite = overwrite;
  66     }
  67
  68     private static InetAddress getLocalAddress() {
  69         try {
  70             Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
  71             while (interfaces.hasMoreElements()) {
  72                 NetworkInterface current = interfaces.nextElement();
  73                 LOG.debug("Interface " + current.toString());
  74                 if (!current.isUp() || current.isLoopback() || current.isVirtual())
  75                     continue;
  76                 Enumeration<InetAddress> addresses = current.getInetAddresses();
  77                 while (addresses.hasMoreElements()) {
  78                     InetAddress current_addr = addresses.nextElement();
  79                     // Skip loopback and link local addresses
  80                     if (current_addr.isLoopbackAddress() || current_addr.isLinkLocalAddress())
  81                         continue;
  82                     LOG.debug(current_addr.getHostAddress());
  83                     return current_addr;
  84                 }
  85             }
  86         } catch (SocketException se) {
  87         }
  88         return null;
  89     }
  90
  91     public void handleMapRegister(MapRegister mapRegister, boolean smr, IMapNotifyHandler callback) {
  92         if (dao == null) {
  93             LOG.warn("handleMapRegister called while dao is uninitialized");
  94         } else {
  95             boolean failed = false;
  96             String password = null;
  97             for (EidToLocatorRecord eidRecord : mapRegister.getEidToLocatorRecord()) {
  98                 if (shouldAuthenticate()) {
  99                     password = DAOMappingUtil.getPassword(eidRecord.getLispAddressContainer(),
 100                             eidRecord.getMaskLength(), dao, shouldIterateMask());
 101                     if (!LispAuthenticationUtil.validate(mapRegister, password)) {
 102                         LOG.warn("Authentication failed");
 103                         failed = true;
 104                         break;
 105                     }
 106                 }
 107                 boolean mappingChanged = DAOMappingUtil.saveRlocs(eidRecord, smr, dao, shouldIterateMask(),
 108                         shouldOverwrite());
 109                 if (smr && mappingChanged) {
 110                     Set<SubscriberRLOC> subscribers = DAOMappingUtil.getSubscribers(
 111                             eidRecord.getLispAddressContainer(), eidRecord.getMaskLength(), dao);
 112                     sendSmrs(eidRecord, subscribers, callback);
 113                 }
 114             }
 115             if (!failed) {
 116                 MapNotifyBuilder builder = new MapNotifyBuilder();
 117                 if (BooleanUtils.isTrue(mapRegister.isWantMapNotify())) {
 118                     LOG.trace("MapRegister wants MapNotify");
 119                     MapNotifyBuilderHelper.setFromMapRegister(builder, mapRegister);
 120                     if (shouldAuthenticate()) {
 121                         builder.setAuthenticationData(LispAuthenticationUtil.createAuthenticationData(builder.build(),
 122                                 password));
 123                     }
 124                     callback.handleMapNotify(builder.build());
 125                 }
 126             }
 127         }
 128     }
 129
 130     public String getAuthenticationKey(LispAddressContainer address, int maskLen) {
 131         return DAOMappingUtil.getPassword(address, maskLen, dao, shouldIterateMask());
 132     }
 133
 134     public void removeAuthenticationKey(LispAddressContainer address, int maskLen) {
 135         DAOMappingUtil.removeAuthenticationKey(address, maskLen, dao);
 136     }
 137
 138     public void removeMapping(LispAddressContainer address, int maskLen, boolean smr, IMapNotifyHandler callback) {
 139         if (smr) {
 140             // mapping is removed before first SMR is sent to avoid inconsistent replies
 141             DAOMappingUtil.removeMapping(address, maskLen, dao, shouldOverwrite());
 142             Set<SubscriberRLOC> subscribers = DAOMappingUtil.getSubscribers(address, maskLen, dao);
 143             sendSmrs(new EidToLocatorRecordBuilder().setLispAddressContainer(address).
 144                     setMaskLength((short) maskLen).build(), subscribers, callback);
 145             DAOMappingUtil.removeSubscribers(address, maskLen, dao, shouldOverwrite());
 146         } else {
 147             DAOMappingUtil.removeMapping(address, maskLen, dao, shouldOverwrite());
 148             DAOMappingUtil.removeSubscribers(address, maskLen, 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(DAOMappingUtil.getDstForLcafSrcDst(eid));
 159             short dstMask = DAOMappingUtil.getDstMaskForLcafSrcDst(eid);
 160             subscribers = DAOMappingUtil.getSubscribers(dstAddr, dstMask, 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         DAOMappingUtil.addSubscribers(record.getLispAddressContainer(), record.getMaskLength(), 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, int maskLen, String key) {
 207         DAOMappingUtil.addAuthenticationKey(address, maskLen, key, dao);
 208     }
 209
 210 }