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