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.lispaddresscontainer.address.LcafKeyValue;
  40 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.lispsimpleaddress.primitiveaddress.DistinguishedName;
  41 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.lispaddress.LispAddressContainerBuilder;
  42 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.lispaddress.lispaddresscontainer.address.Ipv4Builder;
  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()) continue;
  82                 Enumeration<InetAddress> addresses = current.getInetAddresses();
  83                 while (addresses.hasMoreElements()){
  84                     InetAddress current_addr = addresses.nextElement();
  85                     // Skip loopback addresses but not link local or RFC 1918 addresses
  86                     if (current_addr.isLoopbackAddress()) continue;
  87                     logger.debug(current_addr.getHostAddress());
  88                     return current_addr;
  89                 }
  90             }
  91         } catch (SocketException se) {
  92         }
  93         return null;
  94     }
  95     private static MapRequest buildSMR(EidToLocatorRecord eidRecord) {
  96         MapRequestBuilder builder = new MapRequestBuilder();
  97         builder.setAuthoritative(false);
  98         builder.setMapDataPresent(false);
  99         builder.setPitr(false);
 100         builder.setProbe(false);
 101         builder.setSmr(true);
 102         builder.setSmrInvoked(false);
 103
 104         builder.setEidRecord(new ArrayList<org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.eidrecords.EidRecord>());
 105         LispAddressContainer container = eidRecord.getLispAddressContainer();
 106         builder.getEidRecord().add(new EidRecordBuilder().setMask((short) eidRecord.getMaskLength()).setLispAddressContainer(container).build());
 107
 108         builder.setItrRloc(new ArrayList<ItrRloc>());
 109         builder.getItrRloc().add(new ItrRlocBuilder().setLispAddressContainer(
 110                 new LispAddressContainerBuilder().setAddress(
 111                 new Ipv4Builder().setIpv4Address(
 112                 new Ipv4Address(getLocalAddress().getHostAddress())).setAfi((short) AddressFamilyNumberEnum.IP.getIanaCode()).build()).build()).build());
 113
 114         builder.setMapReply(null);
 115         builder.setNonce(new Random().nextLong());
 116
 117         // XXX For now we set source EID to queried EID...
 118         builder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(container).build());
 119         return builder.build();
 120     }
 121
 122     public void handleMapRegister(MapRegister mapRegister, boolean smr, IMapNotifyHandler callback) {
 123         if (dao == null) {
 124             logger.warn("handleMapRegister called while dao is uninitialized");
 125         } else {
 126             boolean failed = false;
 127             String password = null;
 128             for (EidToLocatorRecord eidRecord : mapRegister.getEidToLocatorRecord()) {
 129                 if (shouldAuthenticate()) {
 130                     password = getPassword(eidRecord.getLispAddressContainer(), eidRecord.getMaskLength());
 131                     if (!LispAuthenticationUtil.validate(mapRegister, password)) {
 132                         logger.warn("Authentication failed");
 133                         failed = true;
 134                         break;
 135                     }
 136                 }
 137                 saveRlocs(eidRecord);
 138
 139                 if (smr) {
 140                     HashSet<MappingServiceSubscriberRLOC> subscribers = getSubscribers(eidRecord.getLispAddressContainer(), eidRecord.getMaskLength());
 141                     if (subscribers != null) {
 142                         MapRequest mapRequest = buildSMR(eidRecord);
 143                         logger.trace("Built SMR packet: " + mapRequest.toString());
 144                         for (MappingServiceSubscriberRLOC rloc : subscribers) {
 145                             if (rloc.timedOut()) {
 146                                 logger.trace("Lazy removing expired subscriber entry " + rloc.toString());
 147                                 subscribers.remove(rloc);
 148                             } else {
 149                                 callback.handleSMR(mapRequest, rloc.getSrcRloc());
 150                             }
 151                         }
 152                         IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(eidRecord.getLispAddressContainer(), eidRecord.getMaskLength());
 153                         dao.put(key, new MappingEntry<HashSet<MappingServiceSubscriberRLOC>>(SUBSCRIBERS_SUBKEY, subscribers));
 154                     }
 155                 }
 156
 157             }
 158             if (!failed) {
 159                 MapNotifyBuilder builder = new MapNotifyBuilder();
 160                 if (BooleanUtils.isTrue(mapRegister.isWantMapNotify())) {
 161                     logger.trace("MapRegister wants MapNotify");
 162                     MapNotifyBuilderHelper.setFromMapRegister(builder, mapRegister);
 163                     if (shouldAuthenticate()) {
 164                         builder.setAuthenticationData(LispAuthenticationUtil.createAuthenticationData(builder.build(), password));
 165                     }
 166                     callback.handleMapNotify(builder.build());
 167                 }
 168             }
 169         }
 170     }
 171
 172     public void saveRlocs(EidToLocatorRecord eidRecord) {
 173         IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(eidRecord.getLispAddressContainer(), eidRecord.getMaskLength());
 174         Map<String, MappingServiceRLOCGroup> rlocGroups = new HashMap<String, MappingServiceRLOCGroup>();
 175         if (eidRecord.getLocatorRecord() != null) {
 176             for (LocatorRecord locatorRecord : eidRecord.getLocatorRecord()) {
 177                 String subkey = getLocatorKey(locatorRecord);
 178                 if (!rlocGroups.containsKey(subkey)) {
 179                     rlocGroups.put(subkey, new MappingServiceRLOCGroup(eidRecord.getRecordTtl(), eidRecord.getAction(), eidRecord.isAuthoritative()));
 180                 }
 181                 rlocGroups.get(subkey).addRecord(locatorRecord);
 182             }
 183         }
 184         List<MappingEntry<MappingServiceRLOCGroup>> entries = new ArrayList<>();
 185         for (String subkey : rlocGroups.keySet()) {
 186             entries.add(new MappingEntry<>(subkey, rlocGroups.get(subkey)));
 187         }
 188         dao.put(key, entries.toArray(new MappingEntry[entries.size()]));
 189     }
 190
 191     private String getLocatorKey(LocatorRecord locatorRecord) {
 192         if (locatorRecord.getLispAddressContainer().getAddress() instanceof LcafKeyValue) {
 193             LcafKeyValue keyVal = (LcafKeyValue) locatorRecord.getLispAddressContainer().getAddress();
 194             if (keyVal.getKey().getPrimitiveAddress() instanceof DistinguishedName) {
 195                 return ((DistinguishedName) keyVal.getKey().getPrimitiveAddress()).getDistinguishedName();
 196             }
 197         }
 198         if (shouldOverwrite()) {
 199             return ADDRESS_SUBKEY;
 200         } else {
 201             return String.valueOf(locatorRecord.getLispAddressContainer().getAddress().hashCode());
 202         }
 203     }
 204
 205     public String getAuthenticationKey(LispAddressContainer address, int maskLen) {
 206         return getPassword(address, maskLen);
 207     }
 208
 209     public void removeAuthenticationKey(LispAddressContainer address, int maskLen) {
 210         IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(address, maskLen);
 211         dao.removeSpecific(key, PASSWORD_SUBKEY);
 212     }
 213
 214     public void addAuthenticationKey(LispAddressContainer address, int maskLen, String key) {
 215         IMappingServiceKey mappingServiceKey = MappingServiceKeyUtil.generateMappingServiceKey(address, maskLen);
 216         dao.put(mappingServiceKey, new MappingEntry<String>(PASSWORD_SUBKEY, key));
 217     }
 218
 219     public boolean shouldOverwrite() {
 220         return overwrite;
 221     }
 222
 223     public void setOverwrite(boolean overwrite) {
 224         this.overwrite = overwrite;
 225     }
 226
 227 }