opendaylight/sal/api/src/main/java/org/opendaylight/controller/sal/match/Match.java

   1
   2 /*
   3  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   4  *
   5  * This program and the accompanying materials are made available under the
   6  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   7  * and is available at http://www.eclipse.org/legal/epl-v10.html
   8  */
   9
  10 package org.opendaylight.controller.sal.match;
  11
  12 import java.io.Serializable;
  13 import java.net.Inet4Address;
  14 import java.net.Inet6Address;
  15 import java.net.InetAddress;
  16 import java.util.ArrayList;
  17 import java.util.Arrays;
  18 import java.util.Collections;
  19 import java.util.HashMap;
  20 import java.util.List;
  21 import java.util.Map;
  22 import java.util.Map.Entry;
  23
  24 import javax.xml.bind.annotation.XmlAccessType;
  25 import javax.xml.bind.annotation.XmlAccessorType;
  26 import javax.xml.bind.annotation.XmlElement;
  27 import javax.xml.bind.annotation.XmlRootElement;
  28
  29 import org.opendaylight.controller.sal.utils.EtherTypes;
  30 import org.opendaylight.controller.sal.utils.IPProtocols;
  31 import org.opendaylight.controller.sal.utils.NetUtils;
  32
  33 /**
  34  * Represents the generic match criteria for a network frame/packet/message
  35  * It contains a collection of individual field match
  36  *
  37  */
  38 @XmlRootElement
  39 @XmlAccessorType(XmlAccessType.NONE)
  40 public class Match implements Cloneable, Serializable {
  41         private static final long serialVersionUID = 1L;
  42         private static final Map<MatchType, MatchType> reversableMatches;
  43     static {
  44         Map<MatchType, MatchType> map = new HashMap<MatchType, MatchType>();
  45         map.put(MatchType.DL_SRC, MatchType.DL_DST);
  46         map.put(MatchType.DL_DST, MatchType.DL_SRC);
  47         map.put(MatchType.NW_SRC, MatchType.NW_DST);
  48         map.put(MatchType.NW_DST, MatchType.NW_SRC);
  49         map.put(MatchType.TP_SRC, MatchType.TP_DST);
  50         map.put(MatchType.TP_DST, MatchType.TP_SRC);
  51         reversableMatches = Collections.unmodifiableMap(map);
  52     }
  53     private Map<MatchType, MatchField> fields;
  54     private int matches; // concise way to tell which fields the match is set for (may remove if not needed)
  55
  56     public Match() {
  57         fields = new HashMap<MatchType, MatchField>();
  58         matches = 0;
  59     }
  60
  61     public Match(Match match) {
  62         fields = new HashMap<MatchType, MatchField>(match.fields);
  63         matches = match.matches;
  64     }
  65
  66     /**
  67      * Generic setter for frame/packet/message's header fields against which to match
  68      * Note: For MAC addresses, please pass the cloned value to this function
  69      *
  70      * @param type      packet's header field type
  71      * @param value     field's value to assign to the match
  72      * @param mask      field's bitmask to apply to the match (has to be of the same class type of value)
  73      */
  74     public void setField(MatchType type, Object value, Object mask) {
  75         MatchField field = new MatchField(type, value, mask);
  76         if (field.isValid()) {
  77             fields.put(type, field);
  78             matches |= type.getIndex();
  79         }
  80     }
  81
  82     /**
  83      * Generic setter for frame/packet/message's header fields against which to match
  84      * Note: For MAC addresses, please pass the cloned value to this function
  85      *
  86      * @param type      packet's header field type
  87      * @param value     field's value to assign to the match
  88      */
  89     public void setField(MatchType type, Object value) {
  90         MatchField field = new MatchField(type, value);
  91         if (field.isValid()) {
  92             fields.put(type, field);
  93             matches |= type.getIndex();
  94         }
  95     }
  96
  97     /**
  98      * Generic setter for frame/packet/message's header field against which to match
  99      *
 100      * @param field the fields parameters as MAtchField object
 101      */
 102     public void setField(MatchField field) {
 103         if (field.isValid()) {
 104             fields.put(field.getType(), field);
 105             matches |= field.getType().getIndex();
 106         }
 107     }
 108
 109     /**
 110      * Generic method to clear a field from the match
 111      */
 112     public void clearField(MatchType type) {
 113         fields.remove(type);
 114         matches &= ~type.getIndex();
 115     }
 116
 117     /**
 118      * Generic getter for fields against which the match is programmed
 119      *
 120      * @param type  frame/packet/message's header field type
 121      * @return
 122      */
 123     public MatchField getField(MatchType type) {
 124         return fields.get(type);
 125     }
 126
 127     /**
 128      * Returns the fields the match is set for in a bitmask fashion
 129      * Each bit represents a field the match is configured for
 130      *
 131      * @return the 32 bit long mask (Refer to {@code}org.opendaylight.controller.sal.match.MatchElement)
 132      */
 133     public int getMatches() {
 134         return matches;
 135     }
 136
 137     /**
 138      * Returns the list of MatchType fields the match is set for
 139      *
 140      * @return List of individual MatchType fields.
 141      */
 142     public List<MatchType> getMatchesList() {
 143         return new ArrayList<MatchType>(fields.keySet());
 144     }
 145
 146     /**
 147      * Returns the list of MatchFields the match is set for
 148      *
 149      * @return List of individual MatchField values.
 150      */
 151     @XmlElement(name="matchField")
 152     public List<MatchField> getMatchFields() {
 153         return new ArrayList<MatchField>(fields.values());
 154     }
 155
 156     /**
 157      * Returns whether this match is for an IPv6 flow
 158      */
 159     public boolean isIPv6() {
 160         return (isPresent(MatchType.DL_TYPE)
 161                 && ((Short) getField(MatchType.DL_TYPE).getValue())
 162                         .equals(EtherTypes.IPv6.shortValue())
 163                 || isPresent(MatchType.NW_PROTO)
 164                 && ((Byte) getField(MatchType.NW_PROTO).getValue())
 165                         .equals(IPProtocols.IPV6ICMP.byteValue())
 166                 || isPresent(MatchType.NW_SRC)
 167                 && getField(MatchType.NW_SRC).getValue() instanceof Inet6Address || isPresent(MatchType.NW_DST)
 168                 && getField(MatchType.NW_DST).getValue() instanceof Inet6Address);
 169     }
 170
 171     /**
 172      * Returns whether this match is for an IPv4 flow
 173      */
 174     public boolean isIPv4() {
 175         return !isIPv6();
 176     }
 177
 178     /**
 179      * Returns whether for the specified field type the match is to be considered "any"
 180      * Equivalent to say this match does not care about the value of the specified field
 181      *
 182      * @param type
 183      * @return
 184      */
 185     public boolean isAny(MatchType type) {
 186         //return ((fields.get(type) == null) || (fields.get(type).getBitMask() == 0L));
 187         return !fields.containsKey(type);
 188     }
 189
 190     /**
 191      * Returns whether a match for the specified field type is configured
 192      *
 193      * @param type
 194      * @return
 195      */
 196     public boolean isPresent(MatchType type) {
 197         return (fields.get(type) != null);
 198     }
 199
 200     @Override
 201     public Match clone() {
 202         Match cloned = null;
 203         try {
 204             cloned = (Match) super.clone();
 205             cloned.matches = matches;
 206             cloned.fields = new HashMap<MatchType, MatchField>();
 207             for (Entry<MatchType, MatchField> entry : this.fields.entrySet()) {
 208                 cloned.fields.put(entry.getKey(), entry.getValue().clone());
 209             }
 210         } catch (CloneNotSupportedException e) {
 211             throw new RuntimeException(e);
 212         }
 213         return cloned;
 214     }
 215
 216     /**
 217      * Returns a reversed version of this match
 218      * For example, in the reversed version the network source and destination
 219      * addresses will be exchanged. Non symmetric match field will not be
 220      * copied over into the reversed match version, like input port.
 221      *
 222      * @return
 223      */
 224     public Match reverse() {
 225         // Copy over all fields
 226         Match reverse = this.clone();
 227
 228         // Flip symmetric fields
 229         for (Map.Entry<MatchType, MatchType> entry : Match.reversableMatches.entrySet()) {
 230             MatchType from = entry.getKey();
 231             MatchType to = entry.getValue();
 232             if (this.isPresent(from)) {
 233                 reverse.setField(to, this.getField(from).getValue(), this.getField(from).getMask());
 234                 if (!this.isPresent(to)) {
 235                     reverse.clearField(from);
 236                 }
 237             }
 238         }
 239
 240         // Reset asymmetric fields
 241         reverse.clearField(MatchType.IN_PORT);
 242
 243         return reverse;
 244     }
 245
 246     /**
 247      * Check whether the current match conflicts with the passed filter match
 248      * This match conflicts with the filter if for at least a MatchType defined
 249      * in the filter match, the respective MatchFields differ or are not compatible
 250      *
 251      * For example, Let's suppose the filter has the following MatchFields:
 252      * DL_TYPE = 0x800
 253      * NW_DST =  172.20.30.110/24
 254      *
 255      * while this match has the following MatchFields:
 256      * NW_DST = 172.20.30.45/24
 257      * TP_DST = 80
 258      *
 259      * Then the function would return false as the two Match are not conflicting
 260      *
 261      * Note: the mask value is taken into account only for MatchType.NW_SRC and MatchType.NW_DST
 262      *
 263      * @param match the MAtch describing the filter
 264      * @return true if the match is conflicting with the filter, false otherwise
 265      */
 266     public boolean conflictWithFilter(Match filter) {
 267         // Iterate through the MatchType defined in the filter
 268         for (MatchType type : filter.getMatchesList()) {
 269             if (this.isAny(type)) {
 270                 continue;
 271             }
 272
 273             MatchField thisField = this.getField(type);
 274             MatchField filterField = filter.getField(type);
 275
 276             switch (type) {
 277             case DL_SRC:
 278             case DL_DST:
 279                 if (Arrays.equals((byte[]) thisField.getValue(),
 280                         (byte[]) filterField.getValue())) {
 281                     return false;
 282                 }
 283                 break;
 284             case NW_SRC:
 285             case NW_DST:
 286                 InetAddress thisAddress = (InetAddress) thisField.getValue();
 287                 InetAddress filterAddress = (InetAddress) filterField
 288                         .getValue();
 289                 // Validity check
 290                 if (thisAddress instanceof Inet4Address
 291                         && filterAddress instanceof Inet6Address
 292                         || thisAddress instanceof Inet6Address
 293                         && filterAddress instanceof Inet4Address) {
 294                     return true;
 295                 }
 296                 InetAddress thisMask = (InetAddress) thisField.getMask();
 297                 InetAddress filterMask = (InetAddress) filterField.getMask();
 298                 // thisAddress has to be in same subnet of filterAddress
 299                 if (NetUtils.inetAddressConflict(thisAddress, filterAddress,
 300                         thisMask, filterMask)) {
 301                     return true;
 302                 }
 303                 break;
 304             default:
 305                 if (!thisField.getValue().equals(filterField.getValue())) {
 306                     return true;
 307                 }
 308             }
 309             //TODO: check v4 v6 incompatibility
 310         }
 311         return false;
 312     }
 313
 314     /**
 315      * Merge the current Match fields with the fields of the filter Match
 316      * A check is first run to see if this Match is compatible with the
 317      * filter Match. If it is not, the merge is not attempted.
 318      *
 319      *
 320      * @param filter
 321      * @return
 322      */
 323     public Match mergeWithFilter(Match filter) {
 324         if (!this.conflictWithFilter(filter)) {
 325             /*
 326              * No conflict with the filter
 327              * We can copy over the fields which this match does not have
 328              */
 329             for (MatchType type : filter.getMatchesList()) {
 330                 if (this.isAny(type)) {
 331                     this.setField(filter.getField(type).clone());
 332                 }
 333             }
 334         }
 335         return this;
 336     }
 337
 338     @Override
 339     public int hashCode() {
 340         final int prime = 31;
 341         int result = 1;
 342         result = prime * result + ((fields == null) ? 0 : fields.hashCode());
 343         result = prime * result + matches;
 344         return result;
 345     }
 346
 347     @Override
 348     public boolean equals(Object obj) {
 349         if (this == obj) {
 350             return true;
 351         }
 352         if (obj == null) {
 353             return false;
 354         }
 355         if (getClass() != obj.getClass()) {
 356             return false;
 357         }
 358         Match other = (Match) obj;
 359         if (fields == null) {
 360             if (other.fields != null) {
 361                 return false;
 362             }
 363         } else if (!fields.equals(other.fields)) {
 364             return false;
 365         }
 366         if (matches != other.matches) {
 367             return false;
 368         }
 369         return true;
 370     }
 371
 372     @Override
 373     public String toString() {
 374         return "Match[" + fields.values() + "]";
 375     }
 376 }