| package net.floodlightcontroller.staticflowentry; |
| |
| import java.io.IOException; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| import net.floodlightcontroller.core.annotations.LogMessageCategory; |
| import net.floodlightcontroller.core.annotations.LogMessageDoc; |
| import net.floodlightcontroller.core.util.AppCookie; |
| import net.floodlightcontroller.packet.IPv4; |
| |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| |
| import org.codehaus.jackson.JsonParseException; |
| import org.codehaus.jackson.JsonParser; |
| import org.codehaus.jackson.JsonToken; |
| import org.codehaus.jackson.map.MappingJsonFactory; |
| import org.openflow.protocol.OFFlowMod; |
| import org.openflow.protocol.OFMatch; |
| import org.openflow.protocol.OFPacketOut; |
| import org.openflow.protocol.OFPort; |
| import org.openflow.protocol.action.OFAction; |
| import org.openflow.protocol.action.OFActionDataLayerDestination; |
| import org.openflow.protocol.action.OFActionDataLayerSource; |
| import org.openflow.protocol.action.OFActionEnqueue; |
| 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.OFActionTransportLayerDestination; |
| import org.openflow.protocol.action.OFActionTransportLayerSource; |
| import org.openflow.protocol.action.OFActionVirtualLanIdentifier; |
| import org.openflow.protocol.action.OFActionVirtualLanPriorityCodePoint; |
| import org.openflow.util.HexString; |
| |
| /** |
| * Represents static flow entries to be maintained by the controller on the |
| * switches. |
| */ |
| @LogMessageCategory("Static Flow Pusher") |
| public class StaticFlowEntries { |
| protected final static Logger log = LoggerFactory.getLogger(StaticFlowEntries.class); |
| |
| private static class SubActionStruct { |
| OFAction action; |
| int len; |
| } |
| |
| private static byte[] zeroMac = new byte[] {0x0, 0x0, 0x0, 0x0, 0x0, 0x0}; |
| |
| /** |
| * This function generates a random hash for the bottom half of the cookie |
| * |
| * @param fm |
| * @param userCookie |
| * @param name |
| * @return A cookie that encodes the application ID and a hash |
| */ |
| public static long computeEntryCookie(OFFlowMod fm, int userCookie, String name) { |
| // flow-specific hash is next 20 bits LOOK! who knows if this |
| int prime = 211; |
| int flowHash = 2311; |
| for (int i=0; i < name.length(); i++) |
| flowHash = flowHash * prime + (int)name.charAt(i); |
| |
| return AppCookie.makeCookie(StaticFlowEntryPusher.STATIC_FLOW_APP_ID, flowHash); |
| } |
| |
| /** |
| * Sets defaults for an OFFlowMod |
| * @param fm The OFFlowMod to set defaults for |
| * @param entryName The name of the entry. Used to compute the cookie. |
| */ |
| public static void initDefaultFlowMod(OFFlowMod fm, String entryName) { |
| fm.setIdleTimeout((short) 0); // infinite |
| fm.setHardTimeout((short) 0); // infinite |
| fm.setBufferId(OFPacketOut.BUFFER_ID_NONE); |
| fm.setCommand((short) 0); |
| fm.setFlags((short) 0); |
| fm.setOutPort(OFPort.OFPP_NONE.getValue()); |
| fm.setCookie(computeEntryCookie(fm, 0, entryName)); |
| fm.setPriority(Short.MAX_VALUE); |
| } |
| |
| /** |
| * Gets the entry name of a flow mod |
| * @param fmJson The OFFlowMod in a JSON representation |
| * @return The name of the OFFlowMod, null if not found |
| * @throws IOException If there was an error parsing the JSON |
| */ |
| public static String getEntryNameFromJson(String fmJson) throws IOException{ |
| MappingJsonFactory f = new MappingJsonFactory(); |
| JsonParser jp; |
| |
| try { |
| jp = f.createJsonParser(fmJson); |
| } catch (JsonParseException e) { |
| throw new IOException(e); |
| } |
| |
| jp.nextToken(); |
| if (jp.getCurrentToken() != JsonToken.START_OBJECT) { |
| throw new IOException("Expected START_OBJECT"); |
| } |
| |
| while (jp.nextToken() != JsonToken.END_OBJECT) { |
| if (jp.getCurrentToken() != JsonToken.FIELD_NAME) { |
| throw new IOException("Expected FIELD_NAME"); |
| } |
| |
| String n = jp.getCurrentName(); |
| jp.nextToken(); |
| if (jp.getText().equals("")) |
| continue; |
| |
| if (n == "name") |
| return jp.getText(); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Parses an OFFlowMod (and it's inner OFMatch) to the storage entry format. |
| * @param fm The FlowMod to parse |
| * @param sw The switch the FlowMod is going to be installed on |
| * @param name The name of this static flow entry |
| * @return A Map representation of the storage entry |
| */ |
| public static Map<String, Object> flowModToStorageEntry(OFFlowMod fm, String sw, String name) { |
| Map<String, Object> entry = new HashMap<String, Object>(); |
| OFMatch match = fm.getMatch(); |
| entry.put(StaticFlowEntryPusher.COLUMN_NAME, name); |
| entry.put(StaticFlowEntryPusher.COLUMN_SWITCH, sw); |
| entry.put(StaticFlowEntryPusher.COLUMN_ACTIVE, Boolean.toString(true)); |
| entry.put(StaticFlowEntryPusher.COLUMN_PRIORITY, Short.toString(fm.getPriority())); |
| entry.put(StaticFlowEntryPusher.COLUMN_WILDCARD, Integer.toString(match.getWildcards())); |
| |
| if ((fm.getActions() != null) && (fm.getActions().size() > 0)) |
| entry.put(StaticFlowEntryPusher.COLUMN_ACTIONS, StaticFlowEntries.flowModActionsToString(fm.getActions())); |
| |
| if (match.getInputPort() != 0) |
| entry.put(StaticFlowEntryPusher.COLUMN_IN_PORT, Short.toString(match.getInputPort())); |
| |
| if (!Arrays.equals(match.getDataLayerSource(), zeroMac)) |
| entry.put(StaticFlowEntryPusher.COLUMN_DL_SRC, HexString.toHexString(match.getDataLayerSource())); |
| |
| if (!Arrays.equals(match.getDataLayerDestination(), zeroMac)) |
| entry.put(StaticFlowEntryPusher.COLUMN_DL_DST, HexString.toHexString(match.getDataLayerDestination())); |
| |
| if (match.getDataLayerVirtualLan() != -1) |
| entry.put(StaticFlowEntryPusher.COLUMN_DL_VLAN, Short.toString(match.getDataLayerVirtualLan())); |
| |
| if (match.getDataLayerVirtualLanPriorityCodePoint() != 0) |
| entry.put(StaticFlowEntryPusher.COLUMN_DL_VLAN_PCP, Short.toString(match.getDataLayerVirtualLanPriorityCodePoint())); |
| |
| if (match.getDataLayerType() != 0) |
| entry.put(StaticFlowEntryPusher.COLUMN_DL_TYPE, Short.toString(match.getDataLayerType())); |
| |
| if (match.getNetworkTypeOfService() != 0) |
| entry.put(StaticFlowEntryPusher.COLUMN_NW_TOS, Short.toString(match.getNetworkTypeOfService())); |
| |
| if (match.getNetworkProtocol() != 0) |
| entry.put(StaticFlowEntryPusher.COLUMN_NW_PROTO, Short.toString(match.getNetworkProtocol())); |
| |
| if (match.getNetworkSource() != 0) |
| entry.put(StaticFlowEntryPusher.COLUMN_NW_SRC, IPv4.fromIPv4Address(match.getNetworkSource())); |
| |
| if (match.getNetworkDestination() != 0) |
| entry.put(StaticFlowEntryPusher.COLUMN_NW_DST, IPv4.fromIPv4Address(match.getNetworkDestination())); |
| |
| if (match.getTransportSource() != 0) |
| entry.put(StaticFlowEntryPusher.COLUMN_TP_SRC, Short.toString(match.getTransportSource())); |
| |
| if (match.getTransportDestination() != 0) |
| entry.put(StaticFlowEntryPusher.COLUMN_TP_DST, Short.toString(match.getTransportDestination())); |
| |
| return entry; |
| } |
| |
| /** |
| * Returns a String representation of all the openflow actions. |
| * @param fmActions A list of OFActions to encode into one string |
| * @return A string of the actions encoded for our database |
| */ |
| @LogMessageDoc(level="ERROR", |
| message="Could not decode action {action}", |
| explanation="A static flow entry contained an invalid action", |
| recommendation=LogMessageDoc.REPORT_CONTROLLER_BUG) |
| private static String flowModActionsToString(List<OFAction> fmActions) { |
| StringBuilder sb = new StringBuilder(); |
| for (OFAction a : fmActions) { |
| if (sb.length() > 0) { |
| sb.append(','); |
| } |
| switch(a.getType()) { |
| case OUTPUT: |
| sb.append("output=" + Short.toString(((OFActionOutput)a).getPort())); |
| break; |
| case OPAQUE_ENQUEUE: |
| int queue = ((OFActionEnqueue)a).getQueueId(); |
| short port = ((OFActionEnqueue)a).getPort(); |
| sb.append("enqueue=" + Short.toString(port) + ":0x" + String.format("%02x", queue)); |
| break; |
| case STRIP_VLAN: |
| sb.append("strip-vlan"); |
| break; |
| case SET_VLAN_ID: |
| sb.append("set-vlan-id=" + |
| Short.toString(((OFActionVirtualLanIdentifier)a).getVirtualLanIdentifier())); |
| break; |
| case SET_VLAN_PCP: |
| sb.append("set-vlan-priority=" + |
| Byte.toString(((OFActionVirtualLanPriorityCodePoint)a).getVirtualLanPriorityCodePoint())); |
| break; |
| case SET_DL_SRC: |
| sb.append("set-src-mac=" + |
| HexString.toHexString(((OFActionDataLayerSource)a).getDataLayerAddress())); |
| break; |
| case SET_DL_DST: |
| sb.append("set-dst-mac=" + |
| HexString.toHexString(((OFActionDataLayerDestination)a).getDataLayerAddress())); |
| break; |
| case SET_NW_TOS: |
| sb.append("set-tos-bits=" + |
| Byte.toString(((OFActionNetworkTypeOfService)a).getNetworkTypeOfService())); |
| break; |
| case SET_NW_SRC: |
| sb.append("set-src-ip=" + |
| IPv4.fromIPv4Address(((OFActionNetworkLayerSource)a).getNetworkAddress())); |
| break; |
| case SET_NW_DST: |
| sb.append("set-dst-ip=" + |
| IPv4.fromIPv4Address(((OFActionNetworkLayerDestination)a).getNetworkAddress())); |
| break; |
| case SET_TP_SRC: |
| sb.append("set-src-port=" + |
| Short.toString(((OFActionTransportLayerSource)a).getTransportPort())); |
| break; |
| case SET_TP_DST: |
| sb.append("set-dst-port=" + |
| Short.toString(((OFActionTransportLayerDestination)a).getTransportPort())); |
| break; |
| default: |
| log.error("Could not decode action: {}", a); |
| break; |
| } |
| |
| } |
| return sb.toString(); |
| } |
| |
| /** |
| * Turns a JSON formatted Static Flow Pusher string into a storage entry |
| * Expects a string in JSON along the lines of: |
| * { |
| * "switch": "AA:BB:CC:DD:EE:FF:00:11", |
| * "name": "flow-mod-1", |
| * "cookie": "0", |
| * "priority": "32768", |
| * "ingress-port": "1", |
| * "actions": "output=2", |
| * } |
| * @param fmJson The JSON formatted static flow pusher entry |
| * @return The map of the storage entry |
| * @throws IOException If there was an error parsing the JSON |
| */ |
| public static Map<String, Object> jsonToStorageEntry(String fmJson) throws IOException { |
| Map<String, Object> entry = new HashMap<String, Object>(); |
| MappingJsonFactory f = new MappingJsonFactory(); |
| JsonParser jp; |
| |
| try { |
| jp = f.createJsonParser(fmJson); |
| } catch (JsonParseException e) { |
| throw new IOException(e); |
| } |
| |
| jp.nextToken(); |
| if (jp.getCurrentToken() != JsonToken.START_OBJECT) { |
| throw new IOException("Expected START_OBJECT"); |
| } |
| |
| while (jp.nextToken() != JsonToken.END_OBJECT) { |
| if (jp.getCurrentToken() != JsonToken.FIELD_NAME) { |
| throw new IOException("Expected FIELD_NAME"); |
| } |
| |
| String n = jp.getCurrentName(); |
| jp.nextToken(); |
| if (jp.getText().equals("")) |
| continue; |
| |
| if (n == "name") |
| entry.put(StaticFlowEntryPusher.COLUMN_NAME, jp.getText()); |
| else if (n == "switch") |
| entry.put(StaticFlowEntryPusher.COLUMN_SWITCH, jp.getText()); |
| else if (n == "actions") |
| entry.put(StaticFlowEntryPusher.COLUMN_ACTIONS, jp.getText()); |
| else if (n == "priority") |
| entry.put(StaticFlowEntryPusher.COLUMN_PRIORITY, jp.getText()); |
| else if (n == "active") |
| entry.put(StaticFlowEntryPusher.COLUMN_ACTIVE, jp.getText()); |
| else if (n == "wildcards") |
| entry.put(StaticFlowEntryPusher.COLUMN_WILDCARD, jp.getText()); |
| else if (n == "ingress-port") |
| entry.put(StaticFlowEntryPusher.COLUMN_IN_PORT, jp.getText()); |
| else if (n == "src-mac") |
| entry.put(StaticFlowEntryPusher.COLUMN_DL_SRC, jp.getText()); |
| else if (n == "dst-mac") |
| entry.put(StaticFlowEntryPusher.COLUMN_DL_DST, jp.getText()); |
| else if (n == "vlan-id") |
| entry.put(StaticFlowEntryPusher.COLUMN_DL_VLAN, jp.getText()); |
| else if (n == "vlan-priority") |
| entry.put(StaticFlowEntryPusher.COLUMN_DL_VLAN_PCP, jp.getText()); |
| else if (n == "ether-type") |
| entry.put(StaticFlowEntryPusher.COLUMN_DL_TYPE, jp.getText()); |
| else if (n == "tos-bits") |
| entry.put(StaticFlowEntryPusher.COLUMN_NW_TOS, jp.getText()); |
| else if (n == "protocol") |
| entry.put(StaticFlowEntryPusher.COLUMN_NW_PROTO, jp.getText()); |
| else if (n == "src-ip") |
| entry.put(StaticFlowEntryPusher.COLUMN_NW_SRC, jp.getText()); |
| else if (n == "dst-ip") |
| entry.put(StaticFlowEntryPusher.COLUMN_NW_DST, jp.getText()); |
| else if (n == "src-port") |
| entry.put(StaticFlowEntryPusher.COLUMN_TP_SRC, jp.getText()); |
| else if (n == "dst-port") |
| entry.put(StaticFlowEntryPusher.COLUMN_TP_DST, jp.getText()); |
| } |
| |
| return entry; |
| } |
| |
| /** |
| * Parses OFFlowMod actions from strings. |
| * @param flowMod The OFFlowMod to set the actions for |
| * @param actionstr The string containing all the actions |
| * @param log A logger to log for errors. |
| */ |
| @LogMessageDoc(level="ERROR", |
| message="Unexpected action '{action}', '{subaction}'", |
| explanation="A static flow entry contained an invalid action", |
| recommendation=LogMessageDoc.REPORT_CONTROLLER_BUG) |
| public static void parseActionString(OFFlowMod flowMod, String actionstr, Logger log) { |
| List<OFAction> actions = new LinkedList<OFAction>(); |
| int actionsLength = 0; |
| if (actionstr != null) { |
| actionstr = actionstr.toLowerCase(); |
| for (String subaction : actionstr.split(",")) { |
| String action = subaction.split("[=:]")[0]; |
| SubActionStruct subaction_struct = null; |
| |
| if (action.equals("output")) { |
| subaction_struct = StaticFlowEntries.decode_output(subaction, log); |
| } |
| else if (action.equals("enqueue")) { |
| subaction_struct = decode_enqueue(subaction, log); |
| } |
| else if (action.equals("strip-vlan")) { |
| subaction_struct = decode_strip_vlan(subaction, log); |
| } |
| else if (action.equals("set-vlan-id")) { |
| subaction_struct = decode_set_vlan_id(subaction, log); |
| } |
| else if (action.equals("set-vlan-priority")) { |
| subaction_struct = decode_set_vlan_priority(subaction, log); |
| } |
| else if (action.equals("set-src-mac")) { |
| subaction_struct = decode_set_src_mac(subaction, log); |
| } |
| else if (action.equals("set-dst-mac")) { |
| subaction_struct = decode_set_dst_mac(subaction, log); |
| } |
| else if (action.equals("set-tos-bits")) { |
| subaction_struct = decode_set_tos_bits(subaction, log); |
| } |
| else if (action.equals("set-src-ip")) { |
| subaction_struct = decode_set_src_ip(subaction, log); |
| } |
| else if (action.equals("set-dst-ip")) { |
| subaction_struct = decode_set_dst_ip(subaction, log); |
| } |
| else if (action.equals("set-src-port")) { |
| subaction_struct = decode_set_src_port(subaction, log); |
| } |
| else if (action.equals("set-dst-port")) { |
| subaction_struct = decode_set_dst_port(subaction, log); |
| } |
| else { |
| log.error("Unexpected action '{}', '{}'", action, subaction); |
| } |
| |
| if (subaction_struct != null) { |
| actions.add(subaction_struct.action); |
| actionsLength += subaction_struct.len; |
| } |
| } |
| } |
| log.debug("action {}", actions); |
| |
| flowMod.setActions(actions); |
| flowMod.setLengthU(OFFlowMod.MINIMUM_LENGTH + actionsLength); |
| } |
| |
| @LogMessageDoc(level="ERROR", |
| message="Invalid subaction: '{subaction}'", |
| explanation="A static flow entry contained an invalid subaction", |
| recommendation=LogMessageDoc.REPORT_CONTROLLER_BUG) |
| private static SubActionStruct decode_output(String subaction, Logger log) { |
| SubActionStruct sa = null; |
| Matcher n; |
| |
| n = Pattern.compile("output=(?:((?:0x)?\\d+)|(all)|(controller)|(local)|(ingress-port)|(normal)|(flood))").matcher(subaction); |
| if (n.matches()) { |
| OFActionOutput action = new OFActionOutput(); |
| action.setMaxLength((short) Short.MAX_VALUE); |
| short port = OFPort.OFPP_NONE.getValue(); |
| if (n.group(1) != null) { |
| try { |
| port = get_short(n.group(1)); |
| } |
| catch (NumberFormatException e) { |
| log.debug("Invalid port in: '{}' (error ignored)", subaction); |
| return null; |
| } |
| } |
| else if (n.group(2) != null) |
| port = OFPort.OFPP_ALL.getValue(); |
| else if (n.group(3) != null) |
| port = OFPort.OFPP_CONTROLLER.getValue(); |
| else if (n.group(4) != null) |
| port = OFPort.OFPP_LOCAL.getValue(); |
| else if (n.group(5) != null) |
| port = OFPort.OFPP_IN_PORT.getValue(); |
| else if (n.group(6) != null) |
| port = OFPort.OFPP_NORMAL.getValue(); |
| else if (n.group(7) != null) |
| port = OFPort.OFPP_FLOOD.getValue(); |
| action.setPort(port); |
| log.debug("action {}", action); |
| |
| sa = new SubActionStruct(); |
| sa.action = action; |
| sa.len = OFActionOutput.MINIMUM_LENGTH; |
| } |
| else { |
| log.error("Invalid subaction: '{}'", subaction); |
| return null; |
| } |
| |
| return sa; |
| } |
| |
| private static SubActionStruct decode_enqueue(String subaction, Logger log) { |
| SubActionStruct sa = null; |
| Matcher n; |
| |
| n = Pattern.compile("enqueue=(?:((?:0x)?\\d+)\\:((?:0x)?\\d+))").matcher(subaction); |
| if (n.matches()) { |
| short portnum = 0; |
| if (n.group(1) != null) { |
| try { |
| portnum = get_short(n.group(1)); |
| } |
| catch (NumberFormatException e) { |
| log.debug("Invalid port-num in: '{}' (error ignored)", subaction); |
| return null; |
| } |
| } |
| |
| int queueid = 0; |
| if (n.group(2) != null) { |
| try { |
| queueid = get_int(n.group(2)); |
| } |
| catch (NumberFormatException e) { |
| log.debug("Invalid queue-id in: '{}' (error ignored)", subaction); |
| return null; |
| } |
| } |
| |
| OFActionEnqueue action = new OFActionEnqueue(); |
| action.setPort(portnum); |
| action.setQueueId(queueid); |
| log.debug("action {}", action); |
| |
| sa = new SubActionStruct(); |
| sa.action = action; |
| sa.len = OFActionEnqueue.MINIMUM_LENGTH; |
| } |
| else { |
| log.debug("Invalid action: '{}'", subaction); |
| return null; |
| } |
| |
| return sa; |
| } |
| |
| private static SubActionStruct decode_strip_vlan(String subaction, Logger log) { |
| SubActionStruct sa = null; |
| Matcher n = Pattern.compile("strip-vlan").matcher(subaction); |
| |
| if (n.matches()) { |
| OFActionStripVirtualLan action = new OFActionStripVirtualLan(); |
| log.debug("action {}", action); |
| |
| sa = new SubActionStruct(); |
| sa.action = action; |
| sa.len = OFActionStripVirtualLan.MINIMUM_LENGTH; |
| } |
| else { |
| log.debug("Invalid action: '{}'", subaction); |
| return null; |
| } |
| |
| return sa; |
| } |
| |
| private static SubActionStruct decode_set_vlan_id(String subaction, Logger log) { |
| SubActionStruct sa = null; |
| Matcher n = Pattern.compile("set-vlan-id=((?:0x)?\\d+)").matcher(subaction); |
| |
| if (n.matches()) { |
| if (n.group(1) != null) { |
| try { |
| short vlanid = get_short(n.group(1)); |
| OFActionVirtualLanIdentifier action = new OFActionVirtualLanIdentifier(); |
| action.setVirtualLanIdentifier(vlanid); |
| log.debug(" action {}", action); |
| |
| sa = new SubActionStruct(); |
| sa.action = action; |
| sa.len = OFActionVirtualLanIdentifier.MINIMUM_LENGTH; |
| } |
| catch (NumberFormatException e) { |
| log.debug("Invalid VLAN in: {} (error ignored)", subaction); |
| return null; |
| } |
| } |
| } |
| else { |
| log.debug("Invalid action: '{}'", subaction); |
| return null; |
| } |
| |
| return sa; |
| } |
| |
| private static SubActionStruct decode_set_vlan_priority(String subaction, Logger log) { |
| SubActionStruct sa = null; |
| Matcher n = Pattern.compile("set-vlan-priority=((?:0x)?\\d+)").matcher(subaction); |
| |
| if (n.matches()) { |
| if (n.group(1) != null) { |
| try { |
| byte prior = get_byte(n.group(1)); |
| OFActionVirtualLanPriorityCodePoint action = new OFActionVirtualLanPriorityCodePoint(); |
| action.setVirtualLanPriorityCodePoint(prior); |
| log.debug(" action {}", action); |
| |
| sa = new SubActionStruct(); |
| sa.action = action; |
| sa.len = OFActionVirtualLanPriorityCodePoint.MINIMUM_LENGTH; |
| } |
| catch (NumberFormatException e) { |
| log.debug("Invalid VLAN priority in: {} (error ignored)", subaction); |
| return null; |
| } |
| } |
| } |
| else { |
| log.debug("Invalid action: '{}'", subaction); |
| return null; |
| } |
| |
| return sa; |
| } |
| |
| private static SubActionStruct decode_set_src_mac(String subaction, Logger log) { |
| SubActionStruct sa = null; |
| Matcher n = Pattern.compile("set-src-mac=(?:(\\p{XDigit}+)\\:(\\p{XDigit}+)\\:(\\p{XDigit}+)\\:(\\p{XDigit}+)\\:(\\p{XDigit}+)\\:(\\p{XDigit}+))").matcher(subaction); |
| |
| if (n.matches()) { |
| byte[] macaddr = get_mac_addr(n, subaction, log); |
| if (macaddr != null) { |
| OFActionDataLayerSource action = new OFActionDataLayerSource(); |
| action.setDataLayerAddress(macaddr); |
| log.debug("action {}", action); |
| |
| sa = new SubActionStruct(); |
| sa.action = action; |
| sa.len = OFActionDataLayerSource.MINIMUM_LENGTH; |
| } |
| } |
| else { |
| log.debug("Invalid action: '{}'", subaction); |
| return null; |
| } |
| |
| return sa; |
| } |
| |
| private static SubActionStruct decode_set_dst_mac(String subaction, Logger log) { |
| SubActionStruct sa = null; |
| Matcher n = Pattern.compile("set-dst-mac=(?:(\\p{XDigit}+)\\:(\\p{XDigit}+)\\:(\\p{XDigit}+)\\:(\\p{XDigit}+)\\:(\\p{XDigit}+)\\:(\\p{XDigit}+))").matcher(subaction); |
| |
| if (n.matches()) { |
| byte[] macaddr = get_mac_addr(n, subaction, log); |
| if (macaddr != null) { |
| OFActionDataLayerDestination action = new OFActionDataLayerDestination(); |
| action.setDataLayerAddress(macaddr); |
| log.debug(" action {}", action); |
| |
| sa = new SubActionStruct(); |
| sa.action = action; |
| sa.len = OFActionDataLayerDestination.MINIMUM_LENGTH; |
| } |
| } |
| else { |
| log.debug("Invalid action: '{}'", subaction); |
| return null; |
| } |
| |
| return sa; |
| } |
| |
| private static SubActionStruct decode_set_tos_bits(String subaction, Logger log) { |
| SubActionStruct sa = null; |
| Matcher n = Pattern.compile("set-tos-bits=((?:0x)?\\d+)").matcher(subaction); |
| |
| if (n.matches()) { |
| if (n.group(1) != null) { |
| try { |
| byte tosbits = get_byte(n.group(1)); |
| OFActionNetworkTypeOfService action = new OFActionNetworkTypeOfService(); |
| action.setNetworkTypeOfService(tosbits); |
| log.debug(" action {}", action); |
| |
| sa = new SubActionStruct(); |
| sa.action = action; |
| sa.len = OFActionNetworkTypeOfService.MINIMUM_LENGTH; |
| } |
| catch (NumberFormatException e) { |
| log.debug("Invalid dst-port in: {} (error ignored)", subaction); |
| return null; |
| } |
| } |
| } |
| else { |
| log.debug("Invalid action: '{}'", subaction); |
| return null; |
| } |
| |
| return sa; |
| } |
| |
| private static SubActionStruct decode_set_src_ip(String subaction, Logger log) { |
| SubActionStruct sa = null; |
| Matcher n = Pattern.compile("set-src-ip=(?:(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+))").matcher(subaction); |
| |
| if (n.matches()) { |
| int ipaddr = get_ip_addr(n, subaction, log); |
| OFActionNetworkLayerSource action = new OFActionNetworkLayerSource(); |
| action.setNetworkAddress(ipaddr); |
| log.debug(" action {}", action); |
| |
| sa = new SubActionStruct(); |
| sa.action = action; |
| sa.len = OFActionNetworkLayerSource.MINIMUM_LENGTH; |
| } |
| else { |
| log.debug("Invalid action: '{}'", subaction); |
| return null; |
| } |
| |
| return sa; |
| } |
| |
| private static SubActionStruct decode_set_dst_ip(String subaction, Logger log) { |
| SubActionStruct sa = null; |
| Matcher n = Pattern.compile("set-dst-ip=(?:(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+))").matcher(subaction); |
| |
| if (n.matches()) { |
| int ipaddr = get_ip_addr(n, subaction, log); |
| OFActionNetworkLayerDestination action = new OFActionNetworkLayerDestination(); |
| action.setNetworkAddress(ipaddr); |
| log.debug("action {}", action); |
| |
| sa = new SubActionStruct(); |
| sa.action = action; |
| sa.len = OFActionNetworkLayerDestination.MINIMUM_LENGTH; |
| } |
| else { |
| log.debug("Invalid action: '{}'", subaction); |
| return null; |
| } |
| |
| return sa; |
| } |
| |
| private static SubActionStruct decode_set_src_port(String subaction, Logger log) { |
| SubActionStruct sa = null; |
| Matcher n = Pattern.compile("set-src-port=((?:0x)?\\d+)").matcher(subaction); |
| |
| if (n.matches()) { |
| if (n.group(1) != null) { |
| try { |
| short portnum = get_short(n.group(1)); |
| OFActionTransportLayerSource action = new OFActionTransportLayerSource(); |
| action.setTransportPort(portnum); |
| log.debug("action {}", action); |
| |
| sa = new SubActionStruct(); |
| sa.action = action; |
| sa.len = OFActionTransportLayerSource.MINIMUM_LENGTH;; |
| } |
| catch (NumberFormatException e) { |
| log.debug("Invalid src-port in: {} (error ignored)", subaction); |
| return null; |
| } |
| } |
| } |
| else { |
| log.debug("Invalid action: '{}'", subaction); |
| return null; |
| } |
| |
| return sa; |
| } |
| |
| private static SubActionStruct decode_set_dst_port(String subaction, Logger log) { |
| SubActionStruct sa = null; |
| Matcher n = Pattern.compile("set-dst-port=((?:0x)?\\d+)").matcher(subaction); |
| |
| if (n.matches()) { |
| if (n.group(1) != null) { |
| try { |
| short portnum = get_short(n.group(1)); |
| OFActionTransportLayerDestination action = new OFActionTransportLayerDestination(); |
| action.setTransportPort(portnum); |
| log.debug("action {}", action); |
| |
| sa = new SubActionStruct(); |
| sa.action = action; |
| sa.len = OFActionTransportLayerDestination.MINIMUM_LENGTH;; |
| } |
| catch (NumberFormatException e) { |
| log.debug("Invalid dst-port in: {} (error ignored)", subaction); |
| return null; |
| } |
| } |
| } |
| else { |
| log.debug("Invalid action: '{}'", subaction); |
| return null; |
| } |
| |
| return sa; |
| } |
| |
| private static byte[] get_mac_addr(Matcher n, String subaction, Logger log) { |
| byte[] macaddr = new byte[6]; |
| |
| for (int i=0; i<6; i++) { |
| if (n.group(i+1) != null) { |
| try { |
| macaddr[i] = get_byte("0x" + n.group(i+1)); |
| } |
| catch (NumberFormatException e) { |
| log.debug("Invalid src-mac in: '{}' (error ignored)", subaction); |
| return null; |
| } |
| } |
| else { |
| log.debug("Invalid src-mac in: '{}' (null, error ignored)", subaction); |
| return null; |
| } |
| } |
| |
| return macaddr; |
| } |
| |
| private static int get_ip_addr(Matcher n, String subaction, Logger log) { |
| int ipaddr = 0; |
| |
| for (int i=0; i<4; i++) { |
| if (n.group(i+1) != null) { |
| try { |
| ipaddr = ipaddr<<8; |
| ipaddr = ipaddr | get_int(n.group(i+1)); |
| } |
| catch (NumberFormatException e) { |
| log.debug("Invalid src-ip in: '{}' (error ignored)", subaction); |
| return 0; |
| } |
| } |
| else { |
| log.debug("Invalid src-ip in: '{}' (null, error ignored)", subaction); |
| return 0; |
| } |
| } |
| |
| return ipaddr; |
| } |
| |
| // Parse int as decimal, hex (start with 0x or #) or octal (starts with 0) |
| private static int get_int(String str) { |
| return (int)Integer.decode(str); |
| } |
| |
| // Parse short as decimal, hex (start with 0x or #) or octal (starts with 0) |
| private static short get_short(String str) { |
| return (short)(int)Integer.decode(str); |
| } |
| |
| // Parse byte as decimal, hex (start with 0x or #) or octal (starts with 0) |
| private static byte get_byte(String str) { |
| return Integer.decode(str).byteValue(); |
| } |
| |
| } |
| |