mappingservice/southbound/src/main/java/org/opendaylight/lispflowmapping/southbound/lisp/LispSouthboundService.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.southbound.lisp;
  10
  11 import java.net.DatagramPacket;
  12 import java.net.InetAddress;
  13 import java.nio.ByteBuffer;
  14
  15 import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
  16 import org.opendaylight.lispflowmapping.southbound.util.LispNotificationHelper;
  17 import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
  18 import org.opendaylight.lispflowmapping.lisp.type.LispMessageEnum;
  19 import org.opendaylight.lispflowmapping.lisp.util.ByteUtil;
  20 import org.opendaylight.lispflowmapping.lisp.util.MapRequestUtil;
  21 import org.opendaylight.lispflowmapping.lisp.serializer.MapNotifySerializer;
  22 import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
  23 import org.opendaylight.lispflowmapping.lisp.serializer.MapReplySerializer;
  24 import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
  25 import org.opendaylight.lispflowmapping.southbound.lisp.exception.LispMalformedPacketException;
  26 import org.opendaylight.lispflowmapping.southbound.lisp.network.PacketHeader;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.AddMappingBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.GotMapNotifyBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.GotMapReplyBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapNotify;
  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.MapRequest;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapReply;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.RequestMappingBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.transportaddress.TransportAddressBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
  37 import org.slf4j.Logger;
  38 import org.slf4j.LoggerFactory;
  39
  40 public class LispSouthboundService implements ILispSouthboundService {
  41     private NotificationProviderService notificationProvider;
  42     protected static final Logger LOG = LoggerFactory.getLogger(LispSouthboundService.class);
  43
  44     public void setNotificationProvider(NotificationProviderService nps) {
  45         this.notificationProvider = nps;
  46     }
  47
  48     public void handlePacket(DatagramPacket packet) {
  49         ByteBuffer inBuffer = ByteBuffer.wrap(packet.getData(), 0, packet.getLength());
  50         int type = ByteUtil.getUnsignedByte(inBuffer, LispMessage.Pos.TYPE) >> 4;
  51         Object lispType = LispMessageEnum.valueOf((byte) (type));
  52         if (lispType == LispMessageEnum.EncapsulatedControlMessage) {
  53             LOG.trace("Received packet of type EncapsulatedControlMessage");
  54             handleEncapsulatedControlMessage(inBuffer, packet.getAddress());
  55         } else if (lispType == LispMessageEnum.MapRequest) {
  56             LOG.trace("Received packet of type MapRequest");
  57             handleMapRequest(inBuffer, packet.getPort());
  58         } else if (lispType == LispMessageEnum.MapRegister) {
  59             LOG.trace("Received packet of type MapRegister");
  60             handleMapRegister(inBuffer, packet.getAddress(), packet.getPort());
  61         } else if (lispType == LispMessageEnum.MapNotify) {
  62             LOG.trace("Received packet of type MapNotify");
  63             handleMapNotify(inBuffer, packet.getAddress(), packet.getPort());
  64         } else if (lispType == LispMessageEnum.MapReply) {
  65             LOG.trace("Received packet of type MapReply");
  66             handleMapReply(inBuffer, packet.getAddress(), packet.getPort());
  67         } else {
  68             LOG.warn("Received unknown LISP control packet (type " + ((lispType != null) ? lispType : type) + ")");
  69             LOG.trace("Buffer: " + ByteUtil.bytesToHex(packet.getData(), packet.getLength()));
  70         }
  71     }
  72
  73     private void handleEncapsulatedControlMessage(ByteBuffer inBuffer, InetAddress sourceAddress) {
  74         try {
  75             handleMapRequest(inBuffer, extractEncapsulatedSourcePort(inBuffer));
  76         } catch (RuntimeException re) {
  77             throw new LispMalformedPacketException("Couldn't deserialize Map-Request (len=" + inBuffer.capacity() + ")", re);
  78         }
  79     }
  80
  81     private void handleMapRequest(ByteBuffer inBuffer, int port) {
  82         try {
  83             MapRequest request = MapRequestSerializer.getInstance().deserialize(inBuffer);
  84             InetAddress finalSourceAddress = MapRequestUtil.selectItrRloc(request);
  85             if (finalSourceAddress == null) {
  86                 throw new LispMalformedPacketException("Couldn't deserialize Map-Request, no ITR Rloc found!");
  87             }
  88
  89             RequestMappingBuilder requestMappingBuilder = new RequestMappingBuilder();
  90             requestMappingBuilder.setMapRequest(LispNotificationHelper.convertMapRequest(request));
  91             TransportAddressBuilder transportAddressBuilder = new TransportAddressBuilder();
  92             transportAddressBuilder.setIpAddress(LispNotificationHelper.getIpAddressFromInetAddress(finalSourceAddress));
  93             transportAddressBuilder.setPort(new PortNumber(port));
  94             requestMappingBuilder.setTransportAddress(transportAddressBuilder.build());
  95             if (notificationProvider != null) {
  96                 notificationProvider.publish(requestMappingBuilder.build());
  97                 LOG.trace("MapRequest was published!");
  98             } else {
  99                 LOG.warn("Notification Provider is null!");
 100             }
 101         } catch (RuntimeException re) {
 102             throw new LispMalformedPacketException("Couldn't deserialize Map-Request (len=" + inBuffer.capacity() + ")", re);
 103         }
 104     }
 105
 106     private int extractEncapsulatedSourcePort(ByteBuffer inBuffer) {
 107         try {
 108             inBuffer.position(PacketHeader.Length.LISP_ENCAPSULATION);
 109             int ipType = (inBuffer.get() >> 4);
 110             if (ipType == 4) {
 111                 inBuffer.position(inBuffer.position() + PacketHeader.Length.IPV4 - 1);
 112             } else if (ipType == 6) {
 113                 inBuffer.position(inBuffer.position() + PacketHeader.Length.IPV6_NO_EXT - 1);
 114             } else {
 115                 throw new LispMalformedPacketException("Couldn't deserialize Map-Request: inner packet has unknown IP version: " + ipType);
 116             }
 117
 118             int encapsulatedSourcePort = inBuffer.getShort() & 0xFFFF;
 119             inBuffer.position(inBuffer.position() + PacketHeader.Length.UDP - 2);
 120             return encapsulatedSourcePort;
 121         } catch (RuntimeException re) {
 122             throw new LispMalformedPacketException("Couldn't deserialize Map-Request (len=" + inBuffer.capacity() + ")", re);
 123         }
 124     }
 125
 126     private void handleMapRegister(ByteBuffer inBuffer, InetAddress sourceAddress, int port) {
 127         try {
 128             MapRegister mapRegister = MapRegisterSerializer.getInstance().deserialize(inBuffer);
 129             AddMappingBuilder addMappingBuilder = new AddMappingBuilder();
 130             addMappingBuilder.setMapRegister(LispNotificationHelper.convertMapRegister(mapRegister));
 131             TransportAddressBuilder transportAddressBuilder = new TransportAddressBuilder();
 132             transportAddressBuilder.setIpAddress(LispNotificationHelper.getIpAddressFromInetAddress(sourceAddress));
 133             transportAddressBuilder.setPort(new PortNumber(port));
 134             addMappingBuilder.setTransportAddress(transportAddressBuilder.build());
 135             if (notificationProvider != null) {
 136                 notificationProvider.publish(addMappingBuilder.build());
 137                 LOG.trace("MapRegister was published!");
 138             } else {
 139                 LOG.warn("Notification Provider is null!");
 140             }
 141         } catch (RuntimeException re) {
 142             throw new LispMalformedPacketException("Couldn't deserialize Map-Register (len=" + inBuffer.capacity() + ")", re);
 143         }
 144     }
 145
 146     private void handleMapNotify(ByteBuffer inBuffer, InetAddress sourceAddress, int port) {
 147         try {
 148             MapNotify mapNotify = MapNotifySerializer.getInstance().deserialize(inBuffer);
 149             GotMapNotifyBuilder gotMapNotifyBuilder = new GotMapNotifyBuilder();
 150             gotMapNotifyBuilder.setMapNotify(LispNotificationHelper.convertMapNotify(mapNotify));
 151             TransportAddressBuilder transportAddressBuilder = new TransportAddressBuilder();
 152             transportAddressBuilder.setIpAddress(LispNotificationHelper.getIpAddressFromInetAddress(sourceAddress));
 153             transportAddressBuilder.setPort(new PortNumber(port));
 154             gotMapNotifyBuilder.setTransportAddress(transportAddressBuilder.build());
 155             if (notificationProvider != null) {
 156                 notificationProvider.publish(gotMapNotifyBuilder.build());
 157                 LOG.trace("MapNotify was published!");
 158             } else {
 159                 LOG.warn("Notification Provider is null!");
 160             }
 161         } catch (RuntimeException re) {
 162             throw new LispMalformedPacketException("Couldn't deserialize Map-Notify (len=" + inBuffer.capacity() + ")", re);
 163         }
 164     }
 165
 166     private void handleMapReply(ByteBuffer inBuffer, InetAddress sourceAddress, int port) {
 167         try {
 168             MapReply mapReply = MapReplySerializer.getInstance().deserialize(inBuffer);
 169             GotMapReplyBuilder gotMapReplyBuilder = new GotMapReplyBuilder();
 170             gotMapReplyBuilder.setMapReply(LispNotificationHelper.convertMapReply(mapReply));
 171             TransportAddressBuilder transportAddressBuilder = new TransportAddressBuilder();
 172             transportAddressBuilder.setIpAddress(LispNotificationHelper.getIpAddressFromInetAddress(sourceAddress));
 173             transportAddressBuilder.setPort(new PortNumber(port));
 174             gotMapReplyBuilder.setTransportAddress(transportAddressBuilder.build());
 175             if (notificationProvider != null) {
 176                 notificationProvider.publish(gotMapReplyBuilder.build());
 177                 LOG.trace("MapReply was published!");
 178             } else {
 179                 LOG.warn("Notification Provider is null!");
 180             }
 181         } catch (RuntimeException re) {
 182             throw new LispMalformedPacketException("Couldn't deserialize Map-Reply (len=" + inBuffer.capacity() + ")", re);
 183         }
 184     }
 185 }