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 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();
}
}