openflowplugin/src/main/java/org/opendaylight/openflowplugin/openflow/md/core/sal/convertor/match/MatchConvertorV10Impl.java

   1 /**
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match;
  10
  11 import java.math.BigInteger;
  12 import java.util.Iterator;
  13
  14 import org.opendaylight.openflowplugin.openflow.md.util.InventoryDataServiceUtil;
  15 import org.opendaylight.openflowplugin.openflow.md.util.OpenflowVersion;
  16 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
  17 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.EthernetMatch;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.IpMatch;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer3Match;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer4Match;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.VlanMatch;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4Match;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.TcpMatch;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.UdpMatch;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.FlowWildcardsV10;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.match.v10.grouping.MatchV10;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.match.v10.grouping.MatchV10Builder;
  31
  32 /**
  33  *
  34  */
  35 public class MatchConvertorV10Impl implements MatchConvertor<MatchV10> {
  36
  37     /** default MAC */
  38     public static final MacAddress zeroMac = new MacAddress("00:00:00:00:00:00");
  39     /** default IPv4 */
  40     public static final Ipv4Address zeroIPv4 = new Ipv4Address("0.0.0.0");
  41
  42     /*
  43      * The value 0xffff (OFP_VLAN_NONE) is used to indicate
  44      * that no VLAN ID is set for OF Flow.
  45      */
  46     private static final int OFP_VLAN_NONE = (int) 0xffff;
  47
  48     /**
  49      * Method builds openflow 1.0 specific match (MatchV10) from MD-SAL match.
  50      * @param match MD-SAL match
  51      * @return OF-API match
  52      * @author avishnoi@in.ibm.com
  53      */
  54     @Override
  55     public MatchV10 convert(final Match match,final BigInteger datapathid) {
  56         MatchV10Builder matchBuilder = new MatchV10Builder();
  57         boolean _dLDST = true;
  58         boolean _dLSRC = true;
  59         boolean _dLTYPE = true;
  60         boolean _dLVLAN = true;
  61         boolean _dLVLANPCP = true;
  62         boolean _iNPORT = true;
  63         boolean _nWPROTO = true;
  64         boolean _nWTOS = true;
  65         boolean _tPDST = true;
  66         boolean _tPSRC = true;
  67
  68         matchBuilder.setInPort(0);
  69         matchBuilder.setDlDst(zeroMac);
  70         matchBuilder.setDlSrc(zeroMac);
  71         matchBuilder.setDlType(0);
  72         matchBuilder.setDlVlan(OFP_VLAN_NONE);
  73         matchBuilder.setDlVlanPcp((short) 0);
  74         matchBuilder.setNwDst(zeroIPv4);
  75         matchBuilder.setNwDstMask((short) 0);
  76         matchBuilder.setNwSrc(zeroIPv4);
  77         matchBuilder.setNwSrcMask((short) 0);
  78         matchBuilder.setNwProto((short) 0);
  79         matchBuilder.setNwTos((short) 0);
  80         matchBuilder.setTpSrc(0);
  81         matchBuilder.setTpDst(0);
  82
  83         EthernetMatch ethernetMatch = match.getEthernetMatch();
  84         if(ethernetMatch!= null){
  85             _dLDST = convertEthernetDlDst(matchBuilder, ethernetMatch);
  86             _dLSRC = convertEthernetDlSrc(matchBuilder, ethernetMatch);
  87             _dLTYPE = convertEthernetDlType(matchBuilder, ethernetMatch);
  88         }
  89         VlanMatch vlanMatch = match.getVlanMatch();
  90         if(vlanMatch!= null){
  91             _dLVLAN = convertDlVlan(matchBuilder, vlanMatch);
  92             _dLVLANPCP = convertDlVlanPcp(matchBuilder, vlanMatch);
  93         }
  94         NodeConnectorId inPort = match.getInPort();
  95         if(inPort!=null){
  96             _iNPORT = convertInPortMatch(matchBuilder, inPort);
  97         }
  98         Layer3Match l3Match = match.getLayer3Match();
  99         if(l3Match != null){
 100             if(l3Match instanceof Ipv4Match){
 101                 Ipv4Match ipv4 = (Ipv4Match)l3Match;
 102                 _tPSRC = convertL3Ipv4SrcMatch(matchBuilder, ipv4);
 103                 _tPDST = convertL3Ipv4DstMatch(matchBuilder, ipv4);
 104             }
 105         }
 106         IpMatch ipMatch = match.getIpMatch();
 107         if(ipMatch!=null){
 108             _nWPROTO = convertNwProto(matchBuilder, ipMatch);
 109             _nWTOS = convertNwTos(matchBuilder, ipMatch);
 110         }
 111         Layer4Match layer4Match = match.getLayer4Match();
 112         if (layer4Match != null) {
 113             if (layer4Match instanceof TcpMatch) {
 114                 TcpMatch tcpMatch = (TcpMatch) layer4Match;
 115                 _tPSRC = convertL4TpSrcMatch(matchBuilder, tcpMatch);
 116                 _tPDST = convertL4TpDstMatch(matchBuilder, tcpMatch);
 117             } else if (layer4Match instanceof UdpMatch) {
 118                 UdpMatch udpMatch = (UdpMatch) layer4Match;
 119                 _tPSRC = convertL4UdpSrcMatch(matchBuilder, udpMatch);
 120                 _tPDST = convertL4UdpDstMatch(matchBuilder, udpMatch);
 121             }
 122         }
 123
 124         FlowWildcardsV10 wildCards = new FlowWildcardsV10(
 125                 _dLDST, _dLSRC, _dLTYPE, _dLVLAN,
 126                 _dLVLANPCP, _iNPORT, _nWPROTO, _nWTOS, _tPDST, _tPSRC);
 127         matchBuilder.setWildcards(wildCards);
 128
 129         return matchBuilder.build();
 130     }
 131
 132     /**
 133      * @param matchBuilder
 134      * @param udpMatch
 135      * @return is wildCard
 136      */
 137     private static boolean convertL4UdpDstMatch(final MatchV10Builder matchBuilder,
 138             final UdpMatch udpMatch) {
 139         if (udpMatch.getUdpDestinationPort() != null) {
 140             matchBuilder.setTpDst(udpMatch.getUdpDestinationPort().getValue());
 141             return false;
 142         }
 143         return true;
 144     }
 145
 146     /**
 147      * @param matchBuilder
 148      * @param udpMatch
 149      * @return is wildCard
 150      */
 151     private static boolean convertL4UdpSrcMatch(final MatchV10Builder matchBuilder,
 152             final UdpMatch udpMatch) {
 153         if (udpMatch.getUdpSourcePort() != null) {
 154             matchBuilder.setTpSrc(udpMatch.getUdpSourcePort().getValue());
 155             return false;
 156         }
 157         return true;
 158     }
 159
 160     /**
 161      * @param matchBuilder
 162      * @param tcpMatch
 163      * @return is wildCard
 164      */
 165     private static boolean convertL4TpDstMatch(final MatchV10Builder matchBuilder,
 166             final TcpMatch tcpMatch) {
 167         if (tcpMatch.getTcpDestinationPort() != null) {
 168             matchBuilder.setTpDst(tcpMatch.getTcpDestinationPort().getValue());
 169             return false;
 170         }
 171         return true;
 172     }
 173
 174     /**
 175      * @param matchBuilder
 176      * @param tcpMatch
 177      * @return is wildCard
 178      */
 179     private static boolean convertL4TpSrcMatch(final MatchV10Builder matchBuilder,
 180             final TcpMatch tcpMatch) {
 181         if (tcpMatch.getTcpSourcePort() != null) {
 182             matchBuilder.setTpSrc(tcpMatch.getTcpSourcePort().getValue());
 183             return false;
 184         }
 185         return true;
 186     }
 187
 188     /**
 189      * @param matchBuilder
 190      * @param ipMatch
 191      * @return is wildCard
 192      */
 193     private static boolean convertNwTos(final MatchV10Builder matchBuilder,
 194             final IpMatch ipMatch) {
 195         if (ipMatch.getIpDscp() != null) {
 196             matchBuilder.setNwTos(ipMatch.getIpDscp().getValue());
 197             return false;
 198         }
 199         return true;
 200     }
 201
 202     /**
 203      * @param matchBuilder
 204      * @param ipMatch
 205      * @return is wildCard
 206      */
 207     private static boolean convertNwProto(final MatchV10Builder matchBuilder, final IpMatch ipMatch) {
 208         if (ipMatch.getIpProtocol() != null) {
 209             matchBuilder.setNwProto(ipMatch.getIpProtocol());
 210             return false;
 211         }
 212         return true;
 213     }
 214
 215     /**
 216      * @param matchBuilder
 217      * @param ipv4
 218      * @return is wildCard
 219      */
 220     private static boolean convertL3Ipv4DstMatch(final MatchV10Builder matchBuilder,
 221             final Ipv4Match ipv4) {
 222         if(ipv4.getIpv4Destination()!=null){
 223             Iterator<String> addressParts = MatchConvertorImpl.PREFIX_SPLITTER.split(ipv4.getIpv4Destination().getValue()).iterator();
 224             Ipv4Address ipv4Address = new Ipv4Address(addressParts.next());
 225             Integer prefix = buildPrefix(addressParts);
 226             matchBuilder.setNwDst(ipv4Address);
 227             matchBuilder.setNwDstMask(prefix.shortValue());
 228             return false;
 229         }
 230         return true;
 231     }
 232
 233     /**
 234      * @param matchBuilder
 235      * @param ipv4
 236      * @return is wildCard
 237      */
 238     private static boolean convertL3Ipv4SrcMatch(final MatchV10Builder matchBuilder,
 239             final Ipv4Match ipv4) {
 240         if(ipv4.getIpv4Source()!=null){
 241             Iterator<String> addressParts = MatchConvertorImpl.PREFIX_SPLITTER.split(ipv4.getIpv4Source().getValue()).iterator();
 242             Ipv4Address ipv4Address = new Ipv4Address(addressParts.next());
 243             int prefix = buildPrefix(addressParts);
 244
 245             matchBuilder.setNwSrc(ipv4Address);
 246             matchBuilder.setNwSrcMask((short) prefix);
 247             return false;
 248         }
 249         return true;
 250     }
 251
 252     /**
 253      * @param addressParts
 254      * @return
 255      */
 256     private static int buildPrefix(final Iterator<String> addressParts) {
 257         int prefix = 32;
 258         if (addressParts.hasNext()) {
 259             prefix = Integer.parseInt(addressParts.next());
 260         }
 261         return prefix;
 262     }
 263
 264     /**
 265      * @param matchBuilder
 266      * @param vlanMatch
 267      * @return
 268      */
 269     private static boolean convertDlVlanPcp(final MatchV10Builder matchBuilder,
 270             final VlanMatch vlanMatch) {
 271         if (vlanMatch.getVlanPcp() != null) {
 272             matchBuilder.setDlVlanPcp(vlanMatch.getVlanPcp().getValue());
 273             return false;
 274         }
 275         return true;
 276     }
 277
 278     /**
 279      * @param matchBuilder
 280      * @param vlanMatch
 281      * @return
 282      */
 283     private static boolean convertDlVlan(final MatchV10Builder matchBuilder, final VlanMatch vlanMatch) {
 284         if (vlanMatch.getVlanId() != null) {
 285             int vlanId = vlanMatch.getVlanId().getVlanId().getValue();
 286             matchBuilder.setDlVlan((vlanId == 0 ? OFP_VLAN_NONE : vlanId));
 287             return false;
 288         }
 289         return true;
 290     }
 291
 292     /**
 293      * @param matchBuilder
 294      * @param ethernetMatch
 295      * @return is wildCard
 296      */
 297     private static boolean convertEthernetDlType(final MatchV10Builder matchBuilder,
 298             final EthernetMatch ethernetMatch) {
 299         if (ethernetMatch.getEthernetType() != null) {
 300             matchBuilder.setDlType(ethernetMatch.getEthernetType().getType().getValue().intValue());
 301             return false;
 302         }
 303         return true;
 304     }
 305
 306     /**
 307      * @param matchBuilder
 308      * @param ethernetMatch
 309      * @return is wildCard
 310      */
 311     private static boolean convertEthernetDlSrc(final MatchV10Builder matchBuilder,
 312             final EthernetMatch ethernetMatch) {
 313         if (ethernetMatch.getEthernetSource() != null) {
 314             matchBuilder.setDlSrc(ethernetMatch.getEthernetSource().getAddress());
 315             return false;
 316         }
 317         return true;
 318     }
 319
 320     /**
 321      * @param matchBuilder
 322      * @param ethernetMatch
 323      * @return is wildCard
 324      */
 325     private static boolean convertEthernetDlDst(final MatchV10Builder matchBuilder,
 326             final EthernetMatch ethernetMatch) {
 327         if (ethernetMatch.getEthernetDestination() != null) {
 328             matchBuilder.setDlDst(ethernetMatch.getEthernetDestination().getAddress());
 329             return false;
 330         }
 331         return true;
 332     }
 333
 334     /**
 335      * @param matchBuilder
 336      * @param inPort
 337      */
 338     private static boolean convertInPortMatch(final MatchV10Builder matchBuilder, final NodeConnectorId inPort) {
 339         if (inPort != null) {
 340             matchBuilder.setInPort(InventoryDataServiceUtil.portNumberfromNodeConnectorId(OpenflowVersion.OF10, inPort).intValue());
 341             return false;
 342         }
 343         return true;
 344     }
 345
 346 }