arputil/arputil-impl/src/main/java/org/opendaylight/genius/arputil/internal/ArpUtilImpl.java

   1 /*
   2  * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. 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.genius.arputil.internal;
  10
  11 import com.google.common.base.Optional;
  12 import com.google.common.util.concurrent.FutureCallback;
  13 import com.google.common.util.concurrent.Futures;
  14 import com.google.common.util.concurrent.JdkFutureAdapters;
  15 import com.google.common.util.concurrent.SettableFuture;
  16
  17 import org.opendaylight.controller.liblldp.HexEncode;
  18 import org.opendaylight.controller.liblldp.NetUtils;
  19 import org.opendaylight.controller.liblldp.Packet;
  20 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  21 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
  22 import org.opendaylight.controller.md.sal.binding.api.NotificationService;
  23 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  24 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  25 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  26 import org.opendaylight.genius.mdsalutil.MetaDataUtil;
  27 import org.opendaylight.genius.mdsalutil.NWUtil;
  28 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
  29 import org.opendaylight.genius.mdsalutil.packet.ARP;
  30 import org.opendaylight.genius.mdsalutil.packet.Ethernet;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.ArpRequestReceivedBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.ArpResponseReceivedBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.GetMacInput;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.GetMacOutput;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.GetMacOutputBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.MacChangedBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilService;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInput;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInputBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpResponseInput;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.interfaces.InterfaceAddress;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceInputBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceOutput;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceInputBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexInput;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexOutput;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexInputBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceOutput;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Metadata;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketInReason;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingListener;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.SendToController;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInputBuilder;
  72 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  73 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  74 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  75 import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
  76 import org.opendaylight.yangtools.yang.common.RpcResult;
  77 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  78 import org.slf4j.Logger;
  79 import org.slf4j.LoggerFactory;
  80
  81 import java.math.BigInteger;
  82 import java.net.InetAddress;
  83 import java.net.UnknownHostException;
  84 import java.util.ArrayList;
  85 import java.util.List;
  86 import java.util.concurrent.ConcurrentHashMap;
  87 import java.util.concurrent.ConcurrentMap;
  88 import java.util.concurrent.ExecutionException;
  89 import java.util.concurrent.ExecutorService;
  90 import java.util.concurrent.Executors;
  91 import java.util.concurrent.Future;
  92
  93 import static com.google.common.base.Preconditions.checkArgument;
  94 import static com.google.common.base.Preconditions.checkNotNull;
  95
  96 public class ArpUtilImpl implements OdlArputilService,
  97         PacketProcessingListener, AutoCloseable {
  98
  99     private static final String FAILED_TO_GET_SRC_IP_FOR_INTERFACE = "Failed to get src ip for %s";
 100
 101     private static final String FAILED_TO_GET_SRC_MAC_FOR_INTERFACE = "Failed to get src mac for interface %s iid %s ";
 102
 103     private static final String FAILED_TO_SEND_ARP_REQ_FOR_INTERFACE = "failed to send arp req for interface ";
 104
 105     private static final String UNKNOWN_IP_ADDRESS_SUPPLIED = "unknown ip address supplied";
 106
 107     private static final String NODE_CONNECTOR_NOT_FOUND_ERROR = "Node connector id not found for interface %s";
 108
 109     private static final String DPN_NOT_FOUND_ERROR = "dpn not found for interface %s ";
 110
 111     private static final short ARP_REQUEST_OP = (short) 1;
 112
 113     private static final short ARP_RESPONSE_OP = (short) 2;
 114
 115     private static final short ETH_TYPE_ARP = 0x0806;
 116
 117     private static final Logger LOGGER = LoggerFactory
 118             .getLogger(ArpUtilImpl.class);
 119
 120     static OdlInterfaceRpcService intfRpc;
 121
 122     ExecutorService threadPool = Executors.newFixedThreadPool(1);
 123
 124     DataBroker dataBroker;
 125     PacketProcessingService packetProcessingService;
 126     NotificationPublishService notificationPublishService;
 127     NotificationService notificationService;
 128     IMdsalApiManager mdsalMgr;
 129
 130     RpcProviderRegistry rpc;
 131     ListenerRegistration<ArpUtilImpl> listenerRegistration;
 132
 133     ConcurrentMap<String, String> macsDB = new ConcurrentHashMap<>();
 134     ConcurrentMap<String, SettableFuture<RpcResult<GetMacOutput>>> getMacFutures = new ConcurrentHashMap<>();
 135
 136     public ArpUtilImpl(DataBroker db,
 137                        PacketProcessingService packetProcessingService,
 138                        NotificationPublishService notificationPublishService,
 139                        NotificationService notificationService,
 140                        IMdsalApiManager mdsalApiManager,
 141                        RpcProviderRegistry rpc) {
 142
 143         this.dataBroker = db;
 144         this.packetProcessingService = packetProcessingService;
 145         this.notificationPublishService = notificationPublishService;
 146         this.mdsalMgr = mdsalApiManager;
 147         this.notificationService = notificationService;
 148         this.rpc = rpc;
 149         listenerRegistration = notificationService
 150                 .registerNotificationListener(this);
 151         LOGGER.info("ArpUtil Manager Initialized ");
 152     }
 153
 154     OdlInterfaceRpcService getInterfaceRpcService() {
 155         if (intfRpc == null ) {
 156             intfRpc = rpc.getRpcService(OdlInterfaceRpcService.class);
 157         }
 158         return intfRpc;
 159     }
 160
 161     @Override
 162     public void close() throws Exception {
 163         listenerRegistration.close();
 164         LOGGER.trace("ArpUtil manager Closed");
 165     }
 166
 167     String getIpAddressInString(IpAddress ipAddress)
 168             throws UnknownHostException {
 169         return InetAddress.getByName(ipAddress.getIpv4Address().getValue()).getHostAddress();
 170     }
 171
 172     @Override
 173     public Future<RpcResult<GetMacOutput>> getMac(GetMacInput input) {
 174
 175         try {
 176             final String dstIpAddress = getIpAddressInString(input.getIpaddress());
 177             if (LOGGER.isTraceEnabled()) {
 178                 LOGGER.trace("getMac rpc invoked for ip " + dstIpAddress);
 179             }
 180             if (getMacFutures.get(dstIpAddress) != null) {
 181                 if (LOGGER.isInfoEnabled()) {
 182                     LOGGER.info("get mac already in progress for the ip "
 183                             + dstIpAddress);
 184                 }
 185                 return getMacFutures.get(dstIpAddress);
 186             }
 187             SendArpRequestInputBuilder builder = new SendArpRequestInputBuilder()
 188                     .setInterfaceAddress(input.getInterfaceAddress())
 189                     .setIpaddress(input.getIpaddress());
 190             Future<RpcResult<Void>> arpReqFt = sendArpRequest(builder.build());
 191             final SettableFuture<RpcResult<GetMacOutput>> ft = SettableFuture
 192                     .create();
 193
 194             Futures.addCallback(
 195                     JdkFutureAdapters.listenInPoolThread(arpReqFt, threadPool),
 196                     new FutureCallback<RpcResult<Void>>() {
 197                         @Override
 198                         public void onFailure(Throwable e) {
 199                             RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder
 200                                     .<GetMacOutput> failed().withError(
 201                                             ErrorType.APPLICATION,
 202                                             e.getMessage(), e);
 203                             ft.set(resultBuilder.build());
 204                         }
 205
 206                         @Override
 207                         public void onSuccess(RpcResult<Void> result) {
 208                             LOGGER.trace("Successfully sent the arp pkt out for ip "
 209                                     + dstIpAddress);
 210                         }
 211                     });
 212
 213             getMacFutures.put(dstIpAddress, ft);
 214             return ft;
 215         } catch (Exception e) {
 216             LOGGER.trace("failed to handle getMac request for {} {}",
 217                     input.getIpaddress(), e);
 218             RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder
 219                     .<GetMacOutput> failed().withError(ErrorType.APPLICATION,
 220                             e.getMessage(), e);
 221             return Futures.immediateFuture(resultBuilder.build());
 222         }
 223     }
 224
 225     byte[] getIpAddressBytes(IpAddress ip) throws UnknownHostException {
 226         return InetAddress.getByName(ip.getIpv4Address().getValue())
 227                 .getAddress();
 228     }
 229
 230     @Override
 231     public Future<RpcResult<Void>> sendArpRequest(
 232             SendArpRequestInput arpReqInput) {
 233         if (LOGGER.isTraceEnabled()) {
 234             LOGGER.trace("rpc sendArpRequest invoked for ip "
 235                     + arpReqInput.getIpaddress());
 236         }
 237         BigInteger dpnId;
 238         long groupId;
 239         byte payload[];
 240         String interfaceName = null;
 241         byte srcIpBytes[];
 242         byte[] dstIpBytes = null;
 243
 244         RpcResultBuilder<Void> failureBuilder = RpcResultBuilder
 245                 .<Void> failed();
 246         RpcResultBuilder<Void> successBuilder = RpcResultBuilder
 247                 .<Void> success();
 248
 249         try {
 250             dstIpBytes = getIpAddressBytes(arpReqInput.getIpaddress());
 251         } catch (Exception e) {
 252             failureBuilder.withError(ErrorType.APPLICATION,
 253                     UNKNOWN_IP_ADDRESS_SUPPLIED);
 254             return Futures.immediateFuture(failureBuilder.build());
 255         }
 256
 257         int localErrorCount = 0;
 258         for (InterfaceAddress interfaceAddress : arpReqInput
 259                 .getInterfaceAddress()) {
 260             try {
 261                 interfaceName = interfaceAddress.getInterface();
 262                 srcIpBytes = getIpAddressBytes(interfaceAddress.getIpAddress());
 263
 264                 NodeConnectorId id = getNodeConnectorFromInterfaceName(interfaceName);
 265
 266                 GetPortFromInterfaceOutput portResult = getPortFromInterface(interfaceName);
 267                 checkNotNull(portResult);
 268                 dpnId = portResult.getDpid();
 269                 Long portid = portResult.getPortno();
 270                 checkArgument(null != dpnId && BigInteger.ZERO != dpnId,
 271                         DPN_NOT_FOUND_ERROR, interfaceName);
 272
 273                 NodeConnectorRef ref = MDSALUtil.getNodeConnRef(dpnId,
 274                         portid.toString());
 275                 checkNotNull(ref, NODE_CONNECTOR_NOT_FOUND_ERROR, interfaceName);
 276
 277                 if (LOGGER.isTraceEnabled()) {
 278                     LOGGER.trace(
 279                             "sendArpRequest received dpnId {} out interface {}",
 280                             dpnId, interfaceName);
 281                 }
 282                 byte srcMac[] = MDSALUtil.getMacAddressForNodeConnector(
 283                         dataBroker,
 284                         (InstanceIdentifier<NodeConnector>) ref.getValue());
 285                 checkNotNull(srcMac, FAILED_TO_GET_SRC_MAC_FOR_INTERFACE,
 286                         interfaceName, ref.getValue());
 287                 checkNotNull(srcIpBytes, FAILED_TO_GET_SRC_IP_FOR_INTERFACE,
 288                         interfaceName);
 289
 290                 payload = ArpPacketUtil.getPayload(ARP_REQUEST_OP, srcMac,
 291                         srcIpBytes, ArpPacketUtil.EthernetDestination_Broadcast,
 292                         dstIpBytes);
 293
 294                 List<Action> actions = getEgressAction(interfaceName);
 295                 sendPacketOutWithActions(dpnId, payload, ref, actions);
 296
 297                 if (LOGGER.isTraceEnabled()) {
 298                     LOGGER.trace("sent arp request for "
 299                             + arpReqInput.getIpaddress());
 300                 }
 301             } catch (Throwable e) {
 302                 LOGGER.trace("failed to send arp req for {} on interface {}",
 303                         arpReqInput.getIpaddress(), interfaceName);
 304
 305                 failureBuilder
 306                         .withError(ErrorType.APPLICATION,
 307                                 FAILED_TO_SEND_ARP_REQ_FOR_INTERFACE
 308                                         + interfaceName, e);
 309                 successBuilder
 310                         .withError(ErrorType.APPLICATION,
 311                                 FAILED_TO_SEND_ARP_REQ_FOR_INTERFACE
 312                                         + interfaceName, e);
 313                 localErrorCount++;
 314             }
 315         }
 316         if (localErrorCount == arpReqInput.getInterfaceAddress().size()) {
 317             // All the requests failed
 318             return Futures.immediateFuture(failureBuilder.build());
 319         }
 320         return Futures.immediateFuture(successBuilder.build());
 321     }
 322
 323     public Future<RpcResult<Void>> sendPacketOut(BigInteger dpnId,
 324                                                  byte[] payload, NodeConnectorRef ref) {
 325
 326         NodeConnectorRef nodeConnectorRef = MDSALUtil.getNodeConnRef(dpnId,
 327                 "0xfffffffd");
 328         return packetProcessingService
 329                 .transmitPacket(new TransmitPacketInputBuilder()
 330                         .setPayload(payload)
 331                         .setNode(
 332                                 new NodeRef(InstanceIdentifier
 333                                         .builder(Nodes.class)
 334                                         .child(Node.class,
 335                                                 new NodeKey(new NodeId(
 336                                                         "openflow:" + dpnId)))
 337                                         .toInstance()))
 338                         .setIngress(nodeConnectorRef).setEgress(ref).build());
 339     }
 340
 341     public Future<RpcResult<Void>> sendPacketOutWithActions(BigInteger dpnId,
 342                                                             byte[] payload, NodeConnectorRef ref, List<Action> actions) {
 343
 344         NodeConnectorRef nodeConnectorRef = MDSALUtil.getNodeConnRef(dpnId,
 345                 "0xfffffffd");
 346         return packetProcessingService
 347                 .transmitPacket(new TransmitPacketInputBuilder()
 348                         .setPayload(payload)
 349                         .setNode(
 350                                 new NodeRef(InstanceIdentifier
 351                                         .builder(Nodes.class)
 352                                         .child(Node.class,
 353                                                 new NodeKey(new NodeId(
 354                                                         "openflow:" + dpnId)))
 355                                         .toInstance()))
 356                         .setIngress(nodeConnectorRef).setEgress(ref)
 357                         .setAction(actions).build());
 358     }
 359
 360     private List<Action> getEgressAction(String interfaceName) {
 361         List<Action> actions = new ArrayList<Action>();
 362         try {
 363             GetEgressActionsForInterfaceInputBuilder egressAction = new GetEgressActionsForInterfaceInputBuilder().setIntfName(interfaceName);
 364             OdlInterfaceRpcService intfRpc = getInterfaceRpcService();
 365             if (intfRpc == null) {
 366                 LOGGER.error("Unable to obtain interfaceMgrRpc service, ignoring egress actions for interfaceName {}", interfaceName);
 367                 return actions;
 368             }
 369             Future<RpcResult<GetEgressActionsForInterfaceOutput>> result =
 370                     intfRpc.getEgressActionsForInterface(egressAction.build());
 371             RpcResult<GetEgressActionsForInterfaceOutput> rpcResult = result.get();
 372             if (!rpcResult.isSuccessful()) {
 373                 LOGGER.warn("RPC Call to Get egress actions for interface {} returned with Errors {}", interfaceName, rpcResult.getErrors());
 374             } else {
 375                 actions = rpcResult.getResult().getAction();
 376             }
 377         } catch (InterruptedException | ExecutionException e) {
 378             LOGGER.error("Exception when egress actions for interface {}", interfaceName, e);
 379         } catch ( Exception e) {
 380             LOGGER.error("Exception when egress actions for interface {}", interfaceName, e);
 381         }
 382         return actions;
 383     }
 384
 385     @Override
 386     public Future<RpcResult<Void>> sendArpResponse(SendArpResponseInput input) {
 387         if (LOGGER.isTraceEnabled()) {
 388             LOGGER.trace("sendArpResponse rpc invoked");
 389         }
 390         BigInteger dpnId;
 391         long groupId;
 392         byte payload[];
 393         //byte srcMac[] = new byte[] { (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0 };
 394         byte srcMac[];
 395
 396
 397         try {
 398             String interfaceName = input.getInterface();
 399             GetPortFromInterfaceOutput portResult = getPortFromInterface(interfaceName);
 400             checkNotNull(portResult);
 401             dpnId = portResult.getDpid();
 402             Long portid = portResult.getPortno();
 403             NodeConnectorRef ref = MDSALUtil.getNodeConnRef(dpnId,
 404                     portid.toString());
 405             checkArgument(null != dpnId && BigInteger.ZERO != dpnId,
 406                     DPN_NOT_FOUND_ERROR, interfaceName);
 407             checkNotNull(ref, NODE_CONNECTOR_NOT_FOUND_ERROR, interfaceName);
 408
 409             if (LOGGER.isTraceEnabled()) {
 410                 LOGGER.trace(
 411                         "sendArpRequest received dpnId {} out interface {}",
 412                         dpnId, interfaceName);
 413             }
 414
 415             byte[] srcIpBytes = getIpAddressBytes(input.getSrcIpaddress());
 416             byte[] dstIpBytes = getIpAddressBytes(input.getDstIpaddress());
 417             if(input.getSrcMacaddress() == null) {
 418                 srcMac = MDSALUtil.getMacAddressForNodeConnector(dataBroker,
 419                         (InstanceIdentifier<NodeConnector>) ref.getValue());
 420             }else {
 421                 String macAddr = input.getSrcMacaddress().getValue();
 422                 srcMac = HexEncode.bytesFromHexString(macAddr);
 423             }
 424             byte[] dstMac = NWUtil.parseMacAddress(input.getDstMacaddress()
 425                     .getValue());
 426             checkNotNull(srcIpBytes, FAILED_TO_GET_SRC_IP_FOR_INTERFACE,
 427                     interfaceName);
 428             payload = ArpPacketUtil.getPayload(ARP_RESPONSE_OP, srcMac, srcIpBytes,
 429                     dstMac, dstIpBytes);
 430
 431             List<Action> actions = getEgressAction(interfaceName);
 432             sendPacketOutWithActions(dpnId, payload, ref, actions);
 433             if (LOGGER.isTraceEnabled()) {
 434                 LOGGER.trace("sent the arp response for "
 435                         + input.getSrcIpaddress());
 436             }
 437         } catch (Throwable e) {
 438             LOGGER.error("failed to send arp response for {} {}",
 439                     input.getSrcIpaddress(), e);
 440             return RpcResultBuilder.<Void> failed()
 441                     .withError(ErrorType.APPLICATION, e.getMessage(), e)
 442                     .buildFuture();
 443         }
 444         RpcResultBuilder<Void> rpcResultBuilder = RpcResultBuilder.success();
 445         return Futures.immediateFuture(rpcResultBuilder.build());
 446     }
 447
 448     @Override
 449     public void onPacketReceived(PacketReceived packetReceived) {
 450         Class<? extends PacketInReason> pktInReason = packetReceived
 451                 .getPacketInReason();
 452         if (LOGGER.isTraceEnabled()) {
 453             LOGGER.trace("Packet Received {}", packetReceived);
 454         }
 455
 456         if (pktInReason == SendToController.class) {
 457
 458             try {
 459                 int tableId = packetReceived.getTableId().getValue();
 460
 461                 byte[] data = packetReceived.getPayload();
 462                 Ethernet ethernet = new Ethernet();
 463
 464                 ethernet.deserialize(data, 0, data.length
 465                         * NetUtils.NumBitsInAByte);
 466                 if (ethernet.getEtherType() != ETH_TYPE_ARP) {
 467                     return;
 468                 }
 469
 470                 Packet pkt = ethernet.getPayload();
 471                 ARP arp = (ARP) pkt;
 472                 InetAddress srcInetAddr = InetAddress.getByAddress(arp
 473                         .getSenderProtocolAddress());
 474                 InetAddress dstInetAddr = InetAddress.getByAddress(arp
 475                         .getTargetProtocolAddress());
 476                 InetAddress addr = srcInetAddr;
 477                 //For GARP learn target IP
 478                 if (srcInetAddr.getHostAddress().equalsIgnoreCase(dstInetAddr.getHostAddress()))
 479                     addr = dstInetAddr;
 480                 byte[] srcMac = ethernet.getSourceMACAddress();
 481
 482                 NodeConnectorRef ref = packetReceived.getIngress();
 483
 484                 Metadata metadata  = packetReceived.getMatch().getMetadata();
 485
 486                 String interfaceName = getInterfaceName(ref,metadata, dataBroker);
 487                 //Long vpnId = MetaDataUtil.getVpnIdFromMetadata(metadata.getMetadata());
 488
 489                 checkAndFireMacChangedNotification(interfaceName, srcInetAddr,
 490                         srcMac);
 491                 macsDB.put(interfaceName + "-" + srcInetAddr.getHostAddress(),
 492                         NWUtil.toStringMacAddress(srcMac));
 493                 if (arp.getOpCode() == ARP_REQUEST_OP) {
 494                     fireArpReqRecvdNotification(interfaceName, srcInetAddr,
 495                             srcMac, dstInetAddr, tableId, metadata.getMetadata());
 496                 } else {
 497                     fireArpRespRecvdNotification(interfaceName, srcInetAddr,
 498                             srcMac, tableId, metadata.getMetadata());
 499                 }
 500                 if (getMacFutures.get(srcInetAddr.getHostAddress()) != null) {
 501                     threadPool.submit(new MacResponderTask(arp));
 502                 }
 503
 504             } catch (Throwable e) {
 505                 LOGGER.trace("Failed to decode packet: {}", e);
 506             }
 507         }
 508     }
 509
 510     GetPortFromInterfaceOutput getPortFromInterface(String interfaceName) throws Throwable {
 511         GetPortFromInterfaceInputBuilder getPortFromInterfaceInputBuilder = new GetPortFromInterfaceInputBuilder();
 512         getPortFromInterfaceInputBuilder.setIntfName(interfaceName);
 513         OdlInterfaceRpcService intfRpc = getInterfaceRpcService();
 514         if (intfRpc == null) {
 515             LOGGER.error("Failed to get OF port for interface {}. Unable to obtain OdlInterfaceRpcService",
 516                     interfaceName);
 517             return null;
 518         }
 519
 520         Future<RpcResult<GetPortFromInterfaceOutput>> portFromInterface = intfRpc.getPortFromInterface(getPortFromInterfaceInputBuilder.build());
 521         GetPortFromInterfaceOutput result = portFromInterface.get().getResult();
 522         LOGGER.trace("getPortFromInterface rpc result is {} ", result);
 523         if (result != null) {
 524             LOGGER.trace("getPortFromInterface rpc result is {} {} ", result.getDpid(), result.getPortno());
 525         }
 526         return result;
 527     }
 528
 529     private String getInterfaceName(NodeConnectorRef ref, Metadata metadata, DataBroker dataBroker2) throws Throwable {
 530         LOGGER.debug("metadata received is {} ", metadata);
 531
 532         GetInterfaceFromIfIndexInputBuilder ifIndexInputBuilder = new GetInterfaceFromIfIndexInputBuilder();
 533         BigInteger lportTag = MetaDataUtil.getLportFromMetadata(metadata.getMetadata());
 534
 535         ifIndexInputBuilder.setIfIndex(lportTag.intValue());
 536         GetInterfaceFromIfIndexInput input = ifIndexInputBuilder.build();
 537         OdlInterfaceRpcService intfRpc = getInterfaceRpcService();
 538
 539         Future<RpcResult<GetInterfaceFromIfIndexOutput>> interfaceFromIfIndex = intfRpc.getInterfaceFromIfIndex(input);
 540         GetInterfaceFromIfIndexOutput interfaceFromIfIndexOutput = interfaceFromIfIndex.get().getResult();
 541         return interfaceFromIfIndexOutput.getInterfaceName();
 542     }
 543
 544     class MacResponderTask implements Runnable {
 545         ARP arp;
 546
 547         MacResponderTask(ARP arp) {
 548             this.arp = arp;
 549         }
 550
 551         @Override
 552         public void run() {
 553             InetAddress srcAddr;
 554             GetMacOutputBuilder outputBuilder;
 555             String srcMac;
 556             SettableFuture<RpcResult<GetMacOutput>> future = null;
 557             RpcResultBuilder<GetMacOutput> resultBuilder;
 558             try {
 559                 srcAddr = InetAddress.getByAddress(arp
 560                         .getSenderProtocolAddress());
 561                 srcMac = NWUtil.toStringMacAddress(arp
 562                         .getSenderHardwareAddress());
 563                 future = getMacFutures.remove(srcAddr.getHostAddress());
 564                 if (future == null) {
 565                     LOGGER.trace("There are no pending mac requests.");
 566                     return;
 567                 }
 568                 outputBuilder = new GetMacOutputBuilder()
 569                         .setMacaddress(new PhysAddress(srcMac));
 570                 resultBuilder = RpcResultBuilder.success(outputBuilder.build());
 571                 if (LOGGER.isTraceEnabled()) {
 572                     LOGGER.trace("sent the mac response for ip {}",
 573                             srcAddr.getHostAddress());
 574                 }
 575             } catch (Exception e) {
 576                 LOGGER.trace("failed to send mac response {} ", e);
 577                 resultBuilder = RpcResultBuilder.<GetMacOutput> failed()
 578                         .withError(ErrorType.APPLICATION, e.getMessage(), e);
 579             }
 580             future.set(resultBuilder.build());
 581         }
 582     }
 583
 584     private void fireArpRespRecvdNotification(String interfaceName,
 585                                               InetAddress inetAddr, byte[] macAddressBytes, int tableId, BigInteger metadata)
 586             throws InterruptedException {
 587
 588         IpAddress ip = new IpAddress(inetAddr.getHostAddress().toCharArray());
 589         String macAddress = NWUtil.toStringMacAddress(macAddressBytes);
 590         PhysAddress mac = new PhysAddress(macAddress);
 591         ArpResponseReceivedBuilder builder = new ArpResponseReceivedBuilder();
 592         builder.setInterface(interfaceName);
 593         builder.setIpaddress(ip);
 594         builder.setOfTableId((long) tableId);
 595         builder.setMacaddress(mac);
 596         builder.setMetadata(metadata);
 597         notificationPublishService.putNotification(builder.build());
 598     }
 599
 600     private void fireArpReqRecvdNotification(String interfaceName,
 601                                              InetAddress srcInetAddr, byte[] srcMac, InetAddress dstInetAddr,
 602                                              int tableId, BigInteger metadata) throws InterruptedException {
 603         String macAddress = NWUtil.toStringMacAddress(srcMac);
 604         ArpRequestReceivedBuilder builder = new ArpRequestReceivedBuilder();
 605         builder.setInterface(interfaceName);
 606         builder.setOfTableId((long) tableId);
 607         builder.setSrcIpaddress(new IpAddress(srcInetAddr.getHostAddress()
 608                 .toCharArray()));
 609         builder.setDstIpaddress(new IpAddress(dstInetAddr.getHostAddress()
 610                 .toCharArray()));
 611         builder.setSrcMac(new PhysAddress(macAddress));
 612         builder.setMetadata(metadata);
 613         notificationPublishService.putNotification(builder.build());
 614     }
 615
 616     private void checkAndFireMacChangedNotification(String interfaceName,
 617                                                     InetAddress inetAddr, byte[] macAddressBytes)
 618             throws InterruptedException {
 619
 620         IpAddress ip = new IpAddress(inetAddr.getHostAddress().toCharArray());
 621         String macAddress = NWUtil.toStringMacAddress(macAddressBytes);
 622         PhysAddress mac = new PhysAddress(macAddress);
 623
 624         if (!macAddress.equals(macsDB.get(interfaceName + "-"
 625                 + inetAddr.getHostAddress()))) {
 626             if (LOGGER.isTraceEnabled()) {
 627                 LOGGER.trace("mac address changed for " + inetAddr);
 628             }
 629             MacChangedBuilder builder = new MacChangedBuilder();
 630             builder.setInterface(interfaceName);
 631             builder.setIpaddress(ip);
 632             builder.setMacaddress(mac);
 633             notificationPublishService.putNotification(builder.build());
 634         }
 635     }
 636
 637     private InstanceIdentifier<Interface> buildInterfaceId(String interfaceName) {
 638         InstanceIdentifierBuilder<Interface> idBuilder = InstanceIdentifier
 639                 .builder(Interfaces.class).child(Interface.class,
 640                         new InterfaceKey(interfaceName));
 641         InstanceIdentifier<Interface> id = idBuilder.build();
 642         return id;
 643     }
 644
 645     private NodeConnectorId getNodeConnectorFromInterfaceName(String interfaceName) {
 646         InstanceIdentifierBuilder<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> idBuilder =
 647                 InstanceIdentifier.builder(InterfacesState.class)
 648                         .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class,
 649                                 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey(interfaceName));
 650         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateId = idBuilder.build();
 651
 652         Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateOptional = MDSALUtil.read(dataBroker,
 653                 LogicalDatastoreType.OPERATIONAL,
 654                 ifStateId);
 655
 656         if (ifStateOptional.isPresent()) {
 657             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState = ifStateOptional.get();
 658             List<String> lowerLayerIf = ifState.getLowerLayerIf();
 659             if (!lowerLayerIf.isEmpty()) {
 660                 return new NodeConnectorId(lowerLayerIf.get(0));
 661             }
 662         }
 663         return null;
 664     }
 665 }