third-party/openflow-codec/src/main/java/org/openflow/codec/protocol/OFPHello.java

   1 package org.openflow.codec.protocol;
   2
   3 import java.util.ArrayList;
   4 import java.util.List;
   5
   6 import org.openflow.codec.io.IDataBuffer;
   7 import org.openflow.codec.util.U16;
   8
   9 /**
  10  * Represents an ofp_hello message
  11  *
  12  * @author David Erickson (daviderickson@cs.stanford.edu) - Feb 8, 2010
  13  * @author AnilGujele
  14  */
  15 public class OFPHello extends OFPMessage {
  16     public static int MINIMUM_LENGTH = 8;
  17     private List<OFPHelloElemHeader> elements;
  18
  19     /**
  20      * Construct a ofp_hello message
  21      */
  22     public OFPHello() {
  23         super();
  24         this.type = OFPType.HELLO;
  25         this.length = U16.t(MINIMUM_LENGTH);
  26     }
  27
  28     /**
  29      * get hello elements
  30      *
  31      * @return
  32      */
  33     public List<OFPHelloElemHeader> getHelloElements() {
  34         return elements;
  35     }
  36
  37     /**
  38      * set hello elements
  39      *
  40      * @param elements
  41      */
  42     public void setHelloElements(List<OFPHelloElemHeader> elements) {
  43         this.elements = elements;
  44         updateLength();
  45     }
  46
  47     /**
  48      * update length
  49      */
  50     private void updateLength() {
  51         int newLength = OFPHello.MINIMUM_LENGTH;
  52         if (null != elements) {
  53             for (OFPHelloElemHeader elem : elements) {
  54                 newLength += elem.getLengthU();
  55             }
  56         }
  57         this.length = (short) newLength;
  58     }
  59
  60     /**
  61      * read OFPHello from buffer
  62      *
  63      * @param data
  64      */
  65     public void readFrom(IDataBuffer data) {
  66         super.readFrom(data);
  67         int elementsLength = this.getLengthU() - OFPHello.MINIMUM_LENGTH;
  68         this.elements = readHelloElements(data, elementsLength);
  69
  70     }
  71
  72     /**
  73      * read hello element
  74      *
  75      * @param data
  76      * @param length
  77      * @return
  78      */
  79     private List<OFPHelloElemHeader> readHelloElements(IDataBuffer data, int length) {
  80         List<OFPHelloElemHeader> results = null;
  81         OFPHelloElemHeader tempElem = new OFPHelloElemHeader();
  82         OFPHelloElemHeader ofHelloElem;
  83         int end = data.position() + length;
  84
  85         while (data.position() <= end) {
  86             if (data.remaining() < OFPHelloElemHeader.MINIMUM_LENGTH
  87                     || (data.position() + OFPHelloElemHeader.MINIMUM_LENGTH) > end)
  88                 return results;
  89
  90             // to read element type
  91             data.mark();
  92             tempElem.readFrom(data);
  93             data.reset();
  94
  95             if (tempElem.getLengthU() > data.remaining() || (data.position() + tempElem.getLengthU()) > end)
  96                 return results;
  97
  98             if (null == tempElem.getType()) {
  99                 // element is not supported, so forward the position
 100                 data.position(data.position() + tempElem.getLengthU());
 101                 continue;
 102             }
 103             // create instance of element type
 104             ofHelloElem = tempElem.getType().newInstance();
 105             // read hello element from data
 106             ofHelloElem.readFrom(data);
 107             if (null == results) {
 108                 results = new ArrayList<OFPHelloElemHeader>();
 109             }
 110             results.add(ofHelloElem);
 111         }
 112         return results;
 113     }
 114
 115     /**
 116      * write OFPHello to buffer
 117      *
 118      * @param data
 119      */
 120     public void writeTo(IDataBuffer data) {
 121         super.writeTo(data);
 122         if (null != elements) {
 123             for (OFPHelloElemHeader elem : elements) {
 124                 elem.writeTo(data);
 125             }
 126         }
 127     }
 128
 129     @Override
 130     public int hashCode() {
 131         final int prime = 764;
 132         int result = super.hashCode();
 133         result = prime * result + ((null == elements) ? 0 : elements.hashCode());
 134         return result;
 135     }
 136
 137     @Override
 138     public boolean equals(Object obj) {
 139         if (this == obj) {
 140             return true;
 141         }
 142         if (!super.equals(obj)) {
 143             return false;
 144         }
 145         if (!(obj instanceof OFPHello)) {
 146             return false;
 147         }
 148         OFPHello other = (OFPHello) obj;
 149         if (elements == null) {
 150             if (other.elements != null) {
 151                 return false;
 152             }
 153         } else if (!elements.equals(other.elements)) {
 154             return false;
 155         }
 156
 157         return true;
 158     }
 159
 160 }