diff --git a/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorVer1.java b/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorVer1.java
index 0ea5141..1c5bf63 100644
--- a/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorVer1.java
+++ b/protocols/pcep/pcepio/src/main/java/org/onosproject/pcepio/protocol/ver1/PcepErrorVer1.java
@@ -16,6 +16,7 @@
 package org.onosproject.pcepio.protocol.ver1;
 
 import java.util.LinkedList;
+import java.util.List;
 import java.util.ListIterator;
 
 import org.jboss.netty.buffer.ChannelBuffer;
@@ -23,7 +24,7 @@
 import org.onosproject.pcepio.protocol.PcepError;
 import org.onosproject.pcepio.protocol.PcepErrorObject;
 import org.onosproject.pcepio.protocol.PcepRPObject;
-import org.onosproject.pcepio.protocol.PcepTEObject;
+import org.onosproject.pcepio.protocol.PcepLSObject;
 import org.onosproject.pcepio.types.PcepObjectHeader;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -31,30 +32,30 @@
 import com.google.common.base.MoreObjects;
 
 /**
- * Provides PcepError list which contains RP or TE objects.
- * Reference:PCEP Extension for Transporting TE Data draft-dhodylee-pce-pcep-te-data-extn-02.
+ * Provides PcepError list which contains RP or LS objects.
+ * Reference: draft-dhodylee-pce-pcep-ls-01, section 8.2.
  */
 public class PcepErrorVer1 implements PcepError {
 
     /*
-           <error>::=[<request-id-list> | <te-id-list>]
+           <error>::=[<request-id-list> | <ls-id-list>]
                       <error-obj-list>
 
            <request-id-list>::=<RP>[<request-id-list>]
 
-           <te-id-list>::=<TE>[<te-id-list>]
+           <ls-id-list>::=<LS>[<ls-id-list>]
      */
 
     protected static final Logger log = LoggerFactory.getLogger(PcepErrorVer1.class);
 
     private boolean isErroInfoSet;
     //PcepErrorObject list
-    private LinkedList<PcepErrorObject> llErrObjList;
+    private List<PcepErrorObject> errObjList;
     //PcepRPObject list
-    private LinkedList<PcepRPObject> llRPObjList;
-    //PcepTEObject list
-    private LinkedList<PcepTEObject> llTEObjList;
-    private boolean isTEObjListSet;
+    private List<PcepRPObject> rpObjList;
+    //PcepLSObject list
+    private List<PcepLSObject> lsObjList;
+    private boolean isLSObjListSet;
 
     public static final int OBJECT_HEADER_LENGTH = 4;
 
@@ -62,49 +63,49 @@
      * Constructor to initialize variable.
      */
     public PcepErrorVer1() {
-        this.llRPObjList = null;
-        this.llTEObjList = null;
-        this.llErrObjList = null;
+        this.rpObjList = null;
+        this.lsObjList = null;
+        this.errObjList = null;
     }
 
     /**
      * Constructor to initialize variable.
      *
-     * @param llRPObjList list of PcepRPObject
-     * @param llTEObjList list of PcepTEObject
-     * @param llErrObjListObjList list of PcepErrorObject
+     * @param rpObjList list of PcepRPObject
+     * @param lsObjList list of PcepLSObject
+     * @param errObjListObjList list of PcepErrorObject
      */
-    public PcepErrorVer1(LinkedList<PcepRPObject> llRPObjList, LinkedList<PcepTEObject> llTEObjList,
-            LinkedList<PcepErrorObject> llErrObjListObjList) {
-        this.llRPObjList = llRPObjList;
-        this.llTEObjList = llTEObjList;
-        this.llErrObjList = llErrObjListObjList;
+    public PcepErrorVer1(List<PcepRPObject> rpObjList, List<PcepLSObject> lsObjList,
+            List<PcepErrorObject> errObjListObjList) {
+        this.rpObjList = rpObjList;
+        this.lsObjList = lsObjList;
+        this.errObjList = errObjListObjList;
     }
 
     /**
      * Constructor to initialize PcepError.
      *
-     * @param llErrObjList list of PcepErrorObject
+     * @param errObjList list of PcepErrorObject
      */
-    public PcepErrorVer1(LinkedList<PcepErrorObject> llErrObjList) {
-        this.llRPObjList = null;
-        this.llTEObjList = null;
-        this.llErrObjList = llErrObjList;
+    public PcepErrorVer1(List<PcepErrorObject> errObjList) {
+        this.rpObjList = null;
+        this.lsObjList = null;
+        this.errObjList = errObjList;
     }
 
     @Override
-    public LinkedList<PcepRPObject> getRPObjList() {
-        return this.llRPObjList;
+    public List<PcepRPObject> getRPObjList() {
+        return this.rpObjList;
     }
 
     @Override
-    public LinkedList<PcepTEObject> getTEObjList() {
-        return this.llTEObjList;
+    public List<PcepLSObject> getLSObjList() {
+        return this.lsObjList;
     }
 
     @Override
-    public LinkedList<PcepErrorObject> getErrorObjList() {
-        return this.llErrObjList;
+    public List<PcepErrorObject> getErrorObjList() {
+        return this.errObjList;
     }
 
     /**
@@ -117,7 +118,7 @@
         byte yObjClass;
         byte yObjType;
 
-        llRPObjList = new LinkedList<>();
+        rpObjList = new LinkedList<>();
 
         // caller should verify for RP object
         if (cb.readableBytes() < OBJECT_HEADER_LENGTH) {
@@ -133,7 +134,7 @@
         PcepRPObject rpObj;
         while ((yObjClass == PcepRPObjectVer1.RP_OBJ_CLASS) && (yObjType == PcepRPObjectVer1.RP_OBJ_TYPE)) {
             rpObj = PcepRPObjectVer1.read(cb);
-            llRPObjList.add(rpObj);
+            rpObjList.add(rpObj);
 
             if (cb.readableBytes() > OBJECT_HEADER_LENGTH) {
                 cb.markReaderIndex();
@@ -148,20 +149,20 @@
     }
 
     /**
-     * Parse TE List from the channel buffer.
+     * Parse LS List from the channel buffer.
      *
      * @param cb of type channel buffer
      * @throws PcepParseException if mandatory fields are missing
      */
-    public void parseTEList(ChannelBuffer cb) throws PcepParseException {
+    public void parseLSList(ChannelBuffer cb) throws PcepParseException {
         byte yObjClass;
         byte yObjType;
 
-        llTEObjList = new LinkedList<>();
+        lsObjList = new LinkedList<>();
 
-        // caller should verify for TE object
+        // caller should verify for LS object
         if (cb.readableBytes() < OBJECT_HEADER_LENGTH) {
-            log.debug("Unable to find TE Object");
+            log.debug("Unable to find LS Object");
             return;
         }
 
@@ -170,11 +171,11 @@
         cb.resetReaderIndex();
         yObjClass = tempObjHeader.getObjClass();
         yObjType = tempObjHeader.getObjType();
-        PcepTEObject teObj;
-        while ((yObjClass == PcepTEObjectVer1.TE_OBJ_CLASS) && ((yObjType == PcepTEObjectVer1.TE_OBJ_TYPE_NODE_VALUE)
-                || (yObjType == PcepTEObjectVer1.TE_OBJ_TYPE_LINK_VALUE))) {
-            teObj = PcepTEObjectVer1.read(cb);
-            llTEObjList.add(teObj);
+        PcepLSObject lsObj;
+        while ((yObjClass == PcepLSObjectVer1.LS_OBJ_CLASS) && ((yObjType == PcepLSObjectVer1.LS_OBJ_TYPE_NODE_VALUE)
+                || (yObjType == PcepLSObjectVer1.LS_OBJ_TYPE_LINK_VALUE))) {
+            lsObj = PcepLSObjectVer1.read(cb);
+            lsObjList.add(lsObj);
 
             if (cb.readableBytes() > OBJECT_HEADER_LENGTH) {
                 cb.markReaderIndex();
@@ -199,7 +200,7 @@
         byte yObjType;
         boolean bIsErrorObjFound = false;
 
-        llErrObjList = new LinkedList<>();
+        errObjList = new LinkedList<>();
 
         // caller should verify for RP object
         if (cb.readableBytes() < OBJECT_HEADER_LENGTH) {
@@ -214,7 +215,7 @@
         PcepErrorObject errorObject;
         while ((yObjClass == PcepErrorObjectVer1.ERROR_OBJ_CLASS) && (yObjType == PcepErrorObjectVer1.ERROR_OBJ_TYPE)) {
             errorObject = PcepErrorObjectVer1.read(cb);
-            llErrObjList.add(errorObject);
+            errObjList.add(errorObject);
             bIsErrorObjFound = true;
 
             if (cb.readableBytes() > OBJECT_HEADER_LENGTH) {
@@ -252,14 +253,14 @@
         cb.resetReaderIndex();
         byte yObjClass = tempObjHeader.getObjClass();
 
-        //If RPlist present then store it.RPList and TEList are optional
+        //If RPlist present then store it.RPList and LSList are optional
         if (yObjClass == PcepRPObjectVer1.RP_OBJ_CLASS) {
             log.debug("RP_LIST");
             pcepError.parseRPList(cb);
             yObjClass = checkNextObject(cb);
-        } else if (yObjClass == PcepTEObjectVer1.TE_OBJ_CLASS) {
-            log.debug("TE_LIST");
-            pcepError.parseTEList(cb);
+        } else if (yObjClass == PcepLSObjectVer1.LS_OBJ_CLASS) {
+            log.debug("LS_LIST");
+            pcepError.parseLSList(cb);
             yObjClass = checkNextObject(cb);
         }
 
@@ -301,21 +302,21 @@
 
         // RPlist is optional
         if (this.isErroInfoSet) {
-            ListIterator<PcepRPObject> rpObjlistIterator = this.llRPObjList.listIterator();
+            ListIterator<PcepRPObject> rpObjlistIterator = this.rpObjList.listIterator();
             while (rpObjlistIterator.hasNext()) {
                 rpObjlistIterator.next().write(cb);
             }
         }
 
-        // TElist is optional
-        if (this.isTEObjListSet) {
-            ListIterator<PcepTEObject> teObjlistIterator = this.llTEObjList.listIterator();
+        // LSlist is optional
+        if (this.isLSObjListSet) {
+            ListIterator<PcepLSObject> teObjlistIterator = this.lsObjList.listIterator();
             while (teObjlistIterator.hasNext()) {
                 teObjlistIterator.next().write(cb);
             }
         }
         //ErrList is mandatory
-        ListIterator<PcepErrorObject> errlistIterator = this.llErrObjList.listIterator();
+        ListIterator<PcepErrorObject> errlistIterator = this.errObjList.listIterator();
         while (errlistIterator.hasNext()) {
             errlistIterator.next().write(cb);
         }
@@ -328,72 +329,72 @@
      */
     public static class Builder implements PcepError.Builder {
 
-        private LinkedList<PcepRPObject> llRPObjList;
-        private LinkedList<PcepTEObject> llTEObjList;
-        private LinkedList<PcepErrorObject> llErrObjList;
+        private List<PcepRPObject> rpObjList;
+        private List<PcepLSObject> lsObjList;
+        private List<PcepErrorObject> errObjList;
 
         @Override
         public PcepError build() {
-            return new PcepErrorVer1(llRPObjList, llTEObjList, llErrObjList);
+            return new PcepErrorVer1(rpObjList, lsObjList, errObjList);
         }
 
         @Override
-        public LinkedList<PcepRPObject> getRPObjList() {
-            return this.llRPObjList;
+        public List<PcepRPObject> getRPObjList() {
+            return this.rpObjList;
         }
 
         @Override
-        public Builder setRPObjList(LinkedList<PcepRPObject> llRPObjList) {
-            this.llRPObjList = llRPObjList;
+        public Builder setRPObjList(List<PcepRPObject> rpObjList) {
+            this.rpObjList = rpObjList;
             return this;
         }
 
         @Override
-        public LinkedList<PcepTEObject> getTEObjList() {
-            return this.llTEObjList;
+        public List<PcepLSObject> getLSObjList() {
+            return this.lsObjList;
         }
 
         @Override
-        public Builder setTEObjList(LinkedList<PcepTEObject> llTEObjList) {
-            this.llTEObjList = llTEObjList;
+        public Builder setLSObjList(List<PcepLSObject> lsObjList) {
+            this.lsObjList = lsObjList;
             return this;
         }
 
         @Override
-        public LinkedList<PcepErrorObject> getErrorObjList() {
-            return this.llErrObjList;
+        public List<PcepErrorObject> getErrorObjList() {
+            return this.errObjList;
         }
 
         @Override
-        public Builder setErrorObjList(LinkedList<PcepErrorObject> llErrObjList) {
-            this.llErrObjList = llErrObjList;
+        public Builder setErrorObjList(List<PcepErrorObject> errObjList) {
+            this.errObjList = errObjList;
             return this;
         }
 
     }
 
     @Override
-    public void setRPObjList(LinkedList<PcepRPObject> llRPObjList) {
-        this.llRPObjList = llRPObjList;
+    public void setRPObjList(List<PcepRPObject> rpObjList) {
+        this.rpObjList = rpObjList;
     }
 
     @Override
-    public void setTEObjList(LinkedList<PcepTEObject> llTEObjList) {
-        this.llTEObjList = llTEObjList;
+    public void setLSObjList(List<PcepLSObject> lsObjList) {
+        this.lsObjList = lsObjList;
     }
 
     @Override
-    public void setErrorObjList(LinkedList<PcepErrorObject> llErrObjList) {
-        this.llErrObjList = llErrObjList;
+    public void setErrorObjList(List<PcepErrorObject> errObjList) {
+        this.errObjList = errObjList;
     }
 
     @Override
     public String toString() {
         return MoreObjects.toStringHelper(getClass())
                 .omitNullValues()
-                .add("RpObjectList", llRPObjList)
-                .add("TeObjectList", llTEObjList)
-                .add("ErrorObjectList", llErrObjList)
+                .add("RpObjectList", rpObjList)
+                .add("LsObjectList", lsObjList)
+                .add("ErrorObjectList", errObjList)
                 .toString();
     }
 }