Implementation of PcInitate and PcUpdate messages

Change-Id: I746a5860a8b4a8022d747a02075ed3237741c53a

@@ -15,3 +15,4 @@ dependency-reduced-pom.xml
 
 
 core/store/trivial/data/
 core/store/trivial/data/
 core/store/apps
 core/store/apps
+/bin/

@@ -19,6 +19,7 @@ package org.onosproject.pcepio.protocol;
 import java.util.LinkedList;
 import java.util.LinkedList;
 
 
 import org.jboss.netty.buffer.ChannelBuffer;
 import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
 import org.onosproject.pcepio.types.PcepObjectHeader;
 import org.onosproject.pcepio.types.PcepObjectHeader;
 import org.onosproject.pcepio.types.PcepValueType;
 import org.onosproject.pcepio.types.PcepValueType;
 
 
@@ -62,7 +63,7 @@ public interface PcepCloseMsg extends PcepObject, PcepMessage {
     void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv);
     void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv);
 
 
     @Override
     @Override
-    void writeTo(ChannelBuffer channelBuffer);
+    void writeTo(ChannelBuffer channelBuffer) throws PcepParseException;
 
 
     /**
     /**
      * Builder interface with get and set functions to build Close message.
      * Builder interface with get and set functions to build Close message.

@@ -18,6 +18,7 @@ package org.onosproject.pcepio.protocol;
 
 
 import org.jboss.netty.buffer.ChannelBuffer;
 import org.jboss.netty.buffer.ChannelBuffer;
 import org.onosproject.pcepio.exceptions.PcepParseException;
 import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.ver1.PcepFactoryVer1;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
 
 
@@ -35,15 +36,15 @@ public final class PcepFactories {
     /*
     /*
      * Returns the instance of PCEP Version.
      * Returns the instance of PCEP Version.
      *
      *
-     * @param version
+     * @param version PCEP version
      * @return PCEP version
      * @return PCEP version
      */
      */
     public static PcepFactory getFactory(PcepVersion version) {
     public static PcepFactory getFactory(PcepVersion version) {
         switch (version) {
         switch (version) {
         case PCEP_1:
         case PCEP_1:
-            // TODO :  to get the pcep version 1 factory
+            return PcepFactoryVer1.INSTANCE;
         default:
         default:
-            throw new IllegalArgumentException("[PcepFactory:]Unknown version: " + version);
+            throw new IllegalArgumentException("Unknown version: " + version);
         }
         }
     }
     }
 
 
@@ -53,7 +54,6 @@ public final class PcepFactories {
         public PcepMessage readFrom(ChannelBuffer bb) throws PcepParseException {
         public PcepMessage readFrom(ChannelBuffer bb) throws PcepParseException {
 
 
             if (!bb.readable()) {
             if (!bb.readable()) {
-                log.debug("Empty message received");
                 throw new PcepParseException("Empty message received");
                 throw new PcepParseException("Empty message received");
             }
             }
 
 
@@ -75,13 +75,12 @@ public final class PcepFactories {
             switch (packetVersion) {
             switch (packetVersion) {
 
 
             case 1:
             case 1:
-                // TODO : get the factory for version 1
+                factory = org.onosproject.pcepio.protocol.ver1.PcepFactoryVer1.INSTANCE;
                 break;
                 break;
             default:
             default:
                 throw new IllegalArgumentException("Unknown Packet version: " + packetVersion);
                 throw new IllegalArgumentException("Unknown Packet version: " + packetVersion);
             }
             }
-            // TODO : Read the PCEP message from the factory
-            return null;
+            return factory.getReader().readFrom(bb);
         }
         }
     }
     }
 
 

+/*
+ * 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();
+    }
+}

+/*
+ * 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();
+    }
+
+}

+/*
+ * 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;
+    }
+
+}

+/*
+ * 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();
+    }
+}

+/*
+ * 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");
+    }
+}

+/*
+ * 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);
+            }
+        }
+    }
+}

+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

+/*
+ * 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

+/*
+ * 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.types;
+
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.protocol.PcepVersion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * Provides Autonomous System Tlv which contains opaque value (32 Bit AS Number).
+ */
+public class AutonomousSystemTlv implements PcepValueType {
+
+    /* Reference :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
+     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+     |           Type=[TBD10]         |             Length=4         |
+     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+     |                    opaque value (32 Bit AS Number)            |
+     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+     */
+
+    protected static final Logger log = LoggerFactory.getLogger(AutonomousSystemTlv.class);
+
+    public static final short TYPE = 100; //TODD:change this TBD10
+    public static final short LENGTH = 4;
+
+    private final int rawValue;
+
+    /**
+     * constructor to initialize Autonomous system tlv value.
+     *
+     * @param rawValue value of Autonomous system tlv
+     */
+    public AutonomousSystemTlv(int rawValue) {
+        this.rawValue = rawValue;
+    }
+
+    /**
+     * To create instance of AutonomousSystemTlv.
+     *
+     * @param raw opaque value ofc 32 Bit AS Number
+     * @return object of AutonomousSystemTlv
+     */
+    public static AutonomousSystemTlv of(final int raw) {
+        return new AutonomousSystemTlv(raw);
+    }
+
+    /**
+     * Returns opaque value of 32 Bit AS Number.
+     *
+     * @return int value of rawValue
+     */
+    public int getInt() {
+        return rawValue;
+    }
+
+    @Override
+    public PcepVersion getVersion() {
+        return PcepVersion.PCEP_1;
+    }
+
+    @Override
+    public short getType() {
+        return TYPE;
+    }
+
+    @Override
+    public short getLength() {
+        return LENGTH;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(rawValue);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof AutonomousSystemTlv) {
+            AutonomousSystemTlv other = (AutonomousSystemTlv) obj;
+            return Objects.equals(rawValue, other.rawValue);
+        }
+        return false;
+    }
+
+    @Override
+    public int write(ChannelBuffer c) {
+        int iLenStartIndex = c.writerIndex();
+        c.writeShort(TYPE);
+        c.writeShort(LENGTH);
+        c.writeInt(rawValue);
+        return c.writerIndex() - iLenStartIndex;
+    }
+
+    /**
+     * Reads the channel buffer and returns object of AutonomousSystemTlv.
+     *
+     * @param c type of channel buffer
+     * @return object of AutonomousSystemTlv
+     */
+    public static AutonomousSystemTlv read(ChannelBuffer c) {
+        return AutonomousSystemTlv.of(c.readInt());
+    }
+
+    @Override
+    public void print() {
+        log.debug("AutonomousSystemTlv");
+        log.debug("Type: " + TYPE);
+        log.debug("Length: " + LENGTH);
+        log.debug("Value: " + rawValue);
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("TYPE", TYPE)
+                .add("Length", LENGTH)
+                .add("value", rawValue)
+                .toString();
+    }
+}

@@ -10,14 +10,17 @@ import org.onosproject.pcepio.protocol.PcepOpenObject;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
 
 
+import com.google.common.base.MoreObjects;
+import com.google.common.base.MoreObjects.ToStringHelper;
+
 /*
 /*
  * Provide the error object list with open object.
  * Provide the error object list with open object.
  */
  */
 public class ErrorObjListWithOpen {
 public class ErrorObjListWithOpen {
     //errorObjList is mandatory
     //errorObjList is mandatory
-    LinkedList<PcepErrorObject> llerrorObjList;
+    private LinkedList<PcepErrorObject> llerrorObjList;
     // openObject is optional
     // openObject is optional
-    PcepOpenObject openObject;
+    private PcepOpenObject openObject;
     // flag to check if open object is set or not
     // flag to check if open object is set or not
     public boolean isOpenObjectSet;
     public boolean isOpenObjectSet;
     protected static final Logger log = LoggerFactory.getLogger(ErrorObjListWithOpen.class);
     protected static final Logger log = LoggerFactory.getLogger(ErrorObjListWithOpen.class);
@@ -49,6 +52,11 @@ public class ErrorObjListWithOpen {
         isOpenObjectSet = false;
         isOpenObjectSet = false;
     }
     }
 
 
+    /**
+     * Returns error type.
+     *
+     * @return error type
+     */
     public LinkedList<Integer> getErrorType() {
     public LinkedList<Integer> getErrorType() {
         LinkedList<Integer> errorType = new LinkedList<Integer>();
         LinkedList<Integer> errorType = new LinkedList<Integer>();
         if (llerrorObjList != null) {
         if (llerrorObjList != null) {
@@ -56,7 +64,7 @@ public class ErrorObjListWithOpen {
             int error;
             int error;
             PcepErrorObject errorObj;
             PcepErrorObject errorObj;
             while (errObjListIterator.hasNext()) {
             while (errObjListIterator.hasNext()) {
-                errorObj =  errObjListIterator.next();
+                errorObj = errObjListIterator.next();
                 error = errorObj.getErrorType();
                 error = errorObj.getErrorType();
                 errorType.add(error);
                 errorType.add(error);
             }
             }
@@ -64,6 +72,11 @@ public class ErrorObjListWithOpen {
         return errorType;
         return errorType;
     }
     }
 
 
+    /**
+     * Returns error value.
+     *
+     * @return error value
+     */
     public LinkedList<Integer> getErrorValue() {
     public LinkedList<Integer> getErrorValue() {
         LinkedList<Integer> errorValue = new LinkedList<Integer>();
         LinkedList<Integer> errorValue = new LinkedList<Integer>();
         if (llerrorObjList != null) {
         if (llerrorObjList != null) {
@@ -71,7 +84,7 @@ public class ErrorObjListWithOpen {
             int error;
             int error;
             PcepErrorObject errorObj;
             PcepErrorObject errorObj;
             while (errObjListIterator.hasNext()) {
             while (errObjListIterator.hasNext()) {
-                errorObj =  errObjListIterator.next();
+                errorObj = errObjListIterator.next();
                 error = errorObj.getErrorValue();
                 error = errorObj.getErrorValue();
                 errorValue.add(error);
                 errorValue.add(error);
 
 
@@ -79,7 +92,8 @@ public class ErrorObjListWithOpen {
         }
         }
         return errorValue;
         return errorValue;
     }
     }
-    /*
+
+    /**
      * Checks whether error object list is empty or not.
      * Checks whether error object list is empty or not.
      *
      *
      * @return whether error object list is empty or not
      * @return whether error object list is empty or not
@@ -90,7 +104,7 @@ public class ErrorObjListWithOpen {
         return (!this.llerrorObjList.isEmpty()) ? true : false;
         return (!this.llerrorObjList.isEmpty()) ? true : false;
     }
     }
 
 
-    /*
+    /**
      * Write Error Object List and Open Object to channel buffer.
      * Write Error Object List and Open Object to channel buffer.
      *
      *
      * @param bb of type channel buffer
      * @param bb of type channel buffer
@@ -121,7 +135,7 @@ public class ErrorObjListWithOpen {
         return bb.writerIndex() - iLenStartIndex;
         return bb.writerIndex() - iLenStartIndex;
     }
     }
 
 
-    /*
+    /**
      * Prints the attributes of ErrorObject List with open Object.
      * Prints the attributes of ErrorObject List with open Object.
      */
      */
     public void print() {
     public void print() {
@@ -137,4 +151,19 @@ public class ErrorObjListWithOpen {
             openObject.print();
             openObject.print();
         }
         }
     }
     }
+
+    @Override
+    public String toString() {
+        ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass());
+
+        if (openObject == null) {
+            toStrHelper
+            .add("error Obj List", llerrorObjList);
+        } else {
+            toStrHelper
+            .add("error Obj List", llerrorObjList)
+            .add("open Object", openObject);
+        }
+        return toStrHelper.toString();
+    }
 }
 }

+/*
+ * 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.
+ */
+
+/**
+ * @author b00295750
+ *
+ */
+package org.onosproject.pcepio.types;
+
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.protocol.PcepVersion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * Provides IPv4 Sub Object.
+ */
+public class IPv4SubObject implements PcepValueType {
+
+    /*Reference : RFC 4874:3.1.1
+     *  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    |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+     */
+    protected static final Logger log = LoggerFactory.getLogger(IPv4SubObject.class);
+
+    public static final byte TYPE = 0x01;
+    public static final byte LENGTH = 8;
+    public static final byte VALUE_LENGTH = 6;
+    public static final byte OBJ_LENGTH = 8;
+    public static final byte LBIT = 0;
+    public static final int SHIFT_LBIT_POSITION = 7;
+    private int ipAddress;
+    private byte prefixLen;
+    private byte resvd;
+
+    /**
+     * Constructor to initialize ipv4 address.
+     *
+     * @param ipAddr ipv4 address
+     */
+    public IPv4SubObject(int ipAddr) {
+        this.ipAddress = ipAddr;
+    }
+
+    /**
+     * constructor to initialize ipAddress, prefixLen and resvd.
+     *
+     * @param ipAddress ipv4 address
+     * @param prefixLen prefix length
+     * @param resvd reserved flags value
+     */
+    public IPv4SubObject(int ipAddress, byte prefixLen, byte resvd) {
+        this.ipAddress = ipAddress;
+        this.prefixLen = prefixLen;
+        this.resvd = resvd;
+    }
+
+    /**
+     * Returns a new instance of IPv4SubObject.
+     *
+     * @param ipAddress ipv4 address
+     * @param prefixLen prefix length
+     * @param resvd reserved flags value
+     * @return object of IPv4SubObject
+     */
+    public static IPv4SubObject of(int ipAddress, byte prefixLen, byte resvd) {
+        return new IPv4SubObject(ipAddress, prefixLen, resvd);
+    }
+
+    /**
+     * Returns prefixLen of IPv4 IP address.
+     *
+     * @return byte  value of rawValue
+     */
+    public byte getPrefixLen() {
+        return prefixLen;
+    }
+
+    /**
+     * Returns value of IPv4 IP address.
+     *
+     * @return int value of ipv4 address
+     */
+    public int getIpAddress() {
+        return ipAddress;
+    }
+
+    @Override
+    public PcepVersion getVersion() {
+        return PcepVersion.PCEP_1;
+    }
+
+    @Override
+    public short getType() {
+        return TYPE;
+    }
+
+    @Override
+    public short getLength() {
+        return LENGTH;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(ipAddress, prefixLen, resvd);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof IPv4SubObject) {
+            IPv4SubObject other = (IPv4SubObject) obj;
+            return Objects.equals(this.ipAddress, other.ipAddress) && Objects.equals(this.prefixLen, other.prefixLen)
+                    && Objects.equals(this.resvd, other.resvd);
+        }
+        return false;
+    }
+
+    /**
+     * Reads the channel buffer and returns object of IPv4SubObject.
+     *
+     * @param c type of channel buffer
+     * @return object of IPv4SubObject
+     */
+    public static PcepValueType read(ChannelBuffer c) {
+        int ipAddess = c.readInt();
+        byte prefixLen = c.readByte();
+        byte resvd = c.readByte();
+        return new IPv4SubObject(ipAddess, prefixLen, resvd);
+    }
+
+    @Override
+    public int write(ChannelBuffer c) {
+        int iLenStartIndex = c.writerIndex();
+        byte bValue = LBIT;
+        bValue = (byte) (bValue << SHIFT_LBIT_POSITION);
+        bValue = (byte) (bValue | TYPE);
+        c.writeByte(bValue);
+        c.writeByte(OBJ_LENGTH);
+        c.writeInt(ipAddress);
+        c.writeByte(prefixLen);
+        c.writeByte(resvd);
+
+        return c.writerIndex() - iLenStartIndex;
+    }
+
+    @Override
+    public void print() {
+        log.debug("IPv4SubObject");
+        log.debug("Type: " + TYPE);
+        log.debug("Length: " + LENGTH);
+        log.debug("IPv4 address: " + String.format("%08X", ipAddress));
+        log.debug("Prefix Length: " + prefixLen);
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("Type", TYPE)
+                .add("Length", LENGTH)
+                .add("IPv4  Address", ipAddress)
+                .add("Prefix Length", prefixLen)
+                .toString();
+    }
+}

+/*
+ * 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.types;
+
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.protocol.PcepVersion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * Provides IPv6 Sub Object.
+ */
+public class IPv6SubObject implements PcepValueType {
+
+    /* reference :RFC 4874.
+    Subobject : IPv6 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
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    |      Type     |     Length    | IPv6 address (16 bytes)       |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    | IPv6 address (continued)                                      |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    | IPv6 address (continued)                                      |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    | IPv6 address (continued)                                      |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    | IPv6 address (continued)      | Prefix Length |      Flags    |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+      Type
+
+         0x02  IPv6 address
+
+      Length
+
+         The Length contains the total length of the subobject in bytes,
+         including the Type and Length fields.  The Length is always 20.
+
+      IPv6 address
+
+         A 128-bit unicast host address.
+
+      Prefix length
+
+         128
+
+      Flags
+
+         0x01  Local protection available
+
+               Indicates that the link downstream of this node is
+               protected via a local repair mechanism.  This flag can
+               only be set if the Local protection flag was set in the
+               SESSION_ATTRIBUTE object of the corresponding Path
+               message.
+
+         0x02  Local protection in use
+
+               Indicates that a local repair mechanism is in use to
+               maintain this tunnel (usually in the face of an outage
+               of the link it was previously routed over).
+     */
+    protected static final Logger log = LoggerFactory.getLogger(IPv6SubObject.class);
+
+    public static final short TYPE = 0x02;
+    public static final short LENGTH = 20;
+    public static final byte VALUE_LENGTH = 18;
+
+    private static final byte[] NONE_VAL = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+    public static final IPv6SubObject NONE = new IPv6SubObject(NONE_VAL);
+
+    private static final byte[] NO_MASK_VAL = {(byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF };
+    public static final IPv6SubObject NO_MASK = new IPv6SubObject(NO_MASK_VAL);
+    public static final IPv6SubObject FULL_MASK = NONE;
+
+    private final byte[] rawValue;
+
+    /**
+     * constructor to initialize rawValue with ipv6 address.
+     *
+     * @param rawValue ipv6 address
+     */
+    public IPv6SubObject(byte[] rawValue) {
+        this.rawValue = rawValue;
+    }
+
+    /**
+     * To create instance of IPv6SubObject.
+     *
+     * @param raw byte array of ipv6 address
+     * @return object of IPv6SubObject
+     */
+    public static IPv6SubObject of(final byte[] raw) {
+        //check NONE_VAL
+        boolean bFoundNONE = true;
+        //value starts from 3rd byte.
+        for (int i = 2; i < 20; ++i) {
+            if (NONE_VAL[i] != raw[i]) {
+                bFoundNONE = false;
+            }
+        }
+
+        if (bFoundNONE) {
+            return NONE;
+        }
+
+        //check NO_MASK_VAL
+        boolean bFoundNoMask = true;
+        //value starts from 3rd byte.
+        for (int i = 2; i < 20; ++i) {
+            if (0xFF != raw[i]) {
+                bFoundNoMask = false;
+            }
+        }
+        if (bFoundNoMask) {
+            return NO_MASK;
+        }
+
+        return new IPv6SubObject(raw);
+    }
+
+    /**
+     * Returns value of IPv6 Sub Object.
+     *
+     * @return byte array of ipv6 address
+     */
+    public byte[] getValue() {
+        return rawValue;
+    }
+
+    @Override
+    public PcepVersion getVersion() {
+        return PcepVersion.PCEP_1;
+    }
+
+    @Override
+    public short getType() {
+        return TYPE;
+    }
+
+    @Override
+    public short getLength() {
+        return LENGTH;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(rawValue);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof IPv6SubObject) {
+            IPv6SubObject other = (IPv6SubObject) obj;
+            return Objects.equals(rawValue, other.rawValue);
+        }
+        return false;
+    }
+
+    @Override
+    public int write(ChannelBuffer c) {
+        int iStartIndex = c.writerIndex();
+        c.writeShort(TYPE);
+        c.writeShort(LENGTH);
+        c.writeBytes(rawValue);
+        return c.writerIndex() - iStartIndex;
+    }
+
+    /**
+     * Reads the channel buffer and returns object of IPv6SubObject.
+     *
+     * @param c type of channel buffer
+     * @return object of IPv6SubObject
+     */
+    public static IPv6SubObject read20Bytes(ChannelBuffer c) {
+        byte[] yTemp = new byte[20];
+        c.readBytes(yTemp, 0, 20);
+        return IPv6SubObject.of(yTemp);
+    }
+
+    @Override
+    public void print() {
+        log.debug("IPv6SubObject");
+        log.debug("Type: ", TYPE);
+        log.debug("Length: ", LENGTH);
+        if (null != rawValue) {
+            StringBuffer result = new StringBuffer();
+            for (byte b : rawValue) {
+                result.append(String.format("%02X ", b));
+            }
+            log.debug(result.toString());
+        }
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("Type", TYPE)
+                .add("Length", LENGTH)
+                .add("IPv6  Address", rawValue)
+                .toString();
+    }
+}

+/*
+ * 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.types;
+
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.protocol.PcepVersion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * Path Key SubObject: When a PCC needs to expand a path-key in order to expand a CPS, it
+ * issues a Path Computation Request (PCReq) to the PCE identified in
+ * the PKS in the RSVP-TE ERO that it is processing.  The PCC supplies
+ * the PKS to be expanded in a PATH-KEY SubObject in the PCReq message.
+ */
+public class PathKeySubObject implements PcepValueType {
+
+    /*
+    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)                      |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+     */
+
+    protected static final Logger log = LoggerFactory.getLogger(PathKeySubObject.class);
+
+    public static final byte TYPE = 0x40;
+    public static final byte LENGTH = 8;
+    private final short pathKey;
+    private final int pceID;
+
+    /**
+     * Constructor for Path Key sub Object which initializes pathKey and pceId.
+     *
+     * @param pathKey path key provided by PCC
+     * @param pceID ID for the PCE
+     */
+    public PathKeySubObject(short pathKey, int pceID) {
+        this.pathKey = pathKey;
+        this.pceID = pceID;
+    }
+
+    /**
+     * Creates Path Key sub Object which initializes pathKey and pceId.
+     *
+     * @param pathKey path key provided by PCC
+     * @param pceID PCE id
+     * @return new object of type path key sub object
+     */
+    public static PathKeySubObject of(short pathKey, int pceID) {
+        return new PathKeySubObject(pathKey, pceID);
+    }
+
+    /**
+     * Returns Path Key.
+     *
+     * @return pathKey
+     */
+    public short getPathKey() {
+        return pathKey;
+    }
+
+    /**
+     * Returns pceID.
+     *
+     * @return pceID
+     */
+    public int getPceId() {
+        return pceID;
+    }
+
+    @Override
+    public PcepVersion getVersion() {
+        return PcepVersion.PCEP_1;
+    }
+
+    @Override
+    public short getType() {
+        return TYPE;
+    }
+
+    @Override
+    public short getLength() {
+        return LENGTH;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(pathKey, pceID);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof PathKeySubObject) {
+            PathKeySubObject other = (PathKeySubObject) obj;
+            return Objects.equals(this.pathKey, other.pathKey) && Objects.equals(this.pceID, other.pceID);
+        }
+        return false;
+    }
+
+    @Override
+    public int write(ChannelBuffer c) {
+        int iLenStartIndex = c.writerIndex();
+        c.writeShort(TYPE);
+        c.writeShort(LENGTH);
+
+        c.writeShort(pathKey);
+        c.writeInt(pceID);
+
+        return c.writerIndex() - iLenStartIndex;
+    }
+
+    /**
+     * Reads the channel buffer and returns new path key sub objects.
+     *
+     * @param c of type channel buffer
+     * @return object of type path key sub object
+     */
+    public static PcepValueType read(ChannelBuffer c) {
+        Short pathKey = c.readShort();
+        int pceID = c.readInt();
+        return new PathKeySubObject(pathKey, pceID);
+    }
+
+    @Override
+    public void print() {
+        log.debug("PathKeySubObject");
+        log.debug("Type: " + TYPE);
+        log.debug("Length: " + LENGTH);
+        log.debug("Path Key: " + pathKey);
+        log.debug("PCEID: " + pceID);
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("Type", TYPE).add("Length", LENGTH)
+                .add("Path Key", pathKey)
+                .add("PCE ID", pceID)
+                .toString();
+    }
+}

+/*
+ * 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.types;
+
+/*
+ * Provide the PCEP Error Info Details.
+ */
+public final class PcepErrorDetailInfo {
+
+    private PcepErrorDetailInfo() {
+    }
+
+    // Error Types
+    /**
+    Error-  Meaning                                           Reference:RFC 5440
+    Type
+    1     PCEP session establishment failure
+        Error-value=1: reception of an invalid Open message or a non Open message.
+        Error-value=2: no Open message received before the expiration of the OpenWait timer
+        Error-value=3: unacceptable and non-negotiable session characteristics
+        Error-value=4: unacceptable but negotiable session characteristics
+        Error-value=5: reception of a second Open message with still unacceptable session characteristics
+        Error-value=6: reception of a PCErr message proposing unacceptable session characteristics
+        Error-value=7: No Keepalive or PCErr message received before the expiration of the KeepWait timer
+        Error-value=8: PCEP version not supported
+    2     Capability not supported
+    3     Unknown Object
+         Error-value=1: Unrecognized object class
+         Error-value=2: Unrecognized object Type
+    4     Not supported object
+         Error-value=1: Not supported object class
+         Error-value=2: Not supported object Type
+    5     Policy violation
+         Error-value=1: C bit of the METRIC object set (request rejected)
+         Error-value=2: O bit of the RP object cleared (request rejected)
+    6     Mandatory Object missing
+         Error-value=1: RP object missing
+         Error-value=2: RRO missing for a re-optimization request (R bit of the RP object set)
+         Error-value=3: END-POINTS object missing
+    7     Synchronized path computation request missing
+    8     Unknown request reference
+    9     Attempt to establish a second PCEP session
+    10     Reception of an invalid object
+         Error-value=1: reception of an object with P flag not set although the P flag must be
+                        set according to this specification.
+     */
+    public static final byte ERROR_TYPE_1 = 1;
+    public static final byte ERROR_TYPE_2 = 2;
+    public static final byte ERROR_TYPE_3 = 3;
+    public static final byte ERROR_TYPE_4 = 4;
+    public static final byte ERROR_TYPE_5 = 5;
+    public static final byte ERROR_TYPE_6 = 6;
+    public static final byte ERROR_TYPE_7 = 7;
+    public static final byte ERROR_TYPE_8 = 8;
+    public static final byte ERROR_TYPE_9 = 9;
+    public static final byte ERROR_TYPE_10 = 10;
+
+    // Error Values
+    public static final byte ERROR_VALUE_1 = 1;
+    public static final byte ERROR_VALUE_2 = 2;
+    public static final byte ERROR_VALUE_3 = 3;
+    public static final byte ERROR_VALUE_4 = 4;
+    public static final byte ERROR_VALUE_5 = 5;
+    public static final byte ERROR_VALUE_6 = 6;
+    public static final byte ERROR_VALUE_7 = 7;
+    public static final byte ERROR_VALUE_8 = 8;
+    public static final byte ERROR_VALUE_9 = 9;
+    public static final byte ERROR_VALUE_10 = 10;
+}

@@ -9,7 +9,9 @@ import org.onosproject.pcepio.protocol.PcepSrpObject;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
 
 
-/*
+import com.google.common.base.MoreObjects;
+
+/**
  * Provides Pcep Label.
  * Provides Pcep Label.
  * REference :draft-zhao-pce-pcep-extension-for-pce-controller-01.
  * REference :draft-zhao-pce-pcep-extension-for-pce-controller-01.
  */
  */
@@ -18,13 +20,13 @@ public class PcepLabelDownload {
     protected static final Logger log = LoggerFactory.getLogger(PcepLabelDownload.class);
     protected static final Logger log = LoggerFactory.getLogger(PcepLabelDownload.class);
 
 
     //PCEP SPR Object
     //PCEP SPR Object
-    PcepSrpObject srpObject;
+    private PcepSrpObject srpObject;
     //PCEP LSP Object
     //PCEP LSP Object
-    PcepLspObject lspObject;
+    private PcepLspObject lspObject;
     //LinkList of Labels
     //LinkList of Labels
-    LinkedList<PcepLabelObject> llLabelList;
+    private LinkedList<PcepLabelObject> llLabelList;
 
 
-    /*
+    /**
      * Returns SRP Object.
      * Returns SRP Object.
      *
      *
      * @return PCEP SRP Object
      * @return PCEP SRP Object
@@ -33,7 +35,7 @@ public class PcepLabelDownload {
         return srpObject;
         return srpObject;
     }
     }
 
 
-    /*
+    /**
      * Sets the Pcep Srp Object.
      * Sets the Pcep Srp Object.
      *
      *
      * @param srpobj PCEP SRP Object
      * @param srpobj PCEP SRP Object
@@ -42,7 +44,7 @@ public class PcepLabelDownload {
         this.srpObject = srpobj;
         this.srpObject = srpobj;
     }
     }
 
 
-    /*
+    /**
      * Returns LSP Object.
      * Returns LSP Object.
      *
      *
      * @return PCEP LSP Object
      * @return PCEP LSP Object
@@ -51,7 +53,7 @@ public class PcepLabelDownload {
         return lspObject;
         return lspObject;
     }
     }
 
 
-    /*
+    /**
      * Sets the Pcep LSP Object.
      * Sets the Pcep LSP Object.
      *
      *
      * @param lspObject PCEP LSP Object
      * @param lspObject PCEP LSP Object
@@ -60,7 +62,7 @@ public class PcepLabelDownload {
         this.lspObject = lspObject;
         this.lspObject = lspObject;
     }
     }
 
 
-    /*
+    /**
      * Returns a list of labels.
      * Returns a list of labels.
      *
      *
      * @return llLabelList list of pcep label objects
      * @return llLabelList list of pcep label objects
@@ -69,7 +71,7 @@ public class PcepLabelDownload {
         return llLabelList;
         return llLabelList;
     }
     }
 
 
-    /*
+    /**
      * set the llLabelList list of type PcepLableObject.
      * set the llLabelList list of type PcepLableObject.
      *
      *
      * @param llLabelList list of pcep label objects
      * @param llLabelList list of pcep label objects
@@ -78,7 +80,7 @@ public class PcepLabelDownload {
         this.llLabelList = llLabelList;
         this.llLabelList = llLabelList;
     }
     }
 
 
-    /*
+    /**
      * Prints the attribute of PcepLableObject.
      * Prints the attribute of PcepLableObject.
      */
      */
     public void print() {
     public void print() {
@@ -92,4 +94,13 @@ public class PcepLabelDownload {
             listIterator.next().print();
             listIterator.next().print();
         }
         }
     }
     }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("SRP object", srpObject)
+                .add("LSP object", lspObject)
+                .add("label object list", llLabelList)
+                .toString();
+    }
 }
 }

@@ -22,6 +22,8 @@ import org.onosproject.pcepio.protocol.PcepSrpObject;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
 
 
+import com.google.common.base.MoreObjects;
+
 /**
 /**
  * Provide PCEP Label Map.
  * Provide PCEP Label Map.
  * Reference :draft-zhao-pce-pcep-extension-for-pce-controller-01.
  * Reference :draft-zhao-pce-pcep-extension-for-pce-controller-01.
@@ -30,11 +32,11 @@ public class PcepLabelMap {
 
 
     protected static final Logger log = LoggerFactory.getLogger(PcepLabelMap.class);
     protected static final Logger log = LoggerFactory.getLogger(PcepLabelMap.class);
     //PCEP SRP Object
     //PCEP SRP Object
-    PcepSrpObject srpObject;
+    private PcepSrpObject srpObject;
     //PCEP Label Object
     //PCEP Label Object
-    PcepLabelObject labelObject;
+    private PcepLabelObject labelObject;
     //PCEP FEC Object
     //PCEP FEC Object
-    PcepFecObject fecObject;
+    private PcepFecObject fecObject;
 
 
     /**
     /**
      * Sets Fec Object.
      * Sets Fec Object.
@@ -99,4 +101,13 @@ public class PcepLabelMap {
         labelObject.print();
         labelObject.print();
         fecObject.print();
         fecObject.print();
     }
     }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("SRP object", srpObject)
+                .add("Label object", labelObject)
+                .add("Fec object", fecObject)
+                .toString();
+    }
 }
 }

+/*
+ * 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.types;
+
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.protocol.PcepNai;
+
+import com.google.common.base.MoreObjects;
+
+public class PcepNaiIpv4Adjacency implements PcepNai {
+
+    public static final byte ST_TYPE = 0x03;
+    private final int localIpv4Addr;
+    private final int remoteIpv4Addr;
+
+    /**
+     * Constructor to initialize variables.
+     *
+     * @param localIpv4 local ipv4 address
+     * @param remoteIpv4 remote ipv4 address
+     */
+    public PcepNaiIpv4Adjacency(int localIpv4, int remoteIpv4) {
+        this.localIpv4Addr = localIpv4;
+        this.remoteIpv4Addr = remoteIpv4;
+    }
+
+    @Override
+    public byte getType() {
+        return ST_TYPE;
+    }
+
+    @Override
+    public int write(ChannelBuffer bb) {
+        int iLenStartIndex = bb.writerIndex();
+        bb.writeInt(localIpv4Addr);
+        bb.writeInt(remoteIpv4Addr);
+        return bb.writerIndex() - iLenStartIndex;
+    }
+
+    /**
+     * Reads the channel buffer and returns object of PcepNAIIpv4AdjacencyVer1.
+     *
+     * @param cb of channel buffer
+     * @return object of PcepNAIIpv4Adjacency
+     */
+    public static PcepNaiIpv4Adjacency read(ChannelBuffer cb) {
+        int localIpv4 = cb.readInt();
+        int remoteIpv4 = cb.readInt();
+        return new PcepNaiIpv4Adjacency(localIpv4, remoteIpv4);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(localIpv4Addr, remoteIpv4Addr);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof PcepNaiIpv4Adjacency) {
+            PcepNaiIpv4Adjacency other = (PcepNaiIpv4Adjacency) obj;
+            return Objects.equals(this.localIpv4Addr, other.localIpv4Addr)
+                    && Objects.equals(this.remoteIpv4Addr, other.remoteIpv4Addr);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("local IPv4 Address", localIpv4Addr)
+                .add("remote IPv4 Address", remoteIpv4Addr)
+                .toString();
+    }
+}

+/*
+ * 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.types;
+
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.protocol.PcepNai;
+
+import com.google.common.base.MoreObjects;
+
+public class PcepNaiIpv4NodeId implements PcepNai {
+
+    public static final byte ST_TYPE = 0x01;
+
+    private final int ipv4NodeId;
+
+    /**
+     * Constructor to initialize ipv4NodeId.
+     *
+     * @param value ipv4 node id
+     */
+    public PcepNaiIpv4NodeId(int value) {
+        this.ipv4NodeId = value;
+    }
+
+    /**
+     * Returns an object of PcepNaiIpv4NodeId.
+     *
+     * @param value ipv4 node id
+     * @return object of PcepNaiIpv4NodeId
+     */
+    public static PcepNaiIpv4NodeId of(int value) {
+        return new PcepNaiIpv4NodeId(value);
+    }
+
+    @Override
+    public byte getType() {
+        return ST_TYPE;
+    }
+
+    @Override
+    public int write(ChannelBuffer bb) {
+        int iLenStartIndex = bb.writerIndex();
+        bb.writeInt(ipv4NodeId);
+        return bb.writerIndex() - iLenStartIndex;
+    }
+
+    /**
+     * Reads from the channel buffer and returns object of PcepNAIIpv4NodeIdVer1.
+     *
+     * @param bb of channel buffer.
+     * @return object of PcepNAIIpv4NodeIdVer1
+     */
+    public static PcepNaiIpv4NodeId read(ChannelBuffer bb) {
+        return new PcepNaiIpv4NodeId(bb.readInt());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(ipv4NodeId);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof PcepNaiIpv4NodeId) {
+            PcepNaiIpv4NodeId other = (PcepNaiIpv4NodeId) obj;
+            return Objects.equals(this.ipv4NodeId, other.ipv4NodeId);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("IPv4 Node Id", ipv4NodeId)
+                .toString();
+    }
+}

+/*
+ * 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.types;
+
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.protocol.PcepNai;
+
+import com.google.common.base.MoreObjects;
+
+public class PcepNaiIpv6Adjacency implements PcepNai {
+
+    public static final byte ST_TYPE = 0x04;
+    public static final byte IPV6_LEN = 0x10;
+
+    private final byte[] localIpv6Addr;
+    private final byte[] remoteIpv6Addr;
+
+    /**
+     * Constructor to initialize local ipv6 and remote ipv6.
+     *
+     * @param localIpv6 local ipv6 address
+     * @param remoteIpv6 remote ipv6 address
+     */
+    public PcepNaiIpv6Adjacency(byte[] localIpv6, byte[] remoteIpv6) {
+        this.localIpv6Addr = localIpv6;
+        this.remoteIpv6Addr = remoteIpv6;
+    }
+
+    @Override
+    public byte getType() {
+        return ST_TYPE;
+    }
+
+    @Override
+    public int write(ChannelBuffer bb) {
+        int iLenStartIndex = bb.writerIndex();
+        bb.writeBytes(localIpv6Addr);
+        bb.writeBytes(remoteIpv6Addr);
+        return bb.writerIndex() - iLenStartIndex;
+    }
+
+    /**
+     * Reads from channel buffer and returns object of PcepNAIIpv6AdjacencyVer1.
+     *
+     * @param bb of type channel buffer
+     * @return object of PcepNAIIpv6AdjacencyVer1
+     */
+    public static PcepNaiIpv6Adjacency read(ChannelBuffer bb) {
+        byte[] localIpv6 = new byte[IPV6_LEN];
+        bb.readBytes(localIpv6, 0, IPV6_LEN);
+        byte[] remoteIpv6 = new byte[IPV6_LEN];
+        bb.readBytes(remoteIpv6, 0, IPV6_LEN);
+        return new PcepNaiIpv6Adjacency(localIpv6, remoteIpv6);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(localIpv6Addr, remoteIpv6Addr);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof PcepNaiIpv6Adjacency) {
+            PcepNaiIpv6Adjacency other = (PcepNaiIpv6Adjacency) obj;
+            return Objects.equals(this.localIpv6Addr, other.localIpv6Addr)
+                    && Objects.equals(this.remoteIpv6Addr, other.remoteIpv6Addr);
+        }
+        return false;
+    }
+
+    /**
+     * Creates object of PcepNaiIpv6Adjacency with local ipv6 address and remote ipv6 address.
+     *
+     * @param localIpv6Addr local ipv6 address
+     * @param remoteIpv6Addr remote ipv6 address
+     * @return object of PcepNaiIpv6Adjacency
+     */
+
+    public static PcepNaiIpv6Adjacency of(final byte[] localIpv6Addr, final byte[] remoteIpv6Addr) {
+        return new PcepNaiIpv6Adjacency(localIpv6Addr, remoteIpv6Addr);
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("local IPV6 address", localIpv6Addr)
+                .add("remote IPV6 address", remoteIpv6Addr)
+                .toString();
+    }
+
+}

+/*
+ * 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.types;
+
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.protocol.PcepNai;
+
+import com.google.common.base.MoreObjects;
+
+public class PcepNaiIpv6NodeId implements PcepNai {
+
+    public static final byte ST_TYPE = 0x02;
+    public static final byte IPV6_LEN = 0x10;
+
+    private final byte[] ipv6NodeId;
+
+    /**
+     * Constructor to initialize ipv6NodeId.
+     *
+     * @param value ipv6 node id
+     */
+    public PcepNaiIpv6NodeId(byte[] value) {
+        this.ipv6NodeId = value;
+    }
+
+    @Override
+    public byte getType() {
+        return ST_TYPE;
+    }
+
+    @Override
+    public int write(ChannelBuffer cb) {
+        int iLenStartIndex = cb.writerIndex();
+        cb.writeBytes(ipv6NodeId);
+        return cb.writerIndex() - iLenStartIndex;
+    }
+
+    /**
+     * Reads from the channel buffer and returns object of PcepNAIIpv6NodeId.
+     *
+     * @param cb of type channel buffer.
+     * @return object of PcepNAIIpv6NodeId
+     */
+    public static PcepNaiIpv6NodeId read(ChannelBuffer cb) {
+        byte[] ipv6NodeId = new byte[IPV6_LEN];
+        cb.readBytes(ipv6NodeId, 0, IPV6_LEN);
+        return new PcepNaiIpv6NodeId(ipv6NodeId);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(ipv6NodeId);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof PcepNaiIpv6NodeId) {
+            PcepNaiIpv6NodeId other = (PcepNaiIpv6NodeId) obj;
+            return Objects.equals(this.ipv6NodeId, other.ipv6NodeId);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("IPV6 node ID", ipv6NodeId)
+                .toString();
+    }
+}

+package org.onosproject.pcepio.types;
+
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.protocol.PcepNai;
+
+import com.google.common.base.MoreObjects;
+
+public class PcepNaiUnnumberedAdjacencyIpv4 implements PcepNai {
+    /**
+     * draft-ietf-pce-segment-routing-03 section    5.3.2.
+     */
+    public static final byte ST_TYPE = 0x05;
+
+    private final int localNodeId;
+    private final int localInterfaceId;
+    private final int remoteNodeId;
+    private final int remoteInterfaceId;
+
+    /**
+     * Constructor to initialize all the member variables.
+     *
+     * @param localNodeId local node id
+     * @param localInterfaceId local interface id
+     * @param remoteNodeId remote node id
+     * @param remoteInterfaceId remote interface id
+     */
+    public PcepNaiUnnumberedAdjacencyIpv4(int localNodeId, int localInterfaceId, int remoteNodeId,
+            int remoteInterfaceId) {
+        this.localNodeId = localNodeId;
+        this.localInterfaceId = localInterfaceId;
+        this.remoteNodeId = remoteNodeId;
+        this.remoteInterfaceId = remoteInterfaceId;
+    }
+
+    /**
+     * Returns PCEP Nai Unnumbered Adjacency Ipv4 object.
+     *
+     * @param localNodeId local node id
+     * @param localInterfaceId local interface if
+     * @param remoteNodeId remote node id
+     * @param remoteInterfaceId remote interface id
+     * @return PCEP Nai Unnumbered Adjacency Ipv4 object
+     */
+    public static PcepNaiUnnumberedAdjacencyIpv4 of(int localNodeId, int localInterfaceId, int remoteNodeId,
+            int remoteInterfaceId) {
+        return new PcepNaiUnnumberedAdjacencyIpv4(localNodeId, localInterfaceId, remoteNodeId, remoteInterfaceId);
+    }
+
+    @Override
+    public byte getType() {
+        return ST_TYPE;
+    }
+
+    @Override
+    public int write(ChannelBuffer bb) {
+        int iLenStartIndex = bb.writerIndex();
+        bb.writeInt(localNodeId);
+        bb.writeInt(localInterfaceId);
+        bb.writeInt(remoteNodeId);
+        bb.writeInt(remoteInterfaceId);
+        return bb.writerIndex() - iLenStartIndex;
+    }
+
+    /**
+     * Reads from channel buffer and return object of PcepNAIUnnumberedAdjacencyIpv4.
+     *
+     * @param bb of type channel buffer
+     * @return object of PcepNAIUnnumberedAdjacencyIpv4
+     */
+    public static PcepNaiUnnumberedAdjacencyIpv4 read(ChannelBuffer bb) {
+        int localNodeId;
+        int localInterfaceId;
+        int remoteNodeId;
+        int remoteInterfaceId;
+        localNodeId = bb.readInt();
+        localInterfaceId = bb.readInt();
+        remoteNodeId = bb.readInt();
+        remoteInterfaceId = bb.readInt();
+        return new PcepNaiUnnumberedAdjacencyIpv4(localNodeId, localInterfaceId, remoteNodeId, remoteInterfaceId);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(localNodeId, localInterfaceId, remoteNodeId, remoteInterfaceId);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof PcepNaiUnnumberedAdjacencyIpv4) {
+            PcepNaiUnnumberedAdjacencyIpv4 other = (PcepNaiUnnumberedAdjacencyIpv4) obj;
+            return Objects.equals(this.localNodeId, other.localNodeId)
+                    && Objects.equals(this.localInterfaceId, other.localInterfaceId)
+                    && Objects.equals(this.remoteNodeId, other.remoteNodeId)
+                    && Objects.equals(this.remoteInterfaceId, other.remoteInterfaceId);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("local Node Id", localNodeId)
+                .add("local Interface Id", localInterfaceId)
+                .add("remote Node Id", remoteNodeId)
+                .add("remote Interface Id:", remoteInterfaceId)
+                .toString();
+    }
+}

@@ -20,6 +20,8 @@ import org.jboss.netty.buffer.ChannelBuffer;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
 
 
+import com.google.common.base.MoreObjects;
+
 /**
 /**
  * Provides PCEP Object Header which is common for all the objects.
  * Provides PCEP Object Header which is common for all the objects.
  * Reference : RFC 5440.
  * Reference : RFC 5440.
@@ -66,7 +68,6 @@ public class PcepObjectHeader {
      * @param bIFlag I flag
      * @param bIFlag I flag
      * @param objLen PCEP object length
      * @param objLen PCEP object length
      */
      */
-
     public PcepObjectHeader(byte objClass, byte objType, boolean bPFlag, boolean bIFlag, short objLen) {
     public PcepObjectHeader(byte objClass, byte objType, boolean bPFlag, boolean bIFlag, short objLen) {
         this.objClass = objClass;
         this.objClass = objClass;
         this.objType = objType;
         this.objType = objType;
@@ -221,4 +222,15 @@ public class PcepObjectHeader {
         log.debug("P flag: " + bPFlag);
         log.debug("P flag: " + bPFlag);
         log.debug("I flag: " + bIFlag);
         log.debug("I flag: " + bIFlag);
     }
     }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("Object class:", objClass)
+                .add("Object type:", objType)
+                .add("Object length:", objLen)
+                .add("P flag:", bPFlag)
+                .add("I flag:", bIFlag)
+                .toString();
+    }
 }
 }

+/*
+ * 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.types;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+
+public interface PcepRsvpErrorSpec extends PcepValueType {
+
+    /**
+     *  To write the object information to channelBuffer.
+     *
+     *  @param cb of type channel buffer
+     */
+    @Override
+    int write(ChannelBuffer cb);
+
+    /**
+     * Returns class number.
+     *
+     * @return class number
+     */
+    byte getClassNum();
+
+    /**
+     * Returns class type.
+     *
+     * @return class type
+     */
+    byte getClassType();
+
+    @Override
+    String toString();
+
+}

+/*
+ * 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.types;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.protocol.PcepVersion;
+
+import com.google.common.base.MoreObjects;
+
+public class PcepRsvpIpv4ErrorSpec implements PcepRsvpErrorSpec {
+
+    /*
+       RSVP error spec object header.
+        0             1              2             3
+    +-------------+-------------+-------------+-------------+
+    |       Length (bytes)      |  Class-Num  |   C-Type    |
+    +-------------+-------------+-------------+-------------+
+    |                                                       |
+    //                  (Object contents)                   //
+    |                                                       |
+    +-------------+-------------+-------------+-------------+
+
+    Ref :  ERROR_SPEC @ RFC2205
+
+    IPv4 ERROR_SPEC object: Class = 6, C-Type = 1
+    +-------------+-------------+-------------+-------------+
+    |            IPv4 Error Node Address (4 bytes)          |
+    +-------------+-------------+-------------+-------------+
+    |    Flags    |  Error Code |        Error Value        |
+    +-------------+-------------+-------------+-------------+
+
+     */
+
+    PcepRsvpSpecObjHeader objHeader;
+    public static final byte CLASS_NUM = 0x06;
+    public static final byte CLASS_TYPE = 0x01;
+    public static final byte CLASS_LENGTH = 0x0c;
+    private int ipv4Addr;
+    private byte flags;
+    private byte errCode;
+    private short errValue;
+
+    /**
+     * Constructor to initialize obj header, ipv4 addr, flags, err code and err value.
+     *
+     * @param objHeader rsvp ipv4 error spec object header
+     * @param ipv4Addr ipv4 address
+     * @param flags flags value
+     * @param errCode error code value
+     * @param errValue error value
+     */
+    public PcepRsvpIpv4ErrorSpec(PcepRsvpSpecObjHeader objHeader, int ipv4Addr, byte flags, byte errCode,
+            short errValue) {
+        this.objHeader = objHeader;
+        this.ipv4Addr = ipv4Addr;
+        this.flags = flags;
+        this.errCode = errCode;
+        this.errValue = errValue;
+    }
+
+    /**
+     * Constructor to initialize ipv4 address, flags, err code and err value.
+     *
+     * @param ipv4Addr ipv4 address
+     * @param flags flags value
+     * @param errCode error code
+     * @param errValue error value
+     */
+    public PcepRsvpIpv4ErrorSpec(int ipv4Addr, byte flags, byte errCode, short errValue) {
+        this.objHeader = new PcepRsvpSpecObjHeader(CLASS_LENGTH, CLASS_NUM, CLASS_TYPE);
+        this.ipv4Addr = ipv4Addr;
+        this.flags = flags;
+        this.errCode = errCode;
+        this.errValue = errValue;
+    }
+
+    @Override
+    public int write(ChannelBuffer cb) {
+        int objLenIndex = objHeader.write(cb);
+        cb.writeInt(ipv4Addr);
+        cb.writeByte(flags);
+        cb.writeByte(errCode);
+        cb.writeShort(errValue);
+        short objLen = (short) (cb.writerIndex() - objLenIndex);
+        cb.setShort(objLenIndex, objLen);
+        return objLen;
+    }
+
+    /**
+     * Reads PCPE RSVP error spec from channel buffer and returns PCEP rsvp IPv4 error spec object.
+     *
+     * @param cb channel buffer
+     * @return PCEP rsvp IPv4 error spec object
+     */
+    public static PcepRsvpErrorSpec read(ChannelBuffer cb) {
+        PcepRsvpSpecObjHeader objHeader;
+        int ipv4Addr;
+        byte flags;
+        byte errCode;
+        short errValue;
+
+        objHeader = PcepRsvpSpecObjHeader.read(cb);
+        ipv4Addr = cb.readInt();
+        flags = cb.readByte();
+        errCode = cb.readByte();
+        errValue = cb.readShort();
+        return new PcepRsvpIpv4ErrorSpec(objHeader, ipv4Addr, flags, errCode, errValue);
+    }
+
+    @Override
+    public PcepVersion getVersion() {
+        return PcepVersion.PCEP_1;
+    }
+
+    @Override
+    public short getType() {
+        return StatefulRsvpErrorSpecTlv.TYPE;
+    }
+
+    @Override
+    public short getLength() {
+        return CLASS_LENGTH;
+    }
+
+    @Override
+    public byte getClassNum() {
+        return CLASS_NUM;
+    }
+
+    @Override
+    public byte getClassType() {
+        return CLASS_TYPE;
+    }
+
+    @Override
+    public void print() {
+        // TODO Auto-generated method stub
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("IPv4 Address:", ipv4Addr)
+                .add("flags:", flags)
+                .add("error Code:", errCode)
+                .add("error Value:", errValue)
+                .toString();
+    }
+}

+package org.onosproject.pcepio.types;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.protocol.PcepVersion;
+
+import com.google.common.base.MoreObjects;
+
+public class PcepRsvpIpv6ErrorSpec implements PcepRsvpErrorSpec {
+
+    /*
+        0             1              2             3
+    +-------------+-------------+-------------+-------------+
+    |       Length (bytes)      |  Class-Num  |   C-Type    |
+    +-------------+-------------+-------------+-------------+
+    |                                                       |
+    //                  (Object contents)                   //
+    |                                                       |
+    +-------------+-------------+-------------+-------------+
+
+    Ref :  ERROR_SPEC @ RFC2205
+
+    IPv6 ERROR_SPEC object: Class = 6, C-Type = 2
+    +-------------+-------------+-------------+-------------+
+    |                                                       |
+    +                                                       +
+    |                                                       |
+    +           IPv6 Error Node Address (16 bytes)          +
+    |                                                       |
+    +                                                       +
+    |                                                       |
+    +-------------+-------------+-------------+-------------+
+    |    Flags    |  Error Code |        Error Value        |
+    +-------------+-------------+-------------+-------------+     */
+
+    PcepRsvpSpecObjHeader objHeader;
+    public static final byte CLASS_NUM = 0x06;
+    public static final byte CLASS_TYPE = 0x02;
+    public static final byte CLASS_LENGTH = 0x18;
+    public static final byte IPV6_LEN = 0x10;
+
+    private byte[] ipv6Addr;
+    private byte flags;
+    private byte errCode;
+    private short errValue;
+
+    /**
+     * Constructor to initialize obj header, ipv6 addr, flags, err code and err value.
+     *
+     * @param objHeader rsvp ipv6 error spec object header
+     * @param ipv6Addr ipv6 address
+     * @param flags flags value
+     * @param errCode error code
+     * @param errValue error value
+     */
+    public PcepRsvpIpv6ErrorSpec(PcepRsvpSpecObjHeader objHeader, byte[] ipv6Addr, byte flags, byte errCode,
+            short errValue) {
+        this.objHeader = objHeader;
+        this.ipv6Addr = ipv6Addr;
+        this.flags = flags;
+        this.errCode = errCode;
+        this.errValue = errValue;
+    }
+
+    /**
+     * Constructor to initialize ipv6 addr, flags, err code and err value.
+     *
+     * @param ipv6Addr ipv6 address
+     * @param flags flags value
+     * @param errCode error code
+     * @param errValue error value
+     */
+    public PcepRsvpIpv6ErrorSpec(byte[] ipv6Addr, byte flags, byte errCode, short errValue) {
+        this.objHeader = new PcepRsvpSpecObjHeader(CLASS_LENGTH, CLASS_NUM, CLASS_TYPE);
+        this.ipv6Addr = ipv6Addr;
+        this.flags = flags;
+        this.errCode = errCode;
+        this.errValue = errValue;
+    }
+
+    @Override
+    public int write(ChannelBuffer cb) {
+        int objLenIndex = objHeader.write(cb);
+        cb.writeBytes(ipv6Addr);
+        cb.writeByte(flags);
+        cb.writeByte(errCode);
+        cb.writeShort(errValue);
+        short objLen = (short) (cb.writerIndex() - objLenIndex);
+        cb.setShort(objLenIndex, objLen);
+        return objLen;
+    }
+
+    /**
+     * Returns PCEP rsvp IPv6 error spce object.
+     *
+     * @param cb channel buffer
+     * @return PCEP rsvp IPv6 error spce object
+     */
+    public static PcepRsvpErrorSpec read(ChannelBuffer cb) {
+        PcepRsvpSpecObjHeader objHeader;
+        byte[] ipv6Addr = new byte[IPV6_LEN];
+        byte flags;
+        byte errCode;
+        short errValue;
+
+        objHeader = PcepRsvpSpecObjHeader.read(cb);
+        cb.readBytes(ipv6Addr, 0, IPV6_LEN);
+        flags = cb.readByte();
+        errCode = cb.readByte();
+        errValue = cb.readShort();
+        return new PcepRsvpIpv6ErrorSpec(objHeader, ipv6Addr, flags, errCode, errValue);
+    }
+
+    @Override
+    public PcepVersion getVersion() {
+        return PcepVersion.PCEP_1;
+    }
+
+    @Override
+    public short getType() {
+        return StatefulRsvpErrorSpecTlv.TYPE;
+    }
+
+    @Override
+    public short getLength() {
+        return CLASS_LENGTH;
+    }
+
+    @Override
+    public byte getClassNum() {
+        return CLASS_NUM;
+    }
+
+    @Override
+    public byte getClassType() {
+        return CLASS_TYPE;
+    }
+
+    @Override
+    public void print() {
+        // TODO Auto-generated method stub
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("IPv6 Address:", ipv6Addr)
+                .add("flags:", flags)
+                .add("error Code:", errCode)
+                .add("error Value:", errValue)
+                .toString();
+    }
+}

@@ -20,6 +20,8 @@ import org.jboss.netty.buffer.ChannelBuffer;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
 
 
+import com.google.common.base.MoreObjects;
+
 /**
 /**
  * Provides PcepRsvpObjectHeader.
  * Provides PcepRsvpObjectHeader.
  */
  */
@@ -36,7 +38,7 @@ public class PcepRsvpObjectHeader {
     +-------------+-------------+-------------+-------------+
     +-------------+-------------+-------------+-------------+
 
 
               ERROR_SPEC object Header
               ERROR_SPEC object Header
-    */
+     */
 
 
     protected static final Logger log = LoggerFactory.getLogger(PcepRsvpObjectHeader.class);
     protected static final Logger log = LoggerFactory.getLogger(PcepRsvpObjectHeader.class);
 
 
@@ -158,4 +160,13 @@ public class PcepRsvpObjectHeader {
         log.debug("Object C-Type: " + objClassType);
         log.debug("Object C-Type: " + objClassType);
         log.debug("Object Length: " + objLen);
         log.debug("Object Length: " + objLen);
     }
     }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("Object Class-Num: " , objClassNum)
+                .add("Object C-Type: " , objClassType)
+                .add("Object Length: " , objLen)
+                .toString();
+    }
 }
 }

+/*
+ * 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.types;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * Provides PcepRsvpObjectHeader.
+ */
+public class PcepRsvpSpecObjHeader {
+
+    /*
+    0             1              2             3
+    +-------------+-------------+-------------+-------------+
+    |       Length (bytes)      |  Class-Num  |   C-Type    |
+    +-------------+-------------+-------------+-------------+
+    |                                                       |
+    //                  (Object contents)                   //
+    |                                                       |
+    +-------------+-------------+-------------+-------------+
+
+              ERROR_SPEC object Header
+     */
+
+    protected static final Logger log = LoggerFactory.getLogger(PcepRsvpSpecObjHeader.class);
+
+    private short objLen;
+    private byte objClassNum;
+    private byte objClassType;
+
+    /**
+     * Constructor to initialize length, class num and type.
+     *
+     * @param objLen object length
+     * @param objClassNum pcep rsvp error spec object class num
+     * @param objClassType pcep rsvp error spec object class type
+     */
+    public PcepRsvpSpecObjHeader(short objLen, byte objClassNum, byte objClassType) {
+        this.objLen = objLen;
+        this.objClassNum = objClassNum;
+        this.objClassType = objClassType;
+    }
+
+    /**
+     * Sets the Class num.
+     *
+     * @param value pcep rsvp error spec object class num
+     */
+    public void setObjClassNum(byte value) {
+        this.objClassNum = value;
+    }
+
+    /**
+     * Sets the Class type.
+     *
+     * @param value pcep rsvp error spec object class type
+     */
+    public void setObjClassType(byte value) {
+        this.objClassType = value;
+    }
+
+    /**
+     * Sets the Class Length.
+     *
+     * @param value pcep rsvp error spec object length
+     */
+    public void setObjLen(short value) {
+        this.objLen = value;
+    }
+
+    /**
+     * Returns Object Length.
+     *
+     * @return objLen pcep rsvp error spec object length
+     */
+    public short getObjLen() {
+        return this.objLen;
+    }
+
+    /**
+     * Returns Object num.
+     *
+     * @return objClassNum pcep rsvp error spec object class num
+     */
+    public byte getObjClassNum() {
+        return this.objClassNum;
+    }
+
+    /**
+     * Returns Object type.
+     *
+     * @return objClassType pcep rsvp error spec object class type
+     */
+    public byte getObjClassType() {
+        return this.objClassType;
+    }
+
+    /**
+     * Writes the byte stream of PcepRsvpObjectHeader to channel buffer.
+     *
+     * @param bb of type channel buffer
+     * @return object length index
+     */
+    public int write(ChannelBuffer bb) {
+        int objLenIndex = bb.writerIndex();
+        bb.writeShort(objLen);
+        bb.writeByte(objClassNum);
+        bb.writeByte(objClassType);
+        return bb.writerIndex() - objLenIndex;
+    }
+
+    /**
+     * Reads the PcepRsvpObjectHeader.
+     *
+     * @param bb of type channel buffer
+     * @return PcepRsvpObjectHeader
+     */
+    public static PcepRsvpSpecObjHeader read(ChannelBuffer bb) {
+        byte objClassNum;
+        byte objClassType;
+        short objLen;
+        objLen = bb.readShort();
+        objClassNum = bb.readByte();
+        objClassType = bb.readByte();
+
+        return new PcepRsvpSpecObjHeader(objLen, objClassNum, objClassType);
+    }
+
+    /**
+     * Prints the attribute of PcepRsvpObjectHeader.
+     */
+    public void print() {
+
+        log.debug("PcepObjectHeader");
+        log.debug("Object Class-Num: " + objClassNum);
+        log.debug("Object C-Type: " + objClassType);
+        log.debug("Object Length: " + objLen);
+    }
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("Object Class-Num: " , objClassNum)
+                .add("Object C-Type: " , objClassType)
+                .add("Object Length: " , objLen)
+                .toString();
+    }
+}

+/*
+ * 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.types;
+
+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.PcepVersion;
+
+import com.google.common.base.MoreObjects;
+
+public class PcepRsvpUserErrorSpec implements PcepRsvpErrorSpec {
+
+    /*
+        RSVP error spec object header.
+        0             1              2             3
+    +-------------+-------------+-------------+-------------+
+    |       Length (bytes)      |  Class-Num  |   C-Type    |
+    +-------------+-------------+-------------+-------------+
+    |                                                       |
+    //                  (Object contents)                   //
+    |                                                       |
+    +-------------+-------------+-------------+-------------+
+
+    Ref : USER_ERROR_SPEC @ RFC5284.
+    USER_ERROR_SPEC object: Class = 194, C-Type = 1
+
+    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
+    +---------------+---------------+---------------+---------------+
+    |                       Enterprise Number                       |
+    +---------------+---------------+---------------+---------------+
+    |    Sub Org    |  Err Desc Len |        User Error Value       |
+    +---------------+---------------+---------------+---------------+
+    |                                                               |
+    ~                       Error Description                       ~
+    |                                                               |
+    +---------------+---------------+---------------+---------------+
+    |                                                               |
+    ~                     User-Defined Subobjects                   ~
+    |                                                               |
+    +---------------+---------------+---------------+---------------+
+     */
+
+    public static final byte CLASS_NUM = (byte) 0xc2;
+    public static final byte CLASS_TYPE = 0x01;
+
+    private PcepRsvpSpecObjHeader objHeader;
+    private int enterpriseNum;
+    private byte subOrg;
+    private byte errDescLen;
+    private short userErrorValue;
+    private byte[] errDesc;
+    private LinkedList<PcepValueType> llRsvpUserSpecSubObj;
+
+    /**
+     * Default constructor.
+     *
+     * @param objHeader pcep rsvp spec object header
+     * @param enterpriseNum enterprise number
+     * @param subOrg organization identifier value
+     * @param errDescLen error description length
+     * @param userErrorValue user error value
+     * @param errDesc error description
+     * @param llRsvpUserSpecSubObj list of subobjects
+     */
+    public PcepRsvpUserErrorSpec(PcepRsvpSpecObjHeader objHeader, int enterpriseNum, byte subOrg, byte errDescLen,
+            short userErrorValue, byte[] errDesc, LinkedList<PcepValueType> llRsvpUserSpecSubObj) {
+        this.objHeader = objHeader;
+        this.enterpriseNum = enterpriseNum;
+        this.subOrg = subOrg;
+        this.errDescLen = errDescLen;
+        this.userErrorValue = userErrorValue;
+        this.errDesc = errDesc;
+        this.llRsvpUserSpecSubObj = llRsvpUserSpecSubObj;
+    }
+
+    @Override
+    public int write(ChannelBuffer cb) {
+        int objLenIndex = objHeader.write(cb);
+        cb.writeInt(enterpriseNum);
+        cb.writeByte(subOrg);
+        cb.writeByte(errDescLen);
+        cb.writeShort(userErrorValue);
+        cb.writeBytes(errDesc);
+
+        if (null != llRsvpUserSpecSubObj) {
+
+            ListIterator<PcepValueType> listIterator = llRsvpUserSpecSubObj.listIterator();
+
+            while (listIterator.hasNext()) {
+                PcepValueType tlv = listIterator.next();
+                if (null == tlv) {
+                    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);
+                    }
+                }
+            }
+        }
+        short objLen = (short) (cb.writerIndex() - objLenIndex);
+        cb.setShort(objLenIndex, objLen);
+        return objLen;
+    }
+
+    /**
+     * Reads the channel buffer and returns object of PcepRsvpErrorSpec.
+     *
+     * @param cb of type channel buffer
+     * @return object of PcepRsvpErrorSpec
+     * @throws PcepParseException when expected object is not received
+     */
+    public static PcepRsvpErrorSpec read(ChannelBuffer cb) throws PcepParseException {
+        PcepRsvpSpecObjHeader objHeader;
+        int enterpriseNum;
+        byte subOrg;
+        byte errDescLen;
+        short userErrorValue;
+        byte[] errDesc;
+        LinkedList<PcepValueType> llRsvpUserSpecSubObj = null;
+
+        objHeader = PcepRsvpSpecObjHeader.read(cb);
+
+        if (CLASS_NUM != objHeader.getObjClassNum() || CLASS_TYPE != objHeader.getObjClassType()) {
+            throw new PcepParseException("Expected PcepRsvpUserErrorSpec object.");
+        }
+        enterpriseNum = cb.readInt();
+        subOrg = cb.readByte();
+        errDescLen = cb.readByte();
+        userErrorValue = cb.readShort();
+        errDesc = new byte[errDescLen];
+        cb.readBytes(errDesc, 0, errDescLen);
+
+        llRsvpUserSpecSubObj = parseErrSpecSubObj(cb);
+
+        return new PcepRsvpUserErrorSpec(objHeader, enterpriseNum, subOrg, errDescLen, userErrorValue, errDesc,
+                llRsvpUserSpecSubObj);
+    }
+
+    private static LinkedList<PcepValueType> parseErrSpecSubObj(ChannelBuffer cb) throws PcepParseException {
+        LinkedList<PcepValueType> llRsvpUserSpecSubObj = new LinkedList<PcepValueType>();
+        while (0 < cb.readableBytes()) {
+            PcepValueType tlv = null;
+            short hType = cb.readShort();
+            int iValue = 0;
+            //short hLength = cb.readShort();
+            switch (hType) {
+            case AutonomousSystemTlv.TYPE:
+                iValue = cb.readInt();
+                tlv = new AutonomousSystemTlv(iValue);
+                break;
+            default:
+                throw new PcepParseException("Unsupported Sub TLV type :" + hType);
+            }
+            llRsvpUserSpecSubObj.add(tlv);
+        }
+        return llRsvpUserSpecSubObj;
+    }
+
+    @Override
+    public PcepVersion getVersion() {
+        return PcepVersion.PCEP_1;
+    }
+
+    @Override
+    public short getType() {
+        return StatefulRsvpErrorSpecTlv.TYPE;
+    }
+
+    @Override
+    public short getLength() {
+        return objHeader.getObjLen();
+    }
+
+    @Override
+    public byte getClassNum() {
+        return CLASS_NUM;
+    }
+
+    @Override
+    public byte getClassType() {
+        return CLASS_TYPE;
+    }
+
+    @Override
+    public void print() {
+        // TODO Auto-generated method stub
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("enterprise Number:", enterpriseNum)
+                .add("sub Organization:", subOrg)
+                .add("err Desc Length:", errDescLen)
+                .add("user Error Value:", userErrorValue)
+                .add("err Desc:", errDesc)
+                .add("Rsvp User Spec Sub Object:", llRsvpUserSpecSubObj)
+                .toString();
+    }
+}

+/*
+ * 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.types;
+
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.protocol.PcepVersion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * Provides StatefulIPv4LspIdentidiersTlv.
+ */
+public class StatefulIPv4LspIdentidiersTlv implements PcepValueType {
+
+    /*             IPV4-LSP-IDENTIFIERS TLV format
+     *
+     * Reference :PCEP Extensions for Stateful PCE draft-ietf-pce-stateful-pce-10
+     *
+
+    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
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    |           Type=18             |           Length=16           |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    |                   IPv4 Tunnel Sender Address                  |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    |             LSP ID            |           Tunnel ID           |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    |                        Extended Tunnel ID                     |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    |               IPv4 Tunnel Endpoint Address                    |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+     */
+    protected static final Logger log = LoggerFactory.getLogger(StatefulIPv4LspIdentidiersTlv.class);
+
+    public static final short TYPE = 18;
+    public static final short LENGTH = 16;
+    public static final int VALUE_LENGTH = 16;
+    private final int ipv4IngressAddress;
+    private final short lspId;
+    private final short tunnelId;
+    private final int extendedTunnelId;
+    private final int ipv4EgressAddress;
+
+    /**
+     * Constructor to initialize member variables.
+     *
+     * @param ipv4IngressAddress ingress ipv4 address
+     * @param lspId lsp id
+     * @param tunnelId tunnel id
+     * @param extendedTunnelId extended tunnel id
+     * @param ipv4EgressAddress egress ipv4 address
+     */
+    public StatefulIPv4LspIdentidiersTlv(int ipv4IngressAddress, short lspId, short tunnelId, int extendedTunnelId,
+            int ipv4EgressAddress) {
+
+        this.ipv4IngressAddress = ipv4IngressAddress;
+        this.lspId = lspId;
+        this.tunnelId = tunnelId;
+        this.extendedTunnelId = extendedTunnelId;
+        this.ipv4EgressAddress = ipv4EgressAddress;
+    }
+
+    /**
+     * Creates object of StatefulIPv4LspIdentidiersTlv.
+     *
+     * @param ipv4IngressAddress ingress ipv4 address
+     * @param lspId lsp id
+     * @param tunnelId tunnel id
+     * @param extendedTunnelId extended tunnel id
+     * @param ipv4EgressAddress egress ipv4 address
+     * @return object of StatefulIPv4LspIdentidiersTlv
+     */
+    public static StatefulIPv4LspIdentidiersTlv of(int ipv4IngressAddress, short lspId, short tunnelId,
+            int extendedTunnelId, int ipv4EgressAddress) {
+        return new StatefulIPv4LspIdentidiersTlv(ipv4IngressAddress, lspId, tunnelId, extendedTunnelId,
+                ipv4EgressAddress);
+    }
+
+    /**
+     * Returns tunnel id.
+     *
+     * @return tunnelId
+     */
+    public short getTunnelId() {
+        return this.tunnelId;
+    }
+
+    /**
+     * Returns extendedTunnelId.
+     *
+     * @return extendedTunnelId
+     */
+    public int getextendedTunnelId() {
+        return this.extendedTunnelId;
+    }
+
+    @Override
+    public PcepVersion getVersion() {
+        return PcepVersion.PCEP_1;
+    }
+
+    /**
+     * Returns ipv4IngressAddress.
+     *
+     * @return ipv4IngressAddress
+     */
+    public int getIpv4IngressAddress() {
+        return ipv4IngressAddress;
+    }
+
+    /**
+     * Returns ipv4EgressAddress.
+     *
+     * @return ipv4EgressAddress
+     */
+    public int getIpv4EgressAddress() {
+        return ipv4EgressAddress;
+    }
+
+    @Override
+    public short getType() {
+        return TYPE;
+    }
+
+    @Override
+    public short getLength() {
+        return LENGTH;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(ipv4IngressAddress, lspId, tunnelId, extendedTunnelId, ipv4EgressAddress);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof StatefulIPv4LspIdentidiersTlv) {
+            StatefulIPv4LspIdentidiersTlv other = (StatefulIPv4LspIdentidiersTlv) obj;
+            return Objects.equals(this.ipv4IngressAddress, other.ipv4IngressAddress)
+                    && Objects.equals(this.lspId, other.lspId) && Objects.equals(this.tunnelId, other.tunnelId)
+                    && Objects.equals(this.extendedTunnelId, other.extendedTunnelId)
+                    && Objects.equals(this.ipv4EgressAddress, other.ipv4EgressAddress);
+        }
+        return false;
+    }
+
+    @Override
+    public int write(ChannelBuffer c) {
+        int iLenStartIndex = c.writerIndex();
+        c.writeShort(TYPE);
+        c.writeShort(LENGTH);
+        c.writeInt(ipv4IngressAddress);
+        c.writeShort(lspId);
+        c.writeShort(tunnelId);
+        c.writeInt(extendedTunnelId);
+        c.writeInt(ipv4EgressAddress);
+
+        return c.writerIndex() - iLenStartIndex;
+    }
+
+    /**
+     * Reads the channel buffer and returns object of StatefulIPv4LspIdentidiersTlv.
+     *
+     * @param c of type channel buffer
+     * @return object of StatefulIPv4LspIdentidiersTlv
+     */
+    public static PcepValueType read(ChannelBuffer c) {
+        int ipv4IngressAddress = c.readInt();
+        short lspId = c.readShort();
+        short tunnelId = c.readShort();
+        int extendedTunnelId = c.readInt();
+        int ipv4EgressAddress = c.readInt();
+        return new StatefulIPv4LspIdentidiersTlv(ipv4IngressAddress, lspId, tunnelId, extendedTunnelId,
+                ipv4EgressAddress);
+    }
+
+    @Override
+    public void print() {
+
+        log.debug("StatefulIPv4LspIdentidiersTlv");
+        log.debug("Type: " + TYPE);
+        log.debug("Length: " + LENGTH);
+        log.debug("Ipv4IngressAddress: " + ipv4IngressAddress);
+        log.debug("LspId: " + lspId);
+        log.debug("TunnelId: " + tunnelId);
+        log.debug("ExtendedTunnelId: " + extendedTunnelId);
+        log.debug("Ipv4EgressAddress: " + ipv4EgressAddress);
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass())
+                .add("Type:", TYPE)
+                .add("Length:", LENGTH)
+                .add("Ipv4IngressAddress:", ipv4IngressAddress)
+                .add("LspId:", lspId)
+                .add("TunnelId:", tunnelId)
+                .add("ExtendedTunnelId:", extendedTunnelId)
+                .add("Ipv4EgressAddress:", ipv4EgressAddress)
+                .toString();
+    }
+}

+/*
+ * 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.types;
+
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.protocol.PcepVersion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * Provides StatefulLspErrorCodeTlv.
+ */
+public class StatefulLspErrorCodeTlv implements PcepValueType {
+
+    /*                  LSP-ERROR-CODE TLV format
+     *
+     * Reference :PCEP Extensions for Stateful PCE draft-ietf-pce-stateful-pce-10
+     *
+
+    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
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    |           Type=20             |            Length=4           |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    |                          LSP Error Code                       |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+     */
+
+    protected static final Logger log = LoggerFactory.getLogger(StatefulLspErrorCodeTlv.class);
+
+    public static final short TYPE = 20;
+    public static final short LENGTH = 4;
+    private final int rawValue;
+
+    /**
+     * Constructor to initialize raw Value.
+     *
+     * @param rawValue lsp error code value
+     */
+    public StatefulLspErrorCodeTlv(int rawValue) {
+        this.rawValue = rawValue;
+    }
+
+    /**
+     * Creates object of StatefulLspErrorCodeTlv.
+     *
+     * @param raw lsp error code value
+     * @return object of StatefulLspErrorCodeTlv
+     */
+    public static StatefulLspErrorCodeTlv of(int raw) {
+        return new StatefulLspErrorCodeTlv(raw);
+    }
+
+    @Override
+    public PcepVersion getVersion() {
+        return PcepVersion.PCEP_1;
+    }
+
+    /**
+     * Returns lsp error code value.
+     *
+     * @return lsp error code value
+     */
+    public int getInt() {
+        return rawValue;
+    }
+
+    @Override
+    public short getLength() {
+        return LENGTH;
+    }
+
+    @Override
+    public short getType() {
+        return TYPE;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(rawValue);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof StatefulLspErrorCodeTlv) {
+            StatefulLspErrorCodeTlv other = (StatefulLspErrorCodeTlv) obj;
+            return Objects.equals(this.rawValue, other.rawValue);
+        }
+        return false;
+    }
+
+    @Override
+    public int write(ChannelBuffer c) {
+        int iLenStartIndex = c.writerIndex();
+        c.writeShort(TYPE);
+        c.writeShort(LENGTH);
+        c.writeInt(rawValue);
+        return c.writerIndex() - iLenStartIndex;
+    }
+
+    /**
+     * Reads the channel buffer and returns object of StatefulLspErrorCodeTlv.
+     *
+     * @param c of type channel buffer
+     * @return object of StatefulLspErrorCodeTlv
+     */
+    public static StatefulLspErrorCodeTlv read(ChannelBuffer c) {
+        return StatefulLspErrorCodeTlv.of(c.readInt());
+    }
+
+    @Override
+    public void print() {
+
+        log.debug("StatefulLspErrorCodeTlv");
+        log.debug("Type: " + TYPE);
+        log.debug("Length: " + LENGTH);
+        log.debug("Value: " + rawValue);
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass()).add("Type", TYPE).add("Length", LENGTH).add("Value", rawValue)
+                .toString();
+    }
+
+}

+/*
+ * 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.types;
+
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.exceptions.PcepParseException;
+import org.onosproject.pcepio.protocol.PcepVersion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.MoreObjects.ToStringHelper;
+
+/**
+ * Provides StatefulRsvpErrorSpecTlv.
+ */
+public class StatefulRsvpErrorSpecTlv implements PcepValueType {
+
+    protected static final Logger log = LoggerFactory.getLogger(StatefulRsvpErrorSpecTlv.class);
+
+    /*                  RSVP-ERROR-SPEC TLV format
+     * Reference :PCEP Extensions for Stateful PCE draft-ietf-pce-stateful-pce-10
+     *
+     *
+
+    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
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    |           Type=21             |            Length (variable)  |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    |                                                               |
+    +                RSVP ERROR_SPEC or USER_ERROR_SPEC Object      +
+    |                                                               |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+        0             1              2             3
+    +-------------+-------------+-------------+-------------+
+    |       Length (bytes)      |  Class-Num  |   C-Type    |
+    +-------------+-------------+-------------+-------------+
+    |                                                       |
+    //                  (Object contents)                   //
+    |                                                       |
+    +-------------+-------------+-------------+-------------+
+
+    Ref :  ERROR_SPEC @ RFC2205
+
+    IPv4 ERROR_SPEC object: Class = 6, C-Type = 1
+    +-------------+-------------+-------------+-------------+
+    |            IPv4 Error Node Address (4 bytes)          |
+    +-------------+-------------+-------------+-------------+
+    |    Flags    |  Error Code |        Error Value        |
+    +-------------+-------------+-------------+-------------+
+
+
+    IPv6 ERROR_SPEC object: Class = 6, C-Type = 2
+    +-------------+-------------+-------------+-------------+
+    |                                                       |
+    +                                                       +
+    |                                                       |
+    +           IPv6 Error Node Address (16 bytes)          +
+    |                                                       |
+    +                                                       +
+    |                                                       |
+    +-------------+-------------+-------------+-------------+
+    |    Flags    |  Error Code |        Error Value        |
+    +-------------+-------------+-------------+-------------+
+
+
+    Ref : USER_ERROR_SPEC @ RFC5284
+    USER_ERROR_SPEC object: Class = 194, C-Type = 1
+    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
+    +---------------+---------------+---------------+---------------+
+    |                       Enterprise Number                       |
+    +---------------+---------------+---------------+---------------+
+    |    Sub Org    |  Err Desc Len |        User Error Value       |
+    +---------------+---------------+---------------+---------------+
+    |                                                               |
+    ~                       Error Description                       ~
+    |                                                               |
+    +---------------+---------------+---------------+---------------+
+    |                                                               |
+    ~                     User-Defined Subobjects                   ~
+    |                                                               |
+    +---------------+---------------+---------------+---------------+
+
+     */
+
+    public static final short TYPE = 21;
+    public static final int OBJECT_HEADER_LENGTH = 4;
+    private final short hLength;
+
+    private final PcepRsvpErrorSpec rsvpErrSpecObj;
+    private final boolean isErrSpceObjSet;
+
+    /**
+     * Constructor to initialize errSpecObj.
+     *
+     * @param rsvpErrSpecObj Rsvp error spec object
+     * @param hLength length of rsvp error spec object
+     */
+    public StatefulRsvpErrorSpecTlv(PcepRsvpErrorSpec rsvpErrSpecObj, short hLength) {
+        this.rsvpErrSpecObj = rsvpErrSpecObj;
+        this.isErrSpceObjSet = true;
+        this.hLength = hLength;
+    }
+
+    /**
+     * Returns PcepRsvpErrorSpecObject.
+     *
+     * @return rsvpErrSpecObj
+     */
+    public PcepRsvpErrorSpec getPcepRsvpErrorSpec() {
+        return this.rsvpErrSpecObj;
+    }
+
+    @Override
+    public PcepVersion getVersion() {
+        return PcepVersion.PCEP_1;
+    }
+
+    @Override
+    public short getType() {
+        return TYPE;
+    }
+
+    @Override
+    public short getLength() {
+        return hLength;
+    }
+
+    /**
+     * Reads channel buffer and returns object of StatefulRsvpErrorSpecTlv.
+     *
+     * @param cb of type channel buffer
+     * @return object of StatefulRsvpErrorSpecTlv
+     */
+    public static PcepValueType read(ChannelBuffer cb) throws PcepParseException {
+
+        PcepRsvpErrorSpec rsvpErrSpecObj = null;
+        PcepRsvpSpecObjHeader rsvpErrSpecObjHeader;
+
+        cb.markReaderIndex();
+        rsvpErrSpecObjHeader = PcepRsvpSpecObjHeader.read(cb);
+        cb.resetReaderIndex();
+
+        if (PcepRsvpIpv4ErrorSpec.CLASS_NUM == rsvpErrSpecObjHeader.getObjClassNum()
+                && PcepRsvpIpv4ErrorSpec.CLASS_TYPE == rsvpErrSpecObjHeader.getObjClassType()) {
+            rsvpErrSpecObj = PcepRsvpIpv4ErrorSpec.read(cb);
+        } else if (PcepRsvpIpv6ErrorSpec.CLASS_NUM == rsvpErrSpecObjHeader.getObjClassNum()
+                && PcepRsvpIpv6ErrorSpec.CLASS_TYPE == rsvpErrSpecObjHeader.getObjClassType()) {
+            rsvpErrSpecObj = PcepRsvpIpv6ErrorSpec.read(cb);
+        } else if (PcepRsvpUserErrorSpec.CLASS_NUM == rsvpErrSpecObjHeader.getObjClassNum()
+                && PcepRsvpUserErrorSpec.CLASS_TYPE == rsvpErrSpecObjHeader.getObjClassType()) {
+            rsvpErrSpecObj = PcepRsvpUserErrorSpec.read(cb);
+        }
+        return rsvpErrSpecObj;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(rsvpErrSpecObj.hashCode());
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof StatefulRsvpErrorSpecTlv) {
+            StatefulRsvpErrorSpecTlv other = (StatefulRsvpErrorSpecTlv) obj;
+            return Objects.equals(this.rsvpErrSpecObj, other.rsvpErrSpecObj);
+        }
+        return false;
+    }
+
+    @Override
+    public int write(ChannelBuffer c) {
+        int iStartIndex = c.writerIndex();
+        c.writeShort(TYPE);
+        int tlvLenIndex = c.writerIndex();
+        c.writeShort(hLength);
+        if (isErrSpceObjSet) {
+            rsvpErrSpecObj.write(c);
+        }
+        short tlvLen = (short) (c.writerIndex() - iStartIndex + 4);
+        c.setShort(tlvLenIndex, tlvLen);
+
+        return tlvLen;
+    }
+
+    @Override
+    public void print() {
+
+        log.debug("StatefulRsvpErrorSpecTlv");
+        log.debug("Type: " + TYPE);
+        log.debug("Length: " + hLength);
+        if (isErrSpceObjSet) {
+            rsvpErrSpecObj.print();
+        }
+    }
+
+    @Override
+    public String toString() {
+        ToStringHelper toStrHelper = MoreObjects.toStringHelper(getClass());
+
+        if (!isErrSpceObjSet) {
+            toStrHelper
+            .add("Type", TYPE)
+            .add("Length", hLength);
+        } else {
+            toStrHelper
+            .add("Type", TYPE)
+            .add("Length", hLength)
+            .add("RSVP Error Spec Object", rsvpErrSpecObj);
+        }
+        return toStrHelper.toString();
+    }
+}

+/*
+ * 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.types;
+
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.pcepio.protocol.PcepVersion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * Provides SymbolicPathNameTlv.
+ */
+public class SymbolicPathNameTlv implements PcepValueType {
+
+    /*
+     *    SYMBOLIC-PATH-NAME TLV format
+     *    Reference :PCEP Extensions for Stateful PCE draft-ietf-pce-stateful-pce-10
+     *
+         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
+         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         |           Type=17             |       Length (variable)       |
+         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         |                                                               |
+         //                      Symbolic Path Name                     //
+         |                                                               |
+         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+     */
+    protected static final Logger log = LoggerFactory.getLogger(SymbolicPathNameTlv.class);
+
+    public static final short TYPE = 17;
+    private short hLength;
+
+    private final byte[] rawValue;
+
+    /**
+     * Constructor to initialize raw Value.
+     *
+     * @param rawValue Symbolic path name
+     */
+    public SymbolicPathNameTlv(byte[] rawValue) {
+        this.rawValue = rawValue;
+        this.hLength = (short) rawValue.length;
+    }
+
+    /**
+     * Constructor to initialize raw Value.
+     *
+     * @param rawValue Symbolic path name
+     * @param hLength length of Symbolic path name
+     */
+    public SymbolicPathNameTlv(byte[] rawValue, short hLength) {
+        this.rawValue = rawValue;
+        if (0 == hLength) {
+            this.hLength = (short) rawValue.length;
+        } else {
+            this.hLength = hLength;
+        }
+    }
+
+    /**
+     * Creates an object of SymbolicPathNameTlv.
+     *
+     * @param raw Symbolic path name
+     * @param hLength length of Symbolic path name
+     * @return object of SymbolicPathNameTlv
+     */
+    public static SymbolicPathNameTlv of(final byte[] raw, short hLength) {
+        return new SymbolicPathNameTlv(raw, hLength);
+    }
+
+    /**
+     * Returns Symbolic path name.
+     *
+     * @return Symbolic path name byte array
+     */
+    public byte[] getValue() {
+        return rawValue;
+    }
+
+    @Override
+    public PcepVersion getVersion() {
+        return PcepVersion.PCEP_1;
+    }
+
+    @Override
+    public short getType() {
+        return TYPE;
+    }
+
+    @Override
+    public short getLength() {
+        return hLength;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(rawValue);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof SymbolicPathNameTlv) {
+            SymbolicPathNameTlv other = (SymbolicPathNameTlv) obj;
+            return Objects.equals(this.rawValue, other.rawValue);
+        }
+        return false;
+    }
+
+    @Override
+    public int write(ChannelBuffer c) {
+        int iLenStartIndex = c.writerIndex();
+        c.writeShort(TYPE);
+        c.writeShort(hLength);
+        c.writeBytes(rawValue);
+        return c.writerIndex() - iLenStartIndex;
+    }
+
+    /**
+     * Reads channel buffer and returns object of SymbolicPathNameTlv.
+     *
+     * @param c of type channel buffer
+     * @param hLength length of bytes to read
+     * @return object of SymbolicPathNameTlv
+     */
+    public static SymbolicPathNameTlv read(ChannelBuffer c, short hLength) {
+        byte[] symbolicPathName = new byte[hLength];
+        c.readBytes(symbolicPathName, 0, hLength);
+        return new SymbolicPathNameTlv(symbolicPathName, hLength);
+    }
+
+    @Override
+    public void print() {
+        log.debug("SymbolicPathNameTlv");
+        log.debug("Type: " + TYPE);
+        log.debug("Length: " + hLength);
+        log.debug("Symbolic Path Name : " + rawValue);
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(getClass()).add("Symbolic Path Name ", rawValue).toString();
+    }
+}

+/*
+ * Copyright 2014-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;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.jboss.netty.buffer.ChannelBuffers;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+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.protocol.PcepCloseMsg;
+
+import java.util.Arrays;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class PcepCloseMsgTest {
+    protected static final Logger log = LoggerFactory.getLogger(PcepCloseMsgTest.class);
+
+    @Before
+    public void startUp() {
+    }
+
+    @After
+    public void tearDown() {
+
+    }
+
+    @Test
+    public void closeMessageTest1() throws PcepParseException {
+        byte[] closeMsg = new byte[] {0x20, 0x07, 0x00, 0x0C, /* common header */
+                0x0f, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02 };
+
+        byte[] testCloseMsg = {0};
+        ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+        buffer.writeBytes(closeMsg);
+
+        PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
+        PcepMessage message = null;
+        try {
+            message = reader.readFrom(buffer);
+        } catch (PcepParseException e) {
+            e.printStackTrace();
+        }
+
+        if (message instanceof PcepCloseMsg) {
+            ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
+            message.writeTo(buf);
+            testCloseMsg = buf.array();
+
+            int iReadLen = buf.writerIndex() - 0;
+            testCloseMsg = new byte[iReadLen];
+            buf.readBytes(testCloseMsg, 0, iReadLen);
+            if (Arrays.equals(closeMsg, testCloseMsg)) {
+                Assert.assertArrayEquals(closeMsg, testCloseMsg);
+                log.debug("CloseMsg are equal :" + closeMsg);
+            } else {
+                Assert.fail("test case failed");
+                log.debug("not equal");
+            }
+        } else {
+            Assert.fail("test case failed");
+            log.debug("not equal");
+        }
+    }
+}