Implementation of PcInitate and PcUpdate messages
Change-Id: I746a5860a8b4a8022d747a02075ed3237741c53a
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepCloseMsg.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepCloseMsg.java
old mode 100755
new mode 100644
index 15bd6bb..00fad80
--- a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepCloseMsg.java
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepCloseMsg.java
@@ -19,6 +19,7 @@
import java.util.LinkedList;
import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
import org.onosproject.pcepio.types.PcepObjectHeader;
import org.onosproject.pcepio.types.PcepValueType;
@@ -62,7 +63,7 @@
void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv);
@Override
- void writeTo(ChannelBuffer channelBuffer);
+ void writeTo(ChannelBuffer channelBuffer) throws PcepParseException;
/**
* Builder interface with get and set functions to build Close message.
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFactories.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFactories.java
old mode 100755
new mode 100644
index 3cc23b9..5cca7e3
--- a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFactories.java
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/PcepFactories.java
@@ -18,6 +18,7 @@
import org.jboss.netty.buffer.ChannelBuffer;
import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.ver1.PcepFactoryVer1;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -35,15 +36,15 @@
/*
* Returns the instance of PCEP Version.
*
- * @param version
+ * @param version PCEP version
* @return PCEP version
*/
public static PcepFactory getFactory(PcepVersion version) {
switch (version) {
case PCEP_1:
- // TODO : to get the pcep version 1 factory
+ return PcepFactoryVer1.INSTANCE;
default:
- throw new IllegalArgumentException("[PcepFactory:]Unknown version: " + version);
+ throw new IllegalArgumentException("Unknown version: " + version);
}
}
@@ -53,7 +54,6 @@
public PcepMessage readFrom(ChannelBuffer bb) throws PcepParseException {
if (!bb.readable()) {
- log.debug("Empty message received");
throw new PcepParseException("Empty message received");
}
@@ -75,13 +75,12 @@
switch (packetVersion) {
case 1:
- // TODO : get the factory for version 1
+ factory = org.onosproject.pcepio.protocol.ver1.PcepFactoryVer1.INSTANCE;
break;
default:
throw new IllegalArgumentException("Unknown Packet version: " + packetVersion);
}
- // TODO : Read the PCEP message from the factory
- return null;
+ return factory.getReader().readFrom(bb);
}
}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcInitiatedLspRequestVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcInitiatedLspRequestVer1.java
new file mode 100644
index 0000000..f035914
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcInitiatedLspRequestVer1.java
@@ -0,0 +1,323 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcInitiatedLspRequest;
+import org.onosproject.pcepio.protocol.PcepAttribute;
+import org.onosproject.pcepio.protocol.PcepEndPointsObject;
+import org.onosproject.pcepio.protocol.PcepEroObject;
+import org.onosproject.pcepio.protocol.PcepLspObject;
+import org.onosproject.pcepio.protocol.PcepSrpObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.MoreObjects.ToStringHelper;
+
+/**
+ * Provides PcInitiatedLspRequest for PCEP Initiate message.
+ * Reference : PCE initiated tunnel setup draft-ietf-pce-pce-initiated-lsp-03.
+ */
+public class PcInitiatedLspRequestVer1 implements PcInitiatedLspRequest {
+
+ /*
+ * <PCE-initiated-lsp-request> ::= (<PCE-initiated-lsp-instantiation>|<PCE-initiated-lsp-deletion>)
+ <PCE-initiated-lsp-instantiation> ::= <SRP>
+ <LSP>
+ <END-POINTS>
+ <ERO>
+ [<attribute-list>]
+ <PCE-initiated-lsp-deletion> ::= <SRP>
+ <LSP>
+ */
+
+ protected static final Logger log = LoggerFactory.getLogger(PcInitiatedLspRequestVer1.class);
+
+ //PCEP SRP Object
+ private PcepSrpObject srpObject;
+ //PCEP LSP Object
+ private PcepLspObject lspObject;
+ //PCEP End Point Object
+ private PcepEndPointsObject endPointsObject;
+ //PCEP ERO Object
+ private PcepEroObject eroObject;
+ //PCEP Attribute list
+ private PcepAttribute pcepAttribute;
+
+ /**
+ * Default constructor.
+ */
+ public PcInitiatedLspRequestVer1() {
+ srpObject = null;
+ lspObject = null;
+ endPointsObject = null;
+ eroObject = null;
+ pcepAttribute = null;
+
+ }
+
+ /**
+ * Constructor to initialize all parameters of PC initiated lsp request.
+ *
+ * @param srpObject PCEP srp Object
+ * @param lspObject PCEP lsp object
+ * @param endPointsObject PCPE endpoints object
+ * @param eroObject PCEP ero object
+ * @param pcepAttribute PCEP attribute
+ */
+ public PcInitiatedLspRequestVer1(PcepSrpObject srpObject, PcepLspObject lspObject,
+ PcepEndPointsObject endPointsObject, PcepEroObject eroObject, PcepAttribute pcepAttribute) {
+ this.srpObject = srpObject;
+ this.lspObject = lspObject;
+ this.endPointsObject = endPointsObject;
+ this.eroObject = eroObject;
+ this.pcepAttribute = pcepAttribute;
+
+ }
+
+ @Override
+ public PcepSrpObject getSrpObject() {
+ return srpObject;
+ }
+
+ @Override
+ public PcepLspObject getLspObject() {
+ return lspObject;
+ }
+
+ @Override
+ public PcepEndPointsObject getEndPointsObject() {
+ return endPointsObject;
+ }
+
+ @Override
+ public PcepEroObject getEroObject() {
+ return eroObject;
+ }
+
+ @Override
+ public PcepAttribute getPcepAttribute() {
+ return pcepAttribute;
+ }
+
+ @Override
+ public void setSrpObject(PcepSrpObject srpobj) {
+ this.srpObject = srpobj;
+
+ }
+
+ @Override
+ public void setLspObject(PcepLspObject lspObject) {
+ this.lspObject = lspObject;
+ }
+
+ @Override
+ public void setEndPointsObject(PcepEndPointsObject endPointsObject) {
+ this.endPointsObject = endPointsObject;
+ }
+
+ @Override
+ public void setEroObject(PcepEroObject eroObject) {
+ this.eroObject = eroObject;
+ }
+
+ @Override
+ public void setPcepAttribute(PcepAttribute pcepAttribute) {
+ this.pcepAttribute = pcepAttribute;
+ }
+
+ /**
+ * Builder class for PC initiated lsp reuqest.
+ */
+ public static class Builder implements PcInitiatedLspRequest.Builder {
+
+ private boolean bIsSRPObjectSet = false;
+ private boolean bIsLSPObjectSet = false;
+ private boolean bIsEndPointsObjectSet = false;
+ private boolean bIsEROObjectSet = false;
+ private boolean bIsPcepAttributeSet = false;
+ private boolean bIsbRFlagSet = false;
+
+ //PCEP SRP Object
+ private PcepSrpObject srpObject;
+ //PCEP LSP Object
+ private PcepLspObject lspObject;
+ //PCEP End Point Object
+ private PcepEndPointsObject endPointsObject;
+ //PCEP ERO Object
+ private PcepEroObject eroObject;
+ //PCEP Attribute list
+ private PcepAttribute pcepAttribute;
+
+ @Override
+ public PcInitiatedLspRequest build() throws PcepParseException {
+
+ //PCEP SRP Object
+ PcepSrpObject srpObject = null;
+ //PCEP LSP Object
+ PcepLspObject lspObject = null;
+ //PCEP End Point Object
+ PcepEndPointsObject endPointsObject = null;
+ //PCEP ERO Object
+ PcepEroObject eroObject = null;
+ //PCEP Attribute list
+ PcepAttribute pcepAttribute = null;
+ boolean bRFlag = false;
+
+ if (!this.bIsSRPObjectSet) {
+ throw new PcepParseException("Srp object NOT Set while building PcInitiatedLspRequest");
+ } else {
+ srpObject = this.srpObject;
+ bRFlag = srpObject.getRFlag();
+ }
+
+ if (bRFlag) {
+ this.bIsbRFlagSet = true;
+ } else {
+ this.bIsbRFlagSet = false;
+ }
+
+ if (!this.bIsLSPObjectSet) {
+ throw new PcepParseException("LSP Object NOT Set while building PcInitiatedLspRequest");
+ } else {
+ lspObject = this.lspObject;
+ }
+ if (!this.bIsbRFlagSet) {
+
+ if (!this.bIsEndPointsObjectSet) {
+ throw new PcepParseException("EndPoints Object NOT Set while building PcInitiatedLspRequest");
+ } else {
+ endPointsObject = this.endPointsObject;
+ }
+ if (!this.bIsEROObjectSet) {
+ throw new PcepParseException("ERO Object NOT Set while building PcInitiatedLspRequest");
+ } else {
+ eroObject = this.eroObject;
+ }
+ if (bIsPcepAttributeSet) {
+ pcepAttribute = this.pcepAttribute;
+ }
+ }
+ return new PcInitiatedLspRequestVer1(srpObject, lspObject, endPointsObject, eroObject, pcepAttribute);
+ }
+
+ @Override
+ public PcepSrpObject getSrpObject() {
+ return this.srpObject;
+ }
+
+ @Override
+ public PcepLspObject getLspObject() {
+ return this.lspObject;
+ }
+
+ @Override
+ public PcepEndPointsObject getEndPointsObject() {
+ return this.endPointsObject;
+ }
+
+ @Override
+ public PcepEroObject getEroObject() {
+ return this.eroObject;
+ }
+
+ @Override
+ public PcepAttribute getPcepAttribute() {
+ return this.pcepAttribute;
+ }
+
+ @Override
+ public Builder setSrpObject(PcepSrpObject srpobj) {
+ this.srpObject = srpobj;
+ this.bIsSRPObjectSet = true;
+ return this;
+
+ }
+
+ @Override
+ public Builder setLspObject(PcepLspObject lspObject) {
+ this.lspObject = lspObject;
+ this.bIsLSPObjectSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setEndPointsObject(PcepEndPointsObject endPointsObject) {
+ this.endPointsObject = endPointsObject;
+ this.bIsEndPointsObjectSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setEroObject(PcepEroObject eroObject) {
+ this.eroObject = eroObject;
+ this.bIsEROObjectSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setPcepAttribute(PcepAttribute pcepAttribute) {
+ this.pcepAttribute = pcepAttribute;
+ this.bIsPcepAttributeSet = true;
+ return this;
+ }
+
+ }
+
+ @Override
+ public void print() {
+
+ log.debug(" PC-INITIATED LSP INITIATION REQUEST");
+ srpObject.print();
+ lspObject.print();
+ //if PC initiate then print end point and ero object [pcepattribute].
+ if (endPointsObject instanceof PcepEndPointsObject) {
+ endPointsObject.print();
+ }
+
+ if (eroObject instanceof PcepEroObject) {
+ eroObject.print();
+ }
+
+ if (pcepAttribute instanceof PcepAttribute) {
+ pcepAttribute.print();
+ }
+ }
+
+ @Override
+ public String toString() {
+ ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass());
+ toStrHelper
+ .add("SRP Object", srpObject)
+ .add("LSP object", lspObject);
+
+ if (endPointsObject instanceof PcepEndPointsObject) {
+ toStrHelper
+ .add("End Point Object", endPointsObject);
+ }
+ if (eroObject instanceof PcepEroObject) {
+ toStrHelper
+ .add("ERO Object", eroObject);
+ }
+ if (pcepAttribute instanceof PcepAttribute) {
+ toStrHelper
+ .add("Pcep Attribute", pcepAttribute);
+ }
+ return toStrHelper.toString();
+ }
+}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepAttributeVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepAttributeVer1.java
new file mode 100644
index 0000000..e6215f9
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepAttributeVer1.java
@@ -0,0 +1,469 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+/*
+ * Provides PCEP Attribute List.
+ */
+import java.util.LinkedList;
+import java.util.ListIterator;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepAttribute;
+import org.onosproject.pcepio.protocol.PcepBandwidthObject;
+import org.onosproject.pcepio.protocol.PcepIroObject;
+import org.onosproject.pcepio.protocol.PcepLspaObject;
+import org.onosproject.pcepio.protocol.PcepMetricObject;
+import org.onosproject.pcepio.types.PcepObjectHeader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.MoreObjects.ToStringHelper;
+
+/* Reference : RFC5440
+ * where:
+ * <attribute-list> ::=[<LSPA>]
+ * [<BANDWIDTH>]
+ * [<metric-list>]
+ * [<IRO>]
+ *
+ * <metric-list> ::=<METRIC>[<metric-list>]
+ */
+
+public class PcepAttributeVer1 implements PcepAttribute {
+
+ protected static final Logger log = LoggerFactory.getLogger(PcepAttributeVer1.class);
+
+ public static final int OBJECT_HEADER_LENGTH = 4;
+
+ //PCEP LSPA Object
+ private PcepLspaObject lspaObject;
+ private boolean isLspaObjectSet;
+
+ //PCEP Bandwidth Object
+ private PcepBandwidthObject bandwidthObject;
+ private boolean isBandwidthObjectSet;
+
+ //PCEP Metric list
+ private LinkedList<PcepMetricObject> llMetricList;
+ private boolean isMetricListSet;
+
+ //PCEP IRO object
+ private PcepIroObject iroObject;
+ private boolean isIroObjectSet;
+
+ /**
+ * Default constructor to initialize member variables.
+ */
+ public PcepAttributeVer1() {
+
+ lspaObject = null;
+ bandwidthObject = null;
+ llMetricList = null;
+ iroObject = null;
+ this.isLspaObjectSet = false;
+ this.isBandwidthObjectSet = false;
+ this.isMetricListSet = false;
+ this.isIroObjectSet = false;
+ }
+
+ /**
+ * Constructor to initialize all parameters for PCEP attribute.
+ *
+ * @param lspaObject PCEP lspa Object.
+ * @param bandwidthObject PCEP bandwidth object.
+ * @param llMetricList list of PCEP metric objects.
+ * @param iroObject PCEP iro object.
+ */
+ public PcepAttributeVer1(PcepLspaObject lspaObject, PcepBandwidthObject bandwidthObject,
+ LinkedList<PcepMetricObject> llMetricList, PcepIroObject iroObject) {
+
+ this.lspaObject = lspaObject;
+ this.bandwidthObject = bandwidthObject;
+ this.llMetricList = llMetricList;
+ this.iroObject = iroObject;
+ if (lspaObject == null) {
+ this.isLspaObjectSet = false;
+ } else {
+ this.isLspaObjectSet = true;
+ }
+ if (bandwidthObject == null) {
+ this.isBandwidthObjectSet = false;
+ } else {
+ this.isBandwidthObjectSet = true;
+ }
+ if (llMetricList == null) {
+ this.isMetricListSet = false;
+ } else {
+ this.isMetricListSet = true;
+ }
+ if (iroObject == null) {
+ this.isIroObjectSet = false;
+ } else {
+ this.isIroObjectSet = true;
+ }
+ }
+
+ /**
+ * constructor to initialize bandwidthObject.
+ *
+ * @param bandwidthObject bandwidth object
+ */
+ public PcepAttributeVer1(PcepBandwidthObject bandwidthObject) {
+ this.isLspaObjectSet = false;
+
+ this.bandwidthObject = bandwidthObject;
+ this.isBandwidthObjectSet = true;
+
+ this.isMetricListSet = false;
+
+ this.isIroObjectSet = false;
+ }
+
+ /**
+ * Parse list for MeticObject.
+ *
+ * @param cb of type channel buffer
+ * @return true if parsing metric list is success
+ * @throws PcepParseException when a non metric object is received
+ */
+ public boolean parseMetricList(ChannelBuffer cb) throws PcepParseException {
+
+ if (null == llMetricList) {
+ llMetricList = new LinkedList<PcepMetricObject>();
+ }
+
+ PcepMetricObject metriclist;
+
+ //caller should verify for metric object
+ byte yObjClass = PcepMetricObjectVer1.METRIC_OBJ_CLASS;
+ byte yObjType = PcepMetricObjectVer1.METRIC_OBJ_TYPE;
+
+ while ((yObjClass == PcepMetricObjectVer1.METRIC_OBJ_CLASS)
+ && (yObjType == PcepMetricObjectVer1.METRIC_OBJ_TYPE)) {
+
+ metriclist = PcepMetricObjectVer1.read(cb);
+ llMetricList.add(metriclist);
+ yObjClass = 0;
+ yObjType = 0;
+
+ if (cb.readableBytes() > OBJECT_HEADER_LENGTH) {
+ cb.markReaderIndex();
+ PcepObjectHeader tempObjHeader = PcepObjectHeader.read(cb);
+ cb.resetReaderIndex();
+ yObjClass = tempObjHeader.getObjClass();
+ yObjType = tempObjHeader.getObjType();
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Reads lspa , bandwidth , Metriclist and Iro objects and sets the objects.
+ *
+ * @param cb of type channel buffer
+ * @return instance of Pcep Attribute
+ * @throws PcepParseException while parsing Pcep Attributes from channel buffer
+ */
+
+ public static PcepAttribute read(ChannelBuffer cb) throws PcepParseException {
+ if (cb.readableBytes() < OBJECT_HEADER_LENGTH) {
+ return null;
+ }
+ //check whether any pcep attribute is present
+ cb.markReaderIndex();
+ PcepObjectHeader tempObjHeader = PcepObjectHeader.read(cb);
+ cb.resetReaderIndex();
+ byte yObjClass = tempObjHeader.getObjClass();
+
+ if (PcepLspaObjectVer1.LSPA_OBJ_CLASS != yObjClass && PcepBandwidthObjectVer1.BANDWIDTH_OBJ_CLASS != yObjClass
+ && PcepMetricObjectVer1.METRIC_OBJ_CLASS != yObjClass && PcepIroObjectVer1.IRO_OBJ_CLASS != yObjClass) {
+ //No PCEP attribute is present
+ return null;
+ }
+
+ PcepAttributeVer1 pcepAttribute = new PcepAttributeVer1();
+
+ //If LSPA present then store it.LSPA is optional
+ if (yObjClass == PcepLspaObjectVer1.LSPA_OBJ_CLASS) {
+ pcepAttribute.setLspaObject(PcepLspaObjectVer1.read(cb));
+ yObjClass = checkNextObject(cb);
+ }
+
+ //If BANDWIDTH present then store it.BANDWIDTH is optional
+ if (yObjClass == PcepBandwidthObjectVer1.BANDWIDTH_OBJ_CLASS) {
+ pcepAttribute.setBandwidthObject(PcepBandwidthObjectVer1.read(cb));
+ yObjClass = checkNextObject(cb);
+ }
+
+ //If Metric list present then store it.MetricList is optional
+ if (yObjClass == PcepMetricObjectVer1.METRIC_OBJ_CLASS) {
+ pcepAttribute.parseMetricList(cb);
+ yObjClass = checkNextObject(cb);
+ }
+
+ //If IRO present then store it.IRO is optional
+ if (yObjClass == PcepIroObjectVer1.IRO_OBJ_CLASS) {
+ pcepAttribute.setIroObject(PcepIroObjectVer1.read(cb));
+ }
+
+ PcepLspaObject lspaObject = pcepAttribute.getLspaObject();
+ PcepBandwidthObject bandwidthObject = pcepAttribute.getBandwidthObject();
+ LinkedList<PcepMetricObject> metriclist = pcepAttribute.llMetricList;
+ PcepIroObject iroObject = pcepAttribute.getIroObject();
+
+ return new PcepAttributeVer1(lspaObject, bandwidthObject, metriclist, iroObject);
+ }
+
+ /**
+ * Checks whether there is a more object or not.
+ *
+ * @param cb of type channel buffer
+ * @return instance of object header
+ */
+ private static byte checkNextObject(ChannelBuffer cb) {
+ if (cb.readableBytes() < OBJECT_HEADER_LENGTH) {
+ return 0;
+ }
+ cb.markReaderIndex();
+ PcepObjectHeader tempObjHeader = PcepObjectHeader.read(cb);
+ cb.resetReaderIndex();
+ return tempObjHeader.getObjClass();
+ }
+
+ @Override
+ public int write(ChannelBuffer cb) throws PcepParseException {
+ int iLenStartIndex = cb.writerIndex();
+ //PCEP LSPA object is optional
+ if (this.isLspaObjectSet) {
+ this.lspaObject.write(cb);
+ }
+
+ //PCEP BANDWIDTH object is optional
+ if (this.isBandwidthObjectSet) {
+ this.bandwidthObject.write(cb);
+ }
+
+ //PCEP Metric list is optional
+ if (this.isMetricListSet) {
+ ListIterator<PcepMetricObject> listIterator = this.llMetricList.listIterator();
+ while (listIterator.hasNext()) {
+ listIterator.next().write(cb);
+ }
+ }
+
+ //PCEP IRO object is optional
+ if (this.isIroObjectSet) {
+ this.iroObject.write(cb);
+ }
+ return cb.writerIndex() - iLenStartIndex;
+ }
+
+ @Override
+ public PcepLspaObject getLspaObject() {
+ return lspaObject;
+ }
+
+ @Override
+ public PcepBandwidthObject getBandwidthObject() {
+ return bandwidthObject;
+ }
+
+ @Override
+ public LinkedList<PcepMetricObject> getMetricObjectList() {
+ return llMetricList;
+ }
+
+ @Override
+ public PcepIroObject getIroObject() {
+ return iroObject;
+ }
+
+ @Override
+ public void setBandwidthObject(PcepBandwidthObject bandwidthObject) {
+ this.isBandwidthObjectSet = true;
+ this.bandwidthObject = bandwidthObject;
+ }
+
+ @Override
+ public void setMetricObjectList(LinkedList<PcepMetricObject> llMetricList) {
+ this.isMetricListSet = true;
+ this.llMetricList = llMetricList;
+
+ }
+
+ @Override
+ public void setLspaObject(PcepLspaObject lspaObject) {
+ this.isLspaObjectSet = true;
+ this.lspaObject = lspaObject;
+ }
+
+ @Override
+ public void setIroObject(PcepIroObject iroObject) {
+ this.isIroObjectSet = true;
+ this.iroObject = iroObject;
+ }
+
+ /**
+ * Builder class for PCEP attributes.
+ */
+ public static class Builder implements PcepAttribute.Builder {
+
+ //PCEP LSPA Object
+ private PcepLspaObject lspaObject;
+ private boolean isLspaObjectSet;
+
+ //PCEP BANDWIDTH Object
+ private PcepBandwidthObject bandwidthObject;
+ private boolean isBandwidthObjectSet;
+
+ //PCEP Metric list
+ private LinkedList<PcepMetricObject> llMetricList;
+ private boolean isMetricListSet;
+
+ //PCEP IRO object
+ private PcepIroObject iroObject;
+ private boolean isIroObjectSet;
+
+ @Override
+ public PcepAttribute build() {
+
+ //PCEP LSPA Object
+ PcepLspaObject lspaObject = null;
+
+ //PCEP BANDWIDTH Object
+ PcepBandwidthObject bandwidthObject = null;
+
+ //PCEP Metric list
+ LinkedList<PcepMetricObject> llMetricList = null;
+
+ //PCEP IRO object
+ PcepIroObject iroObject = null;
+
+ if (this.isLspaObjectSet) {
+ lspaObject = this.lspaObject;
+ }
+ if (this.isBandwidthObjectSet) {
+ bandwidthObject = this.bandwidthObject;
+ }
+ if (this.isMetricListSet) {
+ llMetricList = this.llMetricList;
+ }
+ if (this.isIroObjectSet) {
+ iroObject = this.iroObject;
+ }
+ return new PcepAttributeVer1(lspaObject, bandwidthObject, llMetricList, iroObject);
+ }
+
+ @Override
+ public PcepLspaObject getLspaObject() {
+ return this.lspaObject;
+ }
+
+ @Override
+ public PcepBandwidthObject getBandwidthObject() {
+ return this.bandwidthObject;
+ }
+
+ @Override
+ public LinkedList<PcepMetricObject> getMetricObjectList() {
+ return this.llMetricList;
+ }
+
+ @Override
+ public PcepIroObject getIroObject() {
+ return this.iroObject;
+ }
+
+ @Override
+ public Builder setBandwidthObject(PcepBandwidthObject bandwidthObject) {
+ this.isBandwidthObjectSet = true;
+ this.bandwidthObject = bandwidthObject;
+ return this;
+ }
+
+ @Override
+ public Builder setMetricObjectList(LinkedList<PcepMetricObject> llMetricList) {
+ this.isMetricListSet = true;
+ this.llMetricList = llMetricList;
+ return this;
+ }
+
+ @Override
+ public Builder setLspaObject(PcepLspaObject lspaObject) {
+ this.isLspaObjectSet = true;
+ this.lspaObject = lspaObject;
+ return this;
+ }
+
+ @Override
+ public Builder setIroObject(PcepIroObject iroObject) {
+ this.isIroObjectSet = true;
+ this.iroObject = iroObject;
+ return this;
+ }
+ }
+
+ @Override
+ public void print() {
+
+ log.debug("ATTRIBUTE LIST");
+ if (lspaObject instanceof PcepLspaObject) {
+ lspaObject.print();
+ }
+
+ if (bandwidthObject instanceof PcepBandwidthObject) {
+ bandwidthObject.print();
+ }
+
+ if (llMetricList != null) {
+ log.debug("METRIC LIST");
+ ListIterator<PcepMetricObject> listIterator = llMetricList.listIterator();
+ while (listIterator.hasNext()) {
+ listIterator.next().print();
+ }
+ }
+ if (iroObject instanceof PcepIroObject) {
+ iroObject.print();
+ }
+ }
+
+ @Override
+ public String toString() {
+ ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass());
+
+ if (lspaObject instanceof PcepLspaObject) {
+ toStrHelper
+ .add("PCEP lspa Object", lspaObject);
+ }
+ if (bandwidthObject instanceof PcepBandwidthObject) {
+ toStrHelper
+ .add("bandwidth Object", bandwidthObject);
+ }
+ if (llMetricList instanceof PcepMetricObject) {
+ toStrHelper
+ .add("Pcep Metric object List", llMetricList);
+ }
+ if (iroObject instanceof PcepIroObject) {
+ toStrHelper
+ .add("iro Object", iroObject);
+ }
+ return toStrHelper.toString();
+ }
+}
\ No newline at end of file
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepBandwidthObjectVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepBandwidthObjectVer1.java
new file mode 100644
index 0000000..f46ff72
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepBandwidthObjectVer1.java
@@ -0,0 +1,242 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepBandwidthObject;
+import org.onosproject.pcepio.types.PcepObjectHeader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * Provides PcepBandwidthObject.
+ */
+public class PcepBandwidthObjectVer1 implements PcepBandwidthObject {
+
+ /*
+ * RFC : 5440 , section : 7.7.
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Bandwidth |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ The BANDWIDTH Object format
+ */
+
+ protected static final Logger log = LoggerFactory.getLogger(PcepBandwidthObjectVer1.class);
+ /*
+ * Requested bandwidth: BANDWIDTH Object-Type is 1.
+ Bandwidth of an existing TE LSP for which a re-optimization is
+ requested. BANDWIDTH Object-Type is 2.
+ */
+ //Right now handling type 1
+ public static final byte BANDWIDTH_OBJ_TYPE = 1;
+ public static final byte BANDWIDTH_OBJ_CLASS = 5;
+ public static final byte BANDWIDTH_OBJECT_VERSION = 1;
+ public static final short BANDWIDTH_OBJ_MINIMUM_LENGTH = 8;
+
+ static final PcepObjectHeader DEFAULT_BANDWIDTH_OBJECT_HEADER = new PcepObjectHeader(BANDWIDTH_OBJ_CLASS,
+ BANDWIDTH_OBJ_TYPE, PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED,
+ BANDWIDTH_OBJ_MINIMUM_LENGTH);
+
+ private PcepObjectHeader bandwidthObjHeader;
+ private int iBandwidth;
+
+ /**
+ * Constructor to bandwidth object header and bandwidth.
+ *
+ * @param bandwidthObjHeader bandwidth object header
+ * @param iBandwidth bandwidth value
+ */
+ public PcepBandwidthObjectVer1(PcepObjectHeader bandwidthObjHeader, int iBandwidth) {
+ this.bandwidthObjHeader = bandwidthObjHeader;
+ this.iBandwidth = iBandwidth;
+ }
+
+ /**
+ * Constructor to initialize bandwidth.
+ *
+ * @param iBandwidth bandwidth value
+ */
+ public PcepBandwidthObjectVer1(int iBandwidth) {
+ this.bandwidthObjHeader = DEFAULT_BANDWIDTH_OBJECT_HEADER;
+ this.iBandwidth = iBandwidth;
+ }
+
+ /**
+ * Returns Object Header.
+ *
+ * @return bandwidthObjHeader
+ */
+ public PcepObjectHeader getBandwidthObjHeader() {
+ return this.bandwidthObjHeader;
+ }
+
+ /**
+ * Sets Object Header.
+ *
+ * @param obj bandwidth object header
+ */
+ public void setBandwidthObjHeader(PcepObjectHeader obj) {
+ this.bandwidthObjHeader = obj;
+ }
+
+ @Override
+ public int getBandwidth() {
+ return this.iBandwidth;
+ }
+
+ @Override
+ public void setBandwidth(int iBandwidth) {
+ this.iBandwidth = iBandwidth;
+ }
+
+ /**
+ * Reads from channel buffer and returns object of PcepBandwidthObject.
+ *
+ * @param cb channel buffer to parse
+ * @return object of PcepBandwidthObject
+ * @throws PcepParseException while parsing channel buffer
+ */
+ public static PcepBandwidthObject read(ChannelBuffer cb) throws PcepParseException {
+
+ PcepObjectHeader bandwidthObjHeader;
+ int iBandwidth;
+
+ bandwidthObjHeader = PcepObjectHeader.read(cb);
+ iBandwidth = cb.readInt();
+
+ return new PcepBandwidthObjectVer1(bandwidthObjHeader, iBandwidth);
+ }
+
+ @Override
+ public int write(ChannelBuffer cb) throws PcepParseException {
+
+ //write Object header
+ int objStartIndex = cb.writerIndex();
+ int objLenIndex = bandwidthObjHeader.write(cb);
+
+ if (objLenIndex <= 0) {
+ throw new PcepParseException("Failed to write bandwidth object header. Index " + objLenIndex);
+ }
+
+ cb.writeInt(iBandwidth);
+ short hLength = (short) (cb.writerIndex() - objStartIndex);
+ cb.setShort(objLenIndex, hLength);
+ //will be helpful during print().
+ bandwidthObjHeader.setObjLen(hLength);
+
+ return cb.writerIndex() - objStartIndex;
+ }
+
+ /**
+ * builder class for PCEP bandwidth object.
+ */
+ public static class Builder implements PcepBandwidthObject.Builder {
+
+ private PcepObjectHeader bandwidthObjHeader;
+ private boolean bIsHeaderSet = false;
+
+ private int iBandwidth;
+ private boolean bIsBandwidthSet = false;
+
+ private boolean bPFlag;
+ private boolean bIsPFlagSet = false;
+
+ private boolean bIFlag;
+ private boolean bIsIFlagSet = false;
+
+ @Override
+ public PcepBandwidthObject build() throws PcepParseException {
+
+ PcepObjectHeader bandwidthObjHeader = this.bIsHeaderSet ? this.bandwidthObjHeader
+ : DEFAULT_BANDWIDTH_OBJECT_HEADER;
+
+ if (bIsPFlagSet) {
+ bandwidthObjHeader.setPFlag(bPFlag);
+ }
+
+ if (bIsIFlagSet) {
+ bandwidthObjHeader.setIFlag(bIFlag);
+ }
+
+ if (!this.bIsBandwidthSet) {
+ throw new PcepParseException("bandwidth not Set while building Bandwidth Object.");
+ }
+
+ return new PcepBandwidthObjectVer1(bandwidthObjHeader, iBandwidth);
+ }
+
+ @Override
+ public int getBandwidth() {
+ return this.iBandwidth;
+ }
+
+ @Override
+ public PcepObjectHeader getBandwidthObjHeader() {
+ return this.bandwidthObjHeader;
+ }
+
+ @Override
+ public Builder setBandwidthObjHeader(PcepObjectHeader obj) {
+ this.bandwidthObjHeader = obj;
+ return this;
+ }
+
+ @Override
+ public Builder setBandwidth(int iBandwidth) {
+ this.iBandwidth = iBandwidth;
+ this.bIsBandwidthSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setPFlag(boolean value) {
+ this.bPFlag = value;
+ this.bIsPFlagSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setIFlag(boolean value) {
+ this.bIFlag = value;
+ this.bIsIFlagSet = true;
+ return this;
+ }
+
+ }
+
+ @Override
+ public void print() {
+
+ log.debug("BANDWIDTH OBJECT");
+ bandwidthObjHeader.print();
+ log.debug("Bandwidth: " + iBandwidth);
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("bandwidth Object Header", bandwidthObjHeader)
+ .add("Bandwidth", iBandwidth)
+ .toString();
+ }
+}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepCloseMsgVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepCloseMsgVer1.java
new file mode 100644
index 0000000..54ed78f
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepCloseMsgVer1.java
@@ -0,0 +1,356 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import java.util.LinkedList;
+import java.util.ListIterator;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepCloseMsg;
+import org.onosproject.pcepio.protocol.PcepMessageReader;
+import org.onosproject.pcepio.protocol.PcepMessageWriter;
+import org.onosproject.pcepio.protocol.PcepType;
+import org.onosproject.pcepio.protocol.PcepVersion;
+import org.onosproject.pcepio.types.PcepObjectHeader;
+import org.onosproject.pcepio.types.PcepValueType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/*
+ * RFC : 5440 , section : 6.8
+ * <Close Message> ::= <Common Header> <CLOSE>
+ *
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Ver | Flags | Message-Type | Message-Length |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Object-Class | OT |Res|P|I| Object Length (bytes) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Reserved | Flags | Reason |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | |
+ // Optional TLVs //
+ | |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+class PcepCloseMsgVer1 implements PcepCloseMsg {
+
+ protected static final Logger log = LoggerFactory.getLogger(PcepCloseMsgVer1.class);
+
+ // Pcep version: 1
+ public static final byte PACKET_VERSION = 1;
+ public static final int PACKET_MINIMUM_LENGTH = 12;
+ public static final PcepType MSG_TYPE = PcepType.CLOSE;
+ public static final byte CLOSE_OBJ_TYPE = 1;
+ public static final byte CLOSE_OBJ_CLASS = 15;
+ public static final byte CLOSE_OBJECT_VERSION = 1;
+ public static final byte DEFAULT_REASON = 1; // Default reason to close
+ public static final short CLOSE_OBJ_MINIMUM_LENGTH = 8;
+ public static final int SHIFT_FLAG = 5;
+ static final PcepObjectHeader DEFAULT_CLOSE_HEADER = new PcepObjectHeader(CLOSE_OBJ_CLASS, CLOSE_OBJ_TYPE,
+ PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, CLOSE_OBJ_MINIMUM_LENGTH);
+
+ private final PcepObjectHeader closeObjHeader;
+ private byte yReason;
+ private LinkedList<PcepValueType> llOptionalTlv;
+
+ public static final PcepCloseMsgVer1.Reader READER = new Reader();
+
+ static class Reader implements PcepMessageReader<PcepCloseMsg> {
+ PcepObjectHeader closeObjHeader;
+ byte yReason;
+ // Optional TLV
+ private LinkedList<PcepValueType> llOptionalTlv;
+
+ @Override
+ public PcepCloseMsg readFrom(ChannelBuffer cb) throws PcepParseException {
+
+ if (cb.readableBytes() < PACKET_MINIMUM_LENGTH) {
+ throw new PcepParseException("Packet size is less than the minimum length.");
+ }
+ // fixed value property version == 1
+ byte version = cb.readByte();
+ version = (byte) (version >> SHIFT_FLAG);
+ if (version != PACKET_VERSION) {
+ throw new PcepParseException("Wrong version. Expected=PcepVersion.PCEP_1(1), got=" + version);
+ }
+ // fixed value property type == 7
+ byte type = cb.readByte();
+ if (type != MSG_TYPE.getType()) {
+ throw new PcepParseException("Wrong type. Expected=PcepType.CLOSE(7), got=" + type);
+ }
+ short length = cb.readShort();
+ if (length < PACKET_MINIMUM_LENGTH) {
+ throw new PcepParseException("Wrong length. Expected to be >= " + PACKET_MINIMUM_LENGTH + ", was: "
+ + length);
+ }
+ closeObjHeader = PcepObjectHeader.read(cb);
+ // Reserved
+ cb.readShort();
+ // Flags
+ cb.readByte();
+ // Reason
+ yReason = cb.readByte();
+ // parse optional TLV
+ llOptionalTlv = parseOptionalTlv(cb);
+ return new PcepCloseMsgVer1(closeObjHeader, yReason, llOptionalTlv);
+ }
+ }
+
+ /**
+ * Parse the list of Optional Tlvs.
+ *
+ * @param cb channel buffer
+ * @return list of Optional Tlvs
+ * @throws PcepParseException when fails to parse optional tlvs
+ */
+ public static LinkedList<PcepValueType> parseOptionalTlv(ChannelBuffer cb) throws PcepParseException {
+
+ LinkedList<PcepValueType> llOptionalTlv = new LinkedList<PcepValueType>();
+ /*
+ rfc 5440:
+ Optional TLVs may be included within the CLOSE object body. The
+ specification of such TLVs is outside the scope of this document.
+ */
+ return llOptionalTlv;
+ }
+
+ /**
+ * constructor to initialize PCEP close Message with all the parameters.
+ *
+ * @param closeObjHeader object header for close message
+ * @param yReason reason for closing the channel
+ * @param llOptionalTlv list of optional tlvs
+ */
+ PcepCloseMsgVer1(PcepObjectHeader closeObjHeader, byte yReason, LinkedList<PcepValueType> llOptionalTlv) {
+
+ this.closeObjHeader = closeObjHeader;
+ this.yReason = yReason;
+ this.llOptionalTlv = llOptionalTlv;
+ }
+
+ /**
+ * Builder class for PCEP close message.
+ */
+ static class Builder implements PcepCloseMsg.Builder {
+
+ // PCEP Close message fields
+ private boolean bIsHeaderSet = false;
+ private PcepObjectHeader closeObjHeader;
+ private boolean bIsReasonSet = false;
+ private byte yReason;
+ LinkedList<PcepValueType> llOptionalTlv = new LinkedList<PcepValueType>();
+
+ private boolean bIsPFlagSet = false;
+ private boolean bPFlag;
+
+ private boolean bIsIFlagSet = false;
+ private boolean bIFlag;
+
+ @Override
+ public PcepVersion getVersion() {
+ return PcepVersion.PCEP_1;
+ }
+
+ @Override
+ public PcepType getType() {
+ return PcepType.CLOSE;
+ }
+
+ @Override
+ public PcepCloseMsg build() {
+
+ PcepObjectHeader closeObjHeader = this.bIsHeaderSet ? this.closeObjHeader : DEFAULT_CLOSE_HEADER;
+ byte yReason = this.bIsReasonSet ? this.yReason : DEFAULT_REASON;
+
+ if (bIsPFlagSet) {
+ closeObjHeader.setPFlag(bPFlag);
+ }
+
+ if (bIsIFlagSet) {
+ closeObjHeader.setIFlag(bIFlag);
+ }
+ return new PcepCloseMsgVer1(closeObjHeader, yReason, this.llOptionalTlv);
+ }
+
+ @Override
+ public PcepObjectHeader getCloseObjHeader() {
+ return this.closeObjHeader;
+ }
+
+ @Override
+ public Builder setCloseObjHeader(PcepObjectHeader obj) {
+ this.closeObjHeader = obj;
+ this.bIsHeaderSet = true;
+ return this;
+ }
+
+ @Override
+ public byte getReason() {
+ return this.yReason;
+ }
+
+ @Override
+ public Builder setReason(byte value) {
+ this.yReason = value;
+ this.bIsReasonSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) {
+ this.llOptionalTlv = llOptionalTlv;
+ return this;
+ }
+
+ @Override
+ public LinkedList<PcepValueType> getOptionalTlv() {
+ return this.llOptionalTlv;
+ }
+
+ @Override
+ public Builder setPFlag(boolean value) {
+ this.bPFlag = value;
+ this.bIsPFlagSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setIFlag(boolean value) {
+ this.bIFlag = value;
+ this.bIsIFlagSet = true;
+ return this;
+ }
+ }
+
+ @Override
+ public void writeTo(ChannelBuffer cb) throws PcepParseException {
+ WRITER.write(cb, this);
+ }
+
+ static final Writer WRITER = new Writer();
+
+ static class Writer implements PcepMessageWriter<PcepCloseMsgVer1> {
+
+ @Override
+ public void write(ChannelBuffer cb, PcepCloseMsgVer1 message) throws PcepParseException {
+ int startIndex = cb.writerIndex();
+ // first 3 bits set to version
+ cb.writeByte((byte) (PACKET_VERSION << SHIFT_FLAG));
+ // message type
+ cb.writeByte(MSG_TYPE.getType());
+ // length is length of variable message, will be updated at the end
+ // Store the position of message
+ // length in buffer
+ int msgLenIndex = cb.writerIndex();
+ cb.writeShort((short) 0);
+ int objStartIndex = cb.writerIndex();
+ int objLenIndex = message.closeObjHeader.write(cb);
+ if (objLenIndex <= 0) {
+ throw new PcepParseException("Failed to write Close object header.");
+ }
+ // first 3 bits set to version
+ cb.writeShort(0); // Reserved
+ cb.writeByte(0); // Flags
+ cb.writeByte(message.yReason);
+ // Pack optional TLV
+ packOptionalTlv(cb, message);
+ int length = cb.writerIndex() - objStartIndex;
+ cb.setShort(objLenIndex, (short) length);
+ // will be helpful during print().
+ message.closeObjHeader.setObjLen((short) length);
+ // As per RFC the length of object should be
+ // multiples of 4
+ int pad = length % 4;
+ if (pad != 0) {
+ pad = 4 - pad;
+ for (int i = 0; i < pad; i++) {
+ cb.writeByte((byte) 0);
+ }
+ length = length + pad;
+ }
+ // update message length field
+ length = cb.writerIndex() - startIndex;
+ cb.setShort(msgLenIndex, (short) length);
+ }
+
+ public void packOptionalTlv(ChannelBuffer cb, PcepCloseMsgVer1 message) {
+
+ LinkedList<PcepValueType> llOptionalTlv = message.llOptionalTlv;
+ ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator();
+ while (listIterator.hasNext()) {
+ listIterator.next().write(cb);
+ }
+ }
+ }
+
+ @Override
+ public PcepVersion getVersion() {
+ return PcepVersion.PCEP_1;
+ }
+
+ @Override
+ public PcepType getType() {
+ return MSG_TYPE;
+ }
+
+ @Override
+ public byte getReason() {
+ return this.yReason;
+ }
+
+ @Override
+ public void setReason(byte value) {
+ this.yReason = value;
+ }
+
+ @Override
+ public LinkedList<PcepValueType> getOptionalTlv() {
+ return this.llOptionalTlv;
+ }
+
+ @Override
+ public void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) {
+ this.llOptionalTlv = llOptionalTlv;
+ }
+
+ @Override
+ public void print() {
+ log.debug("CLOSE MESSAGE");
+ closeObjHeader.print();
+ int x = yReason & 0xFF;
+ log.debug("Reason: " + x);
+ log.debug("OPTINAL TLV:");
+ ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator();
+ while (listIterator.hasNext()) {
+ listIterator.next().print();
+ }
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("close Object Header", closeObjHeader)
+ .add("Reason", yReason)
+ .add("Optional Tlv list", llOptionalTlv)
+ .toString();
+ }
+}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepEndPointsObjectVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepEndPointsObjectVer1.java
new file mode 100644
index 0000000..d57d35b
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepEndPointsObjectVer1.java
@@ -0,0 +1,268 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepEndPointsObject;
+import org.onosproject.pcepio.types.PcepObjectHeader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+public class PcepEndPointsObjectVer1 implements PcepEndPointsObject {
+
+ /*
+ * RFC : 5440 , section : 7.6
+ * An End point is defined as follows:
+ END-POINTS Object-Class is 4.
+
+ END-POINTS Object-Type is 1 for IPv4 and 2 for IPv6.
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Object-Class | OT |Res|P|I| Object Length (bytes) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Source IPv4 address |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Destination IPv4 address |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ */
+ protected static final Logger log = LoggerFactory.getLogger(PcepEndPointsObjectVer1.class);
+
+ static final byte END_POINTS_OBJ_TYPE = 1;
+ static final byte END_POINTS_OBJ_CLASS = 4;
+ static final byte END_POINTS_OBJECT_VERSION = 1;
+ static final short END_POINTS_OBJ_MINIMUM_LENGTH = 12;
+ public static byte endPointObjType;
+
+ static final PcepObjectHeader DEFAULT_END_POINTS_OBJECT_HEADER = new PcepObjectHeader(END_POINTS_OBJ_CLASS,
+ END_POINTS_OBJ_TYPE, PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED,
+ END_POINTS_OBJ_MINIMUM_LENGTH);
+
+ private PcepObjectHeader endPointsObjHeader;
+ public int sourceIpAddress;
+ public int destIpAddress;
+
+ /**
+ * Constructor to initialize all variables.
+ *
+ * @param endPointsObjHeader end points object header
+ * @param sourceIpAddress source IP address
+ * @param destIpAddress destination IP address
+ */
+ public PcepEndPointsObjectVer1(PcepObjectHeader endPointsObjHeader, int sourceIpAddress, int destIpAddress) {
+
+ this.endPointsObjHeader = endPointsObjHeader;
+ this.sourceIpAddress = sourceIpAddress;
+ this.destIpAddress = destIpAddress;
+ }
+
+ /**
+ * Sets End Points Object Header.
+ *
+ * @param obj of PcepObjectHeader
+ */
+ public void setEndPointsObjHeader(PcepObjectHeader obj) {
+ this.endPointsObjHeader = obj;
+ }
+
+ @Override
+ public void setSourceIpAddress(int sourceIpAddress) {
+ this.sourceIpAddress = sourceIpAddress;
+ }
+
+ @Override
+ public void setDestIpAddress(int destIpAddress) {
+ this.destIpAddress = destIpAddress;
+ }
+
+ @Override
+ public int getSourceIpAddress() {
+ return this.sourceIpAddress;
+ }
+
+ @Override
+ public int getDestIpAddress() {
+ return this.destIpAddress;
+ }
+
+ /**
+ * Reads from channel buffer and returns object of PcepEndPointsObject.
+ *
+ * @param cb of channel buffer
+ * @return object of PcepEndPointsObject
+ * @throws PcepParseException while parsing channel buffer
+ */
+ public static PcepEndPointsObject read(ChannelBuffer cb) throws PcepParseException {
+
+ PcepObjectHeader endPointsObjHeader;
+ int sourceIpAddress;
+ int destIpAddress;
+
+ endPointsObjHeader = PcepObjectHeader.read(cb);
+ if (END_POINTS_OBJ_TYPE == endPointsObjHeader.getObjType()
+ && END_POINTS_OBJ_CLASS == endPointsObjHeader.getObjClass()) {
+ sourceIpAddress = cb.readInt();
+ destIpAddress = cb.readInt();
+ } else {
+ throw new PcepParseException("Expected PcepEndPointsObject.");
+ }
+ return new PcepEndPointsObjectVer1(endPointsObjHeader, sourceIpAddress, destIpAddress);
+ }
+
+ @Override
+ public int write(ChannelBuffer cb) throws PcepParseException {
+
+ int objStartIndex = cb.writerIndex();
+ //write common header
+ int objLenIndex = endPointsObjHeader.write(cb);
+
+ //write source IPv4 IP
+ cb.writeInt(sourceIpAddress);
+ //write destination IPv4 IP
+ cb.writeInt(destIpAddress);
+
+ int length = cb.writerIndex() - objStartIndex;
+ //now write EndPoints Object Length
+ cb.setShort(objLenIndex, (short) length);
+ //will be helpful during print().
+ endPointsObjHeader.setObjLen((short) length);
+
+ return cb.writerIndex();
+
+ }
+
+ /**
+ * Builder class for PCEP end points objects.
+ */
+ public static class Builder implements PcepEndPointsObject.Builder {
+
+ private boolean bIsHeaderSet = false;
+ private boolean bIsSourceIpAddressset = false;
+ private boolean bIsDestIpAddressset = false;
+ private PcepObjectHeader endpointsObjHeader;
+ private int sourceIpAddress;
+ private int destIpAddress;
+
+ private boolean bIsPFlagSet = false;
+ private boolean bPFlag;
+
+ private boolean bIsIFlagSet = false;
+ private boolean bIFlag;
+
+ @Override
+ public PcepEndPointsObject build() throws PcepParseException {
+
+ PcepObjectHeader endpointsObjHeader = this.bIsHeaderSet ? this.endpointsObjHeader
+ : DEFAULT_END_POINTS_OBJECT_HEADER;
+
+ if (bIsPFlagSet) {
+ endpointsObjHeader.setPFlag(bPFlag);
+ }
+
+ if (bIsIFlagSet) {
+ endpointsObjHeader.setIFlag(bIFlag);
+ }
+
+ if (!this.bIsSourceIpAddressset) {
+ throw new PcepParseException("SourceIpAddress not set while building EndPoints object");
+ }
+
+ if (!this.bIsDestIpAddressset) {
+ throw new PcepParseException("DestIpAddress not set while building EndPoints object");
+ }
+
+ return new PcepEndPointsObjectVer1(endpointsObjHeader, this.sourceIpAddress, this.destIpAddress);
+ }
+
+ @Override
+ public PcepObjectHeader getEndPointsObjHeader() {
+ return this.endpointsObjHeader;
+ }
+
+ @Override
+ public Builder setEndPointsObjHeader(PcepObjectHeader obj) {
+ this.endpointsObjHeader = obj;
+ this.bIsHeaderSet = true;
+ return this;
+ }
+
+ @Override
+ public int getSourceIpAddress() {
+ return this.sourceIpAddress;
+ }
+
+ @Override
+ public Builder setSourceIpAddress(int sourceIpAddress) {
+ this.sourceIpAddress = sourceIpAddress;
+ this.bIsSourceIpAddressset = true;
+ return this;
+ }
+
+ @Override
+ public int getDestIpAddress() {
+ return this.destIpAddress;
+ }
+
+ @Override
+ public Builder setDestIpAddress(int destIpAddress) {
+ this.destIpAddress = destIpAddress;
+ this.bIsDestIpAddressset = true;
+ return this;
+ }
+
+ @Override
+ public Builder setPFlag(boolean value) {
+ this.bPFlag = value;
+ this.bIsPFlagSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setIFlag(boolean value) {
+ this.bIFlag = value;
+ this.bIsIFlagSet = true;
+ return this;
+ }
+
+ }
+
+ @Override
+ public void print() {
+
+ log.debug("ENDPOINT OBJECT");
+ long lTemp;
+ lTemp = sourceIpAddress & 0xFFFFFFFF;
+ String str = "Source IP Address: " + lTemp;
+ log.debug(str);
+ lTemp = destIpAddress & 0xFFFFFFFF;
+ str = "destination IP Address: " + lTemp;
+ log.debug(str);
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("sourceIpAddress", sourceIpAddress)
+ .add("destIpAddress", destIpAddress)
+ .toString();
+ }
+
+}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepEroObjectVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepEroObjectVer1.java
new file mode 100644
index 0000000..586547e
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepEroObjectVer1.java
@@ -0,0 +1,418 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import java.util.LinkedList;
+import java.util.ListIterator;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepEroObject;
+import org.onosproject.pcepio.types.AutonomousSystemTlv;
+import org.onosproject.pcepio.types.IPv4SubObject;
+import org.onosproject.pcepio.types.IPv6SubObject;
+import org.onosproject.pcepio.types.PathKeySubObject;
+import org.onosproject.pcepio.types.PcepErrorDetailInfo;
+import org.onosproject.pcepio.types.PcepObjectHeader;
+import org.onosproject.pcepio.types.PcepValueType;
+import org.onosproject.pcepio.types.SrEroSubObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/*
+ * rfc3209
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Object-Class | OT |Res|P|I| Object Length (bytes) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | |
+ // (Subobjects) //
+ | |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ If a Path message contains multiple EXPLICIT_ROUTE objects, only the
+ first object is meaningful. Subsequent EXPLICIT_ROUTE objects MAY be
+ ignored and SHOULD NOT be propagated.
+
+ In current implementation, only strict hops are supported. So,
+ empty ERO with no sub-objects is considered illegal.
+
+ Subobjects:
+ 0 1
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-------------//----------------+
+ |L| Type | Length | (Subobject contents) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-------------//----------------+
+
+ L
+
+ The L bit is an attribute of the subobject. The L bit is set
+ if the subobject represents a loose hop in the explicit route.
+ If the bit is not set, the subobject represents a strict hop in
+ the explicit route.
+
+ Type
+
+ The Type indicates the type of contents of the subobject.
+
+
+ Subobject 1: IPv4 address
+
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |L| Type | Length | IPv4 address (4 bytes) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | IPv4 address (continued) | Prefix Length | Resvd |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ Subobject 2: IPv6 Prefix
+
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |L| Type | Length | IPv6 address (16 bytes) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | IPv6 address (continued) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | IPv6 address (continued) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | IPv6 address (continued) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | IPv6 address (continued) | Prefix Length | Resvd |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ Subobject 3: Autonomous System Number
+
+ The contents of an Autonomous System (AS) number subobject are a 2-
+ octet AS number. The abstract node represented by this subobject is
+ the set of nodes belonging to the autonomous system.
+
+ The length of the AS number subobject is 4 octets.
+
+ Subobject 4: PATH_KEY_32_BIT_SUB_OBJ_TYPE:
+
+ Pathkey subobject(RFC 5520):
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |L| Type | Length | Path-Key |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | PCE ID (4 bytes) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ Subobject 5: SR_ERO_SUB_OBJ_TYPE:
+
+ SR-ERO subobject: (draft-ietf-pce-segment-routing-00)
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |L| Type | Length | ST | Flags |F|S|C|M|
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | SID |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // NAI (variable) //
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+public class PcepEroObjectVer1 implements PcepEroObject {
+
+ protected static final Logger log = LoggerFactory.getLogger(PcepEroObjectVer1.class);
+
+ public static final byte ERO_OBJ_TYPE = 1;
+ public static final byte ERO_OBJ_CLASS = 7;
+ public static final byte ERO_OBJECT_VERSION = 1;
+ public static final short ERO_OBJ_MINIMUM_LENGTH = 12;
+ public static final byte IPV4_TYPE = 1;
+ public static final byte PATH_KEY_32_BIT_SUB_OBJ_TYPE = 64;
+ public static final int LABEL_SUB_OBJ_TYPE = 3;
+ public static final int SR_ERO_SUB_OBJ_TYPE = 96;
+ public static final int OBJECT_HEADER_LENGTH = 4;
+ public static final int YTYPE_SHIFT_VALUE = 0x7F;
+
+ static final PcepObjectHeader DEFAULT_ERO_OBJECT_HEADER = new PcepObjectHeader(ERO_OBJ_CLASS, ERO_OBJ_TYPE,
+ PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, ERO_OBJ_MINIMUM_LENGTH);
+
+ private PcepObjectHeader eroObjHeader;
+ private LinkedList<PcepValueType> llSubObjects = new LinkedList<PcepValueType>();
+
+ /**
+ * reset variables.
+ */
+ public PcepEroObjectVer1() {
+ this.eroObjHeader = null;
+ this.llSubObjects = null;
+ }
+
+ /**
+ * Constructor to initialize parameters of ERO object.
+ *
+ * @param eroObjHeader ERO object header
+ * @param llSubObjects list of sub objects.
+ */
+ public PcepEroObjectVer1(PcepObjectHeader eroObjHeader, LinkedList<PcepValueType> llSubObjects) {
+
+ this.eroObjHeader = eroObjHeader;
+ this.llSubObjects = llSubObjects;
+ }
+
+ /**
+ * Returns ERO object header.
+ *
+ * @return eroObjHeader ERO object header
+ */
+ public PcepObjectHeader getEroObjHeader() {
+ return this.eroObjHeader;
+ }
+
+ /**
+ * Sets Object Header.
+ *
+ * @param obj ERO object header
+ */
+ public void setEroObjHeader(PcepObjectHeader obj) {
+ this.eroObjHeader = obj;
+ }
+
+ @Override
+ public LinkedList<PcepValueType> getSubObjects() {
+ return this.llSubObjects;
+ }
+
+ @Override
+ public void setSubObjects(LinkedList<PcepValueType> llSubObjects) {
+ this.llSubObjects = llSubObjects;
+ }
+
+ /**
+ * Reads from channel buffer and returns object of PcepEroObject.
+ *
+ * @param cb channel buffer.
+ * @return object of PcepEroObject
+ * @throws PcepParseException when ERO object is not present in channel buffer
+ */
+ public static PcepEroObject read(ChannelBuffer cb) throws PcepParseException {
+
+ PcepObjectHeader eroObjHeader;
+ LinkedList<PcepValueType> llSubObjects = new LinkedList<PcepValueType>();
+
+ eroObjHeader = PcepObjectHeader.read(cb);
+
+ if (eroObjHeader.getObjClass() != PcepEroObjectVer1.ERO_OBJ_CLASS) {
+ log.debug("ErrorType:" + PcepErrorDetailInfo.ERROR_TYPE_6 + " ErrorValue:"
+ + PcepErrorDetailInfo.ERROR_VALUE_9);
+ throw new PcepParseException(PcepErrorDetailInfo.ERROR_TYPE_6, PcepErrorDetailInfo.ERROR_VALUE_9);
+ }
+
+ if (eroObjHeader.getObjLen() > OBJECT_HEADER_LENGTH) {
+ ChannelBuffer tempCb = cb.readBytes(eroObjHeader.getObjLen() - OBJECT_HEADER_LENGTH);
+ llSubObjects = parseSubObjects(tempCb);
+ }
+ return new PcepEroObjectVer1(eroObjHeader, llSubObjects);
+ }
+
+ /**
+ * Parse list of Sub Objects.
+ *
+ * @param cb channel buffer
+ * @return list of Sub Objects
+ * @throws PcepParseException when fails to parse sub object list
+ */
+ protected static LinkedList<PcepValueType> parseSubObjects(ChannelBuffer cb) throws PcepParseException {
+
+ LinkedList<PcepValueType> llSubObjects = new LinkedList<PcepValueType>();
+
+ while (0 < cb.readableBytes()) {
+
+ //check the Type of the TLV
+ byte yType = cb.readByte();
+ yType = (byte) (yType & (YTYPE_SHIFT_VALUE));
+ byte hLength = cb.readByte();
+
+ PcepValueType subObj;
+
+ switch (yType) {
+
+ case IPv4SubObject.TYPE:
+ subObj = IPv4SubObject.read(cb);
+ break;
+ case IPv6SubObject.TYPE:
+ byte[] ipv6Value = new byte[IPv6SubObject.VALUE_LENGTH];
+ cb.readBytes(ipv6Value, 0, IPv6SubObject.VALUE_LENGTH);
+ subObj = new IPv6SubObject(ipv6Value);
+ break;
+ case AutonomousSystemTlv.TYPE:
+ subObj = AutonomousSystemTlv.read(cb);
+ break;
+ case PathKeySubObject.TYPE:
+ subObj = PathKeySubObject.read(cb);
+ break;
+ case SrEroSubObject.TYPE:
+ subObj = SrEroSubObject.read(cb);
+ break;
+ default:
+ throw new PcepParseException("Unexpected sub object. Type: " + (int) yType);
+ }
+ // Check for the padding
+ int pad = hLength % 4;
+ if (0 < pad) {
+ pad = 4 - pad;
+ if (pad <= cb.readableBytes()) {
+ cb.skipBytes(pad);
+ }
+ }
+
+ llSubObjects.add(subObj);
+ }
+ if (0 < cb.readableBytes()) {
+ throw new PcepParseException("Subobject parsing error. Extra bytes received.");
+ }
+ return llSubObjects;
+ }
+
+ @Override
+ public int write(ChannelBuffer cb) throws PcepParseException {
+
+ //write Object header
+ int objStartIndex = cb.writerIndex();
+
+ int objLenIndex = eroObjHeader.write(cb);
+
+ if (objLenIndex <= 0) {
+ throw new PcepParseException("Failed to write ERO object header. Index " + objLenIndex);
+ }
+
+ ListIterator<PcepValueType> listIterator = llSubObjects.listIterator();
+
+ while (listIterator.hasNext()) {
+ listIterator.next().write(cb);
+ }
+
+ //Update object length now
+ int length = cb.writerIndex() - objStartIndex;
+ cb.setShort(objLenIndex, (short) length);
+ //will be helpful during print().
+ eroObjHeader.setObjLen((short) length);
+
+ //As per RFC the length of object should be multiples of 4
+ int pad = length % 4;
+
+ if (pad != 0) {
+ pad = 4 - pad;
+ for (int i = 0; i < pad; i++) {
+ cb.writeByte((byte) 0);
+ }
+ length = length + pad;
+ }
+
+ objLenIndex = cb.writerIndex();
+ return objLenIndex;
+ }
+
+ /**
+ * Builder class for PCEP ERO object.
+ */
+ public static class Builder implements PcepEroObject.Builder {
+
+ private boolean bIsHeaderSet = false;
+
+ private boolean bIsPFlagSet = false;
+ private boolean bPFlag;
+
+ private boolean bIsIFlagSet = false;
+ private boolean bIFlag;
+
+ private PcepObjectHeader eroObjHeader;
+ LinkedList<PcepValueType> llSubObjects = new LinkedList<PcepValueType>();
+
+ @Override
+ public PcepEroObject build() {
+
+ PcepObjectHeader eroObjHeader = this.bIsHeaderSet ? this.eroObjHeader : DEFAULT_ERO_OBJECT_HEADER;
+
+ if (bIsPFlagSet) {
+ eroObjHeader.setPFlag(bPFlag);
+ }
+
+ if (bIsIFlagSet) {
+ eroObjHeader.setIFlag(bIFlag);
+ }
+
+ return new PcepEroObjectVer1(eroObjHeader, this.llSubObjects);
+ }
+
+ @Override
+ public PcepObjectHeader getEroObjHeader() {
+ return this.eroObjHeader;
+ }
+
+ @Override
+ public Builder setEroObjHeader(PcepObjectHeader obj) {
+ this.eroObjHeader = obj;
+ this.bIsHeaderSet = true;
+ return this;
+ }
+
+ @Override
+ public LinkedList<PcepValueType> getSubObjects() {
+ return this.llSubObjects;
+ }
+
+ @Override
+ public Builder setSubObjects(LinkedList<PcepValueType> llSubObjects) {
+ this.llSubObjects = llSubObjects;
+ return this;
+ }
+
+ @Override
+ public Builder setPFlag(boolean value) {
+ this.bPFlag = value;
+ this.bIsPFlagSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setIFlag(boolean value) {
+ this.bIFlag = value;
+ this.bIsIFlagSet = true;
+ return this;
+ }
+
+ }
+
+ @Override
+ public void print() {
+
+ log.debug("ERO OBJECT");
+ eroObjHeader.print();
+ log.debug("SUBOBJECTS:");
+ ListIterator<PcepValueType> listIterator = llSubObjects.listIterator();
+ while (listIterator.hasNext()) {
+ listIterator.next().print();
+ }
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("ero obj Header", eroObjHeader)
+ .add("Sub-Objects", llSubObjects)
+ .toString();
+ }
+}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFactoryVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFactoryVer1.java
new file mode 100644
index 0000000..6f4b2b2
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepFactoryVer1.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import org.onosproject.pcepio.protocol.PcInitiatedLspRequest;
+import org.onosproject.pcepio.protocol.PcepAttribute;
+import org.onosproject.pcepio.protocol.PcepBandwidthObject;
+import org.onosproject.pcepio.protocol.PcepCloseMsg;
+import org.onosproject.pcepio.protocol.PcepEndPointsObject;
+import org.onosproject.pcepio.protocol.PcepEroObject;
+import org.onosproject.pcepio.protocol.PcepFactory;
+import org.onosproject.pcepio.protocol.PcepInitiateMsg;
+import org.onosproject.pcepio.protocol.PcepKeepaliveMsg;
+import org.onosproject.pcepio.protocol.PcepLspObject;
+import org.onosproject.pcepio.protocol.PcepLspaObject;
+import org.onosproject.pcepio.protocol.PcepMessage;
+import org.onosproject.pcepio.protocol.PcepMessageReader;
+import org.onosproject.pcepio.protocol.PcepMetricObject;
+import org.onosproject.pcepio.protocol.PcepMsgPath;
+
+import org.onosproject.pcepio.protocol.PcepSrpObject;
+import org.onosproject.pcepio.protocol.PcepUpdateMsg;
+import org.onosproject.pcepio.protocol.PcepUpdateRequest;
+import org.onosproject.pcepio.protocol.PcepVersion;
+
+public class PcepFactoryVer1 implements PcepFactory {
+
+ public static final PcepFactoryVer1 INSTANCE = new PcepFactoryVer1();
+
+ @Override
+ public org.onosproject.pcepio.protocol.PcepOpenMsg.Builder buildOpenMsg() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public org.onosproject.pcepio.protocol.PcepOpenObject.Builder buildOpenObject() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public PcepKeepaliveMsg.Builder buildKeepaliveMsg() {
+ return new PcepKeepaliveMsgVer1.Builder();
+ }
+
+ @Override
+ public PcepCloseMsg.Builder buildCloseMsg() {
+ return new PcepCloseMsgVer1.Builder();
+ }
+
+ @Override
+ public PcepUpdateMsg.Builder buildUpdateMsg() {
+ return new PcepUpdateMsgVer1.Builder();
+ }
+
+ @Override
+ public org.onosproject.pcepio.protocol.PcepReportMsg.Builder buildReportMsg() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public PcepInitiateMsg.Builder buildPcepInitiateMsg() {
+ return new PcepInitiateMsgVer1.Builder();
+ }
+
+ @Override
+ public PcepLspObject.Builder buildLspObject() {
+ return new PcepLspObjectVer1.Builder();
+ }
+
+ @Override
+ public PcepMessageReader<PcepMessage> getReader() {
+ return PcepMessageVer1.READER;
+ }
+
+ @Override
+ public PcepVersion getVersion() {
+ return PcepVersion.PCEP_1;
+ }
+
+ @Override
+ public PcepSrpObject.Builder buildSrpObject() {
+ return new PcepSrpObjectVer1.Builder();
+ }
+
+ @Override
+ public PcepEndPointsObject.Builder buildEndPointsObject() {
+ return new PcepEndPointsObjectVer1.Builder();
+ }
+
+ @Override
+ public PcepEroObject.Builder buildEroObject() {
+ return new PcepEroObjectVer1.Builder();
+ }
+
+ @Override
+ public org.onosproject.pcepio.protocol.PcepRroObject.Builder buildRroObject() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public PcepLspaObject.Builder buildLspaObject() {
+ return new PcepLspaObjectVer1.Builder();
+ }
+
+ @Override
+ public org.onosproject.pcepio.protocol.PcepIroObject.Builder buildIroObject() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public PcepMetricObject.Builder buildMetricObject() {
+ return new PcepMetricObjectVer1.Builder();
+ }
+
+ @Override
+ public PcepBandwidthObject.Builder buildBandwidthObject() {
+ return new PcepBandwidthObjectVer1.Builder();
+ }
+
+ @Override
+ public PcepMsgPath.Builder buildPcepMsgPath() {
+ return new PcepMsgPathVer1.Builder();
+ }
+
+ @Override
+ public org.onosproject.pcepio.protocol.PcepStateReport.Builder buildPcepStateReport() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public PcepUpdateRequest.Builder buildPcepUpdateRequest() {
+ return new PcepUpdateRequestVer1.Builder();
+ }
+
+ @Override
+ public PcInitiatedLspRequest.Builder buildPcInitiatedLspRequest() {
+ return new PcInitiatedLspRequestVer1.Builder();
+ }
+
+ @Override
+ public PcepAttribute.Builder buildPcepAttribute() {
+ return new PcepAttributeVer1.Builder();
+ }
+
+ @Override
+ public org.onosproject.pcepio.protocol.PcepLabelUpdateMsg.Builder buildPcepLabelUpdateMsg() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public org.onosproject.pcepio.protocol.PcepLabelUpdate.Builder buildPcepLabelUpdateObject() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public org.onosproject.pcepio.protocol.PcepLabelObject.Builder buildLabelObject() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public org.onosproject.pcepio.protocol.PcepErrorMsg.Builder buildPcepErrorMsg() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public org.onosproject.pcepio.protocol.PcepErrorObject.Builder buildPcepErrorObject() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public org.onosproject.pcepio.protocol.PcepFecObjectIPv4Adjacency.Builder buildFecIpv4Adjacency() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public org.onosproject.pcepio.protocol.PcepErrorInfo.Builder buildPcepErrorInfo() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public org.onosproject.pcepio.protocol.PcepError.Builder buildPcepError() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepInitiateMsgVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepInitiateMsgVer1.java
new file mode 100644
index 0000000..7392370
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepInitiateMsgVer1.java
@@ -0,0 +1,334 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import java.util.LinkedList;
+import java.util.ListIterator;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcInitiatedLspRequest;
+import org.onosproject.pcepio.protocol.PcepAttribute;
+import org.onosproject.pcepio.protocol.PcepEndPointsObject;
+import org.onosproject.pcepio.protocol.PcepEroObject;
+import org.onosproject.pcepio.protocol.PcepInitiateMsg;
+import org.onosproject.pcepio.protocol.PcepLspObject;
+import org.onosproject.pcepio.protocol.PcepMessageReader;
+import org.onosproject.pcepio.protocol.PcepMessageWriter;
+import org.onosproject.pcepio.protocol.PcepSrpObject;
+import org.onosproject.pcepio.protocol.PcepType;
+import org.onosproject.pcepio.protocol.PcepVersion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+class PcepInitiateMsgVer1 implements PcepInitiateMsg {
+
+ protected static final Logger log = LoggerFactory.getLogger(PcepInitiateMsgVer1.class);
+
+ // Ref : PCE initiated tunnel setup draft-ietf-pce-pce-initiated-lsp-03, section 5.1
+ /* <PCInitiate Message> ::= <Common Header>
+ * <PCE-initiated-lsp-list>
+ * Where:
+ * <PCE-initiated-lsp-list> ::= <PCE-initiated-lsp-request>[<PCE-initiated-lsp-list>]
+ * <PCE-initiated-lsp-request> ::= (<PCE-initiated-lsp-instantiation>|<PCE-initiated-lsp-deletion>)
+ * <PCE-initiated-lsp-instantiation> ::= <SRP>
+ * <LSP>
+ * <END-POINTS>
+ * <ERO>
+ * [<attribute-list>]
+ * <PCE-initiated-lsp-deletion> ::= <SRP>
+ * <LSP>
+ */
+
+ static final byte PACKET_VERSION = 1;
+ /* considering LspDelete Request PcInitiate msg will contain
+ * common header
+ * srp object
+ * lsp object
+ * so min length for this can be
+ * PACKET_MINIMUM_LENGTH = CommonHeaderLen(4)+SrpObjectMinLen(12)+LspObjectMinLen(8)
+ */
+ public static final short PACKET_MINIMUM_LENGTH = 24;
+ public static final short MINIMUM_COMMON_HEADER_LENGTH = 4;
+ public static final PcepType MSG_TYPE = PcepType.INITIATE;
+ private LinkedList<PcInitiatedLspRequest> llPcInitiatedLspRequestList;
+ public static final PcepInitiateMsgVer1.Reader READER = new Reader();
+
+ static class Reader implements PcepMessageReader<PcepInitiateMsg> {
+
+ LinkedList<PcInitiatedLspRequest> llPcInitiatedLspRequestList;
+
+ @Override
+ public PcepInitiateMsg readFrom(ChannelBuffer cb) throws PcepParseException {
+
+ if (cb.readableBytes() < PACKET_MINIMUM_LENGTH) {
+ return null;
+ }
+
+ llPcInitiatedLspRequestList = new LinkedList<PcInitiatedLspRequest>();
+
+ byte version = cb.readByte();
+ version = (byte) (version >> PcepMessageVer1.SHIFT_FLAG);
+ if (version != PACKET_VERSION) {
+ throw new PcepParseException("Wrong version. Expected=PcepVersion.PCEP_1(1), received=" + version);
+ }
+ byte type = cb.readByte();
+ if (type != MSG_TYPE.getType()) {
+ throw new PcepParseException("Wrong type. Expected=PcepType.INITIATE(12), recived=" + type);
+ }
+ short length = cb.readShort();
+
+ if (length < PACKET_MINIMUM_LENGTH) {
+ throw new PcepParseException("Wrong length. Initiate message length expected to be >= "
+ + PACKET_MINIMUM_LENGTH + ", but received=" + length);
+ }
+
+ log.debug("reading PcInitiate message of length " + length);
+
+ // parse Start initiate/deletion list
+ if (!parsePcInitiatedLspRequestList(cb)) {
+ throw new PcepParseException("Parsing PCE-initiated-lsp-Request-list failed");
+ }
+
+ return new PcepInitiateMsgVer1(llPcInitiatedLspRequestList);
+ }
+
+ /**
+ * To parse PcInitiatedLspRequestList from PcInitiate Message.
+ *
+ * @param cb of type channel buffer
+ * @return true if parsing PcInitiatedLspRequestList is success, false otherwise
+ * @throws PcepParseException while parsing from channel buffer
+ */
+ public boolean parsePcInitiatedLspRequestList(ChannelBuffer cb) throws PcepParseException {
+
+ boolean isDelLspRequest = false;
+
+ if (null == cb) {
+ throw new PcepParseException("Channel buffer is empty");
+ }
+
+ while (0 < cb.readableBytes()) {
+ PcInitiatedLspRequest pceInitLspReq = new PcInitiatedLspRequestVer1();
+
+ //store SRP object
+ PcepSrpObject srpObj;
+ srpObj = PcepSrpObjectVer1.read(cb);
+ pceInitLspReq.setSrpObject(srpObj);
+ isDelLspRequest = srpObj.getRFlag();
+
+ //store LSP object
+ PcepLspObject lspObj;
+ lspObj = PcepLspObjectVer1.read(cb);
+ pceInitLspReq.setLspObject(lspObj);
+
+ /* if R bit will be set then pcInitiate msg will contain only LSp and SRP objects
+ * so if R bit is not set then we should read for Ero and EndPoint objects also.
+ */
+ if (!isDelLspRequest) {
+
+ //store EndPoint object
+ PcepEndPointsObject endPointObj;
+ endPointObj = PcepEndPointsObjectVer1.read(cb);
+ pceInitLspReq.setEndPointsObject(endPointObj);
+
+ //store ERO object
+ PcepEroObject eroObj;
+ eroObj = PcepEroObjectVer1.read(cb);
+ pceInitLspReq.setEroObject(eroObj);
+
+ if (cb.readableBytes() > MINIMUM_COMMON_HEADER_LENGTH) {
+ pceInitLspReq.setPcepAttribute(PcepAttributeVer1.read(cb));
+ }
+ }
+ llPcInitiatedLspRequestList.add(pceInitLspReq);
+ }
+
+ return true;
+ }
+ }
+
+ /**
+ * Constructor to initialize PcInitiatedLspRequest.
+ *
+ * @param llPcInitiatedLspRequestList list of PcInitiatedLspRequest
+ */
+ PcepInitiateMsgVer1(LinkedList<PcInitiatedLspRequest> llPcInitiatedLspRequestList) {
+
+ if (llPcInitiatedLspRequestList == null) {
+ throw new NullPointerException("PcInitiatedLspRequestList cannot be null.");
+ }
+ this.llPcInitiatedLspRequestList = llPcInitiatedLspRequestList;
+ }
+
+ /**
+ * Builder class for PCEP initiate message.
+ */
+ static class Builder implements PcepInitiateMsg.Builder {
+
+ // Pcep initiate message fields
+ LinkedList<PcInitiatedLspRequest> llPcInitiatedLspRequestList;
+
+ @Override
+ public PcepVersion getVersion() {
+ return PcepVersion.PCEP_1;
+ }
+
+ @Override
+ public PcepType getType() {
+ return PcepType.INITIATE;
+ }
+
+ @Override
+ public PcepInitiateMsg build() {
+ return new PcepInitiateMsgVer1(this.llPcInitiatedLspRequestList);
+ }
+
+ @Override
+ public LinkedList<PcInitiatedLspRequest> getPcInitiatedLspRequestList() {
+ return this.llPcInitiatedLspRequestList;
+ }
+
+ @Override
+ public Builder setPcInitiatedLspRequestList(LinkedList<PcInitiatedLspRequest> ll) {
+ this.llPcInitiatedLspRequestList = ll;
+ return this;
+ }
+ }
+
+ @Override
+ public void writeTo(ChannelBuffer cb) throws PcepParseException {
+ WRITER.write(cb, this);
+ }
+
+ static final Writer WRITER = new Writer();
+
+ static class Writer implements PcepMessageWriter<PcepInitiateMsgVer1> {
+
+ @Override
+ public void write(ChannelBuffer cb, PcepInitiateMsgVer1 message) throws PcepParseException {
+
+ boolean isDelLspRequest = false;
+ int startIndex = cb.writerIndex();
+ // first 3 bits set to version
+ cb.writeByte((byte) (PACKET_VERSION << PcepMessageVer1.SHIFT_FLAG));
+ // message type 0xC
+ cb.writeByte(MSG_TYPE.getType());
+ // length is length of variable message, will be updated at the end
+ // Store the position of message
+ // length in buffer
+ int msgLenIndex = cb.writerIndex();
+ cb.writeShort(0);
+
+ ListIterator<PcInitiatedLspRequest> listIterator = message.llPcInitiatedLspRequestList.listIterator();
+
+ while (listIterator.hasNext()) {
+
+ PcInitiatedLspRequest listReq = listIterator.next();
+
+ //Srp Object is mandatory
+ PcepSrpObject srpObj = listReq.getSrpObject();
+ if (srpObj instanceof PcepSrpObject) {
+ isDelLspRequest = srpObj.getRFlag();
+ srpObj.write(cb);
+ } else {
+ throw new PcepParseException("SRP Object is mandatory for PcInitiate message.");
+ }
+
+ //LSP Object is mandatory
+ PcepLspObject lspObj = listReq.getLspObject();
+ if (lspObj instanceof PcepLspObject) {
+ lspObj.write(cb);
+ } else {
+ throw new PcepParseException("LSP Object is mandatory for PcInitiate message.");
+ }
+
+ /* if R bit will be set then pcInitiate msg will contain only LSp and SRP objects
+ * so if R bit is not set then we should read for Ero and EndPoint objects also.
+ */
+
+ if (!isDelLspRequest) {
+
+ //EndPoints object is mandatory
+ PcepEndPointsObject endPointObj = listReq.getEndPointsObject();
+ if (endPointObj instanceof PcepEndPointsObject) {
+ endPointObj.write(cb);
+ } else {
+ throw new PcepParseException("End points Object is mandatory for PcInitiate message.");
+ }
+
+ //Ero object is mandatory
+ PcepEroObject eroObj = listReq.getEroObject();
+ if (eroObj instanceof PcepEroObject) {
+ eroObj.write(cb);
+ } else {
+ throw new PcepParseException("ERO Object is mandatory for PcInitiate message.");
+ }
+
+ //PcepAttribute is optional
+ PcepAttribute pcepAttribute = listReq.getPcepAttribute();
+ if (pcepAttribute instanceof PcepAttribute) {
+ pcepAttribute.write(cb);
+ }
+ }
+ }
+
+ // PCInitiate message length field
+ int length = cb.writerIndex() - startIndex;
+ cb.setShort(msgLenIndex, (short) length);
+ }
+ }
+
+ @Override
+ public PcepVersion getVersion() {
+ return PcepVersion.PCEP_1;
+ }
+
+ @Override
+ public PcepType getType() {
+ return MSG_TYPE;
+ }
+
+ @Override
+ public LinkedList<PcInitiatedLspRequest> getPcInitiatedLspRequestList() {
+ return this.llPcInitiatedLspRequestList;
+ }
+
+ @Override
+ public void setPcInitiatedLspRequestList(LinkedList<PcInitiatedLspRequest> ll) {
+ this.llPcInitiatedLspRequestList = ll;
+ }
+
+ @Override
+ public void print() {
+
+ log.debug("PCEP INITIATE MESSAGE");
+ ListIterator<PcInitiatedLspRequest> listIterator = llPcInitiatedLspRequestList.listIterator();
+ while (listIterator.hasNext()) {
+ listIterator.next().print();
+ }
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("PC initiaited lsp request list", llPcInitiatedLspRequestList)
+ .toString();
+ }
+}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepIroObjectVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepIroObjectVer1.java
new file mode 100644
index 0000000..cd9f906
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepIroObjectVer1.java
@@ -0,0 +1,306 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import java.util.LinkedList;
+import java.util.ListIterator;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepIroObject;
+import org.onosproject.pcepio.types.IPv4SubObject;
+import org.onosproject.pcepio.types.PcepObjectHeader;
+import org.onosproject.pcepio.types.PcepValueType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/*
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | |
+ // (Sub-objects) //
+ | |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ The IRO Object format
+
+ Each IPV4 suboject
+
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |L| Type | Length | IPv4 address (4 bytes) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | IPv4 address (continued) | Prefix Length | Resvd |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+public class PcepIroObjectVer1 implements PcepIroObject {
+
+ protected static final Logger log = LoggerFactory.getLogger(PcepIroObjectVer1.class);
+
+ public static final byte IRO_OBJ_TYPE = 1;
+ public static final byte IRO_OBJ_CLASS = 10;
+ public static final byte IRO_OBJECT_VERSION = 1;
+ public static final short IRO_OBJ_MINIMUM_LENGTH = 12;
+ public static final int OBJECT_HEADER_LENGTH = 4;
+ public static final int YTYPE_SHIFT_VALUE = 0x7F;
+
+ public static final PcepObjectHeader DEFAULT_IRO_OBJECT_HEADER = new PcepObjectHeader(IRO_OBJ_CLASS, IRO_OBJ_TYPE,
+ PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, IRO_OBJ_MINIMUM_LENGTH);
+
+ private short iroObjType = 0;
+ private byte yLength;
+ private byte yPrefixLength;
+ private byte yResvd;
+ private PcepObjectHeader iroObjHeader;
+ private LinkedList<PcepValueType> llSubObjects = new LinkedList<PcepValueType>();
+
+ /**
+ * Default constructor.
+ */
+ public PcepIroObjectVer1() {
+ this.iroObjHeader = null;
+ this.iroObjType = 0;
+ this.yLength = 0;
+ }
+
+ /**
+ * Constructor to initialize member variables.
+ *
+ * @param iroObjHeader IRO object header
+ * @param llSubObjects list of sub-objects
+ */
+ public PcepIroObjectVer1(PcepObjectHeader iroObjHeader, LinkedList<PcepValueType> llSubObjects) {
+ this.iroObjHeader = iroObjHeader;
+ this.llSubObjects = llSubObjects;
+ }
+
+ /**
+ * Returns object header.
+ *
+ * @return iroObjHeader IRO object header
+ */
+ public PcepObjectHeader getIroObjHeader() {
+ return this.iroObjHeader;
+ }
+
+ /**
+ * Sets IRO Object Header.
+ *
+ * @param obj IRO object header
+ */
+ public void setIroObjHeader(PcepObjectHeader obj) {
+ this.iroObjHeader = obj;
+ }
+
+ @Override
+ public LinkedList<PcepValueType> getSubObjects() {
+ return this.llSubObjects;
+ }
+
+ @Override
+ public void setSubObjects(LinkedList<PcepValueType> llSubObjects) {
+ this.llSubObjects = llSubObjects;
+ }
+
+ /**
+ * Reads from channel buffer and return object of PcepIroObject.
+ *
+ * @param cb of type channel buffer
+ * @return object of PcepIroObject
+ * @throws PcepParseException while parsing from channel buffer
+ */
+ public static PcepIroObject read(ChannelBuffer cb) throws PcepParseException {
+
+ PcepObjectHeader iroObjHeader;
+ LinkedList<PcepValueType> llSubObjects;
+
+ iroObjHeader = PcepObjectHeader.read(cb);
+
+ //take only IroObject buffer.
+ ChannelBuffer tempCb = cb.readBytes(iroObjHeader.getObjLen() - OBJECT_HEADER_LENGTH);
+ llSubObjects = parseSubObjects(tempCb);
+ return new PcepIroObjectVer1(iroObjHeader, llSubObjects);
+ }
+
+ /**
+ * Returns linked list of sub objects.
+ *
+ * @param cb of type channel buffer
+ * @return linked list of sub objects
+ * @throws PcepParseException while parsing subobjects from channel buffer
+ */
+ protected static LinkedList<PcepValueType> parseSubObjects(ChannelBuffer cb) throws PcepParseException {
+
+ LinkedList<PcepValueType> llSubObjects = new LinkedList<PcepValueType>();
+
+ while (0 < cb.readableBytes()) {
+
+ //check the Type of the Subobjects.
+ byte yType = cb.readByte();
+ yType = (byte) (yType & (YTYPE_SHIFT_VALUE));
+ byte hLength = cb.readByte();
+
+ PcepValueType subObj;
+ switch (yType) {
+
+ case IPv4SubObject.TYPE:
+ subObj = IPv4SubObject.read(cb);
+ break;
+
+ default:
+ throw new PcepParseException("Invalid sub object. Type: " + (int) yType);
+ }
+
+ // Check for the padding
+ int pad = hLength % 4;
+ if (0 < pad) {
+ pad = 4 - pad;
+ if (pad <= cb.readableBytes()) {
+ cb.skipBytes(pad);
+ }
+ }
+ llSubObjects.add(subObj);
+ }
+ return llSubObjects;
+ }
+
+ @Override
+ public int write(ChannelBuffer cb) throws PcepParseException {
+ //write Object header
+ int objStartIndex = cb.writerIndex();
+
+ int objLenIndex = iroObjHeader.write(cb);
+
+ if (objLenIndex <= 0) {
+ throw new PcepParseException(" ObjectLength is " + objLenIndex);
+ }
+
+ ListIterator<PcepValueType> listIterator = llSubObjects.listIterator();
+ while (listIterator.hasNext()) {
+ listIterator.next().write(cb);
+ }
+
+ //Update object length now
+ int length = cb.writerIndex() - objStartIndex;
+ //will be helpful during print().
+ iroObjHeader.setObjLen((short) length);
+ // As per RFC the length of object should be
+ // multiples of 4
+ int pad = length % 4;
+ if (pad != 0) {
+ pad = 4 - pad;
+ for (int i = 0; i < pad; i++) {
+ cb.writeByte((byte) 0);
+ }
+ length = length + pad;
+ }
+ cb.setShort(objLenIndex, (short) length);
+ objLenIndex = cb.writerIndex();
+ return objLenIndex;
+ }
+
+ public static class Builder implements PcepIroObject.Builder {
+
+ private boolean bIsHeaderSet = false;
+
+ private PcepObjectHeader iroObjHeader;
+ LinkedList<PcepValueType> llSubObjects = new LinkedList<PcepValueType>();
+
+ private boolean bIsPFlagSet = false;
+ private boolean bPFlag;
+
+ private boolean bIsIFlagSet = false;
+ private boolean bIFlag;
+
+ @Override
+ public PcepIroObject build() {
+
+ PcepObjectHeader iroObjHeader = this.bIsHeaderSet ? this.iroObjHeader : DEFAULT_IRO_OBJECT_HEADER;
+
+ if (bIsPFlagSet) {
+ iroObjHeader.setPFlag(bPFlag);
+ }
+
+ if (bIsIFlagSet) {
+ iroObjHeader.setIFlag(bIFlag);
+ }
+
+ return new PcepIroObjectVer1(iroObjHeader, this.llSubObjects);
+ }
+
+ @Override
+ public PcepObjectHeader getIroObjHeader() {
+ return this.iroObjHeader;
+ }
+
+ @Override
+ public Builder setIroObjHeader(PcepObjectHeader obj) {
+ this.iroObjHeader = obj;
+ this.bIsHeaderSet = true;
+ return this;
+ }
+
+ @Override
+ public LinkedList<PcepValueType> getSubObjects() {
+ return this.llSubObjects;
+ }
+
+ @Override
+ public Builder setSubObjects(LinkedList<PcepValueType> llSubObjects) {
+ this.llSubObjects = llSubObjects;
+ return this;
+ }
+
+ @Override
+ public Builder setPFlag(boolean value) {
+ this.bPFlag = value;
+ this.bIsPFlagSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setIFlag(boolean value) {
+ this.bIFlag = value;
+ this.bIsIFlagSet = true;
+ return this;
+ }
+
+ }
+
+ @Override
+ public void print() {
+ log.debug("IRO OBJECT");
+ iroObjHeader.print();
+ log.debug("SUBOBJECTS:");
+ ListIterator<PcepValueType> listIterator = llSubObjects.listIterator();
+ while (listIterator.hasNext()) {
+ listIterator.next().print();
+ }
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("IRO object header", iroObjHeader)
+ .add("List of sub object", llSubObjects)
+ .toString();
+ }
+}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepKeepaliveMsgVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepKeepaliveMsgVer1.java
new file mode 100644
index 0000000..f0ff5cf
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepKeepaliveMsgVer1.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepKeepaliveMsg;
+import org.onosproject.pcepio.protocol.PcepMessageReader;
+import org.onosproject.pcepio.protocol.PcepMessageWriter;
+import org.onosproject.pcepio.protocol.PcepType;
+import org.onosproject.pcepio.protocol.PcepVersion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+class PcepKeepaliveMsgVer1 implements PcepKeepaliveMsg {
+
+ /*
+ <Keepalive Message>::= <Common Header>
+
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Ver | Flags | Message-Type | Message-Length |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+
+ protected static final Logger log = LoggerFactory.getLogger(PcepKeepaliveMsgVer1.class);
+ // Pcep version: 1
+ public static final byte PACKET_VERSION = 1;
+ public static final int PACKET_MINIMUM_LENGTH = 4;
+ public static final PcepType MSG_TYPE = PcepType.KEEP_ALIVE;
+
+ public static final PcepKeepaliveMsgVer1.Reader READER = new Reader();
+
+ static class Reader implements PcepMessageReader<PcepKeepaliveMsg> {
+
+ @Override
+ public PcepKeepaliveMsg readFrom(ChannelBuffer cb) throws PcepParseException {
+
+ if (cb.readableBytes() < PACKET_MINIMUM_LENGTH) {
+ throw new PcepParseException("Packet size is less than the minimum required length.");
+ }
+ // fixed value property version == 1
+ byte version = cb.readByte();
+ version = (byte) (version >> PcepMessageVer1.SHIFT_FLAG);
+ if (version != PACKET_VERSION) {
+ throw new PcepParseException("Wrong version: Expected=PcepVersion.KEEP_ALIVE_1(2), got=" + version);
+ }
+ // fixed value property type == 2
+ byte type = cb.readByte();
+ if (type != MSG_TYPE.getType()) {
+ throw new PcepParseException("Wrong type: Expected=PcepType.KEEP_ALIVE_1(2), got=" + type);
+ }
+ short length = cb.readShort();
+ if (length < PACKET_MINIMUM_LENGTH) {
+ throw new PcepParseException("Wrong length: Expected to be >= " + PACKET_MINIMUM_LENGTH + ", was: "
+ + length);
+ }
+ return new PcepKeepaliveMsgVer1();
+ }
+ }
+
+ /**
+ * Default constructor.
+ */
+ PcepKeepaliveMsgVer1() {
+ }
+
+ static class Builder implements PcepKeepaliveMsg.Builder {
+ @Override
+ public PcepVersion getVersion() {
+ return PcepVersion.PCEP_1;
+ }
+
+ @Override
+ public PcepType getType() {
+ return PcepType.KEEP_ALIVE;
+ }
+
+ @Override
+ public PcepKeepaliveMsg build() {
+ return new PcepKeepaliveMsgVer1();
+ }
+ }
+
+ @Override
+ public void writeTo(ChannelBuffer cb) {
+ WRITER.write(cb, this);
+ }
+
+ static final Writer WRITER = new Writer();
+
+ static class Writer implements PcepMessageWriter<PcepKeepaliveMsgVer1> {
+
+ @Override
+ public void write(ChannelBuffer cb, PcepKeepaliveMsgVer1 message) {
+ int startIndex = cb.writerIndex();
+ // first 3 bits set to version
+ cb.writeByte((byte) (PACKET_VERSION << PcepMessageVer1.SHIFT_FLAG));
+ // message type
+ cb.writeByte(MSG_TYPE.getType());
+ // length is length of variable message, will be updated at the end
+ // Store the position of message
+ // length in buffer
+ int msgLenIndex = cb.writerIndex();
+ cb.writeShort((short) 0);
+ // update message length field
+ int length = cb.writerIndex() - startIndex;
+ cb.setShort(msgLenIndex, (short) length);
+ }
+ }
+
+ @Override
+ public PcepVersion getVersion() {
+ return PcepVersion.PCEP_1;
+ }
+
+ @Override
+ public PcepType getType() {
+ return MSG_TYPE;
+ }
+
+ @Override
+ public void print() {
+ log.debug("KEEPALIVE MESSAGE");
+ }
+}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLspObjectVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLspObjectVer1.java
new file mode 100644
index 0000000..137e81a
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLspObjectVer1.java
@@ -0,0 +1,593 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import java.util.LinkedList;
+import java.util.ListIterator;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepLspObject;
+import org.onosproject.pcepio.types.PcepErrorDetailInfo;
+import org.onosproject.pcepio.types.PcepObjectHeader;
+import org.onosproject.pcepio.types.PcepValueType;
+import org.onosproject.pcepio.types.StatefulIPv4LspIdentidiersTlv;
+import org.onosproject.pcepio.types.StatefulLspErrorCodeTlv;
+import org.onosproject.pcepio.types.StatefulRsvpErrorSpecTlv;
+import org.onosproject.pcepio.types.SymbolicPathNameTlv;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/*
+ message format.
+ Reference : draft-ietf-pce-stateful-pce-11, section 7.3.
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Object-Class | OT |Res|P|I| Object Length (bytes) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | PLSP-ID | Flag | O|A|R|S|D|
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ // TLVs //
+ | |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ The LSP Object format
+ */
+
+public class PcepLspObjectVer1 implements PcepLspObject {
+
+ protected static final Logger log = LoggerFactory.getLogger(PcepLspObjectVer1.class);
+
+ public static final byte LSP_OBJ_TYPE = 1;
+ public static final byte LSP_OBJ_CLASS = 32;
+ public static final byte LSP_OBJECT_VERSION = 1;
+
+ // LSP_OBJ_MINIMUM_LENGTH = CommonHeaderLen(4)+ LspObjectHeaderLen(4)+TlvAssumedMinLength(8)
+ public static final short LSP_OBJ_MINIMUM_LENGTH = 16;
+
+ public static final int DEFAULT_PLSPID = 0;
+ public static final byte DEFAULT_OFLAG = 1;
+ public static final boolean DEFAULT_AFLAG = false;
+ public static final boolean DEFAULT_RFLAG = false;
+ public static final boolean DEFAULT_SFLAG = false;
+ public static final boolean DEFAULT_DFLAG = false;
+ public static final int OBJECT_HEADER_LENGTH = 4;
+ public static final int PLSPID_SHIFT_VALUE = 12;
+ public static final int OFLAG_SHIFT_VALUE = 4;
+ public static final int AFLAG_SHIFT_VALUE = 3;
+ public static final int RFLAG_SHIFT_VALUE = 2;
+ public static final int SFLAG_SHIFT_VALUE = 1;
+ public static final int PLSPID_TEMP_SHIFT_VALUE = 0xFFFFF000;
+ public static final int OFLAG_TEMP_SHIFT_VALUE = 0x70;
+ public static final int AFLAG_TEMP_SHIFT_VALUE = 0x08;
+ public static final int RFLAG_TEMP_SHIFT_VALUE = 0x04;
+ public static final int SFLAG_TEMP_SHIFT_VALUE = 0x02;
+ public static final int DFLAG_TEMP_SHIFT_VALUE = 0x01;
+ public static final int BIT_SET = 1;
+ public static final int BIT_RESET = 0;
+ public static final int MINIMUM_COMMON_HEADER_LENGTH = 4;
+
+ static final PcepObjectHeader DEFAULT_LSP_OBJECT_HEADER = new PcepObjectHeader(LSP_OBJ_CLASS, LSP_OBJ_TYPE,
+ PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, LSP_OBJ_MINIMUM_LENGTH);
+
+ private PcepObjectHeader lspObjHeader;
+ private int iPlspId;
+ // 3-bits
+ private byte yOFlag;
+ private boolean bAFlag;
+ private boolean bRFlag;
+ private boolean bSFlag;
+ private boolean bDFlag;
+
+ // Optional TLV
+ private LinkedList<PcepValueType> llOptionalTlv;
+
+ /**
+ * Constructor to initialize all the member variables.
+ *
+ * @param lspObjHeader lsp object header
+ * @param iPlspId plsp id
+ * @param yOFlag O flag
+ * @param bAFlag A flag
+ * @param bRFlag R flag
+ * @param bSFlag S flag
+ * @param bDFlag D flag
+ * @param llOptionalTlv list of optional tlv
+ */
+ public PcepLspObjectVer1(PcepObjectHeader lspObjHeader, int iPlspId, byte yOFlag, boolean bAFlag, boolean bRFlag,
+ boolean bSFlag, boolean bDFlag, LinkedList<PcepValueType> llOptionalTlv) {
+
+ this.lspObjHeader = lspObjHeader;
+ this.iPlspId = iPlspId;
+ this.yOFlag = yOFlag;
+ this.bAFlag = bAFlag;
+ this.bRFlag = bRFlag;
+ this.bSFlag = bSFlag;
+ this.bDFlag = bDFlag;
+ this.llOptionalTlv = llOptionalTlv;
+ }
+
+ /**
+ * Sets lsp Object Header.
+ *
+ * @param obj lsp object header
+ */
+ public void setLspObjHeader(PcepObjectHeader obj) {
+ this.lspObjHeader = obj;
+ }
+
+ @Override
+ public void setPlspId(int iPlspId) {
+ this.iPlspId = iPlspId;
+ }
+
+ @Override
+ public void setOFlag(byte yOFlag) {
+ this.yOFlag = yOFlag;
+ }
+
+ @Override
+ public void setAFlag(boolean bAFlag) {
+ this.bAFlag = bAFlag;
+ }
+
+ @Override
+ public void setRFlag(boolean bRFlag) {
+ this.bRFlag = bRFlag;
+ }
+
+ @Override
+ public void setSFlag(boolean bSFlag) {
+ this.bSFlag = bSFlag;
+ }
+
+ @Override
+ public void setDFlag(boolean bDFlag) {
+ this.bDFlag = bDFlag;
+ }
+
+ /**
+ * Returns lsp object header.
+ *
+ * @return lspObjHeader
+ */
+ public PcepObjectHeader getLspObjHeader() {
+ return this.lspObjHeader;
+ }
+
+ @Override
+ public int getPlspId() {
+ return this.iPlspId;
+ }
+
+ @Override
+ public byte getOFlag() {
+ return this.yOFlag;
+ }
+
+ @Override
+ public boolean getAFlag() {
+ return this.bAFlag;
+ }
+
+ @Override
+ public boolean getRFlag() {
+ return this.bRFlag;
+ }
+
+ @Override
+ public boolean getSFlag() {
+ return this.bSFlag;
+ }
+
+ @Override
+ public boolean getDFlag() {
+ return this.bDFlag;
+ }
+
+ @Override
+ public LinkedList<PcepValueType> getOptionalTlv() {
+ return this.llOptionalTlv;
+ }
+
+ @Override
+ public void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) {
+ this.llOptionalTlv = llOptionalTlv;
+ }
+
+ /**
+ * Parse channel buffer and returns object of PcepLspObject.
+ *
+ * @param cb of type channel buffer
+ * @return object of PcepLspObject
+ * @throws PcepParseException when lsp object is not present in channel buffer
+ */
+ public static PcepLspObject read(ChannelBuffer cb) throws PcepParseException {
+
+ PcepObjectHeader lspObjHeader;
+ int iPlspId;
+ // 3-bits
+ byte yOFlag;
+ boolean bAFlag;
+ boolean bRFlag;
+ boolean bSFlag;
+ boolean bDFlag;
+
+ // Optional TLV
+ LinkedList<PcepValueType> llOptionalTlv = new LinkedList<PcepValueType>();
+
+ lspObjHeader = PcepObjectHeader.read(cb);
+
+ if (lspObjHeader.getObjClass() != PcepLspObjectVer1.LSP_OBJ_CLASS) {
+ throw new PcepParseException(PcepErrorDetailInfo.ERROR_TYPE_6, PcepErrorDetailInfo.ERROR_VALUE_8);
+ }
+ //take only LspObject buffer.
+ ChannelBuffer tempCb = cb.readBytes(lspObjHeader.getObjLen() - OBJECT_HEADER_LENGTH);
+
+ Integer iTemp = tempCb.readInt();
+ iPlspId = (iTemp & PLSPID_TEMP_SHIFT_VALUE) >> PLSPID_SHIFT_VALUE;
+ Integer iX = (iTemp & OFLAG_TEMP_SHIFT_VALUE) >> OFLAG_SHIFT_VALUE;
+ yOFlag = iX.byteValue();
+ iX = (iTemp & AFLAG_TEMP_SHIFT_VALUE) >> AFLAG_SHIFT_VALUE;
+ bAFlag = (iX > 0) ? true : false;
+ iX = (iTemp & RFLAG_TEMP_SHIFT_VALUE) >> RFLAG_SHIFT_VALUE;
+ bRFlag = (iX > 0) ? true : false;
+ iX = (iTemp & SFLAG_TEMP_SHIFT_VALUE) >> SFLAG_SHIFT_VALUE;
+ bSFlag = (iX > 0) ? true : false;
+ iX = iTemp & DFLAG_TEMP_SHIFT_VALUE;
+ bDFlag = (iX > 0) ? true : false;
+
+ // parse optional TLV
+ llOptionalTlv = parseOptionalTlv(tempCb);
+
+ return new PcepLspObjectVer1(lspObjHeader, iPlspId, yOFlag, bAFlag, bRFlag, bSFlag, bDFlag, llOptionalTlv);
+ }
+
+ @Override
+ public int write(ChannelBuffer cb) throws PcepParseException {
+
+ //write Object header
+ int objStartIndex = cb.writerIndex();
+
+ int objLenIndex = lspObjHeader.write(cb);
+
+ if (objLenIndex <= 0) {
+ throw new PcepParseException("Failed to write lsp object header. Index " + objLenIndex);
+ }
+
+ int iTemp = iPlspId << PLSPID_SHIFT_VALUE;
+ iTemp = iTemp | (yOFlag << OFLAG_SHIFT_VALUE);
+ byte bFlag;
+ iTemp = bAFlag ? (iTemp | AFLAG_TEMP_SHIFT_VALUE) : iTemp;
+
+ bFlag = (bRFlag) ? (byte) BIT_SET : BIT_RESET;
+ iTemp = iTemp | (bFlag << RFLAG_SHIFT_VALUE);
+ bFlag = (bSFlag) ? (byte) BIT_SET : BIT_RESET;
+ iTemp = iTemp | (bFlag << SFLAG_SHIFT_VALUE);
+ bFlag = (bDFlag) ? (byte) BIT_SET : BIT_RESET;
+ iTemp = iTemp | bFlag;
+ cb.writeInt(iTemp);
+
+ // Add optional TLV
+ packOptionalTlv(cb);
+
+ //Update object length now
+ int length = cb.writerIndex() - objStartIndex;
+ //will be helpful during print().
+ lspObjHeader.setObjLen((short) length);
+ // As per RFC the length of object should be
+ // multiples of 4
+
+ cb.setShort(objLenIndex, (short) length);
+
+ return length;
+ }
+
+ /**
+ * Returns Linked list of optional tlvs.
+ *
+ * @param cb of channel buffer.
+ * @return list of optional tlvs
+ * @throws PcepParseException when unsupported tlv is received
+ */
+ protected static LinkedList<PcepValueType> parseOptionalTlv(ChannelBuffer cb) throws PcepParseException {
+
+ LinkedList<PcepValueType> llOutOptionalTlv;
+
+ llOutOptionalTlv = new LinkedList<PcepValueType>();
+
+ while (MINIMUM_COMMON_HEADER_LENGTH <= cb.readableBytes()) {
+
+ PcepValueType tlv;
+ short hType = cb.readShort();
+ short hLength = cb.readShort();
+ int iValue = 0;
+
+ switch (hType) {
+
+ case StatefulIPv4LspIdentidiersTlv.TYPE:
+ tlv = StatefulIPv4LspIdentidiersTlv.read(cb);
+ break;
+ case StatefulLspErrorCodeTlv.TYPE:
+ iValue = cb.readInt();
+ tlv = new StatefulLspErrorCodeTlv(iValue);
+ break;
+ case StatefulRsvpErrorSpecTlv.TYPE:
+ tlv = StatefulRsvpErrorSpecTlv.read(cb);
+ break;
+ case SymbolicPathNameTlv.TYPE:
+ tlv = SymbolicPathNameTlv.read(cb, hLength);
+ break;
+ default:
+ throw new PcepParseException("Received unsupported TLV type :" + hType);
+ }
+ // Check for the padding
+ int pad = hLength % 4;
+ if (0 < pad) {
+ pad = 4 - pad;
+ if (pad <= cb.readableBytes()) {
+ cb.skipBytes(pad);
+ }
+ }
+
+ llOutOptionalTlv.add(tlv);
+ }
+
+ if (0 < cb.readableBytes()) {
+
+ throw new PcepParseException("Optional Tlv parsing error. Extra bytes received.");
+ }
+ return llOutOptionalTlv;
+ }
+
+ /**
+ * returns writer index.
+ *
+ * @param cb of type channel buffer
+ * @return length of bytes written to channel buffer
+ */
+ protected int packOptionalTlv(ChannelBuffer cb) {
+
+ ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator();
+ int startIndex = cb.writerIndex();
+
+ while (listIterator.hasNext()) {
+ PcepValueType tlv = listIterator.next();
+
+ if (null == tlv) {
+ log.debug("tlv is null from OptionalTlv list");
+ continue;
+ }
+
+ tlv.write(cb);
+
+ // need to take care of padding
+ int pad = tlv.getLength() % 4;
+
+ if (0 != pad) {
+ pad = 4 - pad;
+ for (int i = 0; i < pad; ++i) {
+ cb.writeByte((byte) 0);
+ }
+ }
+ }
+
+ return cb.writerIndex() - startIndex;
+ }
+
+ /**
+ * Builder class for PCEP lsp Object.
+ */
+ public static class Builder implements PcepLspObject.Builder {
+
+ private boolean bIsHeaderSet = false;
+ private boolean bIsPlspIdSet = false;
+ private boolean bIsOFlagSet = false;
+ private boolean bIsRFlagSet = false;
+ private boolean bIsAFlagSet = false;
+ private boolean bIsDFlagSet = false;
+ private boolean bIsSFlagSet = false;
+
+ private PcepObjectHeader lspObjHeader;
+ private byte yOFlag;
+ private boolean bAFlag;
+ private boolean bDFlag;
+ private boolean bSFlag;
+ private boolean bRFlag;
+ LinkedList<PcepValueType> llOptionalTlv = null;
+
+ private int plspId;
+
+ private boolean bIsPFlagSet = false;
+ private boolean bPFlag;
+
+ private boolean bIsIFlagSet = false;
+ private boolean bIFlag;
+
+ @Override
+ public PcepLspObject build() {
+ PcepObjectHeader lspObjHeader = this.bIsHeaderSet ? this.lspObjHeader : DEFAULT_LSP_OBJECT_HEADER;
+
+ int plspId = this.bIsPlspIdSet ? this.plspId : DEFAULT_PLSPID;
+ byte yOFlag = this.bIsOFlagSet ? this.yOFlag : DEFAULT_OFLAG;
+ boolean bAFlag = this.bIsAFlagSet ? this.bAFlag : DEFAULT_AFLAG;
+ boolean bRFlag = this.bIsRFlagSet ? this.bRFlag : DEFAULT_RFLAG;
+ boolean bSFlag = this.bIsSFlagSet ? this.bSFlag : DEFAULT_SFLAG;
+ boolean bDFlag = this.bIsDFlagSet ? this.bDFlag : DEFAULT_DFLAG;
+
+ if (bIsPFlagSet) {
+ lspObjHeader.setPFlag(bPFlag);
+ }
+
+ if (bIsIFlagSet) {
+ lspObjHeader.setIFlag(bIFlag);
+ }
+
+ return new PcepLspObjectVer1(lspObjHeader, plspId, yOFlag, bAFlag, bRFlag, bSFlag, bDFlag, llOptionalTlv);
+ }
+
+ @Override
+ public PcepObjectHeader getLspObjHeader() {
+ return this.lspObjHeader;
+ }
+
+ @Override
+ public Builder setLspObjHeader(PcepObjectHeader obj) {
+ this.lspObjHeader = obj;
+ this.bIsHeaderSet = true;
+ return this;
+ }
+
+ @Override
+ public int getPlspId() {
+ return this.plspId;
+ }
+
+ @Override
+ public Builder setPlspId(int value) {
+ this.plspId = value;
+ this.bIsPlspIdSet = true;
+ return this;
+ }
+
+ @Override
+ public byte getOFlag() {
+ return this.yOFlag;
+ }
+
+ @Override
+ public Builder setOFlag(byte value) {
+ this.yOFlag = value;
+ this.bIsOFlagSet = true;
+ return this;
+ }
+
+ @Override
+ public boolean getAFlag() {
+ return this.bAFlag;
+ }
+
+ @Override
+ public Builder setAFlag(boolean value) {
+ this.bAFlag = value;
+ this.bIsAFlagSet = true;
+ return this;
+ }
+
+ @Override
+ public boolean getRFlag() {
+ return this.bRFlag;
+ }
+
+ @Override
+ public Builder setRFlag(boolean value) {
+ this.bRFlag = value;
+ this.bIsRFlagSet = true;
+ return this;
+ }
+
+ @Override
+ public boolean getSFlag() {
+ return this.bSFlag;
+ }
+
+ @Override
+ public Builder setSFlag(boolean value) {
+ this.bSFlag = value;
+ this.bIsSFlagSet = true;
+ return this;
+ }
+
+ @Override
+ public boolean getDFlag() {
+ return this.bDFlag;
+ }
+
+ @Override
+ public Builder setDFlag(boolean value) {
+ this.bDFlag = value;
+ this.bIsDFlagSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) {
+ this.llOptionalTlv = llOptionalTlv;
+ return this;
+ }
+
+ @Override
+ public LinkedList<PcepValueType> getOptionalTlv() {
+ return this.llOptionalTlv;
+ }
+
+ @Override
+ public Builder setPFlag(boolean value) {
+ this.bPFlag = value;
+ this.bIsPFlagSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setIFlag(boolean value) {
+ this.bIFlag = value;
+ this.bIsIFlagSet = true;
+ return this;
+ }
+
+ }
+
+ @Override
+ public void print() {
+
+ log.debug("LSP OBJECT");
+ long lTemp = iPlspId & 0xFFFFFFFF;
+ log.debug("PLSP Id: " + lTemp);
+ lTemp = yOFlag & 0xFFFF;
+ log.debug("O Flag: " + lTemp);
+ lTemp = (bAFlag) ? 1 : 0;
+ log.debug("A Flag: " + lTemp);
+ lTemp = (bRFlag) ? 1 : 0;
+ log.debug("R Flag: " + lTemp);
+ lTemp = (bSFlag) ? 1 : 0;
+ log.debug("S Flag: " + lTemp);
+ lTemp = (bDFlag) ? 1 : 0;
+ log.debug("D Flag: " + lTemp);
+
+ log.debug("OPTIONAL TLV:");
+ ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator();
+ while (listIterator.hasNext()) {
+ listIterator.next().print();
+ }
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("Plsp ID value", iPlspId)
+ .add("o flag", yOFlag)
+ .add("A flag", bAFlag)
+ .add("R flag", bRFlag)
+ .add("S flag", bSFlag)
+ .add("D flag", bDFlag)
+ .add("List of optional tlv", llOptionalTlv)
+ .toString();
+ }
+}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLspaObjectVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLspaObjectVer1.java
new file mode 100644
index 0000000..4db1f9e
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepLspaObjectVer1.java
@@ -0,0 +1,552 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import java.util.LinkedList;
+import java.util.ListIterator;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepLspaObject;
+import org.onosproject.pcepio.types.PcepObjectHeader;
+import org.onosproject.pcepio.types.PcepValueType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+public class PcepLspaObjectVer1 implements PcepLspaObject {
+
+ /* LSPA Object Body Format
+
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Exclude-any |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Include-any |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Include-all |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Setup Prio | Holding Prio | Flags |L| Reserved |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | |
+ | Optional TLVs |
+ | |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+
+ protected static final Logger log = LoggerFactory.getLogger(PcepLspaObjectVer1.class);
+
+ public static final byte LSPA_OBJ_TYPE = 1;
+ public static final byte LSPA_OBJ_CLASS = 9;
+ public static final byte LSPA_OBJECT_VERSION = 1;
+ public static final short LSPA_OBJ_MINIMUM_LENGTH = 20;
+ public static final int OBJECT_HEADER_LENGTH = 4;
+
+ static final PcepObjectHeader DEFAULT_LSPA_OBJECT_HEADER = new PcepObjectHeader(LSPA_OBJ_CLASS, LSPA_OBJ_TYPE,
+ PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, LSPA_OBJ_MINIMUM_LENGTH);
+
+ public static final int SETUP_PRIORITY_SHIFT_VALUE = 24;
+ public static final int HOLD_PRIORITY_SHIFT_VALUE = 16;
+ public static final int BFLAG_SHIFT_VALUE = 8;
+ public static final int LFLAG_SET = 1;
+ public static final int LFLAG_RESET = 0;
+ private PcepObjectHeader lspaObjHeader;
+ private int iExcludeAny;
+ private int iIncludeAny;
+ private int iIncludeAll;
+ private byte cSetupPriority;
+ private byte cHoldPriority;
+ private byte flags;
+ private byte reserved;
+ private boolean bLFlag;
+ private LinkedList<PcepValueType> llOptionalTlv; //Optional TLV
+
+ /**
+ * Constructor to initialize member variables.
+ *
+ * @param lspaObjHeader lspa object header
+ * @param bLFlag b l flag
+ * @param iExcludeAny excludeAny value
+ * @param iIncludeAny includeAny value
+ * @param iIncludeAll includeAll value
+ * @param cSetupPriority setup priority value
+ * @param cHoldPriority hold priority value
+ * @param llOptionalTlv list of optional tlv
+ */
+ public PcepLspaObjectVer1(PcepObjectHeader lspaObjHeader, boolean bLFlag, int iExcludeAny, int iIncludeAny,
+ int iIncludeAll, byte cSetupPriority, byte cHoldPriority, LinkedList<PcepValueType> llOptionalTlv) {
+
+ this.lspaObjHeader = lspaObjHeader;
+ this.bLFlag = bLFlag;
+ this.iExcludeAny = iExcludeAny;
+ this.iIncludeAny = iIncludeAny;
+ this.iIncludeAll = iIncludeAll;
+ this.cSetupPriority = cSetupPriority;
+ this.cHoldPriority = cHoldPriority;
+ this.llOptionalTlv = llOptionalTlv;
+ }
+
+ /**
+ * Sets Object Header.
+ *
+ * @param obj lspa object header
+ */
+ public void setLspaObjHeader(PcepObjectHeader obj) {
+ this.lspaObjHeader = obj;
+ }
+
+ @Override
+ public void setExcludeAny(int iExcludeAny) {
+ this.iExcludeAny = iExcludeAny;
+ }
+
+ @Override
+ public void setIncludeAny(int iIncludeAny) {
+ this.iIncludeAny = iIncludeAny;
+ }
+
+ @Override
+ public void setSetupPriority(byte cSetupPriority) {
+ this.cSetupPriority = cSetupPriority;
+ }
+
+ @Override
+ public void setHoldPriority(byte cHoldPriority) {
+ this.cHoldPriority = cHoldPriority;
+ }
+
+ @Override
+ public void setLFlag(boolean bLFlag) {
+ this.bLFlag = bLFlag;
+ }
+
+ /**
+ * Returns lspa Object Header.
+ *
+ * @return lspa Object Header
+ */
+ public PcepObjectHeader getLspaObjHeader() {
+ return this.lspaObjHeader;
+ }
+
+ @Override
+ public int getExcludeAny() {
+ return this.iExcludeAny;
+ }
+
+ @Override
+ public int getIncludeAny() {
+ return this.iIncludeAny;
+ }
+
+ @Override
+ public int getIncludeAll() {
+ return this.iIncludeAll;
+ }
+
+ @Override
+ public byte getSetupPriority() {
+ return this.cSetupPriority;
+ }
+
+ @Override
+ public byte getHoldPriority() {
+ return this.cHoldPriority;
+ }
+
+ @Override
+ public boolean getLFlag() {
+ return this.bLFlag;
+ }
+
+ @Override
+ public void setIncludeAll(int value) {
+ this.iIncludeAll = value;
+
+ }
+
+ @Override
+ public LinkedList<PcepValueType> getOptionalTlv() {
+ return this.llOptionalTlv;
+ }
+
+ @Override
+ public void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) {
+ this.llOptionalTlv = llOptionalTlv;
+
+ }
+
+ /**
+ * Reads channel buffer and returns object of PcepLspaObject.
+ *
+ * @param cb of type channel buffer.
+ * @return object of PcepLspaObject
+ * @throws PcepParseException while parsing lspa object from channel buffer
+ */
+ public static PcepLspaObject read(ChannelBuffer cb) throws PcepParseException {
+
+ log.debug("LspaObject::read");
+ PcepObjectHeader lspaObjHeader;
+ int iExcludeAny;
+ int iIncludeAny;
+ int iIncludeAll;
+ byte cSetupPriority;
+ byte cHoldPriority;
+ boolean bLFlag;
+ byte flags;
+
+ // Optional TLV
+ LinkedList<PcepValueType> llOptionalTlv;
+
+ lspaObjHeader = PcepObjectHeader.read(cb);
+
+ //take only Lspa Object buffer.
+ ChannelBuffer tempCb = cb.readBytes(lspaObjHeader.getObjLen() - OBJECT_HEADER_LENGTH);
+ iExcludeAny = tempCb.readInt();
+ iIncludeAny = tempCb.readInt();
+ iIncludeAll = tempCb.readInt();
+ cSetupPriority = tempCb.readByte();
+ cHoldPriority = tempCb.readByte();
+ flags = tempCb.readByte();
+ tempCb.readByte();
+
+ bLFlag = (flags & (byte) LFLAG_SET) == LFLAG_SET ? true : false;
+
+ llOptionalTlv = parseOptionalTlv(tempCb);
+
+ return new PcepLspaObjectVer1(lspaObjHeader, bLFlag, iExcludeAny, iIncludeAny, iIncludeAll, cSetupPriority,
+ cHoldPriority, llOptionalTlv);
+ }
+
+ @Override
+ public int write(ChannelBuffer cb) throws PcepParseException {
+
+ //write Object header
+ int objStartIndex = cb.writerIndex();
+
+ int objLenIndex = lspaObjHeader.write(cb);
+
+ if (objLenIndex <= 0) {
+ throw new PcepParseException("Failed to write lspa object header. Index " + objLenIndex);
+ }
+
+ cb.writeInt(iExcludeAny);
+ cb.writeInt(iIncludeAny);
+ cb.writeInt(iIncludeAll);
+
+ int iTemp = cSetupPriority << SETUP_PRIORITY_SHIFT_VALUE;
+ iTemp = iTemp | (cHoldPriority << HOLD_PRIORITY_SHIFT_VALUE);
+ byte bFlag;
+ bFlag = (bLFlag) ? (byte) LFLAG_SET : LFLAG_RESET;
+ iTemp = iTemp | (bFlag << BFLAG_SHIFT_VALUE);
+ cb.writeInt(iTemp);
+
+ // Add optional TLV
+ if (!packOptionalTlv(cb)) {
+ throw new PcepParseException("Faild to write lspa objects tlv to channel buffer");
+ }
+
+ short length = (short) (cb.writerIndex() - objStartIndex);
+
+ lspaObjHeader.setObjLen(length); //will be helpful during print().
+
+ //As per RFC the length of object should be multiples of 4
+ short pad = (short) (length % 4);
+
+ if (pad != 0) {
+ pad = (short) (4 - pad);
+ for (int i = 0; i < pad; i++) {
+ cb.writeByte((byte) 0);
+ }
+ length = (short) (length + pad);
+ }
+ cb.setShort(objLenIndex, length);
+ return cb.writerIndex();
+ }
+
+ /**
+ * Parse list of optional tlvs.
+ *
+ * @param cb channel buffer
+ * @return list of optional tlvs.
+ * @throws PcepParseException when fails to parse optional tlv list.
+ */
+ public static LinkedList<PcepValueType> parseOptionalTlv(ChannelBuffer cb) throws PcepParseException {
+
+ LinkedList<PcepValueType> llOutOptionalTlv = new LinkedList<PcepValueType>();
+
+ return llOutOptionalTlv;
+ }
+
+ /**
+ * Writes optional tlvs to channel buffer.
+ *
+ * @param cb channel buffer
+ * @return true
+ */
+ protected boolean packOptionalTlv(ChannelBuffer cb) {
+ int hTlvType;
+ int hTlvLength;
+
+ ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator();
+ while (listIterator.hasNext()) {
+ PcepValueType tlv = listIterator.next();
+ if (null == tlv) {
+ log.debug("Warning: tlv is null from OptionalTlv list");
+ continue;
+ }
+ hTlvType = tlv.getType();
+ hTlvLength = tlv.getLength();
+ if (0 == hTlvLength) {
+ log.debug("Warning: invalid length in tlv of OptionalTlv list");
+ continue;
+ }
+
+ cb.writeShort(hTlvType);
+ cb.writeShort(hTlvLength);
+
+ switch (hTlvType) {
+ //TODO: optional TLV for LSPA to be added
+
+ default:
+ log.debug("Warning: PcepLspaObject: unknown tlv");
+ }
+
+ // As per RFC the length of object should
+ // be multiples of 4
+ int pad = hTlvLength % 4;
+
+ if (0 < pad) {
+ pad = 4 - pad;
+ if (pad <= cb.readableBytes()) {
+ cb.skipBytes(pad);
+ }
+ }
+ }
+ return true;
+ }
+
+ /**
+ * builder class for PCEP lspa object.
+ */
+ public static class Builder implements PcepLspaObject.Builder {
+ private boolean bIsHeaderSet = false;
+
+ private PcepObjectHeader lspaObjHeader;
+
+ private boolean bLFlag;
+ private int iExcludeAny;
+ private boolean bIsExcludeAnySet = false;
+ private int iIncludeAny;
+ private boolean bIsIncludeAnySet = false;
+ private int iIncludeAll;
+ private boolean bIsIncludeAllSet = false;
+ private byte cSetupPriority;
+ private boolean bIsSetupPrioritySet = false;
+ private byte cHoldPriority;
+ private boolean bIsHoldPrioritySet = false;
+ private LinkedList<PcepValueType> llOptionalTlv;
+
+ private boolean bIsPFlagSet = false;
+ private boolean bPFlag;
+
+ private boolean bIsIFlagSet = false;
+ private boolean bIFlag;
+
+ @Override
+ public PcepLspaObject build() throws PcepParseException {
+
+ PcepObjectHeader lspaObjHeader = this.bIsHeaderSet ? this.lspaObjHeader : DEFAULT_LSPA_OBJECT_HEADER;
+
+ if (!this.bIsExcludeAnySet) {
+ throw new PcepParseException("ExcludeAny NOT Set while building PcepLspaObject.");
+ }
+ if (!this.bIsIncludeAnySet) {
+ throw new PcepParseException("IncludeAny NOT Set while building PcepLspaObject.");
+ }
+ if (!this.bIsIncludeAllSet) {
+ throw new PcepParseException("IncludeAll NOT Set while building PcepLspaObject.");
+ }
+ if (!this.bIsSetupPrioritySet) {
+ throw new PcepParseException("Setup Priority NOT Set while building PcepLspaObject.");
+ }
+ if (!this.bIsHoldPrioritySet) {
+ throw new PcepParseException("Hold Priority NOT Set while building PcepLspaObject.");
+ }
+
+ if (bIsPFlagSet) {
+ lspaObjHeader.setPFlag(bPFlag);
+ }
+
+ if (bIsIFlagSet) {
+ lspaObjHeader.setIFlag(bIFlag);
+ }
+
+ return new PcepLspaObjectVer1(lspaObjHeader, bLFlag, iExcludeAny, iIncludeAny, iIncludeAll, cSetupPriority,
+ cHoldPriority, llOptionalTlv);
+ }
+
+ @Override
+ public PcepObjectHeader getLspaObjHeader() {
+ return this.lspaObjHeader;
+ }
+
+ @Override
+ public Builder setLspaObjHeader(PcepObjectHeader obj) {
+ this.lspaObjHeader = obj;
+ this.bIsHeaderSet = true;
+ return this;
+ }
+
+ @Override
+ public boolean getLFlag() {
+ return this.bLFlag;
+ }
+
+ @Override
+ public Builder setLFlag(boolean value) {
+ this.bLFlag = value;
+ return this;
+ }
+
+ @Override
+ public int getExcludeAny() {
+ return this.iExcludeAny;
+ }
+
+ @Override
+ public Builder setExcludeAny(int value) {
+ this.iExcludeAny = value;
+ this.bIsExcludeAnySet = true;
+ return this;
+ }
+
+ @Override
+ public int getIncludeAny() {
+ return this.iIncludeAny;
+ }
+
+ @Override
+ public Builder setIncludeAny(int value) {
+ this.iIncludeAny = value;
+ this.bIsIncludeAnySet = true;
+ return this;
+ }
+
+ @Override
+ public int getIncludeAll() {
+ return this.iIncludeAll;
+ }
+
+ @Override
+ public Builder setIncludeAll(int value) {
+ this.iIncludeAll = value;
+ this.bIsIncludeAllSet = true;
+ return this;
+ }
+
+ @Override
+ public byte getSetupPriority() {
+ return this.cSetupPriority;
+ }
+
+ @Override
+ public Builder setSetupPriority(byte value) {
+ this.cSetupPriority = value;
+ this.bIsSetupPrioritySet = true;
+ return this;
+ }
+
+ @Override
+ public byte getHoldPriority() {
+ return this.cHoldPriority;
+ }
+
+ @Override
+ public Builder setHoldPriority(byte value) {
+ this.cHoldPriority = value;
+ this.bIsHoldPrioritySet = true;
+ return this;
+ }
+
+ @Override
+ public LinkedList<PcepValueType> getOptionalTlv() {
+ return this.llOptionalTlv;
+ }
+
+ @Override
+ public Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) {
+ this.llOptionalTlv = llOptionalTlv;
+
+ return this;
+ }
+
+ @Override
+ public Builder setPFlag(boolean value) {
+ this.bPFlag = value;
+ this.bIsPFlagSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setIFlag(boolean value) {
+ this.bIFlag = value;
+ this.bIsIFlagSet = true;
+ return this;
+ }
+
+ }
+
+ @Override
+ public void print() {
+ log.debug("LSPA OBJECT");
+ long lTemp = flags & 0xFF;
+ lTemp = (bLFlag) ? 1 : 0;
+ log.debug("l Flag: " + lTemp);
+ lTemp = cSetupPriority & 0xFF;
+ log.debug("SetupPriority: " + lTemp);
+ lTemp = cHoldPriority & 0xFF;
+ log.debug("HoldPriority: " + lTemp);
+ lTemp = iIncludeAll & 0xFFFFFFFF;
+ log.debug("IncludeAll: " + lTemp);
+ lTemp = iIncludeAny & 0xFFFFFFFF;
+ log.debug("IncludeAny: " + lTemp);
+ lTemp = iExcludeAny & 0xFFFFFFFF;
+ log.debug("iExcludeAny: " + lTemp);
+
+ log.debug("OPTIONAL TLV:");
+ ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator();
+ while (listIterator.hasNext()) {
+ listIterator.next().print();
+ }
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("L flag", bLFlag)
+ .add("Setup priority", cSetupPriority)
+ .add("hold priority", cHoldPriority)
+ .add("Include all", iIncludeAll)
+ .add("Include any", iIncludeAny)
+ .add("Exclude any", iExcludeAny)
+ .add("List of optional tlv", llOptionalTlv)
+ .toString();
+ }
+}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMessageVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMessageVer1.java
new file mode 100644
index 0000000..8ca322e
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMessageVer1.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepFactories;
+import org.onosproject.pcepio.protocol.PcepMessage;
+import org.onosproject.pcepio.protocol.PcepMessageReader;
+import org.onosproject.pcepio.types.PcepErrorDetailInfo;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public abstract class PcepMessageVer1 {
+
+ protected static final Logger log = LoggerFactory.getLogger(PcepFactories.class);
+
+ // version: 1.0
+ static final byte WIRE_VERSION = 1;
+ static final int MINIMUM_LENGTH = 4;
+ static final int PACKET_VERSION = 1;
+ static final byte OPEN_MSG_TYPE = 0x1;
+ static final byte KEEPALIVE_MSG_TYPE = 0x2;
+ static final byte REPORT_MSG_TYPE = 0xa;
+ static final byte TE_REPORT_MSG_TYPE = 0xe;
+ static final byte UPDATE_MSG_TYPE = 0xb;
+ static final byte INITIATE_MSG_TYPE = 0xc;
+ static final byte CLOSE_MSG_TYPE = 0x7;
+ static final byte ERROR_MSG_TYPE = 0x6;
+ static final byte LABEL_UPDATE_MSG_TYPE = 0xD;
+ public static final int SHIFT_FLAG = 5;
+ static final int MINIMUM_COMMON_HEADER_LENGTH = 4;
+
+ public static final PcepMessageVer1.Reader READER = new Reader();
+
+ static class Reader implements PcepMessageReader<PcepMessage> {
+ @Override
+ public PcepMessage readFrom(ChannelBuffer cb) throws PcepParseException {
+
+ if (cb.readableBytes() < MINIMUM_LENGTH) {
+ throw new PcepParseException("Packet should have minimum length: " + MINIMUM_LENGTH);
+ }
+
+ try {
+ int start = cb.readerIndex();
+ // fixed value property version == 1
+ byte version = cb.readByte();
+ version = (byte) (version >> PcepMessageVer1.SHIFT_FLAG);
+ if (version != (byte) PACKET_VERSION) {
+ throw new PcepParseException("Wrong version. Expected=PcepVersion.Message_1(1), got=" + version);
+ }
+
+ byte type = cb.readByte();
+ short length = cb.readShort();
+ cb.readerIndex(start);
+
+ switch (type) {
+
+ case OPEN_MSG_TYPE:
+ log.debug("OPEN MESSAGE is received");
+ // message type value 1 means it is open message
+ // return
+ // TODO: Read open message from channel buffer.
+ case KEEPALIVE_MSG_TYPE:
+ log.debug("KEEPALIVE MESSAGE is received");
+ // message type value 2 means it is Keepalive message
+ return PcepKeepaliveMsgVer1.READER.readFrom(cb.readBytes(length));
+ case ERROR_MSG_TYPE:
+ log.debug("ERROR MESSAGE is received");
+ // message type value 6 means it is error message
+ // return
+ // TODO: Read Error message from channel buffer.
+ case REPORT_MSG_TYPE:
+ log.debug("REPORT MESSAGE is received");
+ // message type value 10 means it is Report message
+ // return
+ // TODO: Read Report message from channel buffer.
+ case UPDATE_MSG_TYPE:
+ log.debug("UPDATE MESSAGE is received");
+ //message type value 11 means it is Update message
+ return PcepUpdateMsgVer1.READER.readFrom(cb.readBytes(length));
+ case INITIATE_MSG_TYPE:
+ log.debug("INITIATE MESSAGE is received");
+ //message type value 12 means it is PcInitiate message
+ return PcepInitiateMsgVer1.READER.readFrom(cb.readBytes(length));
+ case CLOSE_MSG_TYPE:
+ log.debug("CLOSE MESSAGE is received");
+ // message type value 7 means it is Close message
+ return PcepCloseMsgVer1.READER.readFrom(cb.readBytes(length));
+ case TE_REPORT_MSG_TYPE:
+ log.debug("TE REPORT MESSAGE is received");
+ // message type value 14 means it is TE REPORT message
+ // return
+ // TODO: Read TE Report message from channel buffer.
+ case LABEL_UPDATE_MSG_TYPE:
+ log.debug("LABEL UPDATE MESSAGE is received");
+ // message type value 13 means it is LABEL UPDATE message
+ // return
+ // TODO: Read Label update message from channel buffer.
+ default:
+ throw new PcepParseException("ERROR: UNKNOWN MESSAGE is received. Msg Type: " + type);
+ }
+ } catch (IndexOutOfBoundsException e) {
+ throw new PcepParseException(PcepErrorDetailInfo.ERROR_TYPE_1, PcepErrorDetailInfo.ERROR_VALUE_1);
+ }
+ }
+ }
+}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMetricObjectVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMetricObjectVer1.java
new file mode 100644
index 0000000..c6c081a
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMetricObjectVer1.java
@@ -0,0 +1,387 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepMetricObject;
+import org.onosproject.pcepio.types.PcepObjectHeader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/*
+ METRIC Object Body Format.
+
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Reserved | Flags |C|B| T |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | metric-value |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+
+public class PcepMetricObjectVer1 implements PcepMetricObject {
+
+ protected static final Logger log = LoggerFactory.getLogger(PcepMetricObjectVer1.class);
+
+ public static final byte METRIC_OBJ_TYPE = 1;
+ public static final byte METRIC_OBJ_CLASS = 6;
+ public static final byte METRIC_OBJECT_VERSION = 1;
+ public static final short METRIC_OBJ_MINIMUM_LENGTH = 12;
+ public static final int OBJECT_HEADER_LENGTH = 4;
+ public static final int IFLAG_SHIFT_VALUE = 9;
+ public static final int BTYPE_SHIFT_VALUE = 8;
+ public static final int CFLAG_SET = 1;
+ public static final int CFLAG_RESET = 0;
+ public static final int BFLAG_SET = 1;
+ public static final int BFLAG_RESET = 0;
+ public static final byte CFLAG_CHECK = 0x02;
+
+ static final PcepObjectHeader DEFAULT_METRIC_OBJECT_HEADER = new PcepObjectHeader(METRIC_OBJ_CLASS,
+ METRIC_OBJ_TYPE, PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED,
+ METRIC_OBJ_MINIMUM_LENGTH);
+
+ private PcepObjectHeader metricObjHeader;
+ private int iMetricVal;
+ private byte yFlag; // 6-flags
+ private boolean bCFlag;
+ private boolean bBFlag;
+ private byte bType;
+
+ /**
+ * Default constructor.
+ */
+ public PcepMetricObjectVer1() {
+ this.metricObjHeader = null;
+ this.iMetricVal = 0;
+ this.yFlag = 0;
+ this.bCFlag = false;
+ this.bBFlag = false;
+ this.bType = 0;
+
+ }
+
+ /**
+ * Constructor to initialize all member variables.
+ *
+ * @param metricObjHeader metric object header
+ * @param iMetricVal metric value
+ * @param yFlag Y flag
+ * @param bCFlag C flag
+ * @param bBFlag B flag
+ * @param bType Type value
+ */
+ public PcepMetricObjectVer1(PcepObjectHeader metricObjHeader, int iMetricVal, byte yFlag, boolean bCFlag,
+ boolean bBFlag, byte bType) {
+
+ this.metricObjHeader = metricObjHeader;
+ this.iMetricVal = iMetricVal;
+ this.yFlag = yFlag;
+ this.bCFlag = bCFlag;
+ this.bBFlag = bBFlag;
+ this.bType = bType;
+
+ }
+
+ @Override
+ public void setMetricVal(int value) {
+ this.iMetricVal = value;
+
+ }
+
+ @Override
+ public int getMetricVal() {
+ return this.iMetricVal;
+ }
+
+ @Override
+ public byte getYFlag() {
+ return this.yFlag;
+ }
+
+ @Override
+ public void setYFlag(byte value) {
+ this.yFlag = value;
+ }
+
+ @Override
+ public boolean getCFlag() {
+ return this.bCFlag;
+ }
+
+ @Override
+ public void setCFlag(boolean value) {
+ this.bCFlag = value;
+ }
+
+ @Override
+ public boolean getBFlag() {
+ return this.bBFlag;
+ }
+
+ @Override
+ public void setBFlag(boolean value) {
+ this.bBFlag = value;
+ }
+
+ @Override
+ public byte getBType() {
+ return this.bType;
+ }
+
+ @Override
+ public void setBType(byte value) {
+ this.bType = value;
+ }
+
+ /**
+ * Sets metric Object Header.
+ *
+ * @param obj metric object header
+ */
+ public void setMetricObjHeader(PcepObjectHeader obj) {
+ this.metricObjHeader = obj;
+ }
+
+ /**
+ * Returns metric Object Header.
+ *
+ * @return metricObjHeader
+ */
+ public PcepObjectHeader getMetricObjHeader() {
+ return this.metricObjHeader;
+ }
+
+ /**
+ * Reads from channel buffer and returns object of PcepMetricObject.
+ *
+ * @param cb of channel buffer.
+ * @return object of PcepMetricObject
+ * @throws PcepParseException when metric object is not present in channel buffer
+ */
+ public static PcepMetricObject read(ChannelBuffer cb) throws PcepParseException {
+
+ log.debug("MetricObject::read");
+ PcepObjectHeader metricObjHeader;
+ int iMetricVal;
+ byte yFlag; // 6-flags
+ boolean bCFlag;
+ boolean bBFlag;
+ byte bType;
+
+ metricObjHeader = PcepObjectHeader.read(cb);
+
+ if (metricObjHeader.getObjClass() != METRIC_OBJ_CLASS) {
+ throw new PcepParseException("This object is not a Metric Object. Object Class: "
+ + metricObjHeader.getObjClass());
+ }
+
+ //take only metric buffer.
+ ChannelBuffer tempCb = cb.readBytes(metricObjHeader.getObjLen() - OBJECT_HEADER_LENGTH);
+
+ tempCb.readShort();
+ yFlag = tempCb.readByte();
+ bType = tempCb.readByte();
+ bCFlag = (yFlag & CFLAG_CHECK) == CFLAG_CHECK ? true : false;
+ bBFlag = (yFlag & BFLAG_SET) == BFLAG_SET ? true : false;
+ iMetricVal = tempCb.readInt();
+
+ return new PcepMetricObjectVer1(metricObjHeader, iMetricVal, yFlag, bCFlag, bBFlag, bType);
+ }
+
+ @Override
+ public int write(ChannelBuffer cb) throws PcepParseException {
+ //write Object header
+ int objStartIndex = cb.writerIndex();
+
+ int objLenIndex = metricObjHeader.write(cb);
+
+ if (objLenIndex <= 0) {
+ throw new PcepParseException("Error: ObjectLength is " + objLenIndex);
+ }
+
+ int iFlag = (bCFlag) ? CFLAG_SET : CFLAG_RESET;
+ int iTemp = iFlag << IFLAG_SHIFT_VALUE;
+ iFlag = (bBFlag) ? BFLAG_SET : BFLAG_RESET;
+ iTemp = iTemp | (iFlag << BTYPE_SHIFT_VALUE);
+ iTemp = iTemp | bType;
+ cb.writeInt(iTemp);
+ cb.writeInt(iMetricVal);
+
+ short hLength = (short) (cb.writerIndex() - objStartIndex);
+ cb.setShort(objLenIndex, hLength);
+ //will be helpful during print().
+ metricObjHeader.setObjLen(hLength);
+ return hLength;
+ }
+
+ /**
+ * Builder class for PCEP metric object.
+ */
+ public static class Builder implements PcepMetricObject.Builder {
+
+ private boolean bIsHeaderSet = false;
+ private PcepObjectHeader metricObjHeader;
+ private int iMetricVal;
+ private boolean bIsMetricValSet = false;
+ private byte yFlag; // 6-flags
+ private boolean bCFlag;
+ private boolean bBFlag;
+ private byte bType;
+ private boolean bIsbTypeSet = false;
+
+ private boolean bIsPFlagSet = false;
+ private boolean bPFlag;
+
+ private boolean bIsIFlagSet = false;
+ private boolean bIFlag;
+
+ @Override
+ public PcepMetricObject build() throws PcepParseException {
+
+ PcepObjectHeader metricObjHeader = this.bIsHeaderSet ? this.metricObjHeader : DEFAULT_METRIC_OBJECT_HEADER;
+
+ if (!this.bIsMetricValSet) {
+ throw new PcepParseException(" Metric Value NOT Set while building PcepMetricObject.");
+ }
+ if (!this.bIsbTypeSet) {
+ throw new PcepParseException(" Type NOT Set while building PcepMetricObject.");
+ }
+
+ if (bIsPFlagSet) {
+ metricObjHeader.setPFlag(bPFlag);
+ }
+
+ if (bIsIFlagSet) {
+ metricObjHeader.setIFlag(bIFlag);
+ }
+
+ return new PcepMetricObjectVer1(metricObjHeader, iMetricVal, yFlag, bCFlag, bBFlag, bType);
+ }
+
+ @Override
+ public PcepObjectHeader getMetricObjHeader() {
+ return this.metricObjHeader;
+ }
+
+ @Override
+ public Builder setMetricObjHeader(PcepObjectHeader obj) {
+ this.metricObjHeader = obj;
+ this.bIsHeaderSet = true;
+ return this;
+ }
+
+ @Override
+ public int getMetricVal() {
+ return this.iMetricVal;
+ }
+
+ @Override
+ public Builder setMetricVal(int value) {
+ this.iMetricVal = value;
+ this.bIsMetricValSet = true;
+ return this;
+ }
+
+ @Override
+ public byte getYFlag() {
+ return this.yFlag;
+ }
+
+ @Override
+ public Builder setYFlag(byte value) {
+ this.yFlag = value;
+ return this;
+ }
+
+ @Override
+ public boolean getCFlag() {
+ return this.bCFlag;
+ }
+
+ @Override
+ public Builder setCFlag(boolean value) {
+ this.bCFlag = value;
+ return this;
+ }
+
+ @Override
+ public boolean getBFlag() {
+ return this.bBFlag;
+ }
+
+ @Override
+ public Builder setBFlag(boolean value) {
+ this.bBFlag = value;
+ return this;
+ }
+
+ @Override
+ public byte getBType() {
+ return this.bType;
+ }
+
+ @Override
+ public Builder setBType(byte value) {
+ this.bType = value;
+ this.bIsbTypeSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setPFlag(boolean value) {
+ this.bPFlag = value;
+ this.bIsPFlagSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setIFlag(boolean value) {
+ this.bIFlag = value;
+ this.bIsIFlagSet = true;
+ return this;
+ }
+
+ }
+
+ @Override
+ public void print() {
+
+ log.debug("METRIC OBJECT");
+ long lTemp = iMetricVal & 0xFFFFFFFF;
+ log.debug("iMetricVal: " + lTemp);
+ lTemp = (bBFlag) ? 1 : 0;
+ log.debug("B Flag: " + lTemp);
+ lTemp = (bCFlag) ? 1 : 0;
+ log.debug("C Flag: " + lTemp);
+ lTemp = bType & 0xFF;
+ log.debug("Type: " + lTemp);
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("Metric value", iMetricVal)
+ .add("B flag", bBFlag)
+ .add("C flag", bCFlag)
+ .add("B-type", bType)
+ .toString();
+ }
+}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMsgPathVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMsgPathVer1.java
new file mode 100644
index 0000000..5334b5f
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepMsgPathVer1.java
@@ -0,0 +1,180 @@
+package org.onosproject.pcepio.protocol.ver1;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepAttribute;
+import org.onosproject.pcepio.protocol.PcepEroObject;
+import org.onosproject.pcepio.protocol.PcepMsgPath;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * Provides PCEP Message PAth for update message.
+ * Reference :PCE extensions for stateful draft-ietf-pce-stateful-pce-10.
+ */
+public class PcepMsgPathVer1 implements PcepMsgPath {
+
+ /*
+ * <path> ::= <ERO><attribute-list>
+ */
+
+ protected static final Logger log = LoggerFactory.getLogger(PcepMsgPathVer1.class);
+ //PcepEroObject
+ private PcepEroObject eroObj;
+ private boolean isEroObjectSet;
+ // PcepAttribute
+ private PcepAttribute attrList;
+ private boolean isAttributeListSet;
+
+ /**
+ * constructor to initialize objects.
+ */
+ public PcepMsgPathVer1() {
+ eroObj = null;
+ attrList = null;
+ isEroObjectSet = false;
+ isAttributeListSet = false;
+ }
+
+ @Override
+ public PcepEroObject getEroObject() {
+ return eroObj;
+ }
+
+ @Override
+ public PcepAttribute getPcepAttribute() {
+ return attrList;
+ }
+
+ @Override
+ public void setEroObject(PcepEroObject eroObj) {
+ this.eroObj = eroObj;
+ }
+
+ @Override
+ public void setPcepAttribute(PcepAttribute attrList) {
+ this.attrList = attrList;
+ }
+
+ /**
+ * constructor to initialize member variables.
+ *
+ * @param eroObj pcep ero object
+ * @param attrList pcep attribute
+ */
+ public PcepMsgPathVer1(PcepEroObject eroObj, PcepAttribute attrList) {
+ this.eroObj = eroObj;
+ isEroObjectSet = true;
+ this.attrList = attrList;
+ if (attrList == null) {
+ isAttributeListSet = false;
+ } else {
+ isAttributeListSet = true;
+ }
+ }
+
+ @Override
+ public PcepMsgPath read(ChannelBuffer cb) throws PcepParseException {
+ PcepEroObject eroObj;
+ PcepAttribute attrList;
+
+ eroObj = PcepEroObjectVer1.read(cb);
+ attrList = PcepAttributeVer1.read(cb);
+
+ return new PcepMsgPathVer1(eroObj, attrList);
+ }
+
+ @Override
+ public int write(ChannelBuffer cb) throws PcepParseException {
+ int iLenStartIndex = cb.writerIndex();
+
+ //write Object header
+ if (this.isEroObjectSet) {
+ this.eroObj.write(cb);
+ }
+ if (this.isAttributeListSet) {
+ attrList.write(cb);
+ }
+
+ return cb.writerIndex() - iLenStartIndex;
+ }
+
+ /**
+ * builder class for PCEP Message path.
+ */
+ public static class Builder implements PcepMsgPath.Builder {
+
+ private boolean bIsEROObjectSet = false;
+ private boolean bIsPcepAttributeSet = false;
+
+ //PCEP ERO Object
+ private PcepEroObject eroObject;
+ //PCEP Attribute list
+ private PcepAttribute pcepAttribute;
+
+ @Override
+ public PcepMsgPath build() throws PcepParseException {
+
+ //PCEP ERO Object
+ PcepEroObject eroObject = null;
+ //PCEP Attribute list
+ PcepAttribute pcepAttribute = null;
+
+ if (!this.bIsEROObjectSet) {
+ throw new PcepParseException("ERO Object NOT Set while building PcepMsgPath.");
+ } else {
+ eroObject = this.eroObject;
+ }
+ if (!this.bIsPcepAttributeSet) {
+ throw new PcepParseException("Pcep Attributes NOT Set while building PcepMsgPath.");
+ } else {
+ pcepAttribute = this.pcepAttribute;
+ }
+
+ return new PcepMsgPathVer1(eroObject, pcepAttribute);
+ }
+
+ @Override
+ public PcepEroObject getEroObject() {
+ return this.eroObject;
+ }
+
+ @Override
+ public PcepAttribute getPcepAttribute() {
+ return this.pcepAttribute;
+ }
+
+ @Override
+ public Builder setEroObject(PcepEroObject eroObject) {
+ this.eroObject = eroObject;
+ this.bIsEROObjectSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setPcepAttribute(PcepAttribute pcepAttribute) {
+ this.pcepAttribute = pcepAttribute;
+ this.bIsPcepAttributeSet = true;
+ return this;
+ }
+
+ }
+
+ @Override
+ public void print() {
+
+ log.debug("PcepMsgPath");
+ eroObj.print();
+ attrList.print();
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("ERO object", eroObj)
+ .add("Attribute list", attrList)
+ .toString();
+ }
+}
\ No newline at end of file
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepSrpObjectVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepSrpObjectVer1.java
new file mode 100644
index 0000000..58aac18
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepSrpObjectVer1.java
@@ -0,0 +1,403 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import java.util.LinkedList;
+import java.util.ListIterator;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepSrpObject;
+import org.onosproject.pcepio.types.PcepObjectHeader;
+import org.onosproject.pcepio.types.PcepValueType;
+import org.onosproject.pcepio.types.SymbolicPathNameTlv;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+public class PcepSrpObjectVer1 implements PcepSrpObject {
+
+ /*
+ * ref : draft-ietf-pce-stateful-pce-10, section : 7.2
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Object-Class | OT |Res|P|I| Object Length (bytes) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Flags |R|
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | SRP-ID-number |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | |
+ // Optional TLVs //
+ | |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ */
+ protected static final Logger log = LoggerFactory.getLogger(PcepSrpObjectVer1.class);
+
+ public static final byte SRP_OBJ_TYPE = 1;
+ public static final byte SRP_OBJ_CLASS = 33;
+ public static final byte SRP_OBJECT_VERSION = 1;
+ public static final short SRP_OBJ_MINIMUM_LENGTH = 12;
+ public static final int MINIMUM_COMMON_HEADER_LENGTH = 4;
+ public static final boolean DEFAULT_RFLAG = false;
+
+ static final PcepObjectHeader DEFAULT_SRP_OBJECT_HEADER = new PcepObjectHeader(SRP_OBJ_CLASS, SRP_OBJ_TYPE,
+ PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, SRP_OBJ_MINIMUM_LENGTH);
+
+ private PcepObjectHeader srpObjHeader;
+ private static int flags;
+ private boolean bRFlag;
+ private int srpId;
+
+ //Optional TLV
+ private LinkedList<PcepValueType> llOptionalTlv;
+ public static final byte BBIT_SET = 1;
+ public static final byte BBIT_RESET = 0;
+
+ /**
+ * Constructor to initialize member variables.
+ *
+ * @param srpObjHeader srp object header
+ * @param bRFlag R flag
+ * @param srpID srp Id
+ * @param llOptionalTlv list of optional tlv
+ */
+ public PcepSrpObjectVer1(PcepObjectHeader srpObjHeader, boolean bRFlag, int srpID,
+ LinkedList<PcepValueType> llOptionalTlv) {
+
+ this.srpObjHeader = srpObjHeader;
+ this.bRFlag = bRFlag;
+ this.srpId = srpID;
+ this.llOptionalTlv = llOptionalTlv;
+ }
+
+ /**
+ * sets the SRP object header.
+ *
+ * @param obj srp object header
+ */
+ public void setSrpObjHeader(PcepObjectHeader obj) {
+ this.srpObjHeader = obj;
+ }
+
+ @Override
+ public void setSrpID(int srpID) {
+ this.srpId = srpID;
+ }
+
+ @Override
+ public void setRFlag(boolean bRFlag) {
+ this.bRFlag = bRFlag;
+ }
+
+ /**
+ * Returns SRP object header.
+ *
+ * @return srpObjHeader
+ */
+ public PcepObjectHeader getSrpObjHeader() {
+ return this.srpObjHeader;
+ }
+
+ @Override
+ public int getSrpID() {
+ return this.srpId;
+ }
+
+ @Override
+ public boolean getRFlag() {
+ return this.bRFlag;
+ }
+
+ @Override
+ public void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) {
+ this.llOptionalTlv = llOptionalTlv;
+
+ }
+
+ @Override
+ public LinkedList<PcepValueType> getOptionalTlv() {
+ return this.llOptionalTlv;
+ }
+
+ /**
+ * Reads from channel buffer and returns instance of PCEP SRP object.
+ *
+ * @param cb of channel buffer.
+ * @return PCEP SRP object
+ * @throws PcepParseException when srp object is not received in channel buffer
+ */
+ public static PcepSrpObject read(ChannelBuffer cb) throws PcepParseException {
+
+ log.debug("SrpObject::read");
+ PcepObjectHeader srpObjHeader;
+ boolean bRFlag;
+
+ int srpID;
+ int flags;
+ LinkedList<PcepValueType> llOptionalTlv = new LinkedList<PcepValueType>();
+
+ srpObjHeader = PcepObjectHeader.read(cb);
+
+ if (SRP_OBJ_CLASS != srpObjHeader.getObjClass()) {
+ throw new PcepParseException("SRP object expected. But received " + srpObjHeader.getObjClass());
+ }
+
+ //take only SrpObject buffer.
+ ChannelBuffer tempCb = cb.readBytes(srpObjHeader.getObjLen() - MINIMUM_COMMON_HEADER_LENGTH);
+ flags = tempCb.readInt();
+ bRFlag = (0 < flags) ? true : false;
+ srpID = tempCb.readInt();
+
+ llOptionalTlv = parseOptionalTlv(tempCb);
+
+ return new PcepSrpObjectVer1(srpObjHeader, bRFlag, srpID, llOptionalTlv);
+ }
+
+ @Override
+ public int write(ChannelBuffer cb) throws PcepParseException {
+
+ int objStartIndex = cb.writerIndex();
+
+ //write common header
+ int objLenIndex = srpObjHeader.write(cb);
+
+ //write Flags
+ byte bFlag;
+
+ bFlag = (bRFlag) ? BBIT_SET : BBIT_RESET;
+
+ cb.writeInt(bFlag);
+
+ //write SrpId
+ cb.writeInt(srpId);
+
+ // Add optional TLV
+ if (!packOptionalTlv(cb)) {
+ throw new PcepParseException("Failed to write srp tlv to channel buffer.");
+ }
+
+ //now write SRP Object Length
+ cb.setShort(objLenIndex, (short) (cb.writerIndex() - objStartIndex));
+
+ return cb.writerIndex();
+ }
+
+ /**
+ * Parse Optional TLvs from the channel buffer.
+ *
+ * @param cb of type channel buffer
+ * @return list of optional tlvs
+ * @throws PcepParseException when unsupported tlv is received in srp object
+ */
+ public static LinkedList<PcepValueType> parseOptionalTlv(ChannelBuffer cb) throws PcepParseException {
+
+ LinkedList<PcepValueType> llOutOptionalTlv = new LinkedList<PcepValueType>();
+
+ while (MINIMUM_COMMON_HEADER_LENGTH <= cb.readableBytes()) {
+
+ PcepValueType tlv;
+ short hType = cb.readShort();
+ short hLength = cb.readShort();
+
+ switch (hType) {
+
+ case SymbolicPathNameTlv.TYPE:
+ tlv = SymbolicPathNameTlv.read(cb, hLength);
+ cb.skipBytes(hLength);
+ break;
+
+ default:
+ throw new PcepParseException("Unsupported TLV received in SRP Object.");
+ }
+
+ // Check for the padding
+ int pad = hLength % 4;
+ if (0 < pad) {
+ pad = 4 - pad;
+ if (pad <= cb.readableBytes()) {
+ cb.skipBytes(pad);
+ }
+ }
+ llOutOptionalTlv.add(tlv);
+ }
+
+ return llOutOptionalTlv;
+ }
+
+ /**
+ * Writes optional tlvs to channel buffer.
+ *
+ * @param cb of type channel buffer
+ * @return true if writing optional tlv to channel buffer is success.
+ */
+ protected boolean packOptionalTlv(ChannelBuffer cb) {
+
+ ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator();
+
+ while (listIterator.hasNext()) {
+ PcepValueType tlv = listIterator.next();
+
+ if (null == tlv) {
+ log.debug("tlv is null from OptionalTlv list");
+ continue;
+ }
+ tlv.write(cb);
+
+ // need to take care of padding
+ int pad = tlv.getLength() % 4;
+
+ if (0 != pad) {
+ pad = 4 - pad;
+ for (int i = 0; i < pad; ++i) {
+ cb.writeByte((byte) 0);
+ }
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * builder class for PCEP srp Object.
+ */
+ public static class Builder implements PcepSrpObject.Builder {
+ private boolean bIsHeaderSet = false;
+ private boolean bIsSrpIdset = false;
+ private boolean bIsRFlagSet = false;
+
+ private PcepObjectHeader srpObjHeader;
+ private int srpId;
+ private boolean bRFlag;
+ LinkedList<PcepValueType> llOptionalTlv = new LinkedList<PcepValueType>();
+
+ private boolean bIsPFlagSet = false;
+ private boolean bPFlag;
+
+ private boolean bIsIFlagSet = false;
+ private boolean bIFlag;
+
+ @Override
+ public PcepSrpObject build() throws PcepParseException {
+ PcepObjectHeader srpObjHeader = this.bIsHeaderSet ? this.srpObjHeader : DEFAULT_SRP_OBJECT_HEADER;
+
+ boolean bRFlag = this.bIsRFlagSet ? this.bRFlag : DEFAULT_RFLAG;
+
+ if (!this.bIsSrpIdset) {
+ throw new PcepParseException("SrpID not set while building SRP Object.");
+ }
+
+ if (bIsPFlagSet) {
+ srpObjHeader.setPFlag(bPFlag);
+ }
+
+ if (bIsIFlagSet) {
+ srpObjHeader.setIFlag(bIFlag);
+ }
+
+ return new PcepSrpObjectVer1(srpObjHeader, bRFlag, this.srpId, this.llOptionalTlv);
+ }
+
+ @Override
+ public PcepObjectHeader getSrpObjHeader() {
+ return this.srpObjHeader;
+ }
+
+ @Override
+ public Builder setSrpObjHeader(PcepObjectHeader obj) {
+ this.srpObjHeader = obj;
+ this.bIsHeaderSet = true;
+ return this;
+ }
+
+ @Override
+ public int getSrpID() {
+ return this.srpId;
+ }
+
+ @Override
+ public Builder setSrpID(int srpID) {
+ this.srpId = srpID;
+ this.bIsSrpIdset = true;
+ return this;
+ }
+
+ @Override
+ public boolean getRFlag() {
+ return this.bRFlag;
+ }
+
+ @Override
+ public Builder setRFlag(boolean bRFlag) {
+ this.bRFlag = bRFlag;
+ this.bIsRFlagSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) {
+ this.llOptionalTlv = llOptionalTlv;
+ return this;
+ }
+
+ @Override
+ public LinkedList<PcepValueType> getOptionalTlv() {
+ return this.llOptionalTlv;
+ }
+
+ @Override
+ public Builder setPFlag(boolean value) {
+ this.bPFlag = value;
+ this.bIsPFlagSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setIFlag(boolean value) {
+ this.bIFlag = value;
+ this.bIsIFlagSet = true;
+ return this;
+ }
+
+ }
+
+ @Override
+ public void print() {
+
+ log.debug("SRP OBJECT");
+ long lTemp = (bRFlag) ? 1 : 0;
+ log.debug("r Flag: " + lTemp);
+ log.debug("SrpID: " + srpId);
+
+ log.debug("OPTIONAL TLV");
+ ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator();
+ while (listIterator.hasNext()) {
+ listIterator.next().print();
+ }
+ }
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("R flag", bRFlag)
+ .add("SRP ID", srpId)
+ .add("Optional tlv list", llOptionalTlv)
+ .toString();
+ }
+}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepUpdateMsgVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepUpdateMsgVer1.java
new file mode 100644
index 0000000..3a4e2bd
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepUpdateMsgVer1.java
@@ -0,0 +1,308 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import java.util.LinkedList;
+import java.util.ListIterator;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepLspObject;
+import org.onosproject.pcepio.protocol.PcepMessageReader;
+import org.onosproject.pcepio.protocol.PcepMessageWriter;
+import org.onosproject.pcepio.protocol.PcepMsgPath;
+import org.onosproject.pcepio.protocol.PcepSrpObject;
+import org.onosproject.pcepio.protocol.PcepType;
+import org.onosproject.pcepio.protocol.PcepUpdateMsg;
+import org.onosproject.pcepio.protocol.PcepUpdateRequest;
+import org.onosproject.pcepio.protocol.PcepVersion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * PCEP Update Message: A Path Computation LSP Update Request message
+ * (also referred to as PCUpd message) is a PCEP message sent by a PCE
+ * to a PCC to update attributes of an LSP.
+ */
+
+class PcepUpdateMsgVer1 implements PcepUpdateMsg {
+
+ // Pcep version: 1
+
+ /* The format of the PCUpd message is as follows:
+ * <PCUpd Message> ::= <Common Header>
+ * <update-request-list>
+ * Where:
+ * <update-request-list> ::= <update-request>[<update-request-list>]
+ * <update-request> ::= <SRP>
+ * <LSP>
+ * <path>
+ * Where:
+ * <path> ::= <ERO><attribute-list>
+ * Where:
+ * <attribute-list> is defined in [RFC5440] and extended by PCEP extensions.
+ * where:
+ * <attribute-list> ::=[<LSPA>]
+ * [<BANDWIDTH>]
+ * [<metric-list>]
+ * [<IRO>]
+ * <metric-list> ::=<METRIC>[<metric-list>]
+ *
+ * 0 1 2 3
+ * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * | Ver | Flags | Message-Type | Message-Length |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * | |
+ * // UPDATE REQUEST LIST //
+ * | |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ * Reference:Internet-Draft-PCEP Extensions-for-Stateful-PCE-10
+ */
+
+ protected static final Logger log = LoggerFactory.getLogger(PcepUpdateMsgVer1.class);
+
+ public static final byte PACKET_VERSION = 1;
+ // UpdateMsgMinLength = SrpObjMinLentgh(12)+LspObjMinLength(8)+EroObjMinLength(12)+ CommonHeaderLength(4)
+ public static final short PACKET_MINIMUM_LENGTH = 36;
+ public static final PcepType MSG_TYPE = PcepType.UPDATE;
+ //Update Request List
+ private LinkedList<PcepUpdateRequest> llUpdateRequestList;
+
+ public static final PcepUpdateMsgVer1.Reader READER = new Reader();
+
+ //Reader reads UpdateMessage from the channel.
+ static class Reader implements PcepMessageReader<PcepUpdateMsg> {
+
+ LinkedList<PcepUpdateRequest> llUpdateRequestList;
+
+ @Override
+ public PcepUpdateMsg readFrom(ChannelBuffer cb) throws PcepParseException {
+
+ if (cb.readableBytes() < PACKET_MINIMUM_LENGTH) {
+ throw new PcepParseException("Readable bytes is less than update message minimum length");
+ }
+
+ llUpdateRequestList = new LinkedList<PcepUpdateRequest>();
+
+ // fixed value property version == 1
+ byte version = cb.readByte();
+ version = (byte) (version >> PcepMessageVer1.SHIFT_FLAG);
+ if (version != PACKET_VERSION) {
+ throw new PcepParseException("Wrong version. Expected=PcepVersion.PCEP_1(1), got=" + version);
+ }
+ // fixed value property type == 11
+ byte type = cb.readByte();
+ if (type != MSG_TYPE.getType()) {
+ throw new PcepParseException("Wrong type. Expected=PcepType.UPDATE(11), got=" + type);
+ }
+ short length = cb.readShort();
+ if (length < PACKET_MINIMUM_LENGTH) {
+ throw new PcepParseException("Wrong length. Expected to be >= " + PACKET_MINIMUM_LENGTH + ", was: "
+ + length);
+ }
+
+ log.debug("reading update message of length " + length);
+
+ // parse Update Request list
+ if (!parseUpdateRequestList(cb)) {
+ throw new PcepParseException("parsing Update Request List Failed.");
+ }
+
+ return new PcepUpdateMsgVer1(llUpdateRequestList);
+ }
+
+ /**
+ * Parse update request list.
+ *
+ * @param cb of type channel buffer
+ * @return true after parsing Update Request List
+ * @throws PcepParseException while parsing update request list from channel buffer
+ */
+ public boolean parseUpdateRequestList(ChannelBuffer cb) throws PcepParseException {
+
+ /* <update-request-list>
+ * Where:
+ * <update-request-list> ::= <update-request>[<update-request-list>]
+ * <update-request> ::= <SRP>
+ * <LSP>
+ * <path>
+ * Where:
+ * <path> ::= <ERO><attribute-list>
+ * Where:
+ * <attribute-list> is defined in [RFC5440] and extended by PCEP extensions.
+ */
+
+ while (0 < cb.readableBytes()) {
+
+ PcepUpdateRequest pceUpdateReq = new PcepUpdateRequestVer1();
+
+ //Read SRP Object and Store it.
+ PcepSrpObject srpObj;
+ srpObj = PcepSrpObjectVer1.read(cb);
+ pceUpdateReq.setSrpObject(srpObj);
+
+ //Read LSP object and Store it.
+ PcepLspObject lspObj;
+ lspObj = PcepLspObjectVer1.read(cb);
+ pceUpdateReq.setLspObject(lspObj);
+
+ // Read Msg Path and store it.
+ PcepMsgPath msgPath = new PcepMsgPathVer1().read(cb);
+ pceUpdateReq.setMsgPath(msgPath);
+
+ llUpdateRequestList.add(pceUpdateReq);
+ }
+ return true;
+ }
+ }
+
+ /**
+ * Constructor to initialize llUpdateRequestList.
+ *
+ * @param llUpdateRequestList list of PcepUpdateRequest.
+ */
+ PcepUpdateMsgVer1(LinkedList<PcepUpdateRequest> llUpdateRequestList) {
+ this.llUpdateRequestList = llUpdateRequestList;
+ }
+
+ /**
+ * builder class for PCPE update message.
+ */
+ static class Builder implements PcepUpdateMsg.Builder {
+
+ // PCEP report message fields
+ LinkedList<PcepUpdateRequest> llUpdateRequestList;
+
+ @Override
+ public PcepVersion getVersion() {
+ return PcepVersion.PCEP_1;
+ }
+
+ @Override
+ public PcepType getType() {
+ return PcepType.UPDATE;
+ }
+
+ @Override
+ public PcepUpdateMsg build() {
+ return new PcepUpdateMsgVer1(this.llUpdateRequestList);
+ }
+
+ @Override
+ public LinkedList<PcepUpdateRequest> getUpdateRequestList() {
+ return this.llUpdateRequestList;
+ }
+
+ @Override
+ public Builder setUpdateRequestList(LinkedList<PcepUpdateRequest> llUpdateRequestList) {
+ this.llUpdateRequestList = llUpdateRequestList;
+ return this;
+ }
+
+ }
+
+ @Override
+ public void writeTo(ChannelBuffer cb) throws PcepParseException {
+ WRITER.write(cb, this);
+ }
+
+ static final Writer WRITER = new Writer();
+
+ //Writer writes UpdateMessage to the channel buffer.
+ static class Writer implements PcepMessageWriter<PcepUpdateMsgVer1> {
+
+ @Override
+ public void write(ChannelBuffer cb, PcepUpdateMsgVer1 message) throws PcepParseException {
+
+ int startIndex = cb.writerIndex();
+ // first 3 bits set to version
+ cb.writeByte((byte) (PACKET_VERSION << PcepMessageVer1.SHIFT_FLAG));
+ // message type
+ cb.writeByte(MSG_TYPE.getType());
+ /* length is length of variable message, will be updated at the end
+ * Store the position of message
+ * length in buffer
+ */
+ int msgLenIndex = cb.writerIndex();
+
+ cb.writeShort((short) 0);
+ ListIterator<PcepUpdateRequest> listIterator = message.llUpdateRequestList.listIterator();
+
+ while (listIterator.hasNext()) {
+
+ PcepUpdateRequest updateReq = listIterator.next();
+
+ //SRP object is mandatory
+ PcepSrpObject srpObj = updateReq.getSrpObject();
+ srpObj.write(cb);
+
+ //LSP object is mandatory
+ PcepLspObject lspObj = updateReq.getLspObject();
+ lspObj.write(cb);
+
+ //PATH object is mandatory
+ PcepMsgPath msgPath = updateReq.getMsgPath();
+ msgPath.write(cb);
+ }
+
+ // update message length field
+ int length = cb.writerIndex() - startIndex;
+ cb.setShort(msgLenIndex, (short) length);
+ }
+ }
+
+ @Override
+ public PcepVersion getVersion() {
+ return PcepVersion.PCEP_1;
+ }
+
+ @Override
+ public PcepType getType() {
+ return MSG_TYPE;
+ }
+
+ @Override
+ public LinkedList<PcepUpdateRequest> getUpdateRequestList() {
+ return this.llUpdateRequestList;
+ }
+
+ @Override
+ public void setUpdateRequestList(LinkedList<PcepUpdateRequest> llUpdateRequestList) {
+ this.llUpdateRequestList = llUpdateRequestList;
+ }
+
+ @Override
+ public void print() {
+
+ log.debug("PCEP UPDATE MESSAGE");
+ ListIterator<PcepUpdateRequest> listIterator = llUpdateRequestList.listIterator();
+ while (listIterator.hasNext()) {
+ listIterator.next().print();
+ }
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("Update Request list", llUpdateRequestList)
+ .toString();
+ }
+}
diff --git a/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepUpdateRequestVer1.java b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepUpdateRequestVer1.java
new file mode 100644
index 0000000..71b98dd
--- /dev/null
+++ b/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepUpdateRequestVer1.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.pcepio.protocol.ver1;
+
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepLspObject;
+import org.onosproject.pcepio.protocol.PcepMsgPath;
+import org.onosproject.pcepio.protocol.PcepSrpObject;
+import org.onosproject.pcepio.protocol.PcepUpdateRequest;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/*
+ * PCEP Update Request List.
+ */
+public class PcepUpdateRequestVer1 implements PcepUpdateRequest {
+
+ /* <update-request-list>
+ * Where:
+ * <update-request-list> ::= <update-request>[<update-request-list>]
+ * <update-request> ::= <SRP>
+ * <LSP>
+ * <path>
+ * Where:
+ * <path> ::= <ERO><attribute-list>
+ * Where:
+ * <attribute-list> is defined in [RFC5440] and extended by PCEP extensions.
+ */
+
+ protected static final Logger log = LoggerFactory.getLogger(PcepUpdateRequestVer1.class);
+
+ //PCEP SRP Object
+ private PcepSrpObject srpObject;
+ //PCEP LSP Object
+ private PcepLspObject lspObject;
+ //PCEP Message path
+ private PcepMsgPath msgPath;
+
+ /**
+ * Default constructor.
+ */
+ public PcepUpdateRequestVer1() {
+ srpObject = null;
+ lspObject = null;
+ msgPath = null;
+ }
+
+ /**
+ * Constructor to initialize all member variables.
+ *
+ * @param srpObject srp object
+ * @param lspObject lsp object
+ * @param msgPath message path object
+ */
+ public PcepUpdateRequestVer1(PcepSrpObject srpObject, PcepLspObject lspObject, PcepMsgPath msgPath) {
+ this.srpObject = srpObject;
+ this.lspObject = lspObject;
+ this.msgPath = msgPath;
+ }
+
+ @Override
+ public PcepSrpObject getSrpObject() {
+ return srpObject;
+ }
+
+ @Override
+ public PcepLspObject getLspObject() {
+ return lspObject;
+ }
+
+ @Override
+ public PcepMsgPath getMsgPath() {
+ return msgPath;
+ }
+
+ @Override
+ public void setSrpObject(PcepSrpObject srpObject) {
+ this.srpObject = srpObject;
+
+ }
+
+ @Override
+ public void setLspObject(PcepLspObject lspObject) {
+ this.lspObject = lspObject;
+ }
+
+ @Override
+ public void setMsgPath(PcepMsgPath msgPath) {
+ this.msgPath = msgPath;
+ }
+
+ /**
+ * Builder class for PCEP update request.
+ */
+ public static class Builder implements PcepUpdateRequest.Builder {
+
+ private boolean bIsSRPObjectSet = false;
+ private boolean bIsLSPObjectSet = false;
+ private boolean bIsPcepMsgPathSet = false;
+
+ //PCEP SRP Object
+ private PcepSrpObject srpObject;
+ //PCEP LSP Object
+ private PcepLspObject lspObject;
+ //PCEP Attribute list
+ private PcepMsgPath msgPath;
+
+ @Override
+ public PcepUpdateRequest build() throws PcepParseException {
+
+ //PCEP SRP Object
+ PcepSrpObject srpObject = null;
+ //PCEP LSP Object
+ PcepLspObject lspObject = null;
+ //PCEP Attribute list
+ PcepMsgPath msgPath = null;
+
+ if (!this.bIsSRPObjectSet) {
+ throw new PcepParseException(" SRP Object NOT Set while building PcepUpdateRequest.");
+ } else {
+ srpObject = this.srpObject;
+ }
+ if (!this.bIsLSPObjectSet) {
+ throw new PcepParseException(" LSP Object NOT Set while building PcepUpdateRequest.");
+ } else {
+ lspObject = this.lspObject;
+ }
+ if (!this.bIsPcepMsgPathSet) {
+ throw new PcepParseException(" Msg Path NOT Set while building PcepUpdateRequest.");
+ } else {
+ msgPath = this.msgPath;
+ }
+
+ return new PcepUpdateRequestVer1(srpObject, lspObject, msgPath);
+ }
+
+ @Override
+ public PcepSrpObject getSrpObject() {
+ return this.srpObject;
+ }
+
+ @Override
+ public PcepLspObject getLspObject() {
+ return this.lspObject;
+ }
+
+ @Override
+ public PcepMsgPath getMsgPath() {
+ return this.msgPath;
+ }
+
+ @Override
+ public Builder setSrpObject(PcepSrpObject srpobj) {
+ this.srpObject = srpobj;
+ this.bIsSRPObjectSet = true;
+ return this;
+
+ }
+
+ @Override
+ public Builder setLspObject(PcepLspObject lspObject) {
+ this.lspObject = lspObject;
+ this.bIsLSPObjectSet = true;
+ return this;
+ }
+
+ @Override
+ public Builder setMsgPath(PcepMsgPath msgPath) {
+ this.msgPath = msgPath;
+ this.bIsPcepMsgPathSet = true;
+ return this;
+ }
+ }
+
+ @Override
+ public void print() {
+
+ log.debug("UPDATE REQUEST");
+ srpObject.print();
+ lspObject.print();
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("SRP Object", srpObject)
+ .add("LSP object", lspObject)
+ .add("message path object", msgPath)
+ .toString();
+ }
+}
\ No newline at end of file