gerrit.opnfv Code Review - onosfw.git/blob

   1 /*
   2  * Copyright 2014-2015 Open Networking Laboratory
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.onosproject.provider.of.flow.impl;
  17
  18 import org.onlab.packet.Ip4Address;
  19 import org.onlab.packet.Ip4Prefix;
  20 import org.onlab.packet.Ip6Address;
  21 import org.onlab.packet.Ip6Prefix;
  22 import org.onlab.packet.VlanId;
  23 import org.onosproject.net.OchSignal;
  24 import org.onosproject.net.driver.DriverService;
  25 import org.onosproject.net.flow.FlowRule;
  26 import org.onosproject.net.flow.TrafficSelector;
  27 import org.onosproject.net.flow.criteria.ArpHaCriterion;
  28 import org.onosproject.net.flow.criteria.ArpOpCriterion;
  29 import org.onosproject.net.flow.criteria.ArpPaCriterion;
  30 import org.onosproject.net.flow.criteria.Criterion;
  31 import org.onosproject.net.flow.criteria.EthCriterion;
  32 import org.onosproject.net.flow.criteria.EthTypeCriterion;
  33 import org.onosproject.net.flow.criteria.IPCriterion;
  34 import org.onosproject.net.flow.criteria.IPDscpCriterion;
  35 import org.onosproject.net.flow.criteria.IPEcnCriterion;
  36 import org.onosproject.net.flow.criteria.IPProtocolCriterion;
  37 import org.onosproject.net.flow.criteria.IPv6ExthdrFlagsCriterion;
  38 import org.onosproject.net.flow.criteria.IPv6FlowLabelCriterion;
  39 import org.onosproject.net.flow.criteria.IPv6NDLinkLayerAddressCriterion;
  40 import org.onosproject.net.flow.criteria.IPv6NDTargetAddressCriterion;
  41 import org.onosproject.net.flow.criteria.IcmpCodeCriterion;
  42 import org.onosproject.net.flow.criteria.IcmpTypeCriterion;
  43 import org.onosproject.net.flow.criteria.Icmpv6CodeCriterion;
  44 import org.onosproject.net.flow.criteria.Icmpv6TypeCriterion;
  45 import org.onosproject.net.flow.criteria.MetadataCriterion;
  46 import org.onosproject.net.flow.criteria.MplsBosCriterion;
  47 import org.onosproject.net.flow.criteria.MplsCriterion;
  48 import org.onosproject.net.flow.criteria.OchSignalCriterion;
  49 import org.onosproject.net.flow.criteria.OchSignalTypeCriterion;
  50 import org.onosproject.net.flow.criteria.PortCriterion;
  51 import org.onosproject.net.flow.criteria.SctpPortCriterion;
  52 import org.onosproject.net.flow.criteria.TcpPortCriterion;
  53 import org.onosproject.net.flow.criteria.TunnelIdCriterion;
  54 import org.onosproject.net.flow.criteria.UdpPortCriterion;
  55 import org.onosproject.net.flow.criteria.VlanIdCriterion;
  56 import org.onosproject.net.flow.criteria.VlanPcpCriterion;
  57 import org.projectfloodlight.openflow.protocol.OFFactory;
  58 import org.projectfloodlight.openflow.protocol.OFFlowAdd;
  59 import org.projectfloodlight.openflow.protocol.OFFlowDelete;
  60 import org.projectfloodlight.openflow.protocol.OFFlowMod;
  61 import org.projectfloodlight.openflow.protocol.match.Match;
  62 import org.projectfloodlight.openflow.protocol.match.MatchField;
  63 import org.projectfloodlight.openflow.types.ArpOpcode;
  64 import org.projectfloodlight.openflow.types.CircuitSignalID;
  65 import org.projectfloodlight.openflow.types.EthType;
  66 import org.projectfloodlight.openflow.types.ICMPv4Code;
  67 import org.projectfloodlight.openflow.types.ICMPv4Type;
  68 import org.projectfloodlight.openflow.types.IPv4Address;
  69 import org.projectfloodlight.openflow.types.IPv6Address;
  70 import org.projectfloodlight.openflow.types.IPv6FlowLabel;
  71 import org.projectfloodlight.openflow.types.IpDscp;
  72 import org.projectfloodlight.openflow.types.IpEcn;
  73 import org.projectfloodlight.openflow.types.IpProtocol;
  74 import org.projectfloodlight.openflow.types.MacAddress;
  75 import org.projectfloodlight.openflow.types.Masked;
  76 import org.projectfloodlight.openflow.types.OFBooleanValue;
  77 import org.projectfloodlight.openflow.types.OFMetadata;
  78 import org.projectfloodlight.openflow.types.OFPort;
  79 import org.projectfloodlight.openflow.types.OFVlanVidMatch;
  80 import org.projectfloodlight.openflow.types.TransportPort;
  81 import org.projectfloodlight.openflow.types.U16;
  82 import org.projectfloodlight.openflow.types.U32;
  83 import org.projectfloodlight.openflow.types.U64;
  84 import org.projectfloodlight.openflow.types.U8;
  85 import org.projectfloodlight.openflow.types.VlanPcp;
  86 import org.projectfloodlight.openflow.types.VlanVid;
  87 import org.slf4j.Logger;
  88
  89 import java.util.Optional;
  90
  91 import static org.slf4j.LoggerFactory.getLogger;
  92
  93 /**
  94  * Builder for OpenFlow flow mods based on FlowRules.
  95  */
  96 public abstract class FlowModBuilder {
  97
  98     private final Logger log = getLogger(getClass());
  99
 100     private final OFFactory factory;
 101     private final FlowRule flowRule;
 102     private final TrafficSelector selector;
 103     protected final Long xid;
 104     protected final Optional<DriverService> driverService;
 105
 106     /**
 107      * Creates a new flow mod builder.
 108      *
 109      * @param flowRule the flow rule to transform into a flow mod
 110      * @param factory the OpenFlow factory to use to build the flow mod
 111      * @param xid the transaction ID
 112      * @param driverService the device driver service
 113      * @return the new flow mod builder
 114      */
 115     public static FlowModBuilder builder(FlowRule flowRule,
 116                                          OFFactory factory,
 117                                          Optional<Long> xid,
 118                                          Optional<DriverService> driverService) {
 119         switch (factory.getVersion()) {
 120         case OF_10:
 121             return new FlowModBuilderVer10(flowRule, factory, xid, driverService);
 122         case OF_13:
 123             return new FlowModBuilderVer13(flowRule, factory, xid, driverService);
 124         default:
 125             throw new UnsupportedOperationException(
 126                     "No flow mod builder for protocol version " + factory.getVersion());
 127         }
 128     }
 129
 130     /**
 131      * Constructs a flow mod builder.
 132      *
 133      * @param flowRule the flow rule to transform into a flow mod
 134      * @param factory the OpenFlow factory to use to build the flow mod
 135      * @param driverService the device driver service
 136      * @param xid the transaction ID
 137      */
 138     protected FlowModBuilder(FlowRule flowRule, OFFactory factory, Optional<Long> xid,
 139                              Optional<DriverService> driverService) {
 140         this.factory = factory;
 141         this.flowRule = flowRule;
 142         this.selector = flowRule.selector();
 143         this.xid = xid.orElse(0L);
 144         this.driverService = driverService;
 145     }
 146
 147     /**
 148      * Builds an ADD flow mod.
 149      *
 150      * @return the flow mod
 151      */
 152     public abstract OFFlowAdd buildFlowAdd();
 153
 154     /**
 155      * Builds a MODIFY flow mod.
 156      *
 157      * @return the flow mod
 158      */
 159     public abstract OFFlowMod buildFlowMod();
 160
 161     /**
 162      * Builds a DELETE flow mod.
 163      *
 164      * @return the flow mod
 165      */
 166     public abstract OFFlowDelete buildFlowDel();
 167
 168     /**
 169      * Builds the match for the flow mod.
 170      *
 171      * @return the match
 172      */
 173     // CHECKSTYLE IGNORE MethodLength FOR NEXT 300 LINES
 174     protected Match buildMatch() {
 175         Match.Builder mBuilder = factory.buildMatch();
 176         Ip6Address ip6Address;
 177         Ip4Prefix ip4Prefix;
 178         Ip6Prefix ip6Prefix;
 179         EthCriterion ethCriterion;
 180         IPCriterion ipCriterion;
 181         TcpPortCriterion tcpPortCriterion;
 182         UdpPortCriterion udpPortCriterion;
 183         SctpPortCriterion sctpPortCriterion;
 184         IPv6NDLinkLayerAddressCriterion llAddressCriterion;
 185         ArpHaCriterion arpHaCriterion;
 186         ArpPaCriterion arpPaCriterion;
 187
 188         for (Criterion c : selector.criteria()) {
 189             switch (c.type()) {
 190             case IN_PORT:
 191                 PortCriterion inPort = (PortCriterion) c;
 192                 mBuilder.setExact(MatchField.IN_PORT,
 193                                   OFPort.of((int) inPort.port().toLong()));
 194                 break;
 195             case IN_PHY_PORT:
 196                 PortCriterion inPhyPort = (PortCriterion) c;
 197                 mBuilder.setExact(MatchField.IN_PORT,
 198                                   OFPort.of((int) inPhyPort.port().toLong()));
 199                 break;
 200             case METADATA:
 201                 MetadataCriterion metadata = (MetadataCriterion) c;
 202                 mBuilder.setExact(MatchField.METADATA,
 203                                   OFMetadata.ofRaw(metadata.metadata()));
 204                 break;
 205             case ETH_DST:
 206                 ethCriterion = (EthCriterion) c;
 207                 mBuilder.setExact(MatchField.ETH_DST,
 208                                   MacAddress.of(ethCriterion.mac().toLong()));
 209                 break;
 210             case ETH_SRC:
 211                 ethCriterion = (EthCriterion) c;
 212                 mBuilder.setExact(MatchField.ETH_SRC,
 213                                   MacAddress.of(ethCriterion.mac().toLong()));
 214                 break;
 215             case ETH_TYPE:
 216                 EthTypeCriterion ethType = (EthTypeCriterion) c;
 217                 mBuilder.setExact(MatchField.ETH_TYPE, EthType.of(ethType.ethType().toShort()));
 218                 break;
 219             case VLAN_VID:
 220                 VlanIdCriterion vid = (VlanIdCriterion) c;
 221
 222                 if (vid.vlanId().equals(VlanId.ANY)) {
 223                     mBuilder.setMasked(MatchField.VLAN_VID, OFVlanVidMatch.PRESENT,
 224                                        OFVlanVidMatch.PRESENT);
 225                 } else if (vid.vlanId().equals(VlanId.NONE)) {
 226                     mBuilder.setExact(MatchField.VLAN_VID, OFVlanVidMatch.NONE);
 227                 } else {
 228                     mBuilder.setExact(MatchField.VLAN_VID,
 229                                       OFVlanVidMatch.ofVlanVid(VlanVid.ofVlan(vid.vlanId().toShort())));
 230                 }
 231                 break;
 232             case VLAN_PCP:
 233                 VlanPcpCriterion vpcp = (VlanPcpCriterion) c;
 234                 mBuilder.setExact(MatchField.VLAN_PCP, VlanPcp.of(vpcp.priority()));
 235                 break;
 236             case IP_DSCP:
 237                 IPDscpCriterion ipDscpCriterion = (IPDscpCriterion) c;
 238                 mBuilder.setExact(MatchField.IP_DSCP,
 239                                   IpDscp.of(ipDscpCriterion.ipDscp()));
 240                 break;
 241             case IP_ECN:
 242                 IPEcnCriterion ipEcnCriterion = (IPEcnCriterion) c;
 243                 mBuilder.setExact(MatchField.IP_ECN,
 244                                   IpEcn.of(ipEcnCriterion.ipEcn()));
 245                 break;
 246             case IP_PROTO:
 247                 IPProtocolCriterion p = (IPProtocolCriterion) c;
 248                 mBuilder.setExact(MatchField.IP_PROTO, IpProtocol.of(p.protocol()));
 249                 break;
 250             case IPV4_SRC:
 251                 ipCriterion = (IPCriterion) c;
 252                 ip4Prefix = ipCriterion.ip().getIp4Prefix();
 253                 if (ip4Prefix.prefixLength() != Ip4Prefix.MAX_MASK_LENGTH) {
 254                     Ip4Address maskAddr =
 255                         Ip4Address.makeMaskPrefix(ip4Prefix.prefixLength());
 256                     Masked<IPv4Address> maskedIp =
 257                         Masked.of(IPv4Address.of(ip4Prefix.address().toInt()),
 258                                   IPv4Address.of(maskAddr.toInt()));
 259                     mBuilder.setMasked(MatchField.IPV4_SRC, maskedIp);
 260                 } else {
 261                     mBuilder.setExact(MatchField.IPV4_SRC,
 262                                 IPv4Address.of(ip4Prefix.address().toInt()));
 263                 }
 264                 break;
 265             case IPV4_DST:
 266                 ipCriterion = (IPCriterion) c;
 267                 ip4Prefix = ipCriterion.ip().getIp4Prefix();
 268                 if (ip4Prefix.prefixLength() != Ip4Prefix.MAX_MASK_LENGTH) {
 269                     Ip4Address maskAddr =
 270                         Ip4Address.makeMaskPrefix(ip4Prefix.prefixLength());
 271                     Masked<IPv4Address> maskedIp =
 272                         Masked.of(IPv4Address.of(ip4Prefix.address().toInt()),
 273                                   IPv4Address.of(maskAddr.toInt()));
 274                     mBuilder.setMasked(MatchField.IPV4_DST, maskedIp);
 275                 } else {
 276                     mBuilder.setExact(MatchField.IPV4_DST,
 277                                 IPv4Address.of(ip4Prefix.address().toInt()));
 278                 }
 279                 break;
 280             case TCP_SRC:
 281                 tcpPortCriterion = (TcpPortCriterion) c;
 282                 mBuilder.setExact(MatchField.TCP_SRC,
 283                                   TransportPort.of(tcpPortCriterion.tcpPort().toInt()));
 284                 break;
 285             case TCP_DST:
 286                 tcpPortCriterion = (TcpPortCriterion) c;
 287                 mBuilder.setExact(MatchField.TCP_DST,
 288                                   TransportPort.of(tcpPortCriterion.tcpPort().toInt()));
 289                 break;
 290             case UDP_SRC:
 291                 udpPortCriterion = (UdpPortCriterion) c;
 292                 mBuilder.setExact(MatchField.UDP_SRC,
 293                                   TransportPort.of(udpPortCriterion.udpPort().toInt()));
 294                 break;
 295             case UDP_DST:
 296                 udpPortCriterion = (UdpPortCriterion) c;
 297                 mBuilder.setExact(MatchField.UDP_DST,
 298                                   TransportPort.of(udpPortCriterion.udpPort().toInt()));
 299                 break;
 300             case SCTP_SRC:
 301                 sctpPortCriterion = (SctpPortCriterion) c;
 302                 mBuilder.setExact(MatchField.SCTP_SRC,
 303                                   TransportPort.of(sctpPortCriterion.sctpPort().toInt()));
 304                 break;
 305             case SCTP_DST:
 306                 sctpPortCriterion = (SctpPortCriterion) c;
 307                 mBuilder.setExact(MatchField.SCTP_DST,
 308                                   TransportPort.of(sctpPortCriterion.sctpPort().toInt()));
 309                 break;
 310             case ICMPV4_TYPE:
 311                 IcmpTypeCriterion icmpType = (IcmpTypeCriterion) c;
 312                 mBuilder.setExact(MatchField.ICMPV4_TYPE,
 313                                   ICMPv4Type.of(icmpType.icmpType()));
 314                 break;
 315             case ICMPV4_CODE:
 316                 IcmpCodeCriterion icmpCode = (IcmpCodeCriterion) c;
 317                 mBuilder.setExact(MatchField.ICMPV4_CODE,
 318                                   ICMPv4Code.of(icmpCode.icmpCode()));
 319                 break;
 320             case IPV6_SRC:
 321                 ipCriterion = (IPCriterion) c;
 322                 ip6Prefix = ipCriterion.ip().getIp6Prefix();
 323                 if (ip6Prefix.prefixLength() != Ip6Prefix.MAX_MASK_LENGTH) {
 324                     Ip6Address maskAddr =
 325                             Ip6Address.makeMaskPrefix(ip6Prefix.prefixLength());
 326                     Masked<IPv6Address> maskedIp =
 327                             Masked.of(IPv6Address.of(ip6Prefix.address().toString()),
 328                                     IPv6Address.of(maskAddr.toString()));
 329                     mBuilder.setMasked(MatchField.IPV6_SRC, maskedIp);
 330                 } else {
 331                     mBuilder.setExact(MatchField.IPV6_SRC,
 332                             IPv6Address.of(ip6Prefix.address().toString()));
 333                 }
 334                 break;
 335             case IPV6_DST:
 336                 ipCriterion = (IPCriterion) c;
 337                 ip6Prefix = ipCriterion.ip().getIp6Prefix();
 338                 if (ip6Prefix.prefixLength() != Ip6Prefix.MAX_MASK_LENGTH) {
 339                     Ip6Address maskAddr =
 340                             Ip6Address.makeMaskPrefix(ip6Prefix.prefixLength());
 341                     Masked<IPv6Address> maskedIp =
 342                             Masked.of(IPv6Address.of(ip6Prefix.address().toString()),
 343                                     IPv6Address.of(maskAddr.toString()));
 344                     mBuilder.setMasked(MatchField.IPV6_DST, maskedIp);
 345                 } else {
 346                     mBuilder.setExact(MatchField.IPV6_DST,
 347                             IPv6Address.of(ip6Prefix.address().toString()));
 348                 }
 349                 break;
 350             case IPV6_FLABEL:
 351                 IPv6FlowLabelCriterion flowLabelCriterion =
 352                     (IPv6FlowLabelCriterion) c;
 353                 mBuilder.setExact(MatchField.IPV6_FLABEL,
 354                                   IPv6FlowLabel.of(flowLabelCriterion.flowLabel()));
 355                 break;
 356             case ICMPV6_TYPE:
 357                 Icmpv6TypeCriterion icmpv6Type = (Icmpv6TypeCriterion) c;
 358                 mBuilder.setExact(MatchField.ICMPV6_TYPE,
 359                                   U8.of(icmpv6Type.icmpv6Type()));
 360                 break;
 361             case ICMPV6_CODE:
 362                 Icmpv6CodeCriterion icmpv6Code = (Icmpv6CodeCriterion) c;
 363                 mBuilder.setExact(MatchField.ICMPV6_CODE,
 364                                   U8.of(icmpv6Code.icmpv6Code()));
 365                 break;
 366             case IPV6_ND_TARGET:
 367                 IPv6NDTargetAddressCriterion targetAddressCriterion =
 368                     (IPv6NDTargetAddressCriterion) c;
 369                 ip6Address = targetAddressCriterion.targetAddress();
 370                 mBuilder.setExact(MatchField.IPV6_ND_TARGET,
 371                                   IPv6Address.of(ip6Address.toOctets()));
 372                 break;
 373             case IPV6_ND_SLL:
 374                 llAddressCriterion =
 375                     (IPv6NDLinkLayerAddressCriterion) c;
 376                 mBuilder.setExact(MatchField.IPV6_ND_SLL,
 377                         MacAddress.of(llAddressCriterion.mac().toLong()));
 378                 break;
 379             case IPV6_ND_TLL:
 380                 llAddressCriterion =
 381                     (IPv6NDLinkLayerAddressCriterion) c;
 382                 mBuilder.setExact(MatchField.IPV6_ND_TLL,
 383                         MacAddress.of(llAddressCriterion.mac().toLong()));
 384                 break;
 385             case MPLS_LABEL:
 386                 MplsCriterion mp = (MplsCriterion) c;
 387                 mBuilder.setExact(MatchField.MPLS_LABEL, U32.of(mp.label().toInt()));
 388                 break;
 389             case IPV6_EXTHDR:
 390                 IPv6ExthdrFlagsCriterion exthdrFlagsCriterion =
 391                     (IPv6ExthdrFlagsCriterion) c;
 392                 mBuilder.setExact(MatchField.IPV6_EXTHDR,
 393                                   U16.of(exthdrFlagsCriterion.exthdrFlags()));
 394                 break;
 395             case OCH_SIGID:
 396                 try {
 397                     OchSignalCriterion ochSignalCriterion = (OchSignalCriterion) c;
 398                     OchSignal signal = ochSignalCriterion.lambda();
 399                     byte gridType = OpenFlowValueMapper.lookupGridType(signal.gridType());
 400                     byte channelSpacing = OpenFlowValueMapper.lookupChannelSpacing(signal.channelSpacing());
 401                     mBuilder.setExact(MatchField.OCH_SIGID,
 402                             new CircuitSignalID(gridType, channelSpacing,
 403                                     (short) signal.spacingMultiplier(), (short) signal.slotGranularity()));
 404                 } catch (NoMappingFoundException e) {
 405                     log.warn(e.getMessage());
 406                 }
 407                 break;
 408             case OCH_SIGTYPE:
 409                 OchSignalTypeCriterion sc = (OchSignalTypeCriterion) c;
 410                 byte signalType = OpenFlowValueMapper.lookupOchSignalType(sc.signalType());
 411                 mBuilder.setExact(MatchField.OCH_SIGTYPE, U8.of(signalType));
 412                 break;
 413             case TUNNEL_ID:
 414                 TunnelIdCriterion tunnelId = (TunnelIdCriterion) c;
 415                 mBuilder.setExact(MatchField.TUNNEL_ID,
 416                                   U64.of(tunnelId.tunnelId()));
 417                 break;
 418             case MPLS_BOS:
 419                 MplsBosCriterion mplsBos = (MplsBosCriterion) c;
 420                 mBuilder.setExact(MatchField.MPLS_BOS,
 421                                   mplsBos.mplsBos() ? OFBooleanValue.TRUE
 422                                                     : OFBooleanValue.FALSE);
 423                 break;
 424             case ARP_OP:
 425                 ArpOpCriterion arpOp = (ArpOpCriterion) c;
 426                 mBuilder.setExact(MatchField.ARP_OP,
 427                                   ArpOpcode.of(arpOp.arpOp()));
 428                 break;
 429             case ARP_SHA:
 430                 arpHaCriterion = (ArpHaCriterion) c;
 431                 mBuilder.setExact(MatchField.ARP_SHA,
 432                                   MacAddress.of(arpHaCriterion.mac().toLong()));
 433                 break;
 434             case ARP_SPA:
 435                 arpPaCriterion = (ArpPaCriterion) c;
 436                 mBuilder.setExact(MatchField.ARP_SPA,
 437                                   IPv4Address.of(arpPaCriterion.ip().toInt()));
 438                 break;
 439             case ARP_THA:
 440                 arpHaCriterion = (ArpHaCriterion) c;
 441                 mBuilder.setExact(MatchField.ARP_THA,
 442                                   MacAddress.of(arpHaCriterion.mac().toLong()));
 443                 break;
 444             case ARP_TPA:
 445                 arpPaCriterion = (ArpPaCriterion) c;
 446                 mBuilder.setExact(MatchField.ARP_TPA,
 447                                   IPv4Address.of(arpPaCriterion.ip().toInt()));
 448                 break;
 449             case MPLS_TC:
 450             case PBB_ISID:
 451             default:
 452                 log.warn("Match type {} not yet implemented.", c.type());
 453             }
 454         }
 455         return mBuilder.build();
 456     }
 457
 458     /**
 459      * Returns the flow rule for this builder.
 460      *
 461      * @return the flow rule
 462      */
 463     protected FlowRule flowRule() {
 464         return flowRule;
 465     }
 466
 467     /**
 468      * Returns the factory used for building OpenFlow constructs.
 469      *
 470      * @return the factory
 471      */
 472     protected OFFactory factory() {
 473         return factory;
 474     }
 475
 476 }