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.HashMap;
  17 import java.util.HashSet;
  18 import java.util.List;
  19 import java.util.Map;
  20 import java.util.Random;
  21
  22 import org.apache.commons.lang3.BooleanUtils;
  23 import org.opendaylight.lispflowmapping.implementation.authentication.LispAuthenticationUtil;
  24 import org.opendaylight.lispflowmapping.implementation.dao.MappingServiceKeyUtil;
  25 import org.opendaylight.lispflowmapping.implementation.util.MapNotifyBuilderHelper;
  26 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
  27 import org.opendaylight.lispflowmapping.interfaces.dao.IMappingServiceKey;
  28 import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
  29 import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceRLOCGroup;
  30 import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceSubscriberRLOC;
  31 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapNotifyHandler;
  32 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapServerAsync;
  33 import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
  34 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.MapRegister;
  35 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.MapRequest;
  36 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.eidrecords.EidRecordBuilder;
  37 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.eidtolocatorrecords.EidToLocatorRecord;
  38 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.lispaddress.LispAddressContainer;
  39 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.lispaddress.LispAddressContainerBuilder;
  40 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.lispaddress.lispaddresscontainer.address.Ipv4Builder;
  41 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.lispaddress.lispaddresscontainer.address.LcafKeyValue;
  42 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.lispsimpleaddress.primitiveaddress.DistinguishedName;
  43 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.locatorrecords.LocatorRecord;
  44 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.mapnotifymessage.MapNotifyBuilder;
  45 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.maprequest.ItrRloc;
  46 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.maprequest.ItrRlocBuilder;
  47 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.maprequest.SourceEidBuilder;
  48 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.maprequestnotification.MapRequestBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
  50 import org.slf4j.Logger;
  51 import org.slf4j.LoggerFactory;
  52
  53 public class MapServer extends AbstractLispComponent implements IMapServerAsync {
  54
  55     protected static final Logger logger = LoggerFactory.getLogger(MapServer.class);
  56     private boolean overwrite;
  57
  58     public MapServer(ILispDAO dao) {
  59         this(dao, true);
  60     }
  61
  62     public MapServer(ILispDAO dao, boolean overwrite) {
  63         this(dao, overwrite, true);
  64     }
  65
  66     public MapServer(ILispDAO dao, boolean overwrite, boolean authenticate) {
  67         this(dao, overwrite, authenticate, true);
  68     }
  69
  70     public MapServer(ILispDAO dao, boolean overwrite, boolean authenticate, boolean iterateAuthenticationMask) {
  71         super(dao, authenticate, iterateAuthenticationMask);
  72         this.overwrite = overwrite;
  73     }
  74
  75     private static InetAddress getLocalAddress() {
  76         try {
  77             Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
  78             while (interfaces.hasMoreElements()) {
  79                 NetworkInterface current = interfaces.nextElement();
  80                 logger.debug("Interface " + current.toString());
  81                 if (!current.isUp() || current.isLoopback() || current.isVirtual())
  82                     continue;
  83                 Enumeration<InetAddress> addresses = current.getInetAddresses();
  84                 while (addresses.hasMoreElements()) {
  85                     InetAddress current_addr = addresses.nextElement();
  86                     // Skip loopback addresses but not link local or RFC 1918
  87                     // addresses
  88                     if (current_addr.isLoopbackAddress())
  89                         continue;
  90                     logger.debug(current_addr.getHostAddress());
  91                     return current_addr;
  92                 }
  93             }
  94         } catch (SocketException se) {
  95         }
  96         return null;
  97     }
  98
  99     private static MapRequest buildSMR(EidToLocatorRecord eidRecord) {
 100         MapRequestBuilder builder = new MapRequestBuilder();
 101         builder.setAuthoritative(false);
 102         builder.setMapDataPresent(false);
 103         builder.setPitr(false);
 104         builder.setProbe(false);
 105         builder.setSmr(true);
 106         builder.setSmrInvoked(false);
 107
 108         builder.setEidRecord(new ArrayList<org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.eidrecords.EidRecord>());
 109         LispAddressContainer container = eidRecord.getLispAddressContainer();
 110         builder.getEidRecord().add(new EidRecordBuilder().setMask((short) eidRecord.getMaskLength()).setLispAddressContainer(container).build());
 111
 112         builder.setItrRloc(new ArrayList<ItrRloc>());
 113         builder.getItrRloc().add(
 114                 new ItrRlocBuilder().setLispAddressContainer(
 115                         new LispAddressContainerBuilder().setAddress(
 116                                 new Ipv4Builder().setIpv4Address(new Ipv4Address(getLocalAddress().getHostAddress()))
 117                                         .setAfi((short) AddressFamilyNumberEnum.IP.getIanaCode()).build()).build()).build());
 118
 119         builder.setMapReply(null);
 120         builder.setNonce(new Random().nextLong());
 121
 122         // XXX For now we set source EID to queried EID...
 123         builder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(container).build());
 124         return builder.build();
 125     }
 126
 127     public void handleMapRegister(MapRegister mapRegister, boolean smr, IMapNotifyHandler callback) {
 128         if (dao == null) {
 129             logger.warn("handleMapRegister called while dao is uninitialized");
 130         } else {
 131             boolean failed = false;
 132             String password = null;
 133             for (EidToLocatorRecord eidRecord : mapRegister.getEidToLocatorRecord()) {
 134                 if (shouldAuthenticate()) {
 135                     password = getPassword(eidRecord.getLispAddressContainer(), eidRecord.getMaskLength());
 136                     if (!LispAuthenticationUtil.validate(mapRegister, password)) {
 137                         logger.warn("Authentication failed");
 138                         failed = true;
 139                         break;
 140                     }
 141                 }
 142                 saveRlocs(eidRecord);
 143
 144                 if (smr) {
 145                     HashSet<MappingServiceSubscriberRLOC> subscribers = getSubscribers(eidRecord.getLispAddressContainer(), eidRecord.getMaskLength());
 146                     if (subscribers != null) {
 147                         MapRequest mapRequest = buildSMR(eidRecord);
 148                         logger.trace("Built SMR packet: " + mapRequest.toString());
 149                         for (MappingServiceSubscriberRLOC rloc : subscribers) {
 150                             if (rloc.timedOut()) {
 151                                 logger.trace("Lazy removing expired subscriber entry " + rloc.toString());
 152                                 subscribers.remove(rloc);
 153                             } else {
 154                                 callback.handleSMR(mapRequest, rloc.getSrcRloc());
 155                             }
 156                         }
 157                         IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(eidRecord.getLispAddressContainer(),
 158                                 eidRecord.getMaskLength());
 159                         dao.put(key, new MappingEntry<HashSet<MappingServiceSubscriberRLOC>>(SUBSCRIBERS_SUBKEY, subscribers));
 160                     }
 161                 }
 162
 163             }
 164             if (!failed) {
 165                 MapNotifyBuilder builder = new MapNotifyBuilder();
 166                 if (BooleanUtils.isTrue(mapRegister.isWantMapNotify())) {
 167                     logger.trace("MapRegister wants MapNotify");
 168                     MapNotifyBuilderHelper.setFromMapRegister(builder, mapRegister);
 169                     if (shouldAuthenticate()) {
 170                         builder.setAuthenticationData(LispAuthenticationUtil.createAuthenticationData(builder.build(), password));
 171                     }
 172                     callback.handleMapNotify(builder.build());
 173                 }
 174             }
 175         }
 176     }
 177
 178     public void saveRlocs(EidToLocatorRecord eidRecord) {
 179         IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(eidRecord.getLispAddressContainer(), eidRecord.getMaskLength());
 180         Map<String, MappingServiceRLOCGroup> rlocGroups = new HashMap<String, MappingServiceRLOCGroup>();
 181         if (eidRecord.getLocatorRecord() != null) {
 182             for (LocatorRecord locatorRecord : eidRecord.getLocatorRecord()) {
 183                 String subkey = getLocatorKey(locatorRecord);
 184                 if (!rlocGroups.containsKey(subkey)) {
 185                     rlocGroups.put(subkey, new MappingServiceRLOCGroup(eidRecord.getRecordTtl(), eidRecord.getAction(), eidRecord.isAuthoritative()));
 186                 }
 187                 rlocGroups.get(subkey).addRecord(locatorRecord);
 188             }
 189         }
 190         List<MappingEntry<MappingServiceRLOCGroup>> entries = new ArrayList<>();
 191         for (String subkey : rlocGroups.keySet()) {
 192             entries.add(new MappingEntry<>(subkey, rlocGroups.get(subkey)));
 193         }
 194         dao.put(key, entries.toArray(new MappingEntry[entries.size()]));
 195     }
 196
 197     private String getLocatorKey(LocatorRecord locatorRecord) {
 198         if (locatorRecord.getLispAddressContainer().getAddress() instanceof LcafKeyValue) {
 199             LcafKeyValue keyVal = (LcafKeyValue) locatorRecord.getLispAddressContainer().getAddress();
 200             if (keyVal.getKey().getPrimitiveAddress() instanceof DistinguishedName) {
 201                 return ((DistinguishedName) keyVal.getKey().getPrimitiveAddress()).getDistinguishedName();
 202             }
 203         }
 204         if (shouldOverwrite()) {
 205             return ADDRESS_SUBKEY;
 206         } else {
 207             return String.valueOf(locatorRecord.getLispAddressContainer().getAddress().hashCode());
 208         }
 209     }
 210
 211     public String getAuthenticationKey(LispAddressContainer address, int maskLen) {
 212         return getPassword(address, maskLen);
 213     }
 214
 215     public void removeAuthenticationKey(LispAddressContainer address, int maskLen) {
 216         IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(address, maskLen);
 217         dao.removeSpecific(key, PASSWORD_SUBKEY);
 218     }
 219
 220     public void addAuthenticationKey(LispAddressContainer address, int maskLen, String key) {
 221         IMappingServiceKey mappingServiceKey = MappingServiceKeyUtil.generateMappingServiceKey(address, maskLen);
 222         dao.put(mappingServiceKey, new MappingEntry<String>(PASSWORD_SUBKEY, key));
 223     }
 224
 225     public boolean shouldOverwrite() {
 226         return overwrite;
 227     }
 228
 229     public void setOverwrite(boolean overwrite) {
 230         this.overwrite = overwrite;
 231     }
 232
 233 }