/** * Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior * University * * Licensed under the Apache License, Version 2.0 (the "License"); you may * not use this file except in compliance with the License. You may obtain * a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations * under the License. **/ package org.openflow.protocol; import java.io.Serializable; import java.nio.ByteBuffer; import java.util.Arrays; import org.codehaus.jackson.map.annotate.JsonSerialize; import org.jboss.netty.buffer.ChannelBuffer; import org.openflow.protocol.serializers.OFMatchJSONSerializer; import org.openflow.util.HexString; import org.openflow.util.U16; import org.openflow.util.U8; /** * Represents an ofp_match structure * * @author David Erickson (daviderickson@cs.stanford.edu) * @author Rob Sherwood (rob.sherwood@stanford.edu) * */ @JsonSerialize(using=OFMatchJSONSerializer.class) public class OFMatch implements Cloneable, Serializable { /** * */ private static final long serialVersionUID = 1L; public static int MINIMUM_LENGTH = 40; final public static int OFPFW_ALL = ((1 << 22) - 1); final public static int OFPFW_IN_PORT = 1 << 0; /* Switch input port. */ final public static int OFPFW_DL_VLAN = 1 << 1; /* VLAN id. */ final public static int OFPFW_DL_SRC = 1 << 2; /* Ethernet source address. */ final public static int OFPFW_DL_DST = 1 << 3; /* * Ethernet destination * address. */ final public static int OFPFW_DL_TYPE = 1 << 4; /* Ethernet frame type. */ final public static int OFPFW_NW_PROTO = 1 << 5; /* IP protocol. */ final public static int OFPFW_TP_SRC = 1 << 6; /* TCP/UDP source port. */ final public static int OFPFW_TP_DST = 1 << 7; /* TCP/UDP destination port. */ /* * IP source address wildcard bit count. 0 is exact match, 1 ignores the * LSB, 2 ignores the 2 least-significant bits, ..., 32 and higher wildcard * the entire field. This is the *opposite* of the usual convention where * e.g. /24 indicates that 8 bits (not 24 bits) are wildcarded. */ final public static int OFPFW_NW_SRC_SHIFT = 8; final public static int OFPFW_NW_SRC_BITS = 6; final public static int OFPFW_NW_SRC_MASK = ((1 << OFPFW_NW_SRC_BITS) - 1) << OFPFW_NW_SRC_SHIFT; final public static int OFPFW_NW_SRC_ALL = 32 << OFPFW_NW_SRC_SHIFT; /* IP destination address wildcard bit count. Same format as source. */ final public static int OFPFW_NW_DST_SHIFT = 14; final public static int OFPFW_NW_DST_BITS = 6; final public static int OFPFW_NW_DST_MASK = ((1 << OFPFW_NW_DST_BITS) - 1) << OFPFW_NW_DST_SHIFT; final public static int OFPFW_NW_DST_ALL = 32 << OFPFW_NW_DST_SHIFT; final public static int OFPFW_DL_VLAN_PCP = 1 << 20; /* VLAN priority. */ final public static int OFPFW_NW_TOS = 1 << 21; /* * IP ToS (DSCP field, 6 * bits). */ /* List of Strings for marshalling and unmarshalling to human readable forms */ final public static String STR_IN_PORT = "in_port"; final public static String STR_DL_DST = "dl_dst"; final public static String STR_DL_SRC = "dl_src"; final public static String STR_DL_TYPE = "dl_type"; final public static String STR_DL_VLAN = "dl_vlan"; final public static String STR_DL_VLAN_PCP = "dl_vlan_pcp"; final public static String STR_NW_DST = "nw_dst"; final public static String STR_NW_SRC = "nw_src"; final public static String STR_NW_PROTO = "nw_proto"; final public static String STR_NW_TOS = "nw_tos"; final public static String STR_TP_DST = "tp_dst"; final public static String STR_TP_SRC = "tp_src"; protected int wildcards; protected short inputPort; protected byte[] dataLayerSource; protected byte[] dataLayerDestination; protected short dataLayerVirtualLan; protected byte dataLayerVirtualLanPriorityCodePoint; protected short dataLayerType; protected byte networkTypeOfService; protected byte networkProtocol; protected int networkSource; protected int networkDestination; protected short transportSource; protected short transportDestination; /** * By default, create a OFMatch that matches everything * * (mostly because it's the least amount of work to make a valid OFMatch) */ public OFMatch() { this.wildcards = OFPFW_ALL; this.dataLayerDestination = new byte[] {0x0, 0x0, 0x0, 0x0, 0x0, 0x0}; this.dataLayerSource = new byte[] {0x0, 0x0, 0x0, 0x0, 0x0, 0x0}; this.dataLayerVirtualLan = -1; this.dataLayerVirtualLanPriorityCodePoint = 0; this.dataLayerType = 0; this.inputPort = 0; this.networkProtocol = 0; this.networkTypeOfService = 0; this.networkSource = 0; this.networkDestination = 0; this.transportDestination = 0; this.transportSource = 0; } /** * Get dl_dst * * @return an arrays of bytes */ public byte[] getDataLayerDestination() { return this.dataLayerDestination; } /** * Set dl_dst * * @param dataLayerDestination */ public OFMatch setDataLayerDestination(byte[] dataLayerDestination) { this.dataLayerDestination = dataLayerDestination; return this; } /** * Set dl_dst, but first translate to byte[] using HexString * * @param mac * A colon separated string of 6 pairs of octets, e..g., * "00:17:42:EF:CD:8D" */ public OFMatch setDataLayerDestination(String mac) { byte bytes[] = HexString.fromHexString(mac); if (bytes.length != 6) throw new IllegalArgumentException( "expected string with 6 octets, got '" + mac + "'"); this.dataLayerDestination = bytes; return this; } /** * Get dl_src * * @return an array of bytes */ public byte[] getDataLayerSource() { return this.dataLayerSource; } /** * Set dl_src * * @param dataLayerSource */ public OFMatch setDataLayerSource(byte[] dataLayerSource) { this.dataLayerSource = dataLayerSource; return this; } /** * Set dl_src, but first translate to byte[] using HexString * * @param mac * A colon separated string of 6 pairs of octets, e..g., * "00:17:42:EF:CD:8D" */ public OFMatch setDataLayerSource(String mac) { byte bytes[] = HexString.fromHexString(mac); if (bytes.length != 6) throw new IllegalArgumentException( "expected string with 6 octets, got '" + mac + "'"); this.dataLayerSource = bytes; return this; } /** * Get dl_type * * @return ether_type */ public short getDataLayerType() { return this.dataLayerType; } /** * Set dl_type * * @param dataLayerType */ public OFMatch setDataLayerType(short dataLayerType) { this.dataLayerType = dataLayerType; return this; } /** * Get dl_vlan * * @return vlan tag; VLAN_NONE == no tag */ public short getDataLayerVirtualLan() { return this.dataLayerVirtualLan; } /** * Set dl_vlan * * @param dataLayerVirtualLan */ public OFMatch setDataLayerVirtualLan(short dataLayerVirtualLan) { this.dataLayerVirtualLan = dataLayerVirtualLan; return this; } /** * Get dl_vlan_pcp * * @return */ public byte getDataLayerVirtualLanPriorityCodePoint() { return this.dataLayerVirtualLanPriorityCodePoint; } /** * Set dl_vlan_pcp * * @param pcp */ public OFMatch setDataLayerVirtualLanPriorityCodePoint(byte pcp) { this.dataLayerVirtualLanPriorityCodePoint = pcp; return this; } /** * Get in_port * * @return */ public short getInputPort() { return this.inputPort; } /** * Set in_port * * @param inputPort */ public OFMatch setInputPort(short inputPort) { this.inputPort = inputPort; return this; } /** * Get nw_dst * * @return */ public int getNetworkDestination() { return this.networkDestination; } /** * Set nw_dst * * @param networkDestination */ public OFMatch setNetworkDestination(int networkDestination) { this.networkDestination = networkDestination; return this; } /** * Parse this match's wildcard fields and return the number of significant * bits in the IP destination field. * * NOTE: this returns the number of bits that are fixed, i.e., like CIDR, * not the number of bits that are free like OpenFlow encodes. * * @return a number between 0 (matches all IPs) and 63 ( 32>= implies exact * match) */ public int getNetworkDestinationMaskLen() { return Math .max(32 - ((wildcards & OFPFW_NW_DST_MASK) >> OFPFW_NW_DST_SHIFT), 0); } /** * Parse this match's wildcard fields and return the number of significant * bits in the IP destination field. * * NOTE: this returns the number of bits that are fixed, i.e., like CIDR, * not the number of bits that are free like OpenFlow encodes. * * @return a number between 0 (matches all IPs) and 32 (exact match) */ public int getNetworkSourceMaskLen() { return Math .max(32 - ((wildcards & OFPFW_NW_SRC_MASK) >> OFPFW_NW_SRC_SHIFT), 0); } /** * Get nw_proto * * @return */ public byte getNetworkProtocol() { return this.networkProtocol; } /** * Set nw_proto * * @param networkProtocol */ public OFMatch setNetworkProtocol(byte networkProtocol) { this.networkProtocol = networkProtocol; return this; } /** * Get nw_src * * @return */ public int getNetworkSource() { return this.networkSource; } /** * Set nw_src * * @param networkSource */ public OFMatch setNetworkSource(int networkSource) { this.networkSource = networkSource; return this; } /** * Get nw_tos * OFMatch stores the ToS bits as top 6-bits, so right shift by 2 bits * before returning the value * * @return : 6-bit DSCP value (0-63) */ public byte getNetworkTypeOfService() { return (byte) ((this.networkTypeOfService >> 2) & 0x3f); } /** * Set nw_tos * OFMatch stores the ToS bits as top 6-bits, so left shift by 2 bits * before storing the value * * @param networkTypeOfService : 6-bit DSCP value (0-63) */ public OFMatch setNetworkTypeOfService(byte networkTypeOfService) { this.networkTypeOfService = (byte)(networkTypeOfService << 2); return this; } /** * Get tp_dst * * @return */ public short getTransportDestination() { return this.transportDestination; } /** * Set tp_dst * * @param transportDestination */ public OFMatch setTransportDestination(short transportDestination) { this.transportDestination = transportDestination; return this; } /** * Get tp_src * * @return */ public short getTransportSource() { return this.transportSource; } /** * Set tp_src * * @param transportSource */ public OFMatch setTransportSource(short transportSource) { this.transportSource = transportSource; return this; } /** * Get wildcards * * @return */ public int getWildcards() { return this.wildcards; } /** * Set wildcards * * @param wildcards */ public OFMatch setWildcards(int wildcards) { this.wildcards = wildcards; return this; } /** * Initializes this OFMatch structure with the corresponding data from the * specified packet. * * Must specify the input port, to ensure that this.in_port is set * correctly. * * Specify OFPort.NONE or OFPort.ANY if input port not applicable or * available * * @param packetData * The packet's data * @param inputPort * the port the packet arrived on */ public OFMatch loadFromPacket(byte[] packetData, short inputPort) { short scratch; int transportOffset = 34; ByteBuffer packetDataBB = ByteBuffer.wrap(packetData); int limit = packetDataBB.limit(); this.wildcards = 0; // all fields have explicit entries this.inputPort = inputPort; if (inputPort == OFPort.OFPP_ALL.getValue()) this.wildcards |= OFPFW_IN_PORT; assert (limit >= 14); // dl dst this.dataLayerDestination = new byte[6]; packetDataBB.get(this.dataLayerDestination); // dl src this.dataLayerSource = new byte[6]; packetDataBB.get(this.dataLayerSource); // dl type this.dataLayerType = packetDataBB.getShort(); if (getDataLayerType() != (short) 0x8100) { // need cast to avoid signed // bug setDataLayerVirtualLan((short) 0xffff); setDataLayerVirtualLanPriorityCodePoint((byte) 0); } else { // has vlan tag scratch = packetDataBB.getShort(); setDataLayerVirtualLan((short) (0xfff & scratch)); setDataLayerVirtualLanPriorityCodePoint((byte) ((0xe000 & scratch) >> 13)); this.dataLayerType = packetDataBB.getShort(); } switch (getDataLayerType()) { case 0x0800: // ipv4 // check packet length scratch = packetDataBB.get(); scratch = (short) (0xf & scratch); transportOffset = (packetDataBB.position() - 1) + (scratch * 4); // nw tos (dscp) scratch = packetDataBB.get(); setNetworkTypeOfService((byte) ((0xfc & scratch) >> 2)); // nw protocol packetDataBB.position(packetDataBB.position() + 7); this.networkProtocol = packetDataBB.get(); // nw src packetDataBB.position(packetDataBB.position() + 2); this.networkSource = packetDataBB.getInt(); // nw dst this.networkDestination = packetDataBB.getInt(); packetDataBB.position(transportOffset); break; case 0x0806: // arp int arpPos = packetDataBB.position(); // opcode scratch = packetDataBB.getShort(arpPos + 6); setNetworkProtocol((byte) (0xff & scratch)); scratch = packetDataBB.getShort(arpPos + 2); // if ipv4 and addr len is 4 if (scratch == 0x800 && packetDataBB.get(arpPos + 5) == 4) { // nw src this.networkSource = packetDataBB.getInt(arpPos + 14); // nw dst this.networkDestination = packetDataBB.getInt(arpPos + 24); } else { setNetworkSource(0); setNetworkDestination(0); } break; default: setNetworkTypeOfService((byte) 0); setNetworkProtocol((byte) 0); setNetworkSource(0); setNetworkDestination(0); break; } switch (getNetworkProtocol()) { case 0x01: // icmp // type this.transportSource = U8.f(packetDataBB.get()); // code this.transportDestination = U8.f(packetDataBB.get()); break; case 0x06: // tcp // tcp src this.transportSource = packetDataBB.getShort(); // tcp dest this.transportDestination = packetDataBB.getShort(); break; case 0x11: // udp // udp src this.transportSource = packetDataBB.getShort(); // udp dest this.transportDestination = packetDataBB.getShort(); break; default: setTransportDestination((short) 0); setTransportSource((short) 0); break; } return this; } /** * Read this message off the wire from the specified ByteBuffer * * @param data */ public void readFrom(ChannelBuffer data) { this.wildcards = data.readInt(); this.inputPort = data.readShort(); this.dataLayerSource = new byte[6]; data.readBytes(this.dataLayerSource); this.dataLayerDestination = new byte[6]; data.readBytes(this.dataLayerDestination); this.dataLayerVirtualLan = data.readShort(); this.dataLayerVirtualLanPriorityCodePoint = data.readByte(); data.readByte(); // pad this.dataLayerType = data.readShort(); this.networkTypeOfService = data.readByte(); this.networkProtocol = data.readByte(); data.readByte(); // pad data.readByte(); // pad this.networkSource = data.readInt(); this.networkDestination = data.readInt(); this.transportSource = data.readShort(); this.transportDestination = data.readShort(); } /** * Write this message's binary format to the specified ByteBuffer * * @param data */ public void writeTo(ChannelBuffer data) { data.writeInt(wildcards); data.writeShort(inputPort); data.writeBytes(this.dataLayerSource); data.writeBytes(this.dataLayerDestination); data.writeShort(dataLayerVirtualLan); data.writeByte(dataLayerVirtualLanPriorityCodePoint); data.writeByte((byte) 0x0); // pad data.writeShort(dataLayerType); data.writeByte(networkTypeOfService); data.writeByte(networkProtocol); data.writeByte((byte) 0x0); // pad data.writeByte((byte) 0x0); // pad data.writeInt(networkSource); data.writeInt(networkDestination); data.writeShort(transportSource); data.writeShort(transportDestination); } @Override public int hashCode() { final int prime = 131; int result = 1; result = prime * result + Arrays.hashCode(dataLayerDestination); result = prime * result + Arrays.hashCode(dataLayerSource); result = prime * result + dataLayerType; result = prime * result + dataLayerVirtualLan; result = prime * result + dataLayerVirtualLanPriorityCodePoint; result = prime * result + inputPort; result = prime * result + networkDestination; result = prime * result + networkProtocol; result = prime * result + networkSource; result = prime * result + networkTypeOfService; result = prime * result + transportDestination; result = prime * result + transportSource; result = prime * result + wildcards; return result; } @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!(obj instanceof OFMatch)) { return false; } OFMatch other = (OFMatch) obj; if (!Arrays.equals(dataLayerDestination, other.dataLayerDestination)) { return false; } if (!Arrays.equals(dataLayerSource, other.dataLayerSource)) { return false; } if (dataLayerType != other.dataLayerType) { return false; } if (dataLayerVirtualLan != other.dataLayerVirtualLan) { return false; } if (dataLayerVirtualLanPriorityCodePoint != other.dataLayerVirtualLanPriorityCodePoint) { return false; } if (inputPort != other.inputPort) { return false; } if (networkDestination != other.networkDestination) { return false; } if (networkProtocol != other.networkProtocol) { return false; } if (networkSource != other.networkSource) { return false; } if (networkTypeOfService != other.networkTypeOfService) { return false; } if (transportDestination != other.transportDestination) { return false; } if (transportSource != other.transportSource) { return false; } if ((wildcards & OFMatch.OFPFW_ALL) != (other.wildcards & OFPFW_ALL)) { // only // consider // allocated // part // of // wildcards return false; } return true; } /** * Implement clonable interface */ @Override public OFMatch clone() { try { OFMatch ret = (OFMatch) super.clone(); ret.dataLayerDestination = this.dataLayerDestination.clone(); ret.dataLayerSource = this.dataLayerSource.clone(); return ret; } catch (CloneNotSupportedException e) { throw new RuntimeException(e); } } /** * Output a dpctl-styled string, i.e., only list the elements that are not * wildcarded * * A match-everything OFMatch outputs "OFMatch[]" * * @return * "OFMatch[dl_src:00:20:01:11:22:33,nw_src:192.168.0.0/24,tp_dst:80]" */ @Override public String toString() { String str = ""; // l1 if ((wildcards & OFPFW_IN_PORT) == 0) str += "," + STR_IN_PORT + "=" + U16.f(this.inputPort); // l2 if ((wildcards & OFPFW_DL_DST) == 0) str += "," + STR_DL_DST + "=" + HexString.toHexString(this.dataLayerDestination); if ((wildcards & OFPFW_DL_SRC) == 0) str += "," + STR_DL_SRC + "=" + HexString.toHexString(this.dataLayerSource); if ((wildcards & OFPFW_DL_TYPE) == 0) str += "," + STR_DL_TYPE + "=0x" + Integer.toHexString(U16.f(this.dataLayerType)); if ((wildcards & OFPFW_DL_VLAN) == 0) str += "," + STR_DL_VLAN + "=0x" + Integer.toHexString(U16.f(this.dataLayerVirtualLan)); if ((wildcards & OFPFW_DL_VLAN_PCP) == 0) str += "," + STR_DL_VLAN_PCP + "=" + Integer.toHexString(U8 .f(this.dataLayerVirtualLanPriorityCodePoint)); // l3 if (getNetworkDestinationMaskLen() > 0) str += "," + STR_NW_DST + "=" + cidrToString(networkDestination, getNetworkDestinationMaskLen()); if (getNetworkSourceMaskLen() > 0) str += "," + STR_NW_SRC + "=" + cidrToString(networkSource, getNetworkSourceMaskLen()); if ((wildcards & OFPFW_NW_PROTO) == 0) str += "," + STR_NW_PROTO + "=" + this.networkProtocol; if ((wildcards & OFPFW_NW_TOS) == 0) str += "," + STR_NW_TOS + "=" + this.getNetworkTypeOfService(); // l4 if ((wildcards & OFPFW_TP_DST) == 0) str += "," + STR_TP_DST + "=" + this.transportDestination; if ((wildcards & OFPFW_TP_SRC) == 0) str += "," + STR_TP_SRC + "=" + this.transportSource; if ((str.length() > 0) && (str.charAt(0) == ',')) str = str.substring(1); // trim the leading "," // done return "OFMatch[" + str + "]"; } private String cidrToString(int ip, int prefix) { String str; if (prefix >= 32) { str = ipToString(ip); } else { // use the negation of mask to fake endian magic int mask = ~((1 << (32 - prefix)) - 1); str = ipToString(ip & mask) + "/" + prefix; } return str; } /** * Set this OFMatch's parameters based on a comma-separated key=value pair * dpctl-style string, e.g., from the output of OFMatch.toString() <br> * <p> * Supported keys/values include <br> * <p> * <TABLE border=1> * <TR> * <TD>KEY(s) * <TD>VALUE * </TR> * <TR> * <TD>"in_port","input_port" * <TD>integer * </TR> * <TR> * <TD>"dl_src","eth_src", "dl_dst","eth_dst" * <TD>hex-string * </TR> * <TR> * <TD>"dl_type", "dl_vlan", "dl_vlan_pcp" * <TD>integer * </TR> * <TR> * <TD>"nw_src", "nw_dst", "ip_src", "ip_dst" * <TD>CIDR-style netmask * </TR> * <TR> * <TD>"tp_src","tp_dst" * <TD>integer (max 64k) * </TR> * </TABLE> * <p> * The CIDR-style netmasks assume 32 netmask if none given, so: * "128.8.128.118/32" is the same as "128.8.128.118" * * @param match * a key=value comma separated string, e.g. * "in_port=5,ip_dst=192.168.0.0/16,tp_src=80" * @throws IllegalArgumentException * on unexpected key or value */ public void fromString(String match) throws IllegalArgumentException { if (match.equals("") || match.equalsIgnoreCase("any") || match.equalsIgnoreCase("all") || match.equals("[]")) match = "OFMatch[]"; String[] tokens = match.split("[\\[,\\]]"); String[] values; int initArg = 0; if (tokens[0].equals("OFMatch")) initArg = 1; this.wildcards = OFPFW_ALL; int i; for (i = initArg; i < tokens.length; i++) { values = tokens[i].split("="); if (values.length != 2) throw new IllegalArgumentException("Token " + tokens[i] + " does not have form 'key=value' parsing " + match); values[0] = values[0].toLowerCase(); // try to make this case insens if (values[0].equals(STR_IN_PORT) || values[0].equals("input_port")) { this.inputPort = U16.t(Integer.valueOf(values[1])); this.wildcards &= ~OFPFW_IN_PORT; } else if (values[0].equals(STR_DL_DST) || values[0].equals("eth_dst")) { this.dataLayerDestination = HexString.fromHexString(values[1]); this.wildcards &= ~OFPFW_DL_DST; } else if (values[0].equals(STR_DL_SRC) || values[0].equals("eth_src")) { this.dataLayerSource = HexString.fromHexString(values[1]); this.wildcards &= ~OFPFW_DL_SRC; } else if (values[0].equals(STR_DL_TYPE) || values[0].equals("eth_type")) { if (values[1].startsWith("0x")) this.dataLayerType = U16.t(Integer.valueOf( values[1].replaceFirst("0x", ""), 16)); else this.dataLayerType = U16.t(Integer.valueOf(values[1])); this.wildcards &= ~OFPFW_DL_TYPE; } else if (values[0].equals(STR_DL_VLAN)) { if (values[1].startsWith("0x")) this.dataLayerVirtualLan = U16.t(Integer.valueOf( values[1].replaceFirst("0x", ""),16)); else this.dataLayerVirtualLan = U16.t(Integer.valueOf(values[1])); this.wildcards &= ~OFPFW_DL_VLAN; } else if (values[0].equals(STR_DL_VLAN_PCP)) { this.dataLayerVirtualLanPriorityCodePoint = U8.t(Short .valueOf(values[1])); this.wildcards &= ~OFPFW_DL_VLAN_PCP; } else if (values[0].equals(STR_NW_DST) || values[0].equals("ip_dst")) { setFromCIDR(values[1], STR_NW_DST); } else if (values[0].equals(STR_NW_SRC) || values[0].equals("ip_src")) { setFromCIDR(values[1], STR_NW_SRC); } else if (values[0].equals(STR_NW_PROTO)) { this.networkProtocol = U8.t(Short.valueOf(values[1])); this.wildcards &= ~OFPFW_NW_PROTO; } else if (values[0].equals(STR_NW_TOS)) { this.setNetworkTypeOfService(U8.t(Short.valueOf(values[1]))); this.wildcards &= ~OFPFW_NW_TOS; } else if (values[0].equals(STR_TP_DST)) { this.transportDestination = U16.t(Integer.valueOf(values[1])); this.wildcards &= ~OFPFW_TP_DST; } else if (values[0].equals(STR_TP_SRC)) { this.transportSource = U16.t(Integer.valueOf(values[1])); this.wildcards &= ~OFPFW_TP_SRC; } else { throw new IllegalArgumentException("unknown token " + tokens[i] + " parsing " + match); } } } /** * Set the networkSource or networkDestionation address and their wildcards * from the CIDR string * * @param cidr * "192.168.0.0/16" or "172.16.1.5" * @param which * one of STR_NW_DST or STR_NW_SRC * @throws IllegalArgumentException */ private void setFromCIDR(String cidr, String which) throws IllegalArgumentException { String values[] = cidr.split("/"); String[] ip_str = values[0].split("\\."); int ip = 0; ip += Integer.valueOf(ip_str[0]) << 24; ip += Integer.valueOf(ip_str[1]) << 16; ip += Integer.valueOf(ip_str[2]) << 8; ip += Integer.valueOf(ip_str[3]); int prefix = 32; // all bits are fixed, by default if (values.length >= 2) prefix = Integer.valueOf(values[1]); int mask = 32 - prefix; if (which.equals(STR_NW_DST)) { this.networkDestination = ip; this.wildcards = (wildcards & ~OFPFW_NW_DST_MASK) | (mask << OFPFW_NW_DST_SHIFT); } else if (which.equals(STR_NW_SRC)) { this.networkSource = ip; this.wildcards = (wildcards & ~OFPFW_NW_SRC_MASK) | (mask << OFPFW_NW_SRC_SHIFT); } } protected static String ipToString(int ip) { return Integer.toString(U8.f((byte) ((ip & 0xff000000) >> 24))) + "." + Integer.toString((ip & 0x00ff0000) >> 16) + "." + Integer.toString((ip & 0x0000ff00) >> 8) + "." + Integer.toString(ip & 0x000000ff); } }