diff --git a/protocols/isis/isisio/src/main/java/org/onosproject/isis/io/isispacket/tlv/AreaAddressTlv.java b/protocols/isis/isisio/src/main/java/org/onosproject/isis/io/isispacket/tlv/AreaAddressTlv.java
old mode 100755
new mode 100644
index add4127..bc24910
--- a/protocols/isis/isisio/src/main/java/org/onosproject/isis/io/isispacket/tlv/AreaAddressTlv.java
+++ b/protocols/isis/isisio/src/main/java/org/onosproject/isis/io/isispacket/tlv/AreaAddressTlv.java
@@ -13,52 +13,58 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package org.onosproject.isis.io.isispacket.tlv;
 
 import com.google.common.base.MoreObjects;
 import com.google.common.primitives.Bytes;
-import io.netty.buffer.ByteBuf;
+import org.jboss.netty.buffer.ChannelBuffer;
 import org.onosproject.isis.io.util.IsisUtil;
 
 import java.util.ArrayList;
 import java.util.List;
 
 /**
- * Represents the area address TLV.
+ * Representation of area address TLV.
  */
 public class AreaAddressTlv extends TlvHeader implements IsisTlv {
 
-    private List<String> areaAddress = new ArrayList();
+    private List<String> areaAddress = new ArrayList<>();
 
     /**
-     * Sets TLV type and TLV length of area address TLV.
+     * Creates an instance of area address TLV.
      *
-     * @param tlvHeader tlvHeader.
+     * @param tlvHeader tlvHeader
      */
     public AreaAddressTlv(TlvHeader tlvHeader) {
-
         this.setTlvType(tlvHeader.tlvType());
         this.setTlvLength(tlvHeader.tlvLength());
-
     }
 
     /**
-     * Gets the area address of area address TLV.
+     * Adds the area address to the area address TLV.
      *
-     * @return area address
+     * @param areaAddress area address
+     */
+    public void addAddress(String areaAddress) {
+        this.areaAddress.add(areaAddress);
+    }
+
+    /**
+     * Returns the area address of area address TLV.
+     *
+     * @return areaAddress area address
      */
     public List<String> areaAddress() {
         return this.areaAddress;
     }
 
     @Override
-    public void readFrom(ByteBuf byteBuf) {
-        while (byteBuf.readableBytes() > 0) {
-            int addressLength = byteBuf.readByte();
-            byte[] addressBytes = new byte[IsisUtil.THREE_BYTES];
-            byteBuf.readBytes(addressBytes, 0, IsisUtil.THREE_BYTES);
-            String areaAddress = IsisUtil.areaAddres(addressBytes);
+    public void readFrom(ChannelBuffer channelBuffer) {
+        while (channelBuffer.readableBytes() > 0) {
+            int addressLength = channelBuffer.readByte();
+            byte[] addressbytes = new byte[addressLength];
+            channelBuffer.readBytes(addressbytes, 0, addressLength);
+            String areaAddress = IsisUtil.areaAddres(addressbytes);
             this.areaAddress.add(areaAddress);
         }
     }
@@ -66,38 +72,32 @@
     @Override
     public byte[] asBytes() {
         byte[] bytes = null;
-
         byte[] tlvHeader = tlvHeaderAsByteArray();
         byte[] tlvBody = tlvBodyAsBytes();
+        tlvHeader[1] = (byte) tlvBody.length;
         bytes = Bytes.concat(tlvHeader, tlvBody);
-
         return bytes;
     }
 
     /**
-     * Gets TLV body of area address TLV.
+     * Returns TLV body of area address TLV.
      *
      * @return byteArray TLV body of area address TLV
      */
-    public byte[] tlvBodyAsBytes() {
-
-        List<Byte> bytes = new ArrayList();
+    private byte[] tlvBodyAsBytes() {
+        List<Byte> bytes = new ArrayList<>();
         for (String areaAddress : this.areaAddress) {
             bytes.add((byte) (areaAddress.length() / 2));
-            bytes.addAll(IsisUtil.areaAddresToBytes(areaAddress));
+            bytes.addAll(IsisUtil.areaAddressToBytes(areaAddress));
         }
-        byte[] byteArray = new byte[bytes.size()];
-        int i = 0;
-        for (byte byt : bytes) {
-            byteArray[i++] = byt;
-        }
-        return byteArray;
+        return Bytes.toArray(bytes);
     }
 
     @Override
     public String toString() {
         return MoreObjects.toStringHelper(getClass())
                 .omitNullValues()
+                .add("areaAddress", areaAddress)
                 .toString();
     }
 }
\ No newline at end of file
