2 * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
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
9 package org.opendaylight.genius.arputil.internal;
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;
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;
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;
93 import static com.google.common.base.Preconditions.checkArgument;
94 import static com.google.common.base.Preconditions.checkNotNull;
96 public class ArpUtilImpl implements OdlArputilService,
97 PacketProcessingListener, AutoCloseable {
99 private static final String FAILED_TO_GET_SRC_IP_FOR_INTERFACE = "Failed to get src ip for %s";
101 private static final String FAILED_TO_GET_SRC_MAC_FOR_INTERFACE = "Failed to get src mac for interface %s iid %s ";
103 private static final String FAILED_TO_SEND_ARP_REQ_FOR_INTERFACE = "failed to send arp req for interface ";
105 private static final String UNKNOWN_IP_ADDRESS_SUPPLIED = "unknown ip address supplied";
107 private static final String NODE_CONNECTOR_NOT_FOUND_ERROR = "Node connector id not found for interface %s";
109 private static final String DPN_NOT_FOUND_ERROR = "dpn not found for interface %s ";
111 private static final short ARP_REQUEST_OP = (short) 1;
113 private static final short ARP_RESPONSE_OP = (short) 2;
115 private static final short ETH_TYPE_ARP = 0x0806;
117 private static final Logger LOGGER = LoggerFactory
118 .getLogger(ArpUtilImpl.class);
120 static OdlInterfaceRpcService intfRpc;
122 ExecutorService threadPool = Executors.newFixedThreadPool(1);
124 DataBroker dataBroker;
125 PacketProcessingService packetProcessingService;
126 NotificationPublishService notificationPublishService;
127 NotificationService notificationService;
128 IMdsalApiManager mdsalMgr;
130 RpcProviderRegistry rpc;
131 ListenerRegistration<ArpUtilImpl> listenerRegistration;
133 ConcurrentMap<String, String> macsDB = new ConcurrentHashMap<>();
134 ConcurrentMap<String, SettableFuture<RpcResult<GetMacOutput>>> getMacFutures = new ConcurrentHashMap<>();
136 public ArpUtilImpl(DataBroker db,
137 PacketProcessingService packetProcessingService,
138 NotificationPublishService notificationPublishService,
139 NotificationService notificationService,
140 IMdsalApiManager mdsalApiManager,
141 RpcProviderRegistry rpc) {
143 this.dataBroker = db;
144 this.packetProcessingService = packetProcessingService;
145 this.notificationPublishService = notificationPublishService;
146 this.mdsalMgr = mdsalApiManager;
147 this.notificationService = notificationService;
149 listenerRegistration = notificationService
150 .registerNotificationListener(this);
151 LOGGER.info("ArpUtil Manager Initialized ");
154 OdlInterfaceRpcService getInterfaceRpcService() {
155 if (intfRpc == null ) {
156 intfRpc = rpc.getRpcService(OdlInterfaceRpcService.class);
162 public void close() throws Exception {
163 listenerRegistration.close();
164 LOGGER.trace("ArpUtil manager Closed");
167 String getIpAddressInString(IpAddress ipAddress)
168 throws UnknownHostException {
169 return InetAddress.getByName(ipAddress.getIpv4Address().getValue()).getHostAddress();
173 public Future<RpcResult<GetMacOutput>> getMac(GetMacInput input) {
176 final String dstIpAddress = getIpAddressInString(input.getIpaddress());
177 if (LOGGER.isTraceEnabled()) {
178 LOGGER.trace("getMac rpc invoked for ip " + dstIpAddress);
180 if (getMacFutures.get(dstIpAddress) != null) {
181 if (LOGGER.isInfoEnabled()) {
182 LOGGER.info("get mac already in progress for the ip "
185 return getMacFutures.get(dstIpAddress);
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
195 JdkFutureAdapters.listenInPoolThread(arpReqFt, threadPool),
196 new FutureCallback<RpcResult<Void>>() {
198 public void onFailure(Throwable e) {
199 RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder
200 .<GetMacOutput> failed().withError(
201 ErrorType.APPLICATION,
203 ft.set(resultBuilder.build());
207 public void onSuccess(RpcResult<Void> result) {
208 LOGGER.trace("Successfully sent the arp pkt out for ip "
213 getMacFutures.put(dstIpAddress, 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,
221 return Futures.immediateFuture(resultBuilder.build());
225 byte[] getIpAddressBytes(IpAddress ip) throws UnknownHostException {
226 return InetAddress.getByName(ip.getIpv4Address().getValue())
231 public Future<RpcResult<Void>> sendArpRequest(
232 SendArpRequestInput arpReqInput) {
233 if (LOGGER.isTraceEnabled()) {
234 LOGGER.trace("rpc sendArpRequest invoked for ip "
235 + arpReqInput.getIpaddress());
240 String interfaceName = null;
242 byte[] dstIpBytes = null;
243 byte[] srcMac = null;
245 RpcResultBuilder<Void> failureBuilder = RpcResultBuilder
247 RpcResultBuilder<Void> successBuilder = RpcResultBuilder
251 dstIpBytes = getIpAddressBytes(arpReqInput.getIpaddress());
252 } catch (Exception e) {
253 failureBuilder.withError(ErrorType.APPLICATION,
254 UNKNOWN_IP_ADDRESS_SUPPLIED);
255 return Futures.immediateFuture(failureBuilder.build());
258 int localErrorCount = 0;
259 for (InterfaceAddress interfaceAddress : arpReqInput
260 .getInterfaceAddress()) {
262 interfaceName = interfaceAddress.getInterface();
263 srcIpBytes = getIpAddressBytes(interfaceAddress.getIpAddress());
265 NodeConnectorId id = getNodeConnectorFromInterfaceName(interfaceName);
267 GetPortFromInterfaceOutput portResult = getPortFromInterface(interfaceName);
268 checkNotNull(portResult);
269 dpnId = portResult.getDpid();
270 Long portid = portResult.getPortno();
271 checkArgument(null != dpnId && BigInteger.ZERO != dpnId,
272 DPN_NOT_FOUND_ERROR, interfaceName);
274 NodeConnectorRef ref = MDSALUtil.getNodeConnRef(dpnId,
276 checkNotNull(ref, NODE_CONNECTOR_NOT_FOUND_ERROR, interfaceName);
278 if (LOGGER.isTraceEnabled()) {
280 "sendArpRequest received dpnId {} out interface {}",
281 dpnId, interfaceName);
283 if (interfaceAddress.getMacaddress() == null) {
284 srcMac = MDSALUtil.getMacAddressForNodeConnector(
286 (InstanceIdentifier<NodeConnector>) ref.getValue());
288 String macAddr = interfaceAddress.getMacaddress().getValue();
289 srcMac = HexEncode.bytesFromHexString(macAddr);
291 checkNotNull(srcMac, FAILED_TO_GET_SRC_MAC_FOR_INTERFACE,
292 interfaceName, ref.getValue());
293 checkNotNull(srcIpBytes, FAILED_TO_GET_SRC_IP_FOR_INTERFACE,
296 payload = ArpPacketUtil.getPayload(ARP_REQUEST_OP, srcMac,
297 srcIpBytes, ArpPacketUtil.EthernetDestination_Broadcast,
300 List<Action> actions = getEgressAction(interfaceName);
301 sendPacketOutWithActions(dpnId, payload, ref, actions);
303 if (LOGGER.isTraceEnabled()) {
304 LOGGER.trace("sent arp request for "
305 + arpReqInput.getIpaddress());
307 } catch (Throwable e) {
308 LOGGER.trace("failed to send arp req for {} on interface {}",
309 arpReqInput.getIpaddress(), interfaceName);
312 .withError(ErrorType.APPLICATION,
313 FAILED_TO_SEND_ARP_REQ_FOR_INTERFACE
316 .withError(ErrorType.APPLICATION,
317 FAILED_TO_SEND_ARP_REQ_FOR_INTERFACE
322 if (localErrorCount == arpReqInput.getInterfaceAddress().size()) {
323 // All the requests failed
324 return Futures.immediateFuture(failureBuilder.build());
326 return Futures.immediateFuture(successBuilder.build());
329 public Future<RpcResult<Void>> sendPacketOut(BigInteger dpnId,
330 byte[] payload, NodeConnectorRef ref) {
332 NodeConnectorRef nodeConnectorRef = MDSALUtil.getNodeConnRef(dpnId,
334 return packetProcessingService
335 .transmitPacket(new TransmitPacketInputBuilder()
338 new NodeRef(InstanceIdentifier
339 .builder(Nodes.class)
341 new NodeKey(new NodeId(
342 "openflow:" + dpnId)))
344 .setIngress(nodeConnectorRef).setEgress(ref).build());
347 public Future<RpcResult<Void>> sendPacketOutWithActions(BigInteger dpnId,
348 byte[] payload, NodeConnectorRef ref, List<Action> actions) {
350 NodeConnectorRef nodeConnectorRef = MDSALUtil.getNodeConnRef(dpnId,
352 return packetProcessingService
353 .transmitPacket(new TransmitPacketInputBuilder()
356 new NodeRef(InstanceIdentifier
357 .builder(Nodes.class)
359 new NodeKey(new NodeId(
360 "openflow:" + dpnId)))
362 .setIngress(nodeConnectorRef).setEgress(ref)
363 .setAction(actions).build());
366 private List<Action> getEgressAction(String interfaceName) {
367 List<Action> actions = new ArrayList<Action>();
369 GetEgressActionsForInterfaceInputBuilder egressAction = new GetEgressActionsForInterfaceInputBuilder().setIntfName(interfaceName);
370 OdlInterfaceRpcService intfRpc = getInterfaceRpcService();
371 if (intfRpc == null) {
372 LOGGER.error("Unable to obtain interfaceMgrRpc service, ignoring egress actions for interfaceName {}", interfaceName);
375 Future<RpcResult<GetEgressActionsForInterfaceOutput>> result =
376 intfRpc.getEgressActionsForInterface(egressAction.build());
377 RpcResult<GetEgressActionsForInterfaceOutput> rpcResult = result.get();
378 if (!rpcResult.isSuccessful()) {
379 LOGGER.warn("RPC Call to Get egress actions for interface {} returned with Errors {}", interfaceName, rpcResult.getErrors());
381 actions = rpcResult.getResult().getAction();
383 } catch (InterruptedException | ExecutionException e) {
384 LOGGER.error("Exception when egress actions for interface {}", interfaceName, e);
385 } catch ( Exception e) {
386 LOGGER.error("Exception when egress actions for interface {}", interfaceName, e);
392 public Future<RpcResult<Void>> sendArpResponse(SendArpResponseInput input) {
393 if (LOGGER.isTraceEnabled()) {
394 LOGGER.trace("sendArpResponse rpc invoked");
399 //byte srcMac[] = new byte[] { (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0 };
404 String interfaceName = input.getInterface();
405 GetPortFromInterfaceOutput portResult = getPortFromInterface(interfaceName);
406 checkNotNull(portResult);
407 dpnId = portResult.getDpid();
408 Long portid = portResult.getPortno();
409 NodeConnectorRef ref = MDSALUtil.getNodeConnRef(dpnId,
411 checkArgument(null != dpnId && BigInteger.ZERO != dpnId,
412 DPN_NOT_FOUND_ERROR, interfaceName);
413 checkNotNull(ref, NODE_CONNECTOR_NOT_FOUND_ERROR, interfaceName);
415 if (LOGGER.isTraceEnabled()) {
417 "sendArpRequest received dpnId {} out interface {}",
418 dpnId, interfaceName);
421 byte[] srcIpBytes = getIpAddressBytes(input.getSrcIpaddress());
422 byte[] dstIpBytes = getIpAddressBytes(input.getDstIpaddress());
423 if(input.getSrcMacaddress() == null) {
424 srcMac = MDSALUtil.getMacAddressForNodeConnector(dataBroker,
425 (InstanceIdentifier<NodeConnector>) ref.getValue());
427 String macAddr = input.getSrcMacaddress().getValue();
428 srcMac = HexEncode.bytesFromHexString(macAddr);
430 byte[] dstMac = NWUtil.parseMacAddress(input.getDstMacaddress()
432 checkNotNull(srcIpBytes, FAILED_TO_GET_SRC_IP_FOR_INTERFACE,
434 payload = ArpPacketUtil.getPayload(ARP_RESPONSE_OP, srcMac, srcIpBytes,
437 List<Action> actions = getEgressAction(interfaceName);
438 sendPacketOutWithActions(dpnId, payload, ref, actions);
439 if (LOGGER.isTraceEnabled()) {
440 LOGGER.trace("sent the arp response for "
441 + input.getSrcIpaddress());
443 } catch (Throwable e) {
444 LOGGER.error("failed to send arp response for {} {}",
445 input.getSrcIpaddress(), e);
446 return RpcResultBuilder.<Void> failed()
447 .withError(ErrorType.APPLICATION, e.getMessage(), e)
450 RpcResultBuilder<Void> rpcResultBuilder = RpcResultBuilder.success();
451 return Futures.immediateFuture(rpcResultBuilder.build());
455 public void onPacketReceived(PacketReceived packetReceived) {
456 Class<? extends PacketInReason> pktInReason = packetReceived
457 .getPacketInReason();
458 if (LOGGER.isTraceEnabled()) {
459 LOGGER.trace("Packet Received {}", packetReceived);
462 if (pktInReason == SendToController.class) {
465 int tableId = packetReceived.getTableId().getValue();
467 byte[] data = packetReceived.getPayload();
468 Ethernet ethernet = new Ethernet();
470 ethernet.deserialize(data, 0, data.length
471 * NetUtils.NumBitsInAByte);
472 if (ethernet.getEtherType() != ETH_TYPE_ARP) {
476 Packet pkt = ethernet.getPayload();
478 InetAddress srcInetAddr = InetAddress.getByAddress(arp
479 .getSenderProtocolAddress());
480 InetAddress dstInetAddr = InetAddress.getByAddress(arp
481 .getTargetProtocolAddress());
482 InetAddress addr = srcInetAddr;
483 //For GARP learn target IP
484 if (srcInetAddr.getHostAddress().equalsIgnoreCase(dstInetAddr.getHostAddress()))
486 byte[] srcMac = ethernet.getSourceMACAddress();
488 NodeConnectorRef ref = packetReceived.getIngress();
490 Metadata metadata = packetReceived.getMatch().getMetadata();
492 String interfaceName = getInterfaceName(ref,metadata, dataBroker);
493 //Long vpnId = MetaDataUtil.getVpnIdFromMetadata(metadata.getMetadata());
495 checkAndFireMacChangedNotification(interfaceName, srcInetAddr,
497 macsDB.put(interfaceName + "-" + srcInetAddr.getHostAddress(),
498 NWUtil.toStringMacAddress(srcMac));
499 if (arp.getOpCode() == ARP_REQUEST_OP) {
500 fireArpReqRecvdNotification(interfaceName, srcInetAddr,
501 srcMac, dstInetAddr, tableId, metadata.getMetadata());
503 fireArpRespRecvdNotification(interfaceName, srcInetAddr,
504 srcMac, tableId, metadata.getMetadata());
506 if (getMacFutures.get(srcInetAddr.getHostAddress()) != null) {
507 threadPool.submit(new MacResponderTask(arp));
510 } catch (Throwable e) {
511 LOGGER.trace("Failed to decode packet: {}", e);
516 GetPortFromInterfaceOutput getPortFromInterface(String interfaceName) throws Throwable {
517 GetPortFromInterfaceInputBuilder getPortFromInterfaceInputBuilder = new GetPortFromInterfaceInputBuilder();
518 getPortFromInterfaceInputBuilder.setIntfName(interfaceName);
519 OdlInterfaceRpcService intfRpc = getInterfaceRpcService();
520 if (intfRpc == null) {
521 LOGGER.error("Failed to get OF port for interface {}. Unable to obtain OdlInterfaceRpcService",
526 Future<RpcResult<GetPortFromInterfaceOutput>> portFromInterface = intfRpc.getPortFromInterface(getPortFromInterfaceInputBuilder.build());
527 GetPortFromInterfaceOutput result = portFromInterface.get().getResult();
528 LOGGER.trace("getPortFromInterface rpc result is {} ", result);
529 if (result != null) {
530 LOGGER.trace("getPortFromInterface rpc result is {} {} ", result.getDpid(), result.getPortno());
535 private String getInterfaceName(NodeConnectorRef ref, Metadata metadata, DataBroker dataBroker2) throws Throwable {
536 LOGGER.debug("metadata received is {} ", metadata);
538 GetInterfaceFromIfIndexInputBuilder ifIndexInputBuilder = new GetInterfaceFromIfIndexInputBuilder();
539 BigInteger lportTag = MetaDataUtil.getLportFromMetadata(metadata.getMetadata());
541 ifIndexInputBuilder.setIfIndex(lportTag.intValue());
542 GetInterfaceFromIfIndexInput input = ifIndexInputBuilder.build();
543 OdlInterfaceRpcService intfRpc = getInterfaceRpcService();
545 Future<RpcResult<GetInterfaceFromIfIndexOutput>> interfaceFromIfIndex = intfRpc.getInterfaceFromIfIndex(input);
546 GetInterfaceFromIfIndexOutput interfaceFromIfIndexOutput = interfaceFromIfIndex.get().getResult();
547 return interfaceFromIfIndexOutput.getInterfaceName();
550 class MacResponderTask implements Runnable {
553 MacResponderTask(ARP arp) {
560 GetMacOutputBuilder outputBuilder;
562 SettableFuture<RpcResult<GetMacOutput>> future = null;
563 RpcResultBuilder<GetMacOutput> resultBuilder;
565 srcAddr = InetAddress.getByAddress(arp
566 .getSenderProtocolAddress());
567 srcMac = NWUtil.toStringMacAddress(arp
568 .getSenderHardwareAddress());
569 future = getMacFutures.remove(srcAddr.getHostAddress());
570 if (future == null) {
571 LOGGER.trace("There are no pending mac requests.");
574 outputBuilder = new GetMacOutputBuilder()
575 .setMacaddress(new PhysAddress(srcMac));
576 resultBuilder = RpcResultBuilder.success(outputBuilder.build());
577 if (LOGGER.isTraceEnabled()) {
578 LOGGER.trace("sent the mac response for ip {}",
579 srcAddr.getHostAddress());
581 } catch (Exception e) {
582 LOGGER.trace("failed to send mac response {} ", e);
583 resultBuilder = RpcResultBuilder.<GetMacOutput> failed()
584 .withError(ErrorType.APPLICATION, e.getMessage(), e);
586 future.set(resultBuilder.build());
590 private void fireArpRespRecvdNotification(String interfaceName,
591 InetAddress inetAddr, byte[] macAddressBytes, int tableId, BigInteger metadata)
592 throws InterruptedException {
594 IpAddress ip = new IpAddress(inetAddr.getHostAddress().toCharArray());
595 String macAddress = NWUtil.toStringMacAddress(macAddressBytes);
596 PhysAddress mac = new PhysAddress(macAddress);
597 ArpResponseReceivedBuilder builder = new ArpResponseReceivedBuilder();
598 builder.setInterface(interfaceName);
599 builder.setIpaddress(ip);
600 builder.setOfTableId((long) tableId);
601 builder.setMacaddress(mac);
602 builder.setMetadata(metadata);
603 notificationPublishService.putNotification(builder.build());
606 private void fireArpReqRecvdNotification(String interfaceName,
607 InetAddress srcInetAddr, byte[] srcMac, InetAddress dstInetAddr,
608 int tableId, BigInteger metadata) throws InterruptedException {
609 String macAddress = NWUtil.toStringMacAddress(srcMac);
610 ArpRequestReceivedBuilder builder = new ArpRequestReceivedBuilder();
611 builder.setInterface(interfaceName);
612 builder.setOfTableId((long) tableId);
613 builder.setSrcIpaddress(new IpAddress(srcInetAddr.getHostAddress()
615 builder.setDstIpaddress(new IpAddress(dstInetAddr.getHostAddress()
617 builder.setSrcMac(new PhysAddress(macAddress));
618 builder.setMetadata(metadata);
619 notificationPublishService.putNotification(builder.build());
622 private void checkAndFireMacChangedNotification(String interfaceName,
623 InetAddress inetAddr, byte[] macAddressBytes)
624 throws InterruptedException {
626 IpAddress ip = new IpAddress(inetAddr.getHostAddress().toCharArray());
627 String macAddress = NWUtil.toStringMacAddress(macAddressBytes);
628 PhysAddress mac = new PhysAddress(macAddress);
630 if (!macAddress.equals(macsDB.get(interfaceName + "-"
631 + inetAddr.getHostAddress()))) {
632 if (LOGGER.isTraceEnabled()) {
633 LOGGER.trace("mac address changed for " + inetAddr);
635 MacChangedBuilder builder = new MacChangedBuilder();
636 builder.setInterface(interfaceName);
637 builder.setIpaddress(ip);
638 builder.setMacaddress(mac);
639 notificationPublishService.putNotification(builder.build());
643 private InstanceIdentifier<Interface> buildInterfaceId(String interfaceName) {
644 InstanceIdentifierBuilder<Interface> idBuilder = InstanceIdentifier
645 .builder(Interfaces.class).child(Interface.class,
646 new InterfaceKey(interfaceName));
647 InstanceIdentifier<Interface> id = idBuilder.build();
651 private NodeConnectorId getNodeConnectorFromInterfaceName(String interfaceName) {
652 InstanceIdentifierBuilder<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> idBuilder =
653 InstanceIdentifier.builder(InterfacesState.class)
654 .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class,
655 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey(interfaceName));
656 InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateId = idBuilder.build();
658 Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateOptional = MDSALUtil.read(dataBroker,
659 LogicalDatastoreType.OPERATIONAL,
662 if (ifStateOptional.isPresent()) {
663 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState = ifStateOptional.get();
664 List<String> lowerLayerIf = ifState.getLowerLayerIf();
665 if (!lowerLayerIf.isEmpty()) {
666 return new NodeConnectorId(lowerLayerIf.get(0));