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