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