--- /dev/null
+
+/*
+ * 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.sal.match.extensible;
+
+import java.io.Serializable;
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+
+
+import org.opendaylight.controller.sal.utils.NetUtils;
+
+/**
+ * Represents the generic match criteria for a network frame/packet/message
+ * It contains a collection of individual field match
+ *
+ */
+@XmlRootElement
+@XmlAccessorType(XmlAccessType.NONE)
+public class Match implements Cloneable, Serializable {
+ private static final long serialVersionUID = 1L;
+ private Map<String, MatchField<?>> fields;
+
+ public Match() {
+ fields = new HashMap<String, MatchField<?>>();
+ }
+
+ public Match(Match match) {
+ fields = new HashMap<String, MatchField<?>>(match.fields);
+ }
+
+ /**
+ * Generic setter for frame/packet/message's header field against which to match
+ *
+ * @param field the fields parameters as MAtchField object
+ */
+ public void setField(MatchField<?> field) {
+ if (field.isValid()) {
+ fields.put(field.getType(), field);
+ }
+ }
+
+ /**
+ * Generic method to clear a field from the match
+ */
+ public void clearField(String type) {
+ fields.remove(type);
+ }
+
+ /**
+ * Generic getter for fields against which the match is programmed
+ *
+ * @param type frame/packet/message's header field type
+ * @return
+ */
+ public MatchField<?> getField(String type) {
+ return fields.get(type);
+ }
+
+ /**
+ * Returns the list of MatchType fields the match is set for
+ *
+ * @return List of individual MatchType fields.
+ */
+ public List<String> getMatchesList() {
+ return new ArrayList<String>(fields.keySet());
+ }
+
+ /**
+ * Returns the list of MatchFields the match is set for
+ *
+ * @return List of individual MatchField values.
+ */
+ @XmlElement(name="matchField")
+ public List<MatchField<?>> getMatchFields() {
+ return new ArrayList<MatchField<?>>(fields.values());
+ }
+
+ /**
+ * Returns whether this match is for an IPv6 flow
+ */
+ public boolean isIPv6() {
+ if (isPresent(DlType.TYPE)) {
+ for (MatchField<?> field : fields.values()) {
+ if (!field.isV6()) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Returns whether this match is for an IPv4 flow
+ */
+ public boolean isIPv4() {
+ return !isIPv6();
+ }
+
+ /**
+ * Returns whether for the specified field type the match is to be considered "any"
+ * Equivalent to say this match does not care about the value of the specified field
+ *
+ * @param type
+ * @return
+ */
+ public boolean isAny(String type) {
+ return !fields.containsKey(type);
+ }
+
+ /**
+ * Returns whether a match for the specified field type is configured
+ *
+ * @param type
+ * @return
+ */
+ public boolean isPresent(String type) {
+ return (fields.get(type) != null);
+ }
+
+ public boolean isEmpty() {
+ return fields.isEmpty();
+ }
+
+ @Override
+ public Match clone() {
+ Match cloned = null;
+ try {
+ cloned = (Match) super.clone();
+ cloned.fields = new HashMap<String, MatchField<?>>();
+ for (Entry<String, MatchField<?>> entry : this.fields.entrySet()) {
+ cloned.fields.put(entry.getKey(), entry.getValue().clone());
+ }
+ } catch (CloneNotSupportedException e) {
+ throw new RuntimeException(e);
+ }
+ return cloned;
+ }
+
+ /**
+ * Returns a reversed version of this match
+ * For example, in the reversed version the network source and destination
+ * addresses will be exchanged. Non symmetric match field will not be
+ * copied over into the reversed match version, like input port.
+ *
+ * @return
+ */
+ public Match reverse() {
+ Match reverse = new Match();
+ for (MatchField<?> field : fields.values()) {
+ reverse.setField(field.hasReverse()? field.getReverse() : field.clone());
+ }
+
+ // Reset asymmetric fields
+ reverse.clearField(InPort.TYPE);
+
+ return reverse;
+ }
+
+ /**
+ * Check whether the current match conflicts with the passed filter match
+ * This match conflicts with the filter if for at least a MatchType defined
+ * in the filter match, the respective MatchFields differ or are not
+ * compatible
+ *
+ * In other words the function returns true if the set of packets described
+ * by one match and the set of packets described by the other match are
+ * disjoint. Equivalently, if the intersection of the two sets of packets
+ * described by the two org.opendaylight.controller.sal.matches is an empty.
+ *
+ * For example, Let's suppose the filter has the following MatchFields:
+ * DL_TYPE = 0x800
+ * NW_DST = 172.20.30.110/24
+ *
+ * while this match has the following MatchFields:
+ * DL_TYPE = 0x800
+ * NW_DST = 172.20.30.45/24
+ * TP_DST = 80
+ *
+ * Then the function would return false as the two Match are not
+ * conflicting.
+ *
+ * Note: the mask value is taken into account only for MatchType.NW_SRC and
+ * MatchType.NW_DST
+ *
+ * @param match
+ * the Match describing the filter
+ * @return true if the set of packets described by one match and the set of
+ * packets described by the other match are disjoint, false
+ * otherwise
+ */
+ public boolean conflictWithFilter(Match filter) {
+ return !this.intersetcs(filter);
+ }
+
+ /**
+ * Merge the current Match fields with the fields of the filter Match. A
+ * check is first run to see if this Match is compatible with the filter
+ * Match. If it is not, the merge is not attempted.
+ *
+ * The result is the match object representing the intersection of the set
+ * of packets described by this match with the set of packets described by
+ * the filter match. If the intersection of the two sets is empty, the
+ * return match will be null.
+ *
+ * @param filter
+ * the match with which attempting the merge
+ * @return a new Match object describing the set of packets represented by
+ * the intersection of this and the filter org.opendaylight.controller.sal.matches. null if the
+ * intersection is empty.
+ */
+ public Match mergeWithFilter(Match filter) {
+ return this.getIntersection(filter);
+ }
+
+ /**
+ * Return the match representing the intersection of the set of packets
+ * described by this match with the set of packets described by the other
+ * match. Such as m.getIntersection(m) == m, m.getIntersection(u) == m and
+ * m.getIntersection(o) == o where u is an empty match (universal set, all
+ * packets) and o is the null match (empty set).
+ *
+ * @param other
+ * the match with which computing the intersection
+ * @return a new Match object representing the intersection of the set of
+ * packets described by this match with the set of packets described
+ * by the other match. null when the intersection is the empty set.
+ */
+ public Match getIntersection(Match other) {
+ // If no intersection, return the empty set
+ if (!this.intersetcs(other)) {
+ return null;
+ }
+ // Check if any of the two is the universal match
+ if (this.isEmpty()) {
+ return other.clone();
+ }
+ if (other.isEmpty()) {
+ return this.clone();
+ }
+ // Get all the match types for both filters
+ Set<String> allTypes = new HashSet<String>(this.fields.keySet());
+ allTypes.addAll(new HashSet<String>(other.fields.keySet()));
+ // Derive the intersection
+ Match intersection = new Match();
+ for (String type : allTypes) {
+ if (this.isAny(type) && other.isAny(type)) {
+ continue;
+ }
+ if (this.isAny(type)) {
+ intersection.setField(other.getField(type).clone());
+ continue;
+ } else if (other.isAny(type)) {
+ intersection.setField(this.getField(type).clone());
+ continue;
+ }
+ // Either they are equal or it is about IP address
+ switch (type) {
+ // When it is about IP address, take the wider prefix address
+ // between the twos
+ case NwSrc.TYPE:
+ case NwDst.TYPE:
+ MatchField<?> thisField = this.getField(type);
+ MatchField<?> otherField = other.getField(type);
+ InetAddress thisAddress = (InetAddress) thisField.getValue();
+ InetAddress otherAddress = (InetAddress) otherField.getValue();
+ InetAddress thisMask = (InetAddress) thisField.getMask();
+ InetAddress otherMask = (InetAddress) otherField.getMask();
+
+ int thisMaskLen = (thisMask == null) ? ((thisAddress instanceof Inet4Address) ? 32 : 128) : NetUtils
+ .getSubnetMaskLength(thisMask);
+ int otherMaskLen = (otherMask == null) ? ((otherAddress instanceof Inet4Address) ? 32 : 128) : NetUtils
+ .getSubnetMaskLength(otherMask);
+
+ InetAddress subnetPrefix = null;
+ InetAddress subnetMask = null;
+ if (thisMaskLen < otherMaskLen) {
+ subnetPrefix = NetUtils.getSubnetPrefix(otherAddress, otherMaskLen);
+ subnetMask = otherMask;
+ } else {
+ subnetPrefix = NetUtils.getSubnetPrefix(thisAddress, thisMaskLen);
+ subnetMask = thisMask;
+ }
+ MatchField<?> field = (type.equals(NwSrc.TYPE)) ? new NwSrc(subnetPrefix, subnetMask) : new NwDst(
+ subnetPrefix, subnetMask);
+ intersection.setField(field);
+ break;
+ default:
+ // this and other match field are equal for this type, pick this
+ // match field
+ intersection.setField(this.getField(type).clone());
+ }
+ }
+ return intersection;
+ }
+
+ /**
+ * Checks whether the intersection of the set of packets described by this
+ * match with the set of packets described by the other match is non empty
+ *
+ * For example, if this match is: DL_SRC = 00:cc:bb:aa:11:22
+ *
+ * and the other match is: DL_TYPE = 0x800 NW_SRC = 1.2.3.4
+ *
+ * then their respective matching packets set intersection is non empty:
+ * DL_SRC = 00:cc:bb:aa:11:22 DL_TYPE = 0x800 NW_SRC = 1.2.3.4
+ *
+ * @param other
+ * the other match with which testing the intersection
+ * @return true if the intersection of the respective matching packets sets
+ * is non empty
+ */
+ public boolean intersetcs(Match other) {
+ // No intersection with the empty set
+ if (other == null) {
+ return false;
+ }
+ // Always intersection with the universal set
+ if (this.isEmpty() || other.isEmpty()) {
+ return true;
+ }
+
+ // Get all the match types for both filters
+ Set<String> allTypes = new HashSet<String>(this.fields.keySet());
+ allTypes.addAll(new HashSet<String>(other.fields.keySet()));
+
+ // Iterate through all the match types defined in the two filters
+ for (String type : allTypes) {
+ if (this.isAny(type) || other.isAny(type)) {
+ continue;
+ }
+
+ MatchField<?> thisField = this.getField(type);
+ MatchField<?> otherField = other.getField(type);
+
+ switch (type) {
+ case DlSrc.TYPE:
+ case DlDst.TYPE:
+ if (!Arrays.equals((byte[]) thisField.getValue(), (byte[]) otherField.getValue())) {
+ return false;
+ }
+ break;
+ case NwSrc.TYPE:
+ case NwDst.TYPE:
+ InetAddress thisAddress = (InetAddress) thisField.getValue();
+ InetAddress otherAddress = (InetAddress) otherField.getValue();
+ // Validity check
+ if (thisAddress instanceof Inet4Address && otherAddress instanceof Inet6Address
+ || thisAddress instanceof Inet6Address && otherAddress instanceof Inet4Address) {
+ return false;
+ }
+ InetAddress thisMask = (InetAddress) thisField.getMask();
+ InetAddress otherMask = (InetAddress) otherField.getMask();
+ if (NetUtils.inetAddressConflict(thisAddress, otherAddress, thisMask, otherMask)
+ && NetUtils.inetAddressConflict(otherAddress, thisAddress, otherMask, thisMask)) {
+ return false;
+ }
+ break;
+ default:
+ if (!thisField.getValue().equals(otherField.getValue())) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + ((fields == null) ? 0 : fields.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj == null) {
+ return false;
+ }
+ if (!(obj instanceof Match)) {
+ return false;
+ }
+ Match other = (Match) obj;
+ if (fields == null) {
+ if (other.fields != null) {
+ return false;
+ }
+ } else if (!fields.equals(other.fields)) {
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ return "Match[" + fields.values() + "]";
+ }
+}
Code Review / controller.git / blobdiff