opendaylight/forwardingrulesmanager/api/src/main/java/org/opendaylight/controller/forwardingrulesmanager/FlowConfig.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.controller.forwardingrulesmanager;
  10
  11 import java.io.Serializable;
  12 import java.net.Inet6Address;
  13 import java.net.InetAddress;
  14 import java.util.ArrayList;
  15 import java.util.List;
  16 import java.util.Set;
  17 import java.util.regex.Matcher;
  18 import java.util.regex.Pattern;
  19
  20 import javax.xml.bind.annotation.XmlAccessType;
  21 import javax.xml.bind.annotation.XmlAccessorType;
  22 import javax.xml.bind.annotation.XmlElement;
  23 import javax.xml.bind.annotation.XmlRootElement;
  24
  25 import org.opendaylight.controller.sal.action.Action;
  26 import org.opendaylight.controller.sal.action.ActionType;
  27 import org.opendaylight.controller.sal.action.Controller;
  28 import org.opendaylight.controller.sal.action.Drop;
  29 import org.opendaylight.controller.sal.action.Flood;
  30 import org.opendaylight.controller.sal.action.HwPath;
  31 import org.opendaylight.controller.sal.action.Loopback;
  32 import org.opendaylight.controller.sal.action.Output;
  33 import org.opendaylight.controller.sal.action.PopVlan;
  34 import org.opendaylight.controller.sal.action.SetDlDst;
  35 import org.opendaylight.controller.sal.action.SetDlSrc;
  36 import org.opendaylight.controller.sal.action.SetNextHop;
  37 import org.opendaylight.controller.sal.action.SetNwDst;
  38 import org.opendaylight.controller.sal.action.SetNwSrc;
  39 import org.opendaylight.controller.sal.action.SetNwTos;
  40 import org.opendaylight.controller.sal.action.SetTpDst;
  41 import org.opendaylight.controller.sal.action.SetTpSrc;
  42 import org.opendaylight.controller.sal.action.SetVlanId;
  43 import org.opendaylight.controller.sal.action.SetVlanPcp;
  44 import org.opendaylight.controller.sal.action.SwPath;
  45 import org.opendaylight.controller.sal.core.ContainerFlow;
  46 import org.opendaylight.controller.sal.core.IContainer;
  47 import org.opendaylight.controller.sal.core.Node;
  48 import org.opendaylight.controller.sal.core.NodeConnector;
  49 import org.opendaylight.controller.sal.flowprogrammer.Flow;
  50 import org.opendaylight.controller.sal.match.Match;
  51 import org.opendaylight.controller.sal.match.MatchType;
  52 import org.opendaylight.controller.sal.utils.GlobalConstants;
  53 import org.opendaylight.controller.sal.utils.HexEncode;
  54 import org.opendaylight.controller.sal.utils.IPProtocols;
  55 import org.opendaylight.controller.sal.utils.NetUtils;
  56 import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
  57 import org.opendaylight.controller.sal.utils.ServiceHelper;
  58 import org.opendaylight.controller.sal.utils.Status;
  59 import org.opendaylight.controller.sal.utils.StatusCode;
  60 import org.opendaylight.controller.switchmanager.ISwitchManager;
  61 import org.opendaylight.controller.switchmanager.Switch;
  62 import org.slf4j.Logger;
  63 import org.slf4j.LoggerFactory;
  64
  65 /**
  66  * Configuration Java Object which represents a flow configuration information
  67  * for Forwarding Rules Manager.
  68  */
  69 @XmlRootElement
  70 @XmlAccessorType(XmlAccessType.NONE)
  71 public class FlowConfig implements Serializable {
  72     private static final long serialVersionUID = 1L;
  73     private static final Logger log = LoggerFactory.getLogger(FlowConfig.class);
  74     private static final String NAMEREGEX = "^[a-zA-Z0-9]+$";
  75     public static final String STATICFLOWGROUP = "__StaticFlows__";
  76     public static final String INTERNALSTATICFLOWGROUP = "__InternalStaticFlows__";
  77     public static final String INTERNALSTATICFLOWBEGIN = "__";
  78     public static final String INTERNALSTATICFLOWEND = "__";
  79     private boolean dynamic;
  80     private String status;
  81
  82     /*
  83      * The order of the object data defined below is used directly in the UI
  84      * built using JSP. Hence try to keep the order in a more logical way.
  85      */
  86     @XmlElement
  87     private String installInHw;
  88     @XmlElement
  89     private String name;
  90     @XmlElement
  91     private Node node;
  92     @XmlElement
  93     private String ingressPort;
  94     private String portGroup;
  95     @XmlElement
  96     private String priority;
  97     @XmlElement
  98     private String etherType;
  99     @XmlElement
 100     private String vlanId;
 101     @XmlElement
 102     private String vlanPriority;
 103     @XmlElement
 104     private String dlSrc;
 105     @XmlElement
 106     private String dlDst;
 107     @XmlElement
 108     private String nwSrc;
 109     @XmlElement
 110     private String nwDst;
 111     @XmlElement
 112     private String protocol;
 113     @XmlElement
 114     private String tosBits;
 115     @XmlElement
 116     private String tpSrc;
 117     @XmlElement
 118     private String tpDst;
 119     @XmlElement
 120     private String cookie;
 121     @XmlElement
 122     private String idleTimeout;
 123     @XmlElement
 124     private String hardTimeout;
 125     @XmlElement
 126     private List<String> actions;
 127
 128     private enum EtherIPType {
 129         ANY, V4, V6;
 130     };
 131
 132     public FlowConfig() {
 133     }
 134
 135     public FlowConfig(String installInHw, String name, Node node, String priority, String cookie, String ingressPort,
 136             String portGroup, String vlanId, String vlanPriority, String etherType, String srcMac, String dstMac,
 137             String protocol, String tosBits, String srcIP, String dstIP, String tpSrc, String tpDst,
 138             String idleTimeout, String hardTimeout, List<String> actions) {
 139         super();
 140         this.installInHw = installInHw;
 141         this.name = name;
 142         this.node = node;
 143         this.priority = priority;
 144         this.cookie = cookie;
 145         this.ingressPort = ingressPort;
 146         this.portGroup = portGroup;
 147         this.vlanId = vlanId;
 148         this.vlanPriority = vlanPriority;
 149         this.etherType = etherType;
 150         this.dlSrc = srcMac;
 151         this.dlDst = dstMac;
 152         this.protocol = protocol;
 153         this.tosBits = tosBits;
 154         this.nwSrc = srcIP;
 155         this.nwDst = dstIP;
 156         this.tpSrc = tpSrc;
 157         this.tpDst = tpDst;
 158         this.idleTimeout = idleTimeout;
 159         this.hardTimeout = hardTimeout;
 160         this.actions = actions;
 161         this.status = StatusCode.SUCCESS.toString();
 162     }
 163
 164     public FlowConfig(FlowConfig from) {
 165         this.installInHw = from.installInHw;
 166         this.name = from.name;
 167         this.node = from.node;
 168         this.priority = from.priority;
 169         this.cookie = from.cookie;
 170         this.ingressPort = from.ingressPort;
 171         this.portGroup = from.portGroup;
 172         this.vlanId = from.vlanId;
 173         this.vlanPriority = from.vlanPriority;
 174         this.etherType = from.etherType;
 175         this.dlSrc = from.dlSrc;
 176         this.dlDst = from.dlDst;
 177         this.protocol = from.protocol;
 178         this.tosBits = from.tosBits;
 179         this.nwSrc = from.nwSrc;
 180         this.nwDst = from.nwDst;
 181         this.tpSrc = from.tpSrc;
 182         this.tpDst = from.tpDst;
 183         this.idleTimeout = from.idleTimeout;
 184         this.hardTimeout = from.hardTimeout;
 185         this.actions = new ArrayList<String>(from.actions);
 186     }
 187
 188     public boolean installInHw() {
 189         if (installInHw == null) {
 190             // backward compatibility
 191             installInHw = "true";
 192         }
 193         return installInHw.equals("true");
 194     }
 195
 196     public void setInstallInHw(boolean inHw) {
 197         installInHw = inHw ? "true" : "false";
 198     }
 199
 200     public String getInstallInHw() {
 201         return installInHw;
 202     }
 203
 204     public boolean isInternalFlow() {
 205         return (this.name != null &&
 206                 this.name.startsWith(FlowConfig.INTERNALSTATICFLOWBEGIN) &&
 207                 this.name.endsWith(FlowConfig.INTERNALSTATICFLOWEND));
 208     }
 209
 210     public String getName() {
 211         return name;
 212     }
 213
 214     public void setName(String name) {
 215         if (name == null) {
 216             return;
 217         }
 218         this.name = name;
 219     }
 220
 221     public Node getNode() {
 222         return this.node;
 223     }
 224
 225     public void setNode(Node node) {
 226         this.node = node;
 227     }
 228
 229     public String getPriority() {
 230         return priority;
 231     }
 232
 233     public void setPriority(String priority) {
 234         this.priority = priority;
 235     }
 236
 237     public String getCookie() {
 238         return cookie;
 239     }
 240
 241     public void setCookie(String cookie) {
 242         this.cookie = cookie;
 243     }
 244
 245     public String getIngressPort() {
 246         return ingressPort;
 247     }
 248
 249     public void setIngressPort(String ingressPort) {
 250         this.ingressPort = ingressPort;
 251     }
 252
 253     public String getPortGroup() {
 254         return portGroup;
 255     }
 256
 257     @Override
 258     public String toString() {
 259         return "FlowConfig [dynamic=" + dynamic + ", status=" + status + ", installInHw=" + installInHw + ", name="
 260                 + name + ", switchId=" + node + ", ingressPort=" + ingressPort + ", portGroup=" + portGroup
 261                 + ", etherType=" + etherType + ", priority=" + priority + ", vlanId=" + vlanId + ", vlanPriority="
 262                 + vlanPriority + ", dlSrc=" + dlSrc + ", dlDst=" + dlDst + ", nwSrc=" + nwSrc + ", nwDst=" + nwDst
 263                 + ", protocol=" + protocol + ", tosBits=" + tosBits + ", tpSrc=" + tpSrc + ", tpDst=" + tpDst
 264                 + ", cookie=" + cookie + ", idleTimeout=" + idleTimeout + ", hardTimeout=" + hardTimeout + ", actions="
 265                 + actions + "]";
 266     }
 267
 268     public void setPortGroup(String portGroup) {
 269         this.portGroup = portGroup;
 270     }
 271
 272     public String getVlanId() {
 273         return vlanId;
 274     }
 275
 276     public void setVlanId(String vlanId) {
 277         this.vlanId = vlanId;
 278     }
 279
 280     public String getVlanPriority() {
 281         return vlanPriority;
 282     }
 283
 284     public void setVlanPriority(String vlanPriority) {
 285         this.vlanPriority = vlanPriority;
 286     }
 287
 288     public String getEtherType() {
 289         return etherType;
 290     }
 291
 292     public void setEtherType(String etherType) {
 293         this.etherType = etherType;
 294     }
 295
 296     public String getSrcMac() {
 297         return dlSrc;
 298     }
 299
 300     public void setSrcMac(String srcMac) {
 301         this.dlSrc = srcMac;
 302     }
 303
 304     public String getDstMac() {
 305         return dlDst;
 306     }
 307
 308     public void setDstMac(String dstMac) {
 309         this.dlDst = dstMac;
 310     }
 311
 312     public String getProtocol() {
 313         return protocol;
 314     }
 315
 316     public void setProtocol(String protocol) {
 317         this.protocol = protocol;
 318     }
 319
 320     public String getTosBits() {
 321         return tosBits;
 322     }
 323
 324     public void setTosBits(String tos_bits) {
 325         this.tosBits = tos_bits;
 326     }
 327
 328     public String getSrcIp() {
 329         return nwSrc;
 330     }
 331
 332     public void setSrcIp(String src_ip) {
 333         this.nwSrc = src_ip;
 334     }
 335
 336     public String getDstIp() {
 337         return nwDst;
 338     }
 339
 340     public void setDstIp(String dst_ip) {
 341         this.nwDst = dst_ip;
 342     }
 343
 344     public String getSrcPort() {
 345         return tpSrc;
 346     }
 347
 348     public void setSrcPort(String src_port) {
 349         this.tpSrc = src_port;
 350     }
 351
 352     public String getDstPort() {
 353         return tpDst;
 354     }
 355
 356     public void setDstPort(String dst_port) {
 357         this.tpDst = dst_port;
 358     }
 359
 360     public String getIdleTimeout() {
 361         return idleTimeout;
 362     }
 363
 364     public void setIdleTimeout(String idleTimeout) {
 365         this.idleTimeout = idleTimeout;
 366     }
 367
 368     public String getHardTimeout() {
 369         return hardTimeout;
 370     }
 371
 372     public void setHardTimeout(String hardTimeout) {
 373         this.hardTimeout = hardTimeout;
 374     }
 375
 376     public boolean isIPv6() {
 377         return NetUtils.isIPv6AddressValid(this.getSrcIp()) || NetUtils.isIPv6AddressValid(this.getDstIp());
 378     }
 379
 380     public List<String> getActions() {
 381         return actions;
 382     }
 383
 384     public void setActions(List<String> actions) {
 385         this.actions = actions;
 386     }
 387
 388     public boolean isPortGroupEnabled() {
 389         return (portGroup != null);
 390     }
 391
 392     public boolean isDynamic() {
 393         return dynamic;
 394     }
 395
 396     public void setDynamic(boolean dynamic) {
 397         this.dynamic = dynamic;
 398     }
 399
 400     public String getStatus() {
 401         return status;
 402     }
 403
 404     public void setStatus(String status) {
 405         this.status = status;
 406     }
 407
 408     public boolean isStatusSuccessful() {
 409         return status.equals(StatusCode.SUCCESS.toString());
 410     }
 411
 412     @Override
 413     public int hashCode() {
 414         final int prime = 31;
 415         int result = 1;
 416         result = prime * result + ((actions == null) ? 0 : actions.hashCode());
 417         result = prime * result + ((cookie == null) ? 0 : cookie.hashCode());
 418         result = prime * result + ((dlDst == null) ? 0 : dlDst.hashCode());
 419         result = prime * result + ((dlSrc == null) ? 0 : dlSrc.hashCode());
 420         result = prime * result + (dynamic ? 1231 : 1237);
 421         result = prime * result + ((etherType == null) ? 0 : etherType.hashCode());
 422         result = prime * result + ((ingressPort == null) ? 0 : ingressPort.hashCode());
 423         result = prime * result + ((name == null) ? 0 : name.hashCode());
 424         result = prime * result + ((nwDst == null) ? 0 : nwDst.hashCode());
 425         result = prime * result + ((nwSrc == null) ? 0 : nwSrc.hashCode());
 426         result = prime * result + ((portGroup == null) ? 0 : portGroup.hashCode());
 427         result = prime * result + ((priority == null) ? 0 : priority.hashCode());
 428         result = prime * result + ((protocol == null) ? 0 : protocol.hashCode());
 429         result = prime * result + ((node == null) ? 0 : node.hashCode());
 430         result = prime * result + ((tosBits == null) ? 0 : tosBits.hashCode());
 431         result = prime * result + ((tpDst == null) ? 0 : tpDst.hashCode());
 432         result = prime * result + ((tpSrc == null) ? 0 : tpSrc.hashCode());
 433         result = prime * result + ((vlanId == null) ? 0 : vlanId.hashCode());
 434         result = prime * result + ((vlanPriority == null) ? 0 : vlanPriority.hashCode());
 435         result = prime * result + ((idleTimeout == null) ? 0 : idleTimeout.hashCode());
 436         result = prime * result + ((hardTimeout == null) ? 0 : hardTimeout.hashCode());
 437         return result;
 438     }
 439
 440     @Override
 441     public boolean equals(Object obj) {
 442         if (this == obj) {
 443             return true;
 444         }
 445         if (obj == null) {
 446             return false;
 447         }
 448         if (getClass() != obj.getClass()) {
 449             return false;
 450         }
 451         FlowConfig other = (FlowConfig) obj;
 452         if (actions == null) {
 453             if (other.actions != null) {
 454                 return false;
 455             }
 456         } else if (!actions.equals(other.actions)) {
 457             return false;
 458         }
 459         if (cookie == null) {
 460             if (other.cookie != null) {
 461                 return false;
 462             }
 463         } else if (!cookie.equals(other.cookie)) {
 464             return false;
 465         }
 466         if (dlDst == null) {
 467             if (other.dlDst != null) {
 468                 return false;
 469             }
 470         } else if (!dlDst.equals(other.dlDst)) {
 471             return false;
 472         }
 473         if (dlSrc == null) {
 474             if (other.dlSrc != null) {
 475                 return false;
 476             }
 477         } else if (!dlSrc.equals(other.dlSrc)) {
 478             return false;
 479         }
 480         if (dynamic != other.dynamic) {
 481             return false;
 482         }
 483         if (etherType == null) {
 484             if (other.etherType != null) {
 485                 return false;
 486             }
 487         } else if (!etherType.equals(other.etherType)) {
 488             return false;
 489         }
 490         if (ingressPort == null) {
 491             if (other.ingressPort != null) {
 492                 return false;
 493             }
 494         } else if (!ingressPort.equals(other.ingressPort)) {
 495             return false;
 496         }
 497         if (name == null) {
 498             if (other.name != null) {
 499                 return false;
 500             }
 501         } else if (!name.equals(other.name)) {
 502             return false;
 503         }
 504         if (nwDst == null) {
 505             if (other.nwDst != null) {
 506                 return false;
 507             }
 508         } else if (!nwDst.equals(other.nwDst)) {
 509             return false;
 510         }
 511         if (nwSrc == null) {
 512             if (other.nwSrc != null) {
 513                 return false;
 514             }
 515         } else if (!nwSrc.equals(other.nwSrc)) {
 516             return false;
 517         }
 518         if (portGroup == null) {
 519             if (other.portGroup != null) {
 520                 return false;
 521             }
 522         } else if (!portGroup.equals(other.portGroup)) {
 523             return false;
 524         }
 525         if (priority == null) {
 526             if (other.priority != null) {
 527                 return false;
 528             }
 529         } else if (!priority.equals(other.priority)) {
 530             return false;
 531         }
 532         if (protocol == null) {
 533             if (other.protocol != null) {
 534                 return false;
 535             }
 536         } else if (!protocol.equals(other.protocol)) {
 537             return false;
 538         }
 539         if (node == null) {
 540             if (other.node != null) {
 541                 return false;
 542             }
 543         } else if (!node.equals(other.node)) {
 544             return false;
 545         }
 546         if (tosBits == null) {
 547             if (other.tosBits != null) {
 548                 return false;
 549             }
 550         } else if (!tosBits.equals(other.tosBits)) {
 551             return false;
 552         }
 553         if (tpDst == null) {
 554             if (other.tpDst != null) {
 555                 return false;
 556             }
 557         } else if (!tpDst.equals(other.tpDst)) {
 558             return false;
 559         }
 560         if (tpSrc == null) {
 561             if (other.tpSrc != null) {
 562                 return false;
 563             }
 564         } else if (!tpSrc.equals(other.tpSrc)) {
 565             return false;
 566         }
 567         if (vlanId == null) {
 568             if (other.vlanId != null) {
 569                 return false;
 570             }
 571         } else if (!vlanId.equals(other.vlanId)) {
 572             return false;
 573         }
 574         if (vlanPriority == null) {
 575             if (other.vlanPriority != null) {
 576                 return false;
 577             }
 578         } else if (!vlanPriority.equals(other.vlanPriority)) {
 579             return false;
 580         }
 581         if (idleTimeout == null) {
 582             if (other.idleTimeout != null) {
 583                 return false;
 584             }
 585         } else if (!idleTimeout.equals(other.idleTimeout)) {
 586             return false;
 587         }
 588         if (hardTimeout == null) {
 589             if (other.hardTimeout != null) {
 590                 return false;
 591             }
 592         } else if (!hardTimeout.equals(other.hardTimeout)) {
 593             return false;
 594         }
 595         return true;
 596     }
 597
 598     public boolean isL2AddressValid(String mac) {
 599         if (mac == null) {
 600             return false;
 601         }
 602
 603         Pattern macPattern = Pattern.compile("([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}");
 604         Matcher mm = macPattern.matcher(mac);
 605         if (!mm.matches()) {
 606             log.debug("Ethernet address {} is not valid. Example: 00:05:b9:7c:81:5f", mac);
 607             return false;
 608         }
 609         return true;
 610     }
 611
 612     public boolean isPortValid(Switch sw, Short port) {
 613         if (port < 1) {
 614             log.debug("port {} is not valid", port);
 615             return false;
 616         }
 617
 618         if (sw == null) {
 619             log.debug("switch info is not available. Skip checking if port is part of a switch or not.");
 620             return true;
 621         }
 622
 623         Set<NodeConnector> nodeConnectorSet = sw.getNodeConnectors();
 624         for (NodeConnector nodeConnector : nodeConnectorSet) {
 625             if (((Short) nodeConnector.getID()).equals(port)) {
 626                 return true;
 627             }
 628         }
 629         log.debug("port {} is not a valid port of node {}", port, sw.getNode());
 630         return false;
 631     }
 632
 633     public boolean isVlanIdValid(String vlanId) {
 634         int vlan = Integer.decode(vlanId);
 635         return ((vlan >= 0) && (vlan < 4096));
 636     }
 637
 638     public boolean isVlanPriorityValid(String vlanPriority) {
 639         int pri = Integer.decode(vlanPriority);
 640         return ((pri >= 0) && (pri < 8));
 641     }
 642
 643     public boolean isTOSBitsValid(String tosBits) {
 644         int tos = Integer.decode(tosBits);
 645         return ((tos >= 0) && (tos < 64));
 646     }
 647
 648     public boolean isTpPortValid(String tpPort) {
 649         int port = Integer.decode(tpPort);
 650         return ((port >= 0) && (port <= 0xffff));
 651     }
 652
 653     public boolean isTimeoutValid(String timeout) {
 654         int to = Integer.decode(timeout);
 655         return ((to >= 0) && (to <= 0xffff));
 656     }
 657
 658     private Status conflictWithContainerFlow(IContainer container) {
 659         // Return true if it's default container
 660         if (container.getName().equals(GlobalConstants.DEFAULT.toString())) {
 661             return new Status(StatusCode.SUCCESS);
 662         }
 663
 664         // No container flow = no conflict
 665         List<ContainerFlow> cFlowList = container.getContainerFlows();
 666         if (((cFlowList == null)) || cFlowList.isEmpty()) {
 667             return new Status(StatusCode.SUCCESS);
 668         }
 669
 670         // Check against each container's flow
 671         Flow flow = this.getFlow();
 672
 673         // Configuration is rejected if it conflicts with _all_ the container
 674         // flows
 675         for (ContainerFlow cFlow : cFlowList) {
 676             if (cFlow.allowsFlow(flow)) {
 677                 log.trace("Config is congruent with at least one container flow");
 678                 return new Status(StatusCode.SUCCESS);
 679             }
 680         }
 681         String msg = "Flow Config conflicts with all existing container flows";
 682         log.trace(msg);
 683
 684         return new Status(StatusCode.BADREQUEST, msg);
 685     }
 686
 687     public Status validate(IContainer container) {
 688         EtherIPType etype = EtherIPType.ANY;
 689         EtherIPType ipsrctype = EtherIPType.ANY;
 690         EtherIPType ipdsttype = EtherIPType.ANY;
 691
 692         String containerName = (container == null) ? GlobalConstants.DEFAULT.toString() : container.getName();
 693         ISwitchManager switchManager = (ISwitchManager) ServiceHelper.getInstance(ISwitchManager.class, containerName,
 694                 this);
 695
 696         Switch sw = null;
 697         try {
 698             if (name == null || name.trim().isEmpty() || !name.matches(FlowConfig.NAMEREGEX)) {
 699                 return new Status(StatusCode.BADREQUEST, "Invalid name");
 700             }
 701
 702             if (node == null) {
 703                 return new Status(StatusCode.BADREQUEST, "Node is null");
 704             }
 705
 706             if (switchManager != null) {
 707                 for (Switch device : switchManager.getNetworkDevices()) {
 708                     if (device.getNode().equals(node)) {
 709                         sw = device;
 710                         break;
 711                     }
 712                 }
 713                 if (sw == null) {
 714                     return new Status(StatusCode.BADREQUEST, String.format("Node %s not found", node));
 715                 }
 716             } else {
 717                 log.debug("switchmanager is not set yet");
 718             }
 719
 720             if (priority != null) {
 721                 if (Integer.decode(priority) < 0 || (Integer.decode(priority) > 65535)) {
 722                     return new Status(StatusCode.BADREQUEST, String.format("priority %s is not in the range 0 - 65535",
 723                             priority));
 724                 }
 725             }
 726
 727             // make sure it's a valid number
 728             if (cookie != null) {
 729                 Long.decode(cookie);
 730             }
 731
 732             if (ingressPort != null) {
 733                 Short port = Short.decode(ingressPort);
 734                 if (isPortValid(sw, port) == false) {
 735                     String msg = String.format("Ingress port %d is not valid for the Switch", port);
 736                     if (!containerName.equals(GlobalConstants.DEFAULT.toString())) {
 737                         msg += " in Container " + containerName;
 738                     }
 739                     return new Status(StatusCode.BADREQUEST, msg);
 740                 }
 741             }
 742
 743             if ((vlanId != null) && !isVlanIdValid(vlanId)) {
 744                 return new Status(StatusCode.BADREQUEST, String.format("Vlan ID %s is not in the range 0 - 4095",
 745                         vlanId));
 746             }
 747
 748             if ((vlanPriority != null) && !isVlanPriorityValid(vlanPriority)) {
 749                 return new Status(StatusCode.BADREQUEST, String.format("Vlan priority %s is not in the range 0 - 7",
 750                         vlanPriority));
 751             }
 752             if (etherType != null) {
 753                 int type = Integer.decode(etherType);
 754                 if ((type < 0) || (type > 0xffff)) {
 755                     return new Status(StatusCode.BADREQUEST, String.format("Ethernet type %s is not valid", etherType));
 756                 } else {
 757                     if (type == 0x800) {
 758                         etype = EtherIPType.V4;
 759                     } else if (type == 0x86dd) {
 760                         etype = EtherIPType.V6;
 761                     }
 762                 }
 763             }
 764
 765             if ((tosBits != null) && !isTOSBitsValid(tosBits)) {
 766                 return new Status(StatusCode.BADREQUEST, String.format("IP ToS bits %s is not in the range 0 - 63",
 767                         tosBits));
 768             }
 769
 770             if ((tpSrc != null) && !isTpPortValid(tpSrc)) {
 771                 return new Status(StatusCode.BADREQUEST, String.format("Transport source port %s is not valid", tpSrc));
 772             }
 773
 774             if ((tpDst != null) && !isTpPortValid(tpDst)) {
 775                 return new Status(StatusCode.BADREQUEST, String.format("Transport destination port %s is not valid",
 776                         tpDst));
 777             }
 778
 779             if ((dlSrc != null) && !isL2AddressValid(dlSrc)) {
 780                 return new Status(StatusCode.BADREQUEST, String.format(
 781                         "Ethernet source address %s is not valid. Example: 00:05:b9:7c:81:5f", dlSrc));
 782             }
 783
 784             if ((dlDst != null) && !isL2AddressValid(dlDst)) {
 785                 return new Status(StatusCode.BADREQUEST, String.format(
 786                         "Ethernet destination address %s is not valid. Example: 00:05:b9:7c:81:5f", dlDst));
 787             }
 788
 789             if (nwSrc != null) {
 790                 if (NetUtils.isIPv4AddressValid(nwSrc)) {
 791                     ipsrctype = EtherIPType.V4;
 792                 } else if (NetUtils.isIPv6AddressValid(nwSrc)) {
 793                     ipsrctype = EtherIPType.V6;
 794                 } else {
 795                     return new Status(StatusCode.BADREQUEST, String.format("IP source address %s is not valid", nwSrc));
 796                 }
 797             }
 798
 799             if (nwDst != null) {
 800                 if (NetUtils.isIPv4AddressValid(nwDst)) {
 801                     ipdsttype = EtherIPType.V4;
 802                 } else if (NetUtils.isIPv6AddressValid(nwDst)) {
 803                     ipdsttype = EtherIPType.V6;
 804                 } else {
 805                     return new Status(StatusCode.BADREQUEST, String.format("IP destination address %s is not valid",
 806                             nwDst));
 807                 }
 808             }
 809
 810             if (etype != EtherIPType.ANY) {
 811                 if ((ipsrctype != EtherIPType.ANY) && (ipsrctype != etype)) {
 812                     return new Status(StatusCode.BADREQUEST, String.format("Type mismatch between Ethernet & Src IP"));
 813                 }
 814                 if ((ipdsttype != EtherIPType.ANY) && (ipdsttype != etype)) {
 815                     return new Status(StatusCode.BADREQUEST, String.format("Type mismatch between Ethernet & Dst IP"));
 816                 }
 817             }
 818             if (ipsrctype != ipdsttype) {
 819                 if (!((ipsrctype == EtherIPType.ANY) || (ipdsttype == EtherIPType.ANY))) {
 820                     return new Status(StatusCode.BADREQUEST, String.format("IP Src Dest Type mismatch"));
 821                 }
 822             }
 823
 824             if ((idleTimeout != null) && !isTimeoutValid(idleTimeout)) {
 825                 return new Status(StatusCode.BADREQUEST, String.format("Idle Timeout value %s is not valid",
 826                         idleTimeout));
 827             }
 828
 829             if ((hardTimeout != null) && !isTimeoutValid(hardTimeout)) {
 830                 return new Status(StatusCode.BADREQUEST, String.format("Hard Timeout value %s is not valid",
 831                         hardTimeout));
 832             }
 833
 834             Matcher sstr;
 835             if (actions != null && !actions.isEmpty()) {
 836                 for (String actiongrp : actions) {
 837                     // check output ports
 838                     sstr = Pattern.compile("OUTPUT=(.*)").matcher(actiongrp);
 839                     if (sstr.matches()) {
 840                         for (String t : sstr.group(1).split(",")) {
 841                             Matcher n = Pattern.compile("(?:(\\d+))").matcher(t);
 842                             if (n.matches()) {
 843                                 if (n.group(1) != null) {
 844                                     Short port = Short.parseShort(n.group(1));
 845                                     if (isPortValid(sw, port) == false) {
 846                                         String msg = String.format("Output port %d is not valid for this switch", port);
 847                                         if (!containerName.equals(GlobalConstants.DEFAULT.toString())) {
 848                                             msg += " in Container " + containerName;
 849                                         }
 850                                         return new Status(StatusCode.BADREQUEST, msg);
 851                                     }
 852                                 }
 853                             }
 854                         }
 855                         continue;
 856                     }
 857                     // Check src IP
 858                     sstr = Pattern.compile(ActionType.FLOOD.toString()).matcher(actiongrp);
 859                     if (sstr.matches()) {
 860                         if (!containerName.equals(GlobalConstants.DEFAULT.toString())) {
 861                             return new Status(StatusCode.BADREQUEST, String.format(
 862                                     "flood is not allowed in container %s", containerName));
 863                         }
 864                         continue;
 865                     }
 866                     // Check src IP
 867                     sstr = Pattern.compile(ActionType.SET_NW_SRC.toString() + "=(.*)").matcher(actiongrp);
 868                     if (sstr.matches()) {
 869                         if (!NetUtils.isIPv4AddressValid(sstr.group(1))) {
 870                             return new Status(StatusCode.BADREQUEST, String.format("IP source address %s is not valid",
 871                                     sstr.group(1)));
 872                         }
 873                         continue;
 874                     }
 875                     // Check dst IP
 876                     sstr = Pattern.compile(ActionType.SET_NW_DST.toString() + "=(.*)").matcher(actiongrp);
 877                     if (sstr.matches()) {
 878                         if (!NetUtils.isIPv4AddressValid(sstr.group(1))) {
 879                             return new Status(StatusCode.BADREQUEST, String.format(
 880                                     "IP destination address %s is not valid", sstr.group(1)));
 881                         }
 882                         continue;
 883                     }
 884
 885                     sstr = Pattern.compile(ActionType.SET_VLAN_ID.toString() + "=(.*)").matcher(actiongrp);
 886                     if (sstr.matches()) {
 887                         if ((sstr.group(1) != null) && !isVlanIdValid(sstr.group(1))) {
 888                             return new Status(StatusCode.BADREQUEST, String.format(
 889                                     "Vlan ID %s is not in the range 0 - 4095", sstr.group(1)));
 890                         }
 891                         continue;
 892                     }
 893
 894                     sstr = Pattern.compile(ActionType.SET_VLAN_PCP.toString() + "=(.*)").matcher(actiongrp);
 895                     if (sstr.matches()) {
 896                         if ((sstr.group(1) != null) && !isVlanPriorityValid(sstr.group(1))) {
 897                             return new Status(StatusCode.BADREQUEST, String.format(
 898                                     "Vlan priority %s is not in the range 0 - 7", sstr.group(1)));
 899                         }
 900                         continue;
 901                     }
 902
 903                     sstr = Pattern.compile(ActionType.SET_DL_SRC.toString() + "=(.*)").matcher(actiongrp);
 904                     if (sstr.matches()) {
 905                         if ((sstr.group(1) != null) && !isL2AddressValid(sstr.group(1))) {
 906                             return new Status(StatusCode.BADREQUEST, String.format(
 907                                     "Ethernet source address %s is not valid. Example: 00:05:b9:7c:81:5f",
 908                                     sstr.group(1)));
 909                         }
 910                         continue;
 911                     }
 912                     sstr = Pattern.compile(ActionType.SET_DL_DST.toString() + "=(.*)").matcher(actiongrp);
 913                     if (sstr.matches()) {
 914                         if ((sstr.group(1) != null) && !isL2AddressValid(sstr.group(1))) {
 915                             return new Status(StatusCode.BADREQUEST, String.format(
 916                                     "Ethernet destination address %s is not valid. Example: 00:05:b9:7c:81:5f",
 917                                     sstr.group(1)));
 918                         }
 919                         continue;
 920                     }
 921
 922                     sstr = Pattern.compile(ActionType.SET_NW_TOS.toString() + "=(.*)").matcher(actiongrp);
 923                     if (sstr.matches()) {
 924                         if ((sstr.group(1) != null) && !isTOSBitsValid(sstr.group(1))) {
 925                             return new Status(StatusCode.BADREQUEST, String.format(
 926                                     "IP ToS bits %s is not in the range 0 - 63", sstr.group(1)));
 927                         }
 928                         continue;
 929                     }
 930
 931                     sstr = Pattern.compile(ActionType.SET_TP_SRC.toString() + "=(.*)").matcher(actiongrp);
 932                     if (sstr.matches()) {
 933                         if ((sstr.group(1) != null) && !isTpPortValid(sstr.group(1))) {
 934                             return new Status(StatusCode.BADREQUEST, String.format(
 935                                     "Transport source port %s is not valid", sstr.group(1)));
 936                         }
 937                         continue;
 938                     }
 939
 940                     sstr = Pattern.compile(ActionType.SET_TP_DST.toString() + "=(.*)").matcher(actiongrp);
 941                     if (sstr.matches()) {
 942                         if ((sstr.group(1) != null) && !isTpPortValid(sstr.group(1))) {
 943                             return new Status(StatusCode.BADREQUEST, String.format(
 944                                     "Transport destination port %s is not valid", sstr.group(1)));
 945                         }
 946                         continue;
 947                     }
 948                     sstr = Pattern.compile(ActionType.SET_NEXT_HOP.toString() + "=(.*)").matcher(actiongrp);
 949                     if (sstr.matches()) {
 950                         if (!NetUtils.isIPAddressValid(sstr.group(1))) {
 951                             return new Status(StatusCode.BADREQUEST, String.format(
 952                                     "IP destination address %s is not valid", sstr.group(1)));
 953                         }
 954                         continue;
 955                     }
 956                 }
 957             }
 958             // Check against the container flow
 959             Status status;
 960             if (!containerName.equals(GlobalConstants.DEFAULT.toString()) && !(status = conflictWithContainerFlow(container)).isSuccess()) {
 961                 return status;
 962             }
 963         } catch (NumberFormatException e) {
 964             return new Status(StatusCode.BADREQUEST, String.format("Invalid number format %s", e.getMessage()));
 965         }
 966
 967         return new Status(StatusCode.SUCCESS);
 968     }
 969
 970     public FlowEntry getFlowEntry() {
 971         String group = this.isInternalFlow() ? FlowConfig.INTERNALSTATICFLOWGROUP : FlowConfig.STATICFLOWGROUP;
 972         return new FlowEntry(group, this.name, this.getFlow(), this.getNode());
 973     }
 974
 975     public Flow getFlow() {
 976         Match match = new Match();
 977
 978         if (this.ingressPort != null) {
 979             match.setField(MatchType.IN_PORT,
 980                     NodeConnectorCreator.createOFNodeConnector(Short.parseShort(ingressPort), getNode()));
 981         }
 982         if (this.dlSrc != null) {
 983             match.setField(MatchType.DL_SRC, HexEncode.bytesFromHexString(this.dlSrc));
 984         }
 985         if (this.dlDst != null) {
 986             match.setField(MatchType.DL_DST, HexEncode.bytesFromHexString(this.dlDst));
 987         }
 988         if (this.etherType != null) {
 989             match.setField(MatchType.DL_TYPE, Integer.decode(etherType).shortValue());
 990         }
 991         if (this.vlanId != null) {
 992             match.setField(MatchType.DL_VLAN, Short.parseShort(this.vlanId));
 993         }
 994         if (this.vlanPriority != null) {
 995             match.setField(MatchType.DL_VLAN_PR, Byte.parseByte(this.vlanPriority));
 996         }
 997         if (this.nwSrc != null) {
 998             String parts[] = this.nwSrc.split("/");
 999             InetAddress ip = NetUtils.parseInetAddress(parts[0]);
1000             InetAddress mask = null;
1001             int maskLen = 0;
1002             if (parts.length > 1) {
1003                 maskLen = Integer.parseInt(parts[1]);
1004             } else {
1005                 maskLen = (ip instanceof Inet6Address) ? 128 : 32;
1006             }
1007             mask = NetUtils.getInetNetworkMask(maskLen, ip instanceof Inet6Address);
1008             match.setField(MatchType.NW_SRC, ip, mask);
1009         }
1010         if (this.nwDst != null) {
1011             String parts[] = this.nwDst.split("/");
1012             InetAddress ip = NetUtils.parseInetAddress(parts[0]);
1013             InetAddress mask = null;
1014             int maskLen = 0;
1015             if (parts.length > 1) {
1016                 maskLen = Integer.parseInt(parts[1]);
1017             } else {
1018                 maskLen = (ip instanceof Inet6Address) ? 128 : 32;
1019             }
1020             mask = NetUtils.getInetNetworkMask(maskLen, ip instanceof Inet6Address);
1021             match.setField(MatchType.NW_DST, ip, mask);
1022         }
1023         if (this.protocol != null) {
1024             match.setField(MatchType.NW_PROTO, IPProtocols.getProtocolNumberByte(this.protocol));
1025         }
1026         if (this.tosBits != null) {
1027             match.setField(MatchType.NW_TOS, Byte.parseByte(this.tosBits));
1028         }
1029         if (this.tpSrc != null) {
1030             match.setField(MatchType.TP_SRC, Integer.valueOf(this.tpSrc).shortValue());
1031         }
1032         if (this.tpDst != null) {
1033             match.setField(MatchType.TP_DST, Integer.valueOf(this.tpDst).shortValue());
1034         }
1035
1036         Flow flow = new Flow(match, getActionList());
1037         if (this.cookie != null) {
1038             flow.setId(Long.parseLong(cookie));
1039         }
1040         if (this.hardTimeout != null) {
1041             flow.setHardTimeout(Short.parseShort(this.hardTimeout));
1042         }
1043         if (this.idleTimeout != null) {
1044             flow.setIdleTimeout(Short.parseShort(idleTimeout));
1045         }
1046         if (this.priority != null) {
1047             flow.setPriority(Integer.decode(this.priority).shortValue());
1048         }
1049         return flow;
1050     }
1051
1052     public boolean isByNameAndNodeIdEqual(FlowConfig that) {
1053         return (this.name.equals(that.name) && this.node.equals(that.node));
1054     }
1055
1056     public boolean isByNameAndNodeIdEqual(String name, Node node) {
1057         return (this.name.equals(name) && this.node.equals(node));
1058     }
1059
1060     public boolean onNode(Node node) {
1061         return this.node.equals(node);
1062     }
1063
1064     public void toggleInstallation() {
1065         installInHw = (installInHw == null) ? "true" : (installInHw.equals("true")) ? "false" : "true";
1066     }
1067
1068     /*
1069      * Parses the actions string and return the List of SAL Action No syntax
1070      * check run, as this function will be called when the config validation
1071      * check has already been performed
1072      */
1073     private List<Action> getActionList() {
1074         List<Action> actionList = new ArrayList<Action>();
1075
1076         if (actions != null) {
1077             Matcher sstr;
1078             for (String actiongrp : actions) {
1079                 sstr = Pattern.compile(ActionType.OUTPUT + "=(.*)").matcher(actiongrp);
1080                 if (sstr.matches()) {
1081                     for (String t : sstr.group(1).split(",")) {
1082                         Matcher n = Pattern.compile("(?:(\\d+))").matcher(t);
1083                         if (n.matches()) {
1084                             if (n.group(1) != null) {
1085                                 short ofPort = Short.parseShort(n.group(1));
1086                                 actionList.add(new Output(NodeConnectorCreator.createOFNodeConnector(ofPort,
1087                                         this.getNode())));
1088                             }
1089                         }
1090                     }
1091                     continue;
1092                 }
1093
1094                 sstr = Pattern.compile(ActionType.DROP.toString()).matcher(actiongrp);
1095                 if (sstr.matches()) {
1096                     actionList.add(new Drop());
1097                     continue;
1098                 }
1099
1100                 sstr = Pattern.compile(ActionType.LOOPBACK.toString()).matcher(actiongrp);
1101                 if (sstr.matches()) {
1102                     actionList.add(new Loopback());
1103                     continue;
1104                 }
1105
1106                 sstr = Pattern.compile(ActionType.FLOOD.toString()).matcher(actiongrp);
1107                 if (sstr.matches()) {
1108                     actionList.add(new Flood());
1109                     continue;
1110                 }
1111
1112                 sstr = Pattern.compile(ActionType.SW_PATH.toString()).matcher(actiongrp);
1113                 if (sstr.matches()) {
1114                     actionList.add(new SwPath());
1115                     continue;
1116                 }
1117
1118                 sstr = Pattern.compile(ActionType.HW_PATH.toString()).matcher(actiongrp);
1119                 if (sstr.matches()) {
1120                     actionList.add(new HwPath());
1121                     continue;
1122                 }
1123
1124                 sstr = Pattern.compile(ActionType.CONTROLLER.toString()).matcher(actiongrp);
1125                 if (sstr.matches()) {
1126                     actionList.add(new Controller());
1127                     continue;
1128                 }
1129
1130                 sstr = Pattern.compile(ActionType.SET_VLAN_ID.toString() + "=(.*)").matcher(actiongrp);
1131                 if (sstr.matches()) {
1132                     actionList.add(new SetVlanId(Short.parseShort(sstr.group(1))));
1133                     continue;
1134                 }
1135
1136                 sstr = Pattern.compile(ActionType.SET_VLAN_PCP.toString() + "=(.*)").matcher(actiongrp);
1137                 if (sstr.matches()) {
1138                     actionList.add(new SetVlanPcp(Byte.parseByte(sstr.group(1))));
1139                     continue;
1140                 }
1141
1142                 sstr = Pattern.compile(ActionType.POP_VLAN.toString()).matcher(actiongrp);
1143                 if (sstr.matches()) {
1144                     actionList.add(new PopVlan());
1145                     continue;
1146                 }
1147
1148                 sstr = Pattern.compile(ActionType.SET_DL_SRC.toString() + "=(.*)").matcher(actiongrp);
1149                 if (sstr.matches()) {
1150                     actionList.add(new SetDlSrc(HexEncode.bytesFromHexString(sstr.group(1))));
1151                     continue;
1152                 }
1153
1154                 sstr = Pattern.compile(ActionType.SET_DL_DST.toString() + "=(.*)").matcher(actiongrp);
1155                 if (sstr.matches()) {
1156                     actionList.add(new SetDlDst(HexEncode.bytesFromHexString(sstr.group(1))));
1157                     continue;
1158                 }
1159                 sstr = Pattern.compile(ActionType.SET_NW_SRC.toString() + "=(.*)").matcher(actiongrp);
1160                 if (sstr.matches()) {
1161                     actionList.add(new SetNwSrc(NetUtils.parseInetAddress(sstr.group(1))));
1162                     continue;
1163                 }
1164                 sstr = Pattern.compile(ActionType.SET_NW_DST.toString() + "=(.*)").matcher(actiongrp);
1165                 if (sstr.matches()) {
1166                     actionList.add(new SetNwDst(NetUtils.parseInetAddress(sstr.group(1))));
1167                     continue;
1168                 }
1169
1170                 sstr = Pattern.compile(ActionType.SET_NW_TOS.toString() + "=(.*)").matcher(actiongrp);
1171                 if (sstr.matches()) {
1172                     actionList.add(new SetNwTos(Byte.parseByte(sstr.group(1))));
1173                     continue;
1174                 }
1175
1176                 sstr = Pattern.compile(ActionType.SET_TP_SRC.toString() + "=(.*)").matcher(actiongrp);
1177                 if (sstr.matches()) {
1178                     actionList.add(new SetTpSrc(Integer.valueOf(sstr.group(1))));
1179                     continue;
1180                 }
1181
1182                 sstr = Pattern.compile(ActionType.SET_TP_DST.toString() + "=(.*)").matcher(actiongrp);
1183                 if (sstr.matches()) {
1184                     actionList.add(new SetTpDst(Integer.valueOf(sstr.group(1))));
1185                     continue;
1186                 }
1187
1188                 sstr = Pattern.compile(ActionType.SET_NEXT_HOP.toString() + "=(.*)").matcher(actiongrp);
1189                 if (sstr.matches()) {
1190                     actionList.add(new SetNextHop(NetUtils.parseInetAddress(sstr.group(1))));
1191                     continue;
1192                 }
1193             }
1194         }
1195         return actionList;
1196     }
1197
1198 }