Performacne improvements via adding a netty-based openflowj and openflow plugin;...
[controller.git] / opendaylight / protocol_plugins / openflow_netty / src / main / java / org / opendaylight / controller / protocol_plugin / openflow / internal / FlowConverter.java
diff --git a/opendaylight/protocol_plugins/openflow_netty/src/main/java/org/opendaylight/controller/protocol_plugin/openflow/internal/FlowConverter.java b/opendaylight/protocol_plugins/openflow_netty/src/main/java/org/opendaylight/controller/protocol_plugin/openflow/internal/FlowConverter.java
new file mode 100644 (file)
index 0000000..7af9ff3
--- /dev/null
@@ -0,0 +1,734 @@
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.controller.protocol_plugin.openflow.internal;
+
+import java.math.BigInteger;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.List;
+
+
+import org.opendaylight.controller.protocol_plugin.openflow.vendorextension.v6extension.V6FlowMod;
+import org.opendaylight.controller.protocol_plugin.openflow.vendorextension.v6extension.V6Match;
+import org.opendaylight.controller.sal.action.Action;
+import org.opendaylight.controller.sal.action.ActionType;
+import org.opendaylight.controller.sal.action.Controller;
+import org.opendaylight.controller.sal.action.Drop;
+import org.opendaylight.controller.sal.action.Flood;
+import org.opendaylight.controller.sal.action.FloodAll;
+import org.opendaylight.controller.sal.action.HwPath;
+import org.opendaylight.controller.sal.action.Loopback;
+import org.opendaylight.controller.sal.action.Output;
+import org.opendaylight.controller.sal.action.PopVlan;
+import org.opendaylight.controller.sal.action.SetDlDst;
+import org.opendaylight.controller.sal.action.SetDlSrc;
+import org.opendaylight.controller.sal.action.SetNwDst;
+import org.opendaylight.controller.sal.action.SetNwSrc;
+import org.opendaylight.controller.sal.action.SetNwTos;
+import org.opendaylight.controller.sal.action.SetTpDst;
+import org.opendaylight.controller.sal.action.SetTpSrc;
+import org.opendaylight.controller.sal.action.SetVlanId;
+import org.opendaylight.controller.sal.action.SetVlanPcp;
+import org.opendaylight.controller.sal.action.SwPath;
+import org.opendaylight.controller.sal.core.Node;
+import org.opendaylight.controller.sal.core.NodeConnector;
+import org.opendaylight.controller.sal.flowprogrammer.Flow;
+import org.opendaylight.controller.sal.match.Match;
+import org.opendaylight.controller.sal.match.MatchField;
+import org.opendaylight.controller.sal.match.MatchType;
+import org.opendaylight.controller.sal.utils.NetUtils;
+import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
+import org.openflow.protocol.OFFlowMod;
+import org.openflow.protocol.OFMatch;
+import org.openflow.protocol.OFMessage;
+import org.openflow.protocol.OFPacketOut;
+import org.openflow.protocol.OFPort;
+import org.openflow.protocol.OFVendor;
+import org.openflow.protocol.action.OFAction;
+import org.openflow.protocol.action.OFActionDataLayerDestination;
+import org.openflow.protocol.action.OFActionDataLayerSource;
+import org.openflow.protocol.action.OFActionNetworkLayerAddress;
+import org.openflow.protocol.action.OFActionNetworkLayerDestination;
+import org.openflow.protocol.action.OFActionNetworkLayerSource;
+import org.openflow.protocol.action.OFActionNetworkTypeOfService;
+import org.openflow.protocol.action.OFActionOutput;
+import org.openflow.protocol.action.OFActionStripVirtualLan;
+import org.openflow.protocol.action.OFActionTransportLayer;
+import org.openflow.protocol.action.OFActionTransportLayerDestination;
+import org.openflow.protocol.action.OFActionTransportLayerSource;
+import org.openflow.protocol.action.OFActionVirtualLanIdentifier;
+import org.openflow.protocol.action.OFActionVirtualLanPriorityCodePoint;
+import org.openflow.util.U16;
+import org.openflow.util.U32;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Utility class for converting a SAL Flow into the OF flow and vice-versa
+ */
+public class FlowConverter {
+    protected static final Logger logger = LoggerFactory
+            .getLogger(FlowConverter.class);
+    private Flow flow; // SAL Flow
+    private OFMatch ofMatch; // OF 1.0 match or OF 1.0 + IPv6 extension match
+    private List<OFAction> actionsList; // OF 1.0 actions
+    private int actionsLength;
+    private boolean isIPv6;
+
+    public FlowConverter(OFMatch ofMatch, List<OFAction> actionsList) {
+        this.ofMatch = ofMatch;
+        this.actionsList = actionsList;
+        this.actionsLength = 0;
+        this.flow = null;
+        this.isIPv6 = ofMatch instanceof V6Match;
+    }
+
+    public FlowConverter(Flow flow) {
+        this.ofMatch = null;
+        this.actionsList = null;
+        this.actionsLength = 0;
+        this.flow = flow;
+        this.isIPv6 = flow.isIPv6();
+    }
+
+    /**
+     * Returns the match in OF 1.0 (OFMatch) form or OF 1.0 + IPv6 extensions
+     * form (V6Match)
+     *
+     * @return
+     */
+    public OFMatch getOFMatch() {
+        if (ofMatch == null) {
+            Match match = flow.getMatch();
+            ofMatch = (isIPv6) ? new V6Match() : new OFMatch();
+
+            int wildcards = OFMatch.OFPFW_ALL;
+            if (match.isPresent(MatchType.IN_PORT)) {
+                short port = (Short) ((NodeConnector) match.getField(
+                        MatchType.IN_PORT).getValue()).getID();
+                if (!isIPv6) {
+                    ofMatch.setInputPort(port);
+                    wildcards &= ~OFMatch.OFPFW_IN_PORT;
+                } else {
+                    ((V6Match) ofMatch).setInputPort(port, (short) 0);
+                }
+            }
+            if (match.isPresent(MatchType.DL_SRC)) {
+                byte[] srcMac = (byte[]) match.getField(MatchType.DL_SRC)
+                        .getValue();
+                if (!isIPv6) {
+                    ofMatch.setDataLayerSource(srcMac.clone());
+                    wildcards &= ~OFMatch.OFPFW_DL_SRC;
+                } else {
+                    ((V6Match) ofMatch).setDataLayerSource(srcMac, null);
+                }
+            }
+            if (match.isPresent(MatchType.DL_DST)) {
+                byte[] dstMac = (byte[]) match.getField(MatchType.DL_DST)
+                        .getValue();
+                if (!isIPv6) {
+                    ofMatch.setDataLayerDestination(dstMac.clone());
+                    wildcards &= ~OFMatch.OFPFW_DL_DST;
+                } else {
+                    ((V6Match) ofMatch).setDataLayerDestination(dstMac, null);
+                }
+            }
+            if (match.isPresent(MatchType.DL_VLAN)) {
+                short vlan = (Short) match.getField(MatchType.DL_VLAN)
+                        .getValue();
+                if (!isIPv6) {
+                    ofMatch.setDataLayerVirtualLan(vlan);
+                    wildcards &= ~OFMatch.OFPFW_DL_VLAN;
+                } else {
+                    ((V6Match) ofMatch).setDataLayerVirtualLan(vlan, (short) 0);
+                }
+            }
+            if (match.isPresent(MatchType.DL_VLAN_PR)) {
+                byte vlanPr = (Byte) match.getField(MatchType.DL_VLAN_PR)
+                        .getValue();
+                if (!isIPv6) {
+                    ofMatch.setDataLayerVirtualLanPriorityCodePoint(vlanPr);
+                    wildcards &= ~OFMatch.OFPFW_DL_VLAN_PCP;
+                } else {
+                    ((V6Match) ofMatch)
+                            .setDataLayerVirtualLanPriorityCodePoint(vlanPr,
+                                    (byte) 0);
+                }
+            }
+            if (match.isPresent(MatchType.DL_TYPE)) {
+                short ethType = (Short) match.getField(MatchType.DL_TYPE)
+                        .getValue();
+                if (!isIPv6) {
+                    ofMatch.setDataLayerType(ethType);
+                    wildcards &= ~OFMatch.OFPFW_DL_TYPE;
+                } else {
+                    ((V6Match) ofMatch).setDataLayerType(ethType, (short) 0);
+                }
+            }
+            if (match.isPresent(MatchType.NW_TOS)) {
+                /*
+                 * OF 1.0 switch expects the TOS as the 6 msb in the byte. it is
+                 * actually the DSCP field followed by a zero ECN
+                 */
+                byte tos = (Byte) match.getField(MatchType.NW_TOS).getValue();
+                byte dscp = (byte) ((int) tos << 2);
+                if (!isIPv6) {
+                    ofMatch.setNetworkTypeOfService(dscp);
+                    wildcards &= ~OFMatch.OFPFW_NW_TOS;
+                } else {
+                    ((V6Match) ofMatch).setNetworkTypeOfService(dscp, (byte) 0);
+                }
+            }
+            if (match.isPresent(MatchType.NW_PROTO)) {
+                byte proto = (Byte) match.getField(MatchType.NW_PROTO)
+                        .getValue();
+                if (!isIPv6) {
+                    ofMatch.setNetworkProtocol(proto);
+                    wildcards &= ~OFMatch.OFPFW_NW_PROTO;
+                } else {
+                    ((V6Match) ofMatch).setNetworkProtocol(proto, (byte) 0);
+                }
+            }
+            if (match.isPresent(MatchType.NW_SRC)) {
+                InetAddress address = (InetAddress) match.getField(
+                        MatchType.NW_SRC).getValue();
+                InetAddress mask = (InetAddress) match.getField(
+                        MatchType.NW_SRC).getMask();
+                if (!isIPv6) {
+                    ofMatch.setNetworkSource(NetUtils.byteArray4ToInt(address
+                            .getAddress()));
+                    int maskLength = NetUtils
+                            .getSubnetMaskLength((mask == null) ? null : mask
+                                    .getAddress());
+                    wildcards = (wildcards & ~OFMatch.OFPFW_NW_SRC_MASK)
+                            | (maskLength << OFMatch.OFPFW_NW_SRC_SHIFT);
+                } else {
+                    ((V6Match) ofMatch).setNetworkSource(address, mask);
+                }
+            }
+            if (match.isPresent(MatchType.NW_DST)) {
+                InetAddress address = (InetAddress) match.getField(
+                        MatchType.NW_DST).getValue();
+                InetAddress mask = (InetAddress) match.getField(
+                        MatchType.NW_DST).getMask();
+                if (!isIPv6) {
+                    ofMatch.setNetworkDestination(NetUtils
+                            .byteArray4ToInt(address.getAddress()));
+                    int maskLength = NetUtils
+                            .getSubnetMaskLength((mask == null) ? null : mask
+                                    .getAddress());
+                    wildcards = (wildcards & ~OFMatch.OFPFW_NW_DST_MASK)
+                            | (maskLength << OFMatch.OFPFW_NW_DST_SHIFT);
+                } else {
+                    ((V6Match) ofMatch).setNetworkDestination(address, mask);
+                }
+            }
+            if (match.isPresent(MatchType.TP_SRC)) {
+                short port = (Short) match.getField(MatchType.TP_SRC)
+                        .getValue();
+                if (!isIPv6) {
+                    ofMatch.setTransportSource(port);
+                    wildcards &= ~OFMatch.OFPFW_TP_SRC;
+                } else {
+                    ((V6Match) ofMatch).setTransportSource(port, (short) 0);
+                }
+            }
+            if (match.isPresent(MatchType.TP_DST)) {
+                short port = (Short) match.getField(MatchType.TP_DST)
+                        .getValue();
+                if (!isIPv6) {
+                    ofMatch.setTransportDestination(port);
+                    wildcards &= ~OFMatch.OFPFW_TP_DST;
+                } else {
+                    ((V6Match) ofMatch)
+                            .setTransportDestination(port, (short) 0);
+                }
+            }
+
+            if (!isIPv6) {
+                ofMatch.setWildcards(U32.t(Long.valueOf(wildcards)));
+            }
+        }
+        logger.trace("SAL Match: {} Openflow Match: {}", flow.getMatch(),
+                ofMatch);
+        return ofMatch;
+    }
+
+    /**
+     * Returns the list of actions in OF 1.0 form
+     *
+     * @return
+     */
+    public List<OFAction> getOFActions() {
+        if (this.actionsList == null) {
+            actionsList = new ArrayList<OFAction>();
+            for (Action action : flow.getActions()) {
+                if (action.getType() == ActionType.OUTPUT) {
+                    Output a = (Output) action;
+                    OFActionOutput ofAction = new OFActionOutput();
+                    ofAction.setMaxLength((short) 0xffff);
+                    ofAction.setPort(PortConverter.toOFPort(a.getPort()));
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionOutput.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.DROP) {
+                    continue;
+                }
+                if (action.getType() == ActionType.LOOPBACK) {
+                    OFActionOutput ofAction = new OFActionOutput();
+                    ofAction.setPort(OFPort.OFPP_IN_PORT.getValue());
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionOutput.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.FLOOD) {
+                    OFActionOutput ofAction = new OFActionOutput();
+                    ofAction.setPort(OFPort.OFPP_FLOOD.getValue());
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionOutput.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.FLOOD_ALL) {
+                    OFActionOutput ofAction = new OFActionOutput();
+                    ofAction.setPort(OFPort.OFPP_ALL.getValue());
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionOutput.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.CONTROLLER) {
+                    OFActionOutput ofAction = new OFActionOutput();
+                    ofAction.setPort(OFPort.OFPP_CONTROLLER.getValue());
+                    // We want the whole frame hitting the match be sent to the
+                    // controller
+                    ofAction.setMaxLength((short) 0xffff);
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionOutput.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.SW_PATH) {
+                    OFActionOutput ofAction = new OFActionOutput();
+                    ofAction.setPort(OFPort.OFPP_LOCAL.getValue());
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionOutput.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.HW_PATH) {
+                    OFActionOutput ofAction = new OFActionOutput();
+                    ofAction.setPort(OFPort.OFPP_NORMAL.getValue());
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionOutput.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.SET_VLAN_ID) {
+                    SetVlanId a = (SetVlanId) action;
+                    OFActionVirtualLanIdentifier ofAction = new OFActionVirtualLanIdentifier();
+                    ofAction.setVirtualLanIdentifier((short) a.getVlanId());
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionVirtualLanIdentifier.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.SET_VLAN_PCP) {
+                    SetVlanPcp a = (SetVlanPcp) action;
+                    OFActionVirtualLanPriorityCodePoint ofAction = new OFActionVirtualLanPriorityCodePoint();
+                    ofAction.setVirtualLanPriorityCodePoint(Integer.valueOf(
+                            a.getPcp()).byteValue());
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionVirtualLanPriorityCodePoint.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.POP_VLAN) {
+                    OFActionStripVirtualLan ofAction = new OFActionStripVirtualLan();
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionStripVirtualLan.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.SET_DL_SRC) {
+                    SetDlSrc a = (SetDlSrc) action;
+                    OFActionDataLayerSource ofAction = new OFActionDataLayerSource();
+                    ofAction.setDataLayerAddress(a.getDlAddress());
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionDataLayerSource.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.SET_DL_DST) {
+                    SetDlDst a = (SetDlDst) action;
+                    OFActionDataLayerDestination ofAction = new OFActionDataLayerDestination();
+                    ofAction.setDataLayerAddress(a.getDlAddress());
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionDataLayerDestination.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.SET_NW_SRC) {
+                    SetNwSrc a = (SetNwSrc) action;
+                    OFActionNetworkLayerSource ofAction = new OFActionNetworkLayerSource();
+                    ofAction.setNetworkAddress(NetUtils.byteArray4ToInt(a
+                            .getAddress().getAddress()));
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionNetworkLayerAddress.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.SET_NW_DST) {
+                    SetNwDst a = (SetNwDst) action;
+                    OFActionNetworkLayerDestination ofAction = new OFActionNetworkLayerDestination();
+                    ofAction.setNetworkAddress(NetUtils.byteArray4ToInt(a
+                            .getAddress().getAddress()));
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionNetworkLayerAddress.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.SET_NW_TOS) {
+                    SetNwTos a = (SetNwTos) action;
+                    OFActionNetworkTypeOfService ofAction = new OFActionNetworkTypeOfService();
+                    ofAction.setNetworkTypeOfService(Integer.valueOf(
+                            a.getNwTos()).byteValue());
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionNetworkTypeOfService.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.SET_TP_SRC) {
+                    SetTpSrc a = (SetTpSrc) action;
+                    OFActionTransportLayerSource ofAction = new OFActionTransportLayerSource();
+                    ofAction.setTransportPort(Integer.valueOf(a.getPort())
+                            .shortValue());
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionTransportLayer.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.SET_TP_DST) {
+                    SetTpDst a = (SetTpDst) action;
+                    OFActionTransportLayerDestination ofAction = new OFActionTransportLayerDestination();
+                    ofAction.setTransportPort(Integer.valueOf(a.getPort())
+                            .shortValue());
+                    actionsList.add(ofAction);
+                    actionsLength += OFActionTransportLayer.MINIMUM_LENGTH;
+                    continue;
+                }
+                if (action.getType() == ActionType.SET_NEXT_HOP) {
+                    // TODO
+                    continue;
+                }
+            }
+        }
+        logger.trace("SAL Actions: {} Openflow Actions: {}", flow.getActions(),
+                actionsList);
+        return actionsList;
+    }
+
+    /**
+     * Utility to convert a SAL flow to an OF 1.0 (OFFlowMod) or to an OF 1.0 +
+     * IPv6 extension (V6FlowMod) Flow modifier Message
+     *
+     * @param sw
+     * @param command
+     * @param port
+     * @return
+     */
+    public OFMessage getOFFlowMod(short command, OFPort port) {
+        OFMessage fm = (isIPv6) ? new V6FlowMod() : new OFFlowMod();
+        if (this.ofMatch == null) {
+            getOFMatch();
+        }
+        if (this.actionsList == null) {
+            getOFActions();
+        }
+        if (!isIPv6) {
+            ((OFFlowMod) fm).setMatch(this.ofMatch);
+            ((OFFlowMod) fm).setActions(this.actionsList);
+            ((OFFlowMod) fm).setPriority(flow.getPriority());
+            ((OFFlowMod) fm).setCookie(flow.getId());
+            ((OFFlowMod) fm).setBufferId(OFPacketOut.BUFFER_ID_NONE);
+            ((OFFlowMod) fm).setLength(U16.t(OFFlowMod.MINIMUM_LENGTH
+                    + actionsLength));
+            ((OFFlowMod) fm).setIdleTimeout(flow.getIdleTimeout());
+            ((OFFlowMod) fm).setHardTimeout(flow.getHardTimeout());
+            ((OFFlowMod) fm).setCommand(command);
+            if (port != null) {
+                ((OFFlowMod) fm).setOutPort(port);
+            }
+            if (command == OFFlowMod.OFPFC_ADD
+                    || command == OFFlowMod.OFPFC_MODIFY
+                    || command == OFFlowMod.OFPFC_MODIFY_STRICT) {
+                if (flow.getIdleTimeout() != 0 || flow.getHardTimeout() != 0) {
+                    // Instruct switch to let controller know when flow expires
+                    ((OFFlowMod) fm).setFlags((short) 1);
+                }
+            }
+        } else {
+            ((V6FlowMod) fm).setVendor();
+            ((V6FlowMod) fm).setMatch((V6Match) ofMatch);
+            ((V6FlowMod) fm).setActions(this.actionsList);
+            ((V6FlowMod) fm).setPriority(flow.getPriority());
+            ((V6FlowMod) fm).setCookie(flow.getId());
+            ((V6FlowMod) fm).setLength(U16.t(OFVendor.MINIMUM_LENGTH
+                    + ((V6Match) ofMatch).getIPv6ExtMinHdrLen()
+                    + ((V6Match) ofMatch).getIPv6MatchLen()
+                    + ((V6Match) ofMatch).getPadSize() + actionsLength));
+            ((V6FlowMod) fm).setIdleTimeout(flow.getIdleTimeout());
+            ((V6FlowMod) fm).setHardTimeout(flow.getHardTimeout());
+            ((V6FlowMod) fm).setCommand(command);
+            if (port != null) {
+                ((V6FlowMod) fm).setOutPort(port);
+            }
+            if (command == OFFlowMod.OFPFC_ADD
+                    || command == OFFlowMod.OFPFC_MODIFY
+                    || command == OFFlowMod.OFPFC_MODIFY_STRICT) {
+                if (flow.getIdleTimeout() != 0 || flow.getHardTimeout() != 0) {
+                    // Instruct switch to let controller know when flow expires
+                    ((V6FlowMod) fm).setFlags((short) 1);
+                }
+            }
+        }
+        logger.trace("Openflow Match: {} Openflow Actions: {}", ofMatch,
+                actionsList);
+        logger.trace("Openflow Mod Message: {}", fm);
+        return fm;
+    }
+
+    public Flow getFlow(Node node) {
+        if (this.flow == null) {
+            Match salMatch = new Match();
+
+            /*
+             * Installed flow may not have a Match defined like in case of a
+             * drop all flow
+             */
+            if (ofMatch != null) {
+                if (!isIPv6) {
+                    // Compute OF1.0 Match
+                    if (ofMatch.getInputPort() != 0) {
+                        salMatch.setField(new MatchField(MatchType.IN_PORT,
+                                NodeConnectorCreator.createNodeConnector(
+                                        (Short) ofMatch.getInputPort(), node)));
+                    }
+                    if (ofMatch.getDataLayerSource() != null
+                            && !NetUtils
+                                    .isZeroMAC(ofMatch.getDataLayerSource())) {
+                        byte srcMac[] = ofMatch.getDataLayerSource();
+                        salMatch.setField(new MatchField(MatchType.DL_SRC,
+                                srcMac.clone()));
+                    }
+                    if (ofMatch.getDataLayerDestination() != null
+                            && !NetUtils.isZeroMAC(ofMatch
+                                    .getDataLayerDestination())) {
+                        byte dstMac[] = ofMatch.getDataLayerDestination();
+                        salMatch.setField(new MatchField(MatchType.DL_DST,
+                                dstMac.clone()));
+                    }
+                    if (ofMatch.getDataLayerType() != 0) {
+                        salMatch.setField(new MatchField(MatchType.DL_TYPE,
+                                ofMatch.getDataLayerType()));
+                    }
+                    if (ofMatch.getDataLayerVirtualLan() != 0) {
+                        salMatch.setField(new MatchField(MatchType.DL_VLAN,
+                                ofMatch.getDataLayerVirtualLan()));
+                    }
+                    if (ofMatch.getDataLayerVirtualLanPriorityCodePoint() != 0) {
+                        salMatch.setField(MatchType.DL_VLAN_PR, ofMatch
+                                .getDataLayerVirtualLanPriorityCodePoint());
+                    }
+                    if (ofMatch.getNetworkSource() != 0) {
+                        salMatch.setField(MatchType.NW_SRC, NetUtils
+                                .getInetAddress(ofMatch.getNetworkSource()),
+                                NetUtils.getInetNetworkMask(
+                                        ofMatch.getNetworkSourceMaskLen(),
+                                        false));
+                    }
+                    if (ofMatch.getNetworkDestination() != 0) {
+                        salMatch.setField(MatchType.NW_DST,
+                                NetUtils.getInetAddress(ofMatch
+                                        .getNetworkDestination()),
+                                NetUtils.getInetNetworkMask(
+                                        ofMatch.getNetworkDestinationMaskLen(),
+                                        false));
+                    }
+                    if (ofMatch.getNetworkTypeOfService() != 0) {
+                        int dscp = NetUtils.getUnsignedByte(ofMatch
+                                .getNetworkTypeOfService());
+                        byte tos = (byte) (dscp >> 2);
+                        salMatch.setField(MatchType.NW_TOS, tos);
+                    }
+                    if (ofMatch.getNetworkProtocol() != 0) {
+                        salMatch.setField(MatchType.NW_PROTO,
+                                ofMatch.getNetworkProtocol());
+                    }
+                    if (ofMatch.getTransportSource() != 0) {
+                        salMatch.setField(MatchType.TP_SRC,
+                                ((Short) ofMatch.getTransportSource()));
+                    }
+                    if (ofMatch.getTransportDestination() != 0) {
+                        salMatch.setField(MatchType.TP_DST,
+                                ((Short) ofMatch.getTransportDestination()));
+                    }
+                } else {
+                    // Compute OF1.0 + IPv6 extensions Match
+                    V6Match v6Match = (V6Match) ofMatch;
+                    if (v6Match.getInputPort() != 0) {
+                        // Mask on input port is not defined
+                        salMatch.setField(new MatchField(MatchType.IN_PORT,
+                                NodeConnectorCreator.createOFNodeConnector(
+                                        (Short) v6Match.getInputPort(), node)));
+                    }
+                    if (v6Match.getDataLayerSource() != null
+                            && !NetUtils
+                                    .isZeroMAC(ofMatch.getDataLayerSource())) {
+                        byte srcMac[] = v6Match.getDataLayerSource();
+                        salMatch.setField(new MatchField(MatchType.DL_SRC,
+                                srcMac.clone()));
+                    }
+                    if (v6Match.getDataLayerDestination() != null
+                            && !NetUtils.isZeroMAC(ofMatch
+                                    .getDataLayerDestination())) {
+                        byte dstMac[] = v6Match.getDataLayerDestination();
+                        salMatch.setField(new MatchField(MatchType.DL_DST,
+                                dstMac.clone()));
+                    }
+                    if (v6Match.getDataLayerType() != 0) {
+                        salMatch.setField(new MatchField(MatchType.DL_TYPE,
+                                v6Match.getDataLayerType()));
+                    }
+                    if (v6Match.getDataLayerVirtualLan() != 0) {
+                        salMatch.setField(new MatchField(MatchType.DL_VLAN,
+                                v6Match.getDataLayerVirtualLan()));
+                    }
+                    if (v6Match.getDataLayerVirtualLanPriorityCodePoint() != 0) {
+                        salMatch.setField(MatchType.DL_VLAN_PR, v6Match
+                                .getDataLayerVirtualLanPriorityCodePoint());
+                    }
+                    if (v6Match.getNetworkSrc() != null) {
+                        salMatch.setField(MatchType.NW_SRC,
+                                v6Match.getNetworkSrc(),
+                                v6Match.getNetworkSourceMask());
+                    }
+                    if (v6Match.getNetworkDest() != null) {
+                        salMatch.setField(MatchType.NW_DST,
+                                v6Match.getNetworkDest(),
+                                v6Match.getNetworkDestinationMask());
+                    }
+                    if (v6Match.getNetworkTypeOfService() != 0) {
+                        int dscp = NetUtils.getUnsignedByte(v6Match
+                                .getNetworkTypeOfService());
+                        byte tos = (byte) (dscp >> 2);
+                        salMatch.setField(MatchType.NW_TOS, tos);
+                    }
+                    if (v6Match.getNetworkProtocol() != 0) {
+                        salMatch.setField(MatchType.NW_PROTO,
+                                v6Match.getNetworkProtocol());
+                    }
+                    if (v6Match.getTransportSource() != 0) {
+                        salMatch.setField(MatchType.TP_SRC,
+                                ((Short) v6Match.getTransportSource()));
+                    }
+                    if (v6Match.getTransportDestination() != 0) {
+                        salMatch.setField(MatchType.TP_DST,
+                                ((Short) v6Match.getTransportDestination()));
+                    }
+                }
+            }
+
+            // Convert actions
+            Action salAction = null;
+            List<Action> salActionList = new ArrayList<Action>();
+            if (actionsList == null) {
+                salActionList.add(new Drop());
+            } else {
+                for (OFAction ofAction : actionsList) {
+                    if (ofAction instanceof OFActionOutput) {
+                        short ofPort = ((OFActionOutput) ofAction).getPort();
+                        if (ofPort == OFPort.OFPP_CONTROLLER.getValue()) {
+                            salAction = new Controller();
+                        } else if (ofPort == OFPort.OFPP_NONE.getValue()) {
+                            salAction = new Drop();
+                        } else if (ofPort == OFPort.OFPP_IN_PORT.getValue()) {
+                            salAction = new Loopback();
+                        } else if (ofPort == OFPort.OFPP_FLOOD.getValue()) {
+                            salAction = new Flood();
+                        } else if (ofPort == OFPort.OFPP_ALL.getValue()) {
+                            salAction = new FloodAll();
+                        } else if (ofPort == OFPort.OFPP_LOCAL.getValue()) {
+                            salAction = new SwPath();
+                        } else if (ofPort == OFPort.OFPP_NORMAL.getValue()) {
+                            salAction = new HwPath();
+                        } else if (ofPort == OFPort.OFPP_TABLE.getValue()) {
+                            salAction = new HwPath(); // TODO: we do not handle
+                                                      // table in sal for now
+                        } else {
+                            salAction = new Output(
+                                    NodeConnectorCreator.createOFNodeConnector(
+                                            ofPort, node));
+                        }
+                    } else if (ofAction instanceof OFActionVirtualLanIdentifier) {
+                        salAction = new SetVlanId(
+                                ((OFActionVirtualLanIdentifier) ofAction)
+                                        .getVirtualLanIdentifier());
+                    } else if (ofAction instanceof OFActionStripVirtualLan) {
+                        salAction = new PopVlan();
+                    } else if (ofAction instanceof OFActionVirtualLanPriorityCodePoint) {
+                        salAction = new SetVlanPcp(
+                                ((OFActionVirtualLanPriorityCodePoint) ofAction)
+                                        .getVirtualLanPriorityCodePoint());
+                    } else if (ofAction instanceof OFActionDataLayerSource) {
+                        salAction = new SetDlSrc(
+                                ((OFActionDataLayerSource) ofAction)
+                                        .getDataLayerAddress().clone());
+                    } else if (ofAction instanceof OFActionDataLayerDestination) {
+                        salAction = new SetDlDst(
+                                ((OFActionDataLayerDestination) ofAction)
+                                        .getDataLayerAddress().clone());
+                    } else if (ofAction instanceof OFActionNetworkLayerSource) {
+                        byte addr[] = BigInteger.valueOf(
+                                ((OFActionNetworkLayerSource) ofAction)
+                                        .getNetworkAddress()).toByteArray();
+                        InetAddress ip = null;
+                        try {
+                            ip = InetAddress.getByAddress(addr);
+                        } catch (UnknownHostException e) {
+                            logger.error("", e);
+                        }
+                        salAction = new SetNwSrc(ip);
+                    } else if (ofAction instanceof OFActionNetworkLayerDestination) {
+                        byte addr[] = BigInteger.valueOf(
+                                ((OFActionNetworkLayerDestination) ofAction)
+                                        .getNetworkAddress()).toByteArray();
+                        InetAddress ip = null;
+                        try {
+                            ip = InetAddress.getByAddress(addr);
+                        } catch (UnknownHostException e) {
+                            logger.error("", e);
+                        }
+                        salAction = new SetNwDst(ip);
+                    } else if (ofAction instanceof OFActionNetworkTypeOfService) {
+                        salAction = new SetNwTos(
+                                ((OFActionNetworkTypeOfService) ofAction)
+                                        .getNetworkTypeOfService());
+                    } else if (ofAction instanceof OFActionTransportLayerSource) {
+                        Short port = ((OFActionTransportLayerSource) ofAction)
+                                .getTransportPort();
+                        int intPort = NetUtils.getUnsignedShort(port);
+                        salAction = new SetTpSrc(intPort);
+                    } else if (ofAction instanceof OFActionTransportLayerDestination) {
+                        Short port = ((OFActionTransportLayerDestination) ofAction)
+                                .getTransportPort();
+                        int intPort = NetUtils.getUnsignedShort(port);
+                        salAction = new SetTpDst(intPort);
+                    }
+                    salActionList.add(salAction);
+                }
+            }
+            // Create Flow
+            flow = new Flow(salMatch, salActionList);
+        }
+        logger.trace("Openflow Match: {} Openflow Actions: {}", ofMatch,
+                actionsList);
+        logger.trace("SAL Flow: {}", flow);
+        return flow;
+    }
+
+}