2 * Copyright (c) 2016, 2017 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
8 package org.opendaylight.genius.arputil.internal;
10 import static com.google.common.base.Preconditions.checkArgument;
11 import static com.google.common.base.Preconditions.checkNotNull;
12 import static java.util.Objects.requireNonNull;
13 import static org.opendaylight.mdsal.binding.util.Datastore.OPERATIONAL;
15 import com.google.common.util.concurrent.FutureCallback;
16 import com.google.common.util.concurrent.Futures;
17 import com.google.common.util.concurrent.ListenableFuture;
18 import com.google.common.util.concurrent.MoreExecutors;
19 import com.google.common.util.concurrent.SettableFuture;
20 import java.net.InetAddress;
21 import java.net.UnknownHostException;
22 import java.nio.charset.StandardCharsets;
23 import java.util.HashMap;
25 import java.util.concurrent.ConcurrentHashMap;
26 import java.util.concurrent.ConcurrentMap;
27 import java.util.concurrent.ExecutionException;
28 import java.util.concurrent.ExecutorService;
29 import java.util.concurrent.Future;
30 import javax.inject.Inject;
31 import javax.inject.Singleton;
32 import org.apache.aries.blueprint.annotation.service.Reference;
33 import org.opendaylight.genius.arputil.api.ArpConstants;
34 import org.opendaylight.genius.mdsalutil.MDSALUtil;
35 import org.opendaylight.genius.mdsalutil.MetaDataUtil;
36 import org.opendaylight.genius.mdsalutil.NWUtil;
37 import org.opendaylight.genius.mdsalutil.packet.ARP;
38 import org.opendaylight.genius.mdsalutil.packet.Ethernet;
39 import org.opendaylight.infrautils.inject.AbstractLifecycle;
40 import org.opendaylight.infrautils.metrics.Meter;
41 import org.opendaylight.infrautils.metrics.MetricProvider;
42 import org.opendaylight.infrautils.utils.concurrent.Executors;
43 import org.opendaylight.mdsal.binding.api.DataBroker;
44 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
45 import org.opendaylight.mdsal.binding.api.NotificationService;
46 import org.opendaylight.mdsal.binding.util.Datastore.Operational;
47 import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunner;
48 import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunnerImpl;
49 import org.opendaylight.openflowplugin.libraries.liblldp.HexEncode;
50 import org.opendaylight.openflowplugin.libraries.liblldp.Packet;
51 import org.opendaylight.openflowplugin.libraries.liblldp.PacketException;
52 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IetfInetUtil;
53 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
54 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
55 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.ArpRequestReceivedBuilder;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.ArpResponseReceivedBuilder;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.GetMacInput;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.GetMacOutput;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.GetMacOutputBuilder;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.MacChangedBuilder;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.OdlArputilService;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInput;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInputBuilder;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestOutput;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpResponseInput;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpResponseOutput;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.interfaces.InterfaceAddress;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceInputBuilder;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceOutput;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexInput;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexInputBuilder;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexOutput;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceInputBuilder;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceOutput;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
85 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
86 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
87 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Metadata;
88 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketInReason;
89 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingListener;
90 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
91 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
92 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.SendToController;
93 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInput;
94 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInputBuilder;
95 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketOutput;
96 import org.opendaylight.yangtools.concepts.ListenerRegistration;
97 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
98 import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
99 import org.opendaylight.yangtools.yang.common.RpcResult;
100 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
101 import org.opendaylight.yangtools.yang.common.Uint64;
102 import org.slf4j.Logger;
103 import org.slf4j.LoggerFactory;
106 public class ArpUtilImpl extends AbstractLifecycle implements OdlArputilService, PacketProcessingListener {
107 private static final Logger LOG = LoggerFactory.getLogger(ArpUtilImpl.class);
108 private static final String MODULENAME = "odl.genius.arputil.";
109 private static final String OPENFLOW_PFX = "openflow:";
111 private final ManagedNewTransactionRunner txRunner;
112 private final PacketProcessingService packetProcessingService;
113 private final NotificationPublishService notificationPublishService;
114 private final NotificationService notificationService;
115 private final OdlInterfaceRpcService odlInterfaceRpcService;
116 private ListenerRegistration<ArpUtilImpl> listenerRegistration;
117 private final ExecutorService threadPool = Executors.newFixedThreadPool(1, "ArpUtil", LOG);
118 private final ConcurrentMap<String, String> macsDB = new ConcurrentHashMap<>();
119 private final ConcurrentMap<String, SettableFuture<RpcResult<GetMacOutput>>> macAddrs = new ConcurrentHashMap<>();
121 private final Meter arpRespRecvd;
122 private final Meter arpRespRecvdNotification;
123 private final Meter arpRespRecvdNotificationRejected;
124 private final Meter arpReqRecvd;
125 private final Meter arpReqRecvdNotification;
126 private final Meter arpReqRecvdNotificationRejected;
130 public ArpUtilImpl(@Reference final DataBroker dataBroker,
131 final PacketProcessingService packetProcessingService,
132 @Reference final NotificationPublishService notificationPublishService,
133 @Reference final NotificationService notificationService,
134 final OdlInterfaceRpcService odlInterfaceRpcService,
135 @Reference final MetricProvider metricProvider) {
136 this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
137 this.packetProcessingService = packetProcessingService;
138 this.notificationPublishService = notificationPublishService;
139 this.notificationService = notificationService;
140 this.odlInterfaceRpcService = odlInterfaceRpcService;
142 arpRespRecvd = metricProvider.newMeter(this,MODULENAME + "arpResponseReceived");
143 arpRespRecvdNotification = metricProvider.newMeter(this,MODULENAME + "arpResponseReceivedNotification");
144 arpRespRecvdNotificationRejected = metricProvider.newMeter(this,
145 MODULENAME + "arpResponseReceivedNotificationRejected");
146 arpReqRecvd = metricProvider.newMeter(this,MODULENAME + "arpRequestReceived");
147 arpReqRecvdNotification = metricProvider.newMeter(this,MODULENAME + "arpRequestReceivedNotification");
148 arpReqRecvdNotificationRejected = metricProvider.newMeter(this,
149 MODULENAME + "arpRequestReceivedNotificationRejected");
153 public void start() {
154 LOG.info("{} start", getClass().getSimpleName());
155 listenerRegistration = notificationService.registerNotificationListener(this);
160 LOG.info("{} stop", getClass().getSimpleName());
162 if (listenerRegistration != null) {
163 listenerRegistration.close();
164 listenerRegistration = null;
168 private String getIpAddressInString(IpAddress ipAddress) throws UnknownHostException {
169 return InetAddress.getByName(ipAddress.getIpv4Address().getValue()).getHostAddress();
173 public ListenableFuture<RpcResult<GetMacOutput>> getMac(GetMacInput input) {
175 final String dstIpAddress = getIpAddressInString(input.getIpaddress());
176 LOG.trace("getMac rpc invoked for ip {}", dstIpAddress);
177 if (macAddrs.get(dstIpAddress) != null) {
178 if (LOG.isInfoEnabled()) {
179 LOG.info("get mac already in progress for the ip {}", dstIpAddress);
181 return macAddrs.get(dstIpAddress);
183 SendArpRequestInputBuilder builder = new SendArpRequestInputBuilder()
184 .setInterfaceAddress(input.getInterfaceAddress()).setIpaddress(input.getIpaddress());
185 ListenableFuture<RpcResult<SendArpRequestOutput>> arpReqFt = sendArpRequest(builder.build());
186 final SettableFuture<RpcResult<GetMacOutput>> ft = SettableFuture.create();
188 Futures.addCallback(arpReqFt, new FutureCallback<RpcResult<SendArpRequestOutput>>() {
190 public void onFailure(Throwable ex) {
191 RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder.<GetMacOutput>failed()
192 .withError(ErrorType.APPLICATION, ex.getMessage(), ex);
193 ft.set(resultBuilder.build());
197 public void onSuccess(RpcResult<SendArpRequestOutput> result) {
198 LOG.trace("Successfully sent the arp pkt out for ip {}", dstIpAddress);
200 }, MoreExecutors.directExecutor());
202 macAddrs.put(dstIpAddress, ft);
204 } catch (UnknownHostException e) {
205 LOG.error("Failed to handle getMac request for {}", input.getIpaddress(), e);
206 RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder.<GetMacOutput>failed()
207 .withError(ErrorType.APPLICATION, e.getMessage(), e);
208 return Futures.immediateFuture(resultBuilder.build());
212 private byte[] getIpAddressBytes(IpAddress ip) throws UnknownHostException {
213 return InetAddress.getByName(ip.getIpv4Address().getValue()).getAddress();
217 public ListenableFuture<RpcResult<SendArpRequestOutput>> sendArpRequest(SendArpRequestInput arpReqInput) {
218 LOG.trace("rpc sendArpRequest invoked for ip {}", arpReqInput.getIpaddress());
221 String interfaceName = null;
226 RpcResultBuilder<SendArpRequestOutput> failureBuilder = RpcResultBuilder.failed();
227 RpcResultBuilder<SendArpRequestOutput> successBuilder = RpcResultBuilder.success();
230 dstIpBytes = getIpAddressBytes(arpReqInput.getIpaddress());
231 } catch (UnknownHostException e) {
232 LOG.error("Cannot get IP address", e);
233 failureBuilder.withError(ErrorType.APPLICATION, ArpConstants.UNKNOWN_IP_ADDRESS_SUPPLIED);
234 return Futures.immediateFuture(failureBuilder.build());
237 int localErrorCount = 0;
238 for (InterfaceAddress interfaceAddress : arpReqInput.nonnullInterfaceAddress().values()) {
240 interfaceName = interfaceAddress.getInterface();
241 srcIpBytes = getIpAddressBytes(interfaceAddress.getIpAddress());
243 GetPortFromInterfaceOutput portResult = getPortFromInterface(interfaceName);
244 requireNonNull(portResult);
245 dpnId = portResult.getDpid();
246 Long portid = portResult.getPortno().toJava();
247 checkArgument(null != dpnId && !Uint64.ZERO.equals(dpnId),
248 ArpConstants.DPN_NOT_FOUND_ERROR, interfaceName);
250 NodeConnectorRef ref = MDSALUtil.getNodeConnRef(dpnId, portid.toString());
251 checkNotNull(ref, ArpConstants.NODE_CONNECTOR_NOT_FOUND_ERROR, interfaceName);
253 LOG.trace("sendArpRequest received dpnId {} out interface {}", dpnId, interfaceName);
254 if (interfaceAddress.getMacaddress() == null) {
255 srcMac = txRunner.<Operational, ExecutionException, byte[]>
256 applyInterruptiblyWithNewReadOnlyTransactionAndClose(OPERATIONAL,
257 tx -> tx.read((InstanceIdentifier<NodeConnector>) ref.getValue()).get()
258 .map(nc -> nc.augmentation(FlowCapableNodeConnector.class))
259 .map(FlowCapableNodeConnector::getHardwareAddress)
260 .map(MacAddress::getValue)
261 .map(HexEncode::bytesFromHexString)
264 String macAddr = interfaceAddress.getMacaddress().getValue();
265 srcMac = HexEncode.bytesFromHexString(macAddr);
267 checkNotNull(srcMac, ArpConstants.FAILED_TO_GET_SRC_MAC_FOR_INTERFACE, interfaceName, ref.getValue());
268 checkNotNull(srcIpBytes, ArpConstants.FAILED_TO_GET_SRC_IP_FOR_INTERFACE, interfaceName);
270 payload = ArpPacketUtil.getPayload(ArpConstants.ARP_REQUEST_OP, srcMac, srcIpBytes,
271 ArpPacketUtil.ETHERNET_BROADCAST_DESTINATION, dstIpBytes);
273 Map<ActionKey, Action> actions = getEgressAction(interfaceName);
274 sendPacketOutWithActions(dpnId, payload, ref, actions);
276 LOG.trace("sent arp request for {}", arpReqInput.getIpaddress());
277 } catch (UnknownHostException | PacketException | InterruptedException | ExecutionException e) {
278 LOG.trace("failed to send arp req for {} on interface {}", arpReqInput.getIpaddress(), interfaceName);
280 failureBuilder.withError(ErrorType.APPLICATION,
281 ArpConstants.FAILED_TO_SEND_ARP_REQ_FOR_INTERFACE + interfaceName, e);
282 successBuilder.withError(ErrorType.APPLICATION,
283 ArpConstants.FAILED_TO_SEND_ARP_REQ_FOR_INTERFACE + interfaceName, e);
287 if (localErrorCount == arpReqInput.getInterfaceAddress().size()) {
288 // All the requests failed
289 return Futures.immediateFuture(failureBuilder.build());
291 return Futures.immediateFuture(successBuilder.build());
294 public ListenableFuture<RpcResult<TransmitPacketOutput>> sendPacketOut(
295 Uint64 dpnId, byte[] payload, NodeConnectorRef ref) {
296 NodeConnectorRef nodeConnectorRef = MDSALUtil.getNodeConnRef(dpnId, "0xfffffffd");
297 return packetProcessingService.transmitPacket(new TransmitPacketInputBuilder().setPayload(payload)
298 .setNode(new NodeRef(InstanceIdentifier.builder(Nodes.class)
299 .child(Node.class, new NodeKey(new NodeId(OPENFLOW_PFX + dpnId))).build()))
300 .setIngress(nodeConnectorRef).setEgress(ref).build());
303 private Future<RpcResult<TransmitPacketOutput>> sendPacketOutWithActions(
304 Uint64 dpnId, byte[] payload, NodeConnectorRef ref, Map<ActionKey, Action> actions) {
305 NodeConnectorRef nodeConnectorRef = MDSALUtil.getNodeConnRef(dpnId, "0xfffffffd");
306 TransmitPacketInput transmitPacketInput = new TransmitPacketInputBuilder().setPayload(payload)
307 .setNode(new NodeRef(InstanceIdentifier.builder(Nodes.class)
308 .child(Node.class, new NodeKey(new NodeId(OPENFLOW_PFX + dpnId))).build()))
309 .setIngress(nodeConnectorRef).setEgress(ref).setAction(actions).build();
310 LOG.trace("PacketOut message framed for transmitting {}", transmitPacketInput);
311 return packetProcessingService.transmitPacket(transmitPacketInput);
314 private Map<ActionKey, Action> getEgressAction(String interfaceName) {
315 Map<ActionKey, Action> actions = new HashMap<>();
317 GetEgressActionsForInterfaceInputBuilder egressAction = new GetEgressActionsForInterfaceInputBuilder()
318 .setIntfName(interfaceName);
319 OdlInterfaceRpcService intfRpc = odlInterfaceRpcService;
320 if (intfRpc == null) {
321 LOG.error("Unable to obtain interfaceMgrRpc service, ignoring egress actions for interfaceName {}",
325 Future<RpcResult<GetEgressActionsForInterfaceOutput>> result = intfRpc
326 .getEgressActionsForInterface(egressAction.build());
327 RpcResult<GetEgressActionsForInterfaceOutput> rpcResult = result.get();
328 if (!rpcResult.isSuccessful()) {
329 LOG.warn("RPC Call to Get egress actions for interface {} returned with Errors {}", interfaceName,
330 rpcResult.getErrors());
332 actions = rpcResult.getResult().getAction();
334 } catch (InterruptedException | ExecutionException e) {
335 LOG.error("Exception when egress actions for interface {}", interfaceName, e);
341 public ListenableFuture<RpcResult<SendArpResponseOutput>> sendArpResponse(SendArpResponseInput input) {
342 LOG.trace("sendArpResponse rpc invoked");
348 String interfaceName = input.getInterface();
349 GetPortFromInterfaceOutput portResult = getPortFromInterface(interfaceName);
350 requireNonNull(portResult);
351 dpnId = portResult.getDpid();
352 Long portid = portResult.getPortno().toJava();
353 NodeConnectorRef ref = MDSALUtil.getNodeConnRef(dpnId, portid.toString());
354 checkArgument(null != dpnId && !Uint64.ZERO.equals(dpnId),
355 ArpConstants.DPN_NOT_FOUND_ERROR, interfaceName);
356 checkNotNull(ref, ArpConstants.NODE_CONNECTOR_NOT_FOUND_ERROR, interfaceName);
358 LOG.trace("sendArpRequest received dpnId {} out interface {}", dpnId, interfaceName);
360 byte[] srcIpBytes = getIpAddressBytes(input.getSrcIpaddress());
361 byte[] dstIpBytes = getIpAddressBytes(input.getDstIpaddress());
362 if (input.getSrcMacaddress() == null) {
363 srcMac = portResult.getPhyAddress().getBytes(StandardCharsets.UTF_8);
365 String macAddr = input.getSrcMacaddress().getValue();
366 srcMac = HexEncode.bytesFromHexString(macAddr);
368 byte[] dstMac = NWUtil.parseMacAddress(input.getDstMacaddress().getValue());
369 checkNotNull(srcIpBytes, ArpConstants.FAILED_TO_GET_SRC_IP_FOR_INTERFACE, interfaceName);
370 payload = ArpPacketUtil.getPayload(ArpConstants.ARP_RESPONSE_OP, srcMac, srcIpBytes, dstMac, dstIpBytes);
372 Map<ActionKey, Action> actions = getEgressAction(interfaceName);
373 sendPacketOutWithActions(dpnId, payload, ref, actions);
374 LOG.debug("Sent ARP response for IP {}, from source MAC {} to target MAC {} and target IP {} via dpnId {}",
375 input.getSrcIpaddress().getIpv4Address().getValue(), HexEncode.bytesToHexStringFormat(srcMac),
376 HexEncode.bytesToHexStringFormat(dstMac), input.getDstIpaddress().getIpv4Address().getValue(),
378 } catch (UnknownHostException | PacketException | InterruptedException | ExecutionException e) {
379 LOG.error("failed to send arp response for {}: ", input.getSrcIpaddress(), e);
380 return RpcResultBuilder.<SendArpResponseOutput>failed()
381 .withError(ErrorType.APPLICATION, e.getMessage(), e).buildFuture();
383 RpcResultBuilder<SendArpResponseOutput> rpcResultBuilder = RpcResultBuilder.success();
384 return Futures.immediateFuture(rpcResultBuilder.build());
388 public void onPacketReceived(PacketReceived packetReceived) {
389 Class<? extends PacketInReason> pktInReason = packetReceived.getPacketInReason();
390 LOG.trace("Packet Received {}", packetReceived);
392 if (pktInReason == SendToController.class) {
394 Uint64 dpnId = extractDpnId(packetReceived);
395 int tableId = packetReceived.getTableId().getValue().toJava();
397 byte[] data = packetReceived.getPayload();
398 Ethernet ethernet = new Ethernet();
400 ethernet.deserialize(data, 0, data.length * Byte.SIZE);
401 if (ethernet.getEtherType() != ArpConstants.ETH_TYPE_ARP) {
405 Packet pkt = ethernet.getPayload();
407 InetAddress srcInetAddr = InetAddress.getByAddress(arp.getSenderProtocolAddress());
408 InetAddress dstInetAddr = InetAddress.getByAddress(arp.getTargetProtocolAddress());
409 byte[] srcMac = ethernet.getSourceMACAddress();
410 byte[] dstMac = ethernet.getDestinationMACAddress();
412 Metadata metadata = packetReceived.getMatch().getMetadata();
414 String interfaceName = getInterfaceName(metadata);
416 checkAndFireMacChangedNotification(interfaceName, srcInetAddr, srcMac);
417 macsDB.put(interfaceName + "-" + srcInetAddr.getHostAddress(), NWUtil.toStringMacAddress(srcMac));
418 if (arp.getOpCode() == ArpConstants.ARP_REQUEST_OP) {
419 fireArpReqRecvdNotification(interfaceName, srcInetAddr, srcMac, dstInetAddr, dpnId, tableId,
420 metadata.getMetadata());
422 fireArpRespRecvdNotification(interfaceName, srcInetAddr, srcMac, dpnId, tableId,
423 metadata.getMetadata(), dstInetAddr, dstMac);
425 if (macAddrs.get(srcInetAddr.getHostAddress()) != null) {
426 threadPool.execute(new MacResponderTask(arp));
428 } catch (PacketException | UnknownHostException | InterruptedException | ExecutionException e) {
429 LOG.trace("Failed to decode packet", e);
434 private GetPortFromInterfaceOutput getPortFromInterface(String interfaceName)
435 throws InterruptedException, ExecutionException {
436 GetPortFromInterfaceInputBuilder getPortFromInterfaceInputBuilder = new GetPortFromInterfaceInputBuilder();
437 getPortFromInterfaceInputBuilder.setIntfName(interfaceName);
439 Future<RpcResult<GetPortFromInterfaceOutput>> portFromInterface = odlInterfaceRpcService
440 .getPortFromInterface(getPortFromInterfaceInputBuilder.build());
441 GetPortFromInterfaceOutput result = portFromInterface.get().getResult();
442 LOG.trace("getPortFromInterface rpc result is {} ", result);
443 if (result != null) {
444 LOG.trace("getPortFromInterface rpc result is {} {} ", result.getDpid(), result.getPortno());
449 private String getInterfaceName(Metadata metadata)
450 throws InterruptedException, ExecutionException {
451 LOG.debug("metadata received is {} ", metadata);
453 GetInterfaceFromIfIndexInputBuilder ifIndexInputBuilder = new GetInterfaceFromIfIndexInputBuilder();
454 Uint64 lportTag = MetaDataUtil.getLportFromMetadata(metadata.getMetadata());
456 ifIndexInputBuilder.setIfIndex(lportTag.intValue());
457 GetInterfaceFromIfIndexInput input = ifIndexInputBuilder.build();
459 Future<RpcResult<GetInterfaceFromIfIndexOutput>> interfaceFromIfIndex = odlInterfaceRpcService
460 .getInterfaceFromIfIndex(input);
461 if (interfaceFromIfIndex.get().isSuccessful()) {
462 GetInterfaceFromIfIndexOutput interfaceFromIfIndexOutput = interfaceFromIfIndex.get().getResult();
463 return interfaceFromIfIndexOutput.getInterfaceName();
465 LOG.error("RPC call to get interface name for if index {} failed with errors {}", lportTag,
466 interfaceFromIfIndex.get().getErrors());
471 private class MacResponderTask implements Runnable {
474 MacResponderTask(ARP arp) {
481 GetMacOutputBuilder outputBuilder;
484 srcAddr = InetAddress.getByAddress(arp.getSenderProtocolAddress());
485 srcMac = NWUtil.toStringMacAddress(arp.getSenderHardwareAddress());
486 SettableFuture<RpcResult<GetMacOutput>> future = macAddrs.remove(srcAddr.getHostAddress());
487 if (future == null) {
488 LOG.trace("There are no pending mac requests.");
491 outputBuilder = new GetMacOutputBuilder().setMacaddress(new PhysAddress(srcMac));
492 future.set(RpcResultBuilder.success(outputBuilder.build()).build());
493 if (LOG.isTraceEnabled()) {
494 LOG.trace("sent the mac response for ip {}", srcAddr.getHostAddress());
496 } catch (UnknownHostException e) {
497 LOG.error("failed to send mac response", e);
502 private void fireArpRespRecvdNotification(String interfaceName, InetAddress srcInetAddr, byte[] srcMacAddressBytes,
503 Uint64 dpnId, int tableId, Uint64 metadata, InetAddress dstInetAddr, byte[] dstMacAddressBytes)
504 throws InterruptedException {
507 IpAddress srcIp = IetfInetUtil.INSTANCE.ipAddressFor(srcInetAddr);
508 IpAddress dstIp = IetfInetUtil.INSTANCE.ipAddressFor(dstInetAddr);
509 String srcMacAddress = NWUtil.toStringMacAddress(srcMacAddressBytes);
510 PhysAddress srcMac = new PhysAddress(srcMacAddress);
511 String dstMacAddress = NWUtil.toStringMacAddress(dstMacAddressBytes);
512 PhysAddress dstMac = new PhysAddress(dstMacAddress);
513 ArpResponseReceivedBuilder builder = new ArpResponseReceivedBuilder();
514 builder.setInterface(interfaceName);
515 builder.setSrcIpaddress(srcIp);
516 builder.setDpnId(dpnId);
517 builder.setOfTableId((long) tableId);
518 builder.setSrcMac(srcMac);
519 builder.setMetadata(metadata);
520 builder.setDstIpaddress(dstIp);
521 builder.setDstMac(dstMac);
522 ListenableFuture<?> offerNotification = notificationPublishService.offerNotification(builder.build());
523 if (offerNotification != null && offerNotification.equals(NotificationPublishService.REJECTED)) {
524 arpRespRecvdNotificationRejected.mark();
527 arpRespRecvdNotification.mark();
531 private void fireArpReqRecvdNotification(String interfaceName, InetAddress srcInetAddr, byte[] srcMac,
532 InetAddress dstInetAddr, Uint64 dpnId, int tableId, Uint64 metadata) throws InterruptedException {
534 String macAddress = NWUtil.toStringMacAddress(srcMac);
535 ArpRequestReceivedBuilder builder = new ArpRequestReceivedBuilder();
536 builder.setInterface(interfaceName);
537 builder.setDpnId(dpnId);
538 builder.setOfTableId((long) tableId);
539 builder.setSrcIpaddress(IetfInetUtil.INSTANCE.ipAddressFor(srcInetAddr));
540 builder.setDstIpaddress(IetfInetUtil.INSTANCE.ipAddressFor(dstInetAddr));
541 builder.setSrcMac(new PhysAddress(macAddress));
542 builder.setMetadata(metadata);
543 ListenableFuture<?> offerNotification = notificationPublishService.offerNotification(builder.build());
544 if (offerNotification != null && offerNotification.equals(NotificationPublishService.REJECTED)) {
545 arpReqRecvdNotificationRejected.mark();
547 arpReqRecvdNotification.mark();
551 private void checkAndFireMacChangedNotification(String interfaceName, InetAddress inetAddr, byte[] macAddressBytes)
552 throws InterruptedException {
554 IpAddress ip = IetfInetUtil.INSTANCE.ipAddressFor(inetAddr);
555 String macAddress = NWUtil.toStringMacAddress(macAddressBytes);
556 PhysAddress mac = new PhysAddress(macAddress);
558 if (!macAddress.equals(macsDB.get(interfaceName + "-" + inetAddr.getHostAddress()))) {
559 if (LOG.isTraceEnabled()) {
560 LOG.trace("mac address changed for {}", inetAddr);
562 MacChangedBuilder builder = new MacChangedBuilder();
563 builder.setInterface(interfaceName);
564 builder.setIpaddress(ip);
565 builder.setMacaddress(mac);
566 notificationPublishService.putNotification(builder.build());
570 private Uint64 extractDpnId(PacketReceived packetReceived) {
571 NodeKey nodeKey = packetReceived.getIngress().getValue().firstKeyOf(Node.class);
572 String nodeKeyString = nodeKey.getId().getValue();
574 if (!nodeKeyString.startsWith(OPENFLOW_PFX)) {
575 LOG.warn("Could not extract DPN for packet-in, doesn't start with 'openflow:' {}", packetReceived);
579 return Uint64.valueOf(nodeKeyString.substring(OPENFLOW_PFX.length()));