diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/AbstractLispRecord.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/AbstractLispRecord.java
new file mode 100644
index 0000000..3126cc8
--- /dev/null
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/AbstractLispRecord.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2017-present 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.lisp.msg.protocols;
+
+import org.onosproject.lisp.msg.types.LispAfiAddress;
+
+/**
+ * Abstract LISP record class that provide default implementations.
+ */
+public abstract class AbstractLispRecord implements LispRecord {
+
+    protected final int recordTtl;
+    protected final byte maskLength;
+    protected final LispMapReplyAction action;
+    protected final boolean authoritative;
+    protected final short mapVersionNumber;
+    protected final LispAfiAddress eidPrefixAfi;
+
+    protected AbstractLispRecord(int recordTtl, byte maskLength,
+                                 LispMapReplyAction action, boolean authoritative,
+                                 short mapVersionNumber, LispAfiAddress eidPrefixAfi) {
+        this.recordTtl = recordTtl;
+        this.maskLength = maskLength;
+        this.action = action;
+        this.authoritative = authoritative;
+        this.mapVersionNumber = mapVersionNumber;
+        this.eidPrefixAfi = eidPrefixAfi;
+    }
+
+    @Override
+    public int getRecordTtl() {
+        return recordTtl;
+    }
+
+    @Override
+    public byte getMaskLength() {
+        return maskLength;
+    }
+
+    @Override
+    public LispMapReplyAction getAction() {
+        return action;
+    }
+
+    @Override
+    public boolean isAuthoritative() {
+        return authoritative;
+    }
+
+    @Override
+    public short getMapVersionNumber() {
+        return mapVersionNumber;
+    }
+
+    @Override
+    public LispAfiAddress getEidPrefixAfi() {
+        return eidPrefixAfi;
+    }
+
+    public static class AbstractRecordBuilder<T> implements RecordBuilder<T> {
+
+        protected int recordTtl;
+        protected byte maskLength;
+        protected LispMapReplyAction action;
+        protected boolean authoritative;
+        protected short mapVersionNumber;
+        protected LispAfiAddress eidPrefixAfi;
+
+        @Override
+        public T withRecordTtl(int recordTtl) {
+            this.recordTtl = recordTtl;
+            return (T) this;
+        }
+
+        @Override
+        public T withMaskLength(byte maskLength) {
+            this.maskLength = maskLength;
+            return (T) this;
+        }
+
+        @Override
+        public T withAction(LispMapReplyAction action) {
+            this.action = action;
+            return (T) this;
+        }
+
+        @Override
+        public T withIsAuthoritative(boolean authoritative) {
+            this.authoritative = authoritative;
+            return (T) this;
+        }
+
+        @Override
+        public T withMapVersionNumber(short mapVersionNumber) {
+            this.mapVersionNumber = mapVersionNumber;
+            return (T) this;
+        }
+
+        @Override
+        public T withEidPrefixAfi(LispAfiAddress prefix) {
+            this.eidPrefixAfi = prefix;
+            return (T) this;
+        }
+    }
+}
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispGenericLocator.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispGenericLocator.java
new file mode 100644
index 0000000..2936b4b
--- /dev/null
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispGenericLocator.java
@@ -0,0 +1,314 @@
+/*
+ * Copyright 2017-present 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.lisp.msg.protocols;
+
+import com.google.common.base.Objects;
+import io.netty.buffer.ByteBuf;
+import org.onlab.util.ByteOperator;
+import org.onosproject.lisp.msg.exceptions.LispParseError;
+import org.onosproject.lisp.msg.exceptions.LispReaderException;
+import org.onosproject.lisp.msg.exceptions.LispWriterException;
+import org.onosproject.lisp.msg.types.LispAfiAddress;
+import org.onosproject.lisp.msg.types.LispAfiAddress.AfiAddressWriter;
+
+import static com.google.common.base.MoreObjects.toStringHelper;
+
+/**
+ * A default implementation class of LISP generic locator interface.
+ */
+public class DefaultLispGenericLocator implements LispGenericLocator {
+
+    protected final byte priority;
+    protected final byte weight;
+    protected final byte multicastPriority;
+    protected final byte multicastWeight;
+    protected final boolean localLocator;
+    protected final boolean rlocProbed;
+    protected final boolean routed;
+    protected final LispAfiAddress locatorAfi;
+
+    private static final int LOCAL_LOCATOR_SHIFT_BIT = 2;
+    private static final int PROBED_SHIFT_BIT = 1;
+
+    private static final int ENABLE_BIT = 1;
+    private static final int DISABLE_BIT = 0;
+
+    private static final int SKIP_UNUSED_FLAG_LENGTH = 1;
+    private static final int LOCAL_LOCATOR_INDEX = 2;
+    private static final int RLOC_PROBED_INDEX = 1;
+    private static final int ROUTED_INDEX = 0;
+
+    /**
+     * A private constructor that protects object instantiation from external.
+     *
+     * @param priority          uni-cast priority
+     * @param weight            uni-cast weight
+     * @param multicastPriority multi-cast priority
+     * @param multicastWeight   multi-cast weight
+     * @param localLocator      local locator flag
+     * @param rlocProbed        RLOC probed flag
+     * @param routed            routed flag
+     * @param locatorAfi        locator AFI
+     */
+    protected DefaultLispGenericLocator(byte priority, byte weight,
+                                        byte multicastPriority,
+                                        byte multicastWeight,
+                                        boolean localLocator, boolean rlocProbed,
+                                        boolean routed, LispAfiAddress locatorAfi) {
+        this.priority = priority;
+        this.weight = weight;
+        this.multicastPriority = multicastPriority;
+        this.multicastWeight = multicastWeight;
+        this.localLocator = localLocator;
+        this.rlocProbed = rlocProbed;
+        this.routed = routed;
+        this.locatorAfi = locatorAfi;
+    }
+
+    @Override
+    public byte getPriority() {
+        return priority;
+    }
+
+    @Override
+    public byte getWeight() {
+        return weight;
+    }
+
+    @Override
+    public byte getMulticastPriority() {
+        return multicastPriority;
+    }
+
+    @Override
+    public byte getMulticastWeight() {
+        return multicastWeight;
+    }
+
+    @Override
+    public boolean isLocalLocator() {
+        return localLocator;
+    }
+
+    @Override
+    public boolean isRlocProbed() {
+        return rlocProbed;
+    }
+
+    @Override
+    public boolean isRouted() {
+        return routed;
+    }
+
+    @Override
+    public LispAfiAddress getLocatorAfi() {
+        return locatorAfi;
+    }
+
+    @Override
+    public void writeTo(ByteBuf byteBuf) throws LispWriterException {
+    }
+
+    @Override
+    public String toString() {
+        return toStringHelper(this)
+                .add("priority", priority)
+                .add("weight", weight)
+                .add("multi-cast priority", multicastPriority)
+                .add("multi-cast weight", multicastWeight)
+                .add("local locator", localLocator)
+                .add("RLOC probed", rlocProbed)
+                .add("routed", routed)
+                .add("locator AFI", locatorAfi).toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        DefaultLispGenericLocator that = (DefaultLispGenericLocator) o;
+        return Objects.equal(priority, that.priority) &&
+                Objects.equal(weight, that.weight) &&
+                Objects.equal(multicastPriority, that.multicastPriority) &&
+                Objects.equal(multicastWeight, that.multicastWeight) &&
+                Objects.equal(localLocator, that.localLocator) &&
+                Objects.equal(rlocProbed, that.rlocProbed) &&
+                Objects.equal(routed, that.routed) &&
+                Objects.equal(locatorAfi, that.locatorAfi);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(priority, weight, multicastPriority,
+                multicastWeight, localLocator, rlocProbed, routed, locatorAfi);
+    }
+
+    public abstract static class AbstractGenericLocatorBuilder<T>
+            implements GenericLocatorBuilder<T> {
+        protected byte priority;
+        protected byte weight;
+        protected byte multicastPriority;
+        protected byte multicastWeight;
+        protected boolean localLocator;
+        protected boolean rlocProbed;
+        protected boolean routed;
+        protected LispAfiAddress locatorAfi;
+
+        @Override
+        public T withPriority(byte priority) {
+            this.priority = priority;
+            return (T) this;
+        }
+
+        @Override
+        public T withWeight(byte weight) {
+            this.weight = weight;
+            return (T) this;
+        }
+
+        @Override
+        public T withMulticastPriority(byte priority) {
+            this.multicastPriority = priority;
+            return (T) this;
+        }
+
+        @Override
+        public T withMulticastWeight(byte weight) {
+            this.multicastWeight = weight;
+            return (T) this;
+        }
+
+        @Override
+        public T withLocalLocator(boolean localLocator) {
+            this.localLocator = localLocator;
+            return (T) this;
+        }
+
+        @Override
+        public T withRlocProbed(boolean rlocProbed) {
+            this.rlocProbed = rlocProbed;
+            return (T) this;
+        }
+
+        @Override
+        public T withRouted(boolean routed) {
+            this.routed = routed;
+            return (T) this;
+        }
+
+        @Override
+        public T withLocatorAfi(LispAfiAddress locatorAfi) {
+            this.locatorAfi = locatorAfi;
+            return (T) this;
+        }
+    }
+
+    /**
+     * Deserializes LispGenericLocator message portion.
+     *
+     * @param byteBuf byte buffer
+     * @return LispGenericLocator
+     * @throws LispParseError      LISP message parse error
+     * @throws LispReaderException LISP message reader exception
+     */
+    public static LispGenericLocator deserialize(ByteBuf byteBuf)
+            throws LispParseError,
+            LispReaderException {
+        // priority -> 8 bits
+        byte priority = (byte) byteBuf.readUnsignedByte();
+
+        // weight -> 8 bits
+        byte weight = (byte) byteBuf.readUnsignedByte();
+
+        // multi-cast priority -> 8 bits
+        byte multicastPriority = (byte) byteBuf.readUnsignedByte();
+
+        // multi-cast weight -> 8 bits
+        byte multicastWeight = (byte) byteBuf.readUnsignedByte();
+
+        // let's skip unused flags
+        byteBuf.skipBytes(SKIP_UNUSED_FLAG_LENGTH);
+
+        byte flags = byteBuf.readByte();
+
+        // local locator flag -> 1 bit
+        boolean localLocator = ByteOperator.getBit(flags, LOCAL_LOCATOR_INDEX);
+
+        // rloc probe flag -> 1 bit
+        boolean rlocProbed = ByteOperator.getBit(flags, RLOC_PROBED_INDEX);
+
+        // routed flag -> 1 bit
+        boolean routed = ByteOperator.getBit(flags, ROUTED_INDEX);
+
+        LispAfiAddress address = new LispAfiAddress.AfiAddressReader().readFrom(byteBuf);
+
+        return new DefaultLispGenericLocator(priority, weight, multicastPriority,
+                multicastWeight, localLocator, rlocProbed, routed, address);
+    }
+
+    /**
+     * Serializes LispGenericLocator message portion.
+     *
+     * @param byteBuf        byte buffer
+     * @param genericLocator generic locator
+     * @throws LispWriterException LISP message writer exception
+     */
+    public static void serialize(ByteBuf byteBuf, LispGenericLocator genericLocator)
+            throws LispWriterException {
+        // priority
+        byteBuf.writeByte(genericLocator.getPriority());
+
+        // weight
+        byteBuf.writeByte(genericLocator.getWeight());
+
+        // multicast priority
+        byteBuf.writeByte(genericLocator.getMulticastPriority());
+
+        // multicast weight
+        byteBuf.writeByte(genericLocator.getMulticastWeight());
+
+        // unused flags
+        byteBuf.writeByte((short) 0);
+
+        // localLocator flag
+        short localLocator = DISABLE_BIT;
+        if (genericLocator.isLocalLocator()) {
+            localLocator = (byte) (ENABLE_BIT << LOCAL_LOCATOR_SHIFT_BIT);
+        }
+
+        // rlocProbed flag
+        short probed = DISABLE_BIT;
+        if (genericLocator.isRlocProbed()) {
+            probed = (byte) (ENABLE_BIT << PROBED_SHIFT_BIT);
+        }
+
+        // routed flag
+        short routed = DISABLE_BIT;
+        if (genericLocator.isRouted()) {
+            routed = (byte) ENABLE_BIT;
+        }
+
+        byteBuf.writeByte((byte) (localLocator + probed + routed));
+
+        // EID prefix AFI with EID prefix
+        AfiAddressWriter afiAddressWriter = new AfiAddressWriter();
+        afiAddressWriter.writeTo(byteBuf, genericLocator.getLocatorAfi());
+    }
+}
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispInfoRequest.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispInfoRequest.java
index 13e36a0..1a29579 100644
--- a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispInfoRequest.java
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispInfoRequest.java
@@ -40,7 +40,7 @@
         implements LispInfoRequest {
 
     private static final Logger log =
-            LoggerFactory.getLogger(DefaultLispInfoRequest.class);
+                         LoggerFactory.getLogger(DefaultLispInfoRequest.class);
 
     static final InfoRequestWriter WRITER;
 
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispLocator.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispLocator.java
new file mode 100644
index 0000000..abaefce
--- /dev/null
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispLocator.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2016-present 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.lisp.msg.protocols;
+
+import io.netty.buffer.ByteBuf;
+import org.onosproject.lisp.msg.exceptions.LispParseError;
+import org.onosproject.lisp.msg.exceptions.LispReaderException;
+import org.onosproject.lisp.msg.exceptions.LispWriterException;
+import org.onosproject.lisp.msg.types.LispAfiAddress;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Default implementation of LispLocator.
+ */
+public final class DefaultLispLocator extends DefaultLispGenericLocator
+                                                        implements LispLocator {
+
+    static final LocatorWriter WRITER;
+    static {
+        WRITER = new LocatorWriter();
+    }
+
+    /**
+     * A private constructor that protects object instantiation from external.
+     *
+     * @param priority          uni-cast priority
+     * @param weight            uni-cast weight
+     * @param multicastPriority multi-cast priority
+     * @param multicastWeight   multi-cast weight
+     * @param localLocator      local locator flag
+     * @param rlocProbed        RLOC probed flag
+     * @param routed            routed flag
+     * @param locatorAfi        locator AFI
+     */
+    private DefaultLispLocator(byte priority, byte weight, byte multicastPriority,
+                               byte multicastWeight, boolean localLocator,
+                               boolean rlocProbed, boolean routed,
+                               LispAfiAddress locatorAfi) {
+        super(priority, weight, multicastPriority, multicastWeight,
+                                localLocator, rlocProbed, routed, locatorAfi);
+    }
+
+    @Override
+    public void writeTo(ByteBuf byteBuf) throws LispWriterException {
+        WRITER.writeTo(byteBuf, this);
+    }
+
+    public static final class DefaultLocatorBuilder
+                                extends AbstractGenericLocatorBuilder<LocatorBuilder>
+                                        implements LocatorBuilder {
+
+        @Override
+        public LispLocator build() {
+
+            checkNotNull(locatorAfi, "Must specify a locator address");
+
+            return new DefaultLispLocator(priority, weight, multicastPriority,
+                    multicastWeight, localLocator, rlocProbed, routed, locatorAfi);
+        }
+    }
+
+    /**
+     * A LISP message reader for Locator portion.
+     */
+    public static final class LocatorReader
+                                    implements LispMessageReader<LispLocator> {
+        @Override
+        public LispLocator readFrom(ByteBuf byteBuf) throws LispParseError,
+                                                            LispReaderException {
+            LispGenericLocator gl = deserialize(byteBuf);
+
+            return new DefaultLocatorBuilder()
+                            .withPriority(gl.getPriority())
+                            .withWeight(gl.getWeight())
+                            .withMulticastPriority(gl.getMulticastPriority())
+                            .withMulticastWeight(gl.getMulticastWeight())
+                            .withLocalLocator(gl.isLocalLocator())
+                            .withRouted(gl.isRouted())
+                            .withLocatorAfi(gl.getLocatorAfi()).build();
+        }
+    }
+
+    /**
+     * A LISP message writer for Locator portion.
+     */
+    public static final class LocatorWriter
+                                    implements LispMessageWriter<LispLocator> {
+
+        @Override
+        public void writeTo(ByteBuf byteBuf, LispLocator message)
+                                                    throws LispWriterException {
+
+            serialize(byteBuf, message);
+        }
+    }
+}
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispLocatorRecord.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispLocatorRecord.java
deleted file mode 100644
index e7e63fb..0000000
--- a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispLocatorRecord.java
+++ /dev/null
@@ -1,335 +0,0 @@
-/*
- * Copyright 2016-present 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.lisp.msg.protocols;
-
-import com.google.common.base.Objects;
-import io.netty.buffer.ByteBuf;
-import org.onlab.util.ByteOperator;
-import org.onosproject.lisp.msg.exceptions.LispParseError;
-import org.onosproject.lisp.msg.exceptions.LispReaderException;
-import org.onosproject.lisp.msg.exceptions.LispWriterException;
-import org.onosproject.lisp.msg.types.LispAfiAddress;
-import org.onosproject.lisp.msg.types.LispAfiAddress.AfiAddressReader;
-import org.onosproject.lisp.msg.types.LispAfiAddress.AfiAddressWriter;
-
-import static com.google.common.base.MoreObjects.toStringHelper;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * Default implementation of LispLocatorRecord.
- */
-public final class DefaultLispLocatorRecord implements LispLocatorRecord {
-
-    private final byte priority;
-    private final byte weight;
-    private final byte multicastPriority;
-    private final byte multicastWeight;
-    private final boolean localLocator;
-    private final boolean rlocProbed;
-    private final boolean routed;
-    private final LispAfiAddress locatorAfi;
-
-    static final LocatorRecordWriter WRITER;
-    static {
-        WRITER = new LocatorRecordWriter();
-    }
-
-    /**
-     * A private constructor that protects object instantiation from external.
-     *
-     * @param priority          uni-cast priority
-     * @param weight            uni-cast weight
-     * @param multicastPriority multi-cast priority
-     * @param multicastWeight   multi-cast weight
-     * @param localLocator      local locator flag
-     * @param rlocProbed        RLOC probed flag
-     * @param routed            routed flag
-     * @param locatorAfi        locator AFI
-     */
-    private DefaultLispLocatorRecord(byte priority, byte weight, byte multicastPriority,
-                                     byte multicastWeight, boolean localLocator, boolean rlocProbed,
-                                     boolean routed, LispAfiAddress locatorAfi) {
-        this.priority = priority;
-        this.weight = weight;
-        this.multicastPriority = multicastPriority;
-        this.multicastWeight = multicastWeight;
-        this.localLocator = localLocator;
-        this.rlocProbed = rlocProbed;
-        this.routed = routed;
-        this.locatorAfi = locatorAfi;
-    }
-
-    @Override
-    public byte getPriority() {
-        return priority;
-    }
-
-    @Override
-    public byte getWeight() {
-        return weight;
-    }
-
-    @Override
-    public byte getMulticastPriority() {
-        return multicastPriority;
-    }
-
-    @Override
-    public byte getMulticastWeight() {
-        return multicastWeight;
-    }
-
-    @Override
-    public boolean isLocalLocator() {
-        return localLocator;
-    }
-
-    @Override
-    public boolean isRlocProbed() {
-        return rlocProbed;
-    }
-
-    @Override
-    public boolean isRouted() {
-        return routed;
-    }
-
-    @Override
-    public LispAfiAddress getLocatorAfi() {
-        return locatorAfi;
-    }
-
-    @Override
-    public void writeTo(ByteBuf byteBuf) throws LispWriterException {
-        WRITER.writeTo(byteBuf, this);
-    }
-
-    @Override
-    public String toString() {
-        return toStringHelper(this)
-                .add("priority", priority)
-                .add("weight", weight)
-                .add("multi-cast priority", multicastPriority)
-                .add("multi-cast weight", multicastWeight)
-                .add("local locator", localLocator)
-                .add("RLOC probed", rlocProbed)
-                .add("routed", routed)
-                .add("locator AFI", locatorAfi).toString();
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) {
-            return true;
-        }
-        if (o == null || getClass() != o.getClass()) {
-            return false;
-        }
-        DefaultLispLocatorRecord that = (DefaultLispLocatorRecord) o;
-        return Objects.equal(priority, that.priority) &&
-                Objects.equal(weight, that.weight) &&
-                Objects.equal(multicastPriority, that.multicastPriority) &&
-                Objects.equal(multicastWeight, that.multicastWeight) &&
-                Objects.equal(localLocator, that.localLocator) &&
-                Objects.equal(rlocProbed, that.rlocProbed) &&
-                Objects.equal(routed, that.routed) &&
-                Objects.equal(locatorAfi, that.locatorAfi);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hashCode(priority, weight, multicastPriority,
-                multicastWeight, localLocator, rlocProbed, routed, locatorAfi);
-    }
-
-    public static final class DefaultLocatorRecordBuilder implements LocatorRecordBuilder {
-
-        private byte priority;
-        private byte weight;
-        private byte multicastPriority;
-        private byte multicastWeight;
-        private boolean localLocator;
-        private boolean rlocProbed;
-        private boolean routed;
-        private LispAfiAddress locatorAfi;
-
-        @Override
-        public LocatorRecordBuilder withPriority(byte priority) {
-            this.priority = priority;
-            return this;
-        }
-
-        @Override
-        public LocatorRecordBuilder withWeight(byte weight) {
-            this.weight = weight;
-            return this;
-        }
-
-        @Override
-        public LocatorRecordBuilder withMulticastPriority(byte priority) {
-            this.multicastPriority = priority;
-            return this;
-        }
-
-        @Override
-        public LocatorRecordBuilder withMulticastWeight(byte weight) {
-            this.multicastWeight = weight;
-            return this;
-        }
-
-        @Override
-        public LocatorRecordBuilder withLocalLocator(boolean localLocator) {
-            this.localLocator = localLocator;
-            return this;
-        }
-
-        @Override
-        public LocatorRecordBuilder withRlocProbed(boolean rlocProbed) {
-            this.rlocProbed = rlocProbed;
-            return this;
-        }
-
-        @Override
-        public LocatorRecordBuilder withRouted(boolean routed) {
-            this.routed = routed;
-            return this;
-        }
-
-        @Override
-        public LocatorRecordBuilder withLocatorAfi(LispAfiAddress locatorAfi) {
-            this.locatorAfi = locatorAfi;
-            return this;
-        }
-
-        @Override
-        public LispLocatorRecord build() {
-
-            checkNotNull(locatorAfi, "Must specify a locator address");
-
-            return new DefaultLispLocatorRecord(priority, weight, multicastPriority,
-                    multicastWeight, localLocator, rlocProbed, routed, locatorAfi);
-        }
-    }
-
-    /**
-     * A LISP message reader for LocatorRecord portion.
-     */
-    public static final class LocatorRecordReader implements LispMessageReader<LispLocatorRecord> {
-
-        private static final int SKIP_UNUSED_FLAG_LENGTH = 1;
-        private static final int LOCAL_LOCATOR_INDEX = 2;
-        private static final int RLOC_PROBED_INDEX = 1;
-        private static final int ROUTED_INDEX = 0;
-
-        @Override
-        public LispLocatorRecord readFrom(ByteBuf byteBuf) throws LispParseError, LispReaderException {
-
-            // priority -> 8 bits
-            byte priority = (byte) byteBuf.readUnsignedByte();
-
-            // weight -> 8 bits
-            byte weight = (byte) byteBuf.readUnsignedByte();
-
-            // multi-cast priority -> 8 bits
-            byte multicastPriority = (byte) byteBuf.readUnsignedByte();
-
-            // multi-cast weight -> 8 bits
-            byte multicastWeight = (byte) byteBuf.readUnsignedByte();
-
-            // let's skip unused flags
-            byteBuf.skipBytes(SKIP_UNUSED_FLAG_LENGTH);
-
-            byte flags = byteBuf.readByte();
-
-            // local locator flag -> 1 bit
-            boolean localLocator = ByteOperator.getBit(flags, LOCAL_LOCATOR_INDEX);
-
-            // rloc probe flag -> 1 bit
-            boolean rlocProbed = ByteOperator.getBit(flags, RLOC_PROBED_INDEX);
-
-            // routed flag -> 1 bit
-            boolean routed = ByteOperator.getBit(flags, ROUTED_INDEX);
-
-            LispAfiAddress address = new AfiAddressReader().readFrom(byteBuf);
-
-            return new DefaultLocatorRecordBuilder()
-                        .withPriority(priority)
-                        .withWeight(weight)
-                        .withMulticastPriority(multicastPriority)
-                        .withMulticastWeight(multicastWeight)
-                        .withLocalLocator(localLocator)
-                        .withRlocProbed(rlocProbed)
-                        .withRouted(routed)
-                        .withLocatorAfi(address)
-                        .build();
-        }
-    }
-
-    /**
-     * A LISP message writer for LocatorRecord portion.
-     */
-    public static final class LocatorRecordWriter implements LispMessageWriter<LispLocatorRecord> {
-
-        private static final int LOCAL_LOCATOR_SHIFT_BIT = 2;
-        private static final int PROBED_SHIFT_BIT = 1;
-
-        private static final int ENABLE_BIT = 1;
-        private static final int DISABLE_BIT = 0;
-
-        @Override
-        public void writeTo(ByteBuf byteBuf, LispLocatorRecord message) throws LispWriterException {
-
-            // priority
-            byteBuf.writeByte(message.getPriority());
-
-            // weight
-            byteBuf.writeByte(message.getWeight());
-
-            // multicast priority
-            byteBuf.writeByte(message.getMulticastPriority());
-
-            // multicast weight
-            byteBuf.writeByte(message.getMulticastWeight());
-
-            // unused flags
-            byteBuf.writeByte((short) 0);
-
-            // localLocator flag
-            short localLocator = DISABLE_BIT;
-            if (message.isLocalLocator()) {
-                localLocator = (byte) (ENABLE_BIT << LOCAL_LOCATOR_SHIFT_BIT);
-            }
-
-            // rlocProbed flag
-            short probed = DISABLE_BIT;
-            if (message.isRlocProbed()) {
-                probed = (byte) (ENABLE_BIT << PROBED_SHIFT_BIT);
-            }
-
-            // routed flag
-            short routed = DISABLE_BIT;
-            if (message.isRouted()) {
-                routed = (byte) ENABLE_BIT;
-            }
-
-            byteBuf.writeByte((byte) (localLocator + probed + routed));
-
-            // EID prefix AFI with EID prefix
-            AfiAddressWriter afiAddressWriter = new AfiAddressWriter();
-            afiAddressWriter.writeTo(byteBuf, message.getLocatorAfi());
-        }
-    }
-}
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispMapRecord.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispMapRecord.java
index ced7306..5d2257a 100644
--- a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispMapRecord.java
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispMapRecord.java
@@ -21,7 +21,8 @@
 import io.netty.buffer.ByteBuf;
 import org.onlab.util.ByteOperator;
 import org.onosproject.lisp.msg.exceptions.LispParseError;
-import org.onosproject.lisp.msg.protocols.DefaultLispLocatorRecord.LocatorRecordReader;
+import org.onosproject.lisp.msg.protocols.DefaultLispLocator.LocatorReader;
+import org.onosproject.lisp.msg.protocols.DefaultLispLocator.LocatorWriter;
 import org.onosproject.lisp.msg.types.LispAfiAddress;
 import org.onosproject.lisp.msg.exceptions.LispReaderException;
 import org.onosproject.lisp.msg.exceptions.LispWriterException;
@@ -31,20 +32,14 @@
 
 import static com.google.common.base.MoreObjects.toStringHelper;
 import static com.google.common.base.Preconditions.checkNotNull;
-import static org.onosproject.lisp.msg.protocols.DefaultLispLocatorRecord.LocatorRecordWriter;
 
 /**
  * Default implementation of LispMapRecord.
  */
-public final class DefaultLispMapRecord implements LispMapRecord {
+public final class DefaultLispMapRecord extends AbstractLispRecord
+                                                implements LispMapRecord {
 
-    private final int recordTtl;
-    private final byte maskLength;
-    private final LispMapReplyAction action;
-    private final boolean authoritative;
-    private final short mapVersionNumber;
-    private final LispAfiAddress eidPrefixAfi;
-    private final List<LispLocatorRecord> locatorRecords;
+    private final List<LispLocator> locators;
 
     static final MapRecordWriter WRITER;
     static {
@@ -60,58 +55,24 @@
      * @param authoritative    authoritative flag
      * @param mapVersionNumber map version number
      * @param eidPrefixAfi     EID prefix AFI address
+     * @param locators         a collection of locators
      */
     private DefaultLispMapRecord(int recordTtl, byte maskLength,
                                  LispMapReplyAction action, boolean authoritative,
                                  short mapVersionNumber, LispAfiAddress eidPrefixAfi,
-                                 List<LispLocatorRecord> locatorRecords) {
-        this.recordTtl = recordTtl;
-        this.maskLength = maskLength;
-        this.action = action;
-        this.authoritative = authoritative;
-        this.mapVersionNumber = mapVersionNumber;
-        this.eidPrefixAfi = eidPrefixAfi;
-        this.locatorRecords = locatorRecords;
-    }
-
-    @Override
-    public int getRecordTtl() {
-        return recordTtl;
+                                 List<LispLocator> locators) {
+        super(recordTtl, maskLength, action, authoritative, mapVersionNumber, eidPrefixAfi);
+        this.locators = locators;
     }
 
     @Override
     public int getLocatorCount() {
-        return locatorRecords.size();
+        return locators.size();
     }
 
     @Override
-    public byte getMaskLength() {
-        return maskLength;
-    }
-
-    @Override
-    public LispMapReplyAction getAction() {
-        return action;
-    }
-
-    @Override
-    public boolean isAuthoritative() {
-        return authoritative;
-    }
-
-    @Override
-    public short getMapVersionNumber() {
-        return mapVersionNumber;
-    }
-
-    @Override
-    public LispAfiAddress getEidPrefixAfi() {
-        return eidPrefixAfi;
-    }
-
-    @Override
-    public List<LispLocatorRecord> getLocators() {
-        return ImmutableList.copyOf(locatorRecords);
+    public List<LispLocator> getLocators() {
+        return ImmutableList.copyOf(locators);
     }
 
     @Override
@@ -128,8 +89,8 @@
                 .add("authoritative", authoritative)
                 .add("mapVersionNumber", mapVersionNumber)
                 .add("EID prefix AFI address", eidPrefixAfi)
-                .add("locator records", locatorRecords).toString();
-
+                .add("locators", locators)
+                .toString();
     }
 
     @Override
@@ -147,65 +108,25 @@
                 Objects.equal(authoritative, that.authoritative) &&
                 Objects.equal(mapVersionNumber, that.mapVersionNumber) &&
                 Objects.equal(eidPrefixAfi, that.eidPrefixAfi) &&
-                Objects.equal(locatorRecords, that.locatorRecords);
+                Objects.equal(locators, that.locators);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hashCode(recordTtl, maskLength, action,
-                                authoritative, mapVersionNumber, eidPrefixAfi, locatorRecords);
+        return Objects.hashCode(recordTtl, maskLength, action, authoritative,
+                                mapVersionNumber, eidPrefixAfi, locators);
     }
 
-    public static final class DefaultMapRecordBuilder implements MapRecordBuilder {
+    public static final class DefaultMapRecordBuilder
+                              extends AbstractRecordBuilder<MapRecordBuilder>
+                                      implements MapRecordBuilder {
 
-        private int recordTtl;
-        private byte maskLength;
-        private LispMapReplyAction action;
-        private boolean authoritative;
-        private short mapVersionNumber;
-        private LispAfiAddress eidPrefixAfi;
-        private List<LispLocatorRecord> locatorRecords = Lists.newArrayList();
+        private List<LispLocator> locators = Lists.newArrayList();
 
         @Override
-        public MapRecordBuilder withRecordTtl(int recordTtl) {
-            this.recordTtl = recordTtl;
-            return this;
-        }
-
-        @Override
-        public MapRecordBuilder withMaskLength(byte maskLength) {
-            this.maskLength = maskLength;
-            return this;
-        }
-
-        @Override
-        public MapRecordBuilder withAction(LispMapReplyAction action) {
-            this.action = action;
-            return this;
-        }
-
-        @Override
-        public MapRecordBuilder withAuthoritative(boolean authoritative) {
-            this.authoritative = authoritative;
-            return this;
-        }
-
-        @Override
-        public MapRecordBuilder withMapVersionNumber(short mapVersionNumber) {
-            this.mapVersionNumber = mapVersionNumber;
-            return this;
-        }
-
-        @Override
-        public MapRecordBuilder withEidPrefixAfi(LispAfiAddress prefix) {
-            this.eidPrefixAfi = prefix;
-            return this;
-        }
-
-        @Override
-        public MapRecordBuilder withLocators(List<LispLocatorRecord> records) {
-            if (records != null) {
-                this.locatorRecords = ImmutableList.copyOf(records);
+        public MapRecordBuilder withLocators(List<LispLocator> locators) {
+            if (locators != null) {
+                this.locators = ImmutableList.copyOf(locators);
             }
             return this;
         }
@@ -216,7 +137,7 @@
             checkNotNull(eidPrefixAfi, "Must specify an EID prefix");
 
             return new DefaultLispMapRecord(recordTtl, maskLength, action,
-                    authoritative, mapVersionNumber, eidPrefixAfi, locatorRecords);
+                    authoritative, mapVersionNumber, eidPrefixAfi, locators);
         }
     }
 
@@ -231,7 +152,8 @@
         private static final int REPLY_ACTION_SHIFT_BIT = 5;
 
         @Override
-        public LispMapRecord readFrom(ByteBuf byteBuf) throws LispParseError, LispReaderException {
+        public LispMapRecord readFrom(ByteBuf byteBuf) throws LispParseError,
+                                                              LispReaderException {
 
             // Record TTL -> 32 bits
             int recordTtl = byteBuf.readInt();
@@ -252,7 +174,8 @@
             }
 
             // authoritative flag -> 1 bit
-            boolean authoritative = ByteOperator.getBit((byte) (actionWithFlag >> AUTHORITATIVE_INDEX), 0);
+            boolean authoritative = ByteOperator.getBit((byte)
+                                    (actionWithFlag >> AUTHORITATIVE_INDEX), 0);
 
             // let's skip the reserved field
             byteBuf.skipBytes(RESERVED_SKIP_LENGTH);
@@ -260,18 +183,19 @@
             // Map version number -> 12 bits, we treat Rsvd field is all zero
             short mapVersionNumber = (short) byteBuf.readUnsignedShort();
 
-            LispAfiAddress eidPrefixAfi = new LispAfiAddress.AfiAddressReader().readFrom(byteBuf);
+            LispAfiAddress eidPrefixAfi =
+                            new LispAfiAddress.AfiAddressReader().readFrom(byteBuf);
 
-            List<LispLocatorRecord> locators = Lists.newArrayList();
+            List<LispLocator> locators = Lists.newArrayList();
             for (int i = 0; i < locatorCount; i++) {
-                locators.add(new LocatorRecordReader().readFrom(byteBuf));
+                locators.add(new LocatorReader().readFrom(byteBuf));
             }
 
             return new DefaultMapRecordBuilder()
                         .withRecordTtl(recordTtl)
                         .withMaskLength(maskLength)
                         .withAction(action)
-                        .withAuthoritative(authoritative)
+                        .withIsAuthoritative(authoritative)
                         .withMapVersionNumber(mapVersionNumber)
                         .withLocators(locators)
                         .withEidPrefixAfi(eidPrefixAfi)
@@ -324,8 +248,8 @@
             afiAddressWriter.writeTo(byteBuf, message.getEidPrefixAfi());
 
             // serialize locator
-            LocatorRecordWriter recordWriter = new LocatorRecordWriter();
-            List<LispLocatorRecord> locators = message.getLocators();
+            LocatorWriter recordWriter = new LocatorWriter();
+            List<LispLocator> locators = message.getLocators();
             for (int i = 0; i < locators.size(); i++) {
                 recordWriter.writeTo(byteBuf, locators.get(i));
             }
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispMapReferral.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispMapReferral.java
new file mode 100644
index 0000000..d796e1e
--- /dev/null
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispMapReferral.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2017-present 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.lisp.msg.protocols;
+
+/**
+ * Default LISP referral message class.
+ */
+public class DefaultLispMapReferral implements LispMapReferral {
+}
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispReferral.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispReferral.java
new file mode 100644
index 0000000..6e1635ac
--- /dev/null
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispReferral.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2016-present 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.lisp.msg.protocols;
+
+import io.netty.buffer.ByteBuf;
+import org.onlab.packet.DeserializationException;
+import org.onosproject.lisp.msg.exceptions.LispParseError;
+import org.onosproject.lisp.msg.exceptions.LispReaderException;
+import org.onosproject.lisp.msg.exceptions.LispWriterException;
+import org.onosproject.lisp.msg.types.LispAfiAddress;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Default implementation of LispReferral.
+ */
+public final class DefaultLispReferral extends DefaultLispGenericLocator
+                                                        implements LispReferral {
+
+    static final DefaultLispReferral.ReferralWriter WRITER;
+    static {
+        WRITER = new ReferralWriter();
+    }
+
+    /**
+     * A private constructor that protects object instantiation from external.
+     *
+     * @param priority          uni-cast priority
+     * @param weight            uni-cast weight
+     * @param multicastPriority multi-cast priority
+     * @param multicastWeight   multi-cast weight
+     * @param localLocator      local locator flag
+     * @param rlocProbed        RLOC probed flag
+     * @param routed            routed flag
+     * @param locatorAfi        locator AFI
+     */
+    private DefaultLispReferral(byte priority, byte weight, byte multicastPriority,
+                                byte multicastWeight, boolean localLocator,
+                                boolean rlocProbed, boolean routed,
+                                LispAfiAddress locatorAfi) {
+        super(priority, weight, multicastPriority, multicastWeight,
+                                localLocator, rlocProbed, routed, locatorAfi);
+    }
+
+    @Override
+    public void writeTo(ByteBuf byteBuf) throws LispWriterException {
+        WRITER.writeTo(byteBuf, this);
+    }
+
+    public static final class DefaultReferralBuilder
+                                extends AbstractGenericLocatorBuilder<ReferralBuilder>
+                                        implements ReferralBuilder {
+
+        @Override
+        public LispReferral build() {
+
+            checkNotNull(locatorAfi, "Must specify a locator address");
+
+            return new DefaultLispReferral(priority, weight, multicastPriority,
+                    multicastWeight, localLocator, rlocProbed, routed, locatorAfi);
+        }
+    }
+
+    /**
+     * A LISP message reader for Referral portion.
+     */
+    public static final class ReferralReader implements LispMessageReader<LispReferral> {
+
+        @Override
+        public LispReferral readFrom(ByteBuf byteBuf) throws LispParseError,
+                                                             LispReaderException,
+                                                             DeserializationException {
+            LispGenericLocator gl = deserialize(byteBuf);
+
+            return new DefaultReferralBuilder()
+                            .withPriority(gl.getPriority())
+                            .withWeight(gl.getWeight())
+                            .withMulticastPriority(gl.getMulticastPriority())
+                            .withMulticastWeight(gl.getMulticastWeight())
+                            .withLocalLocator(gl.isLocalLocator())
+                            .withRouted(gl.isRouted())
+                            .withLocatorAfi(gl.getLocatorAfi()).build();
+        }
+    }
+
+    /**
+     * A LISP message writer for Referral portion.
+     */
+    public static final class ReferralWriter implements LispMessageWriter<LispReferral> {
+
+        @Override
+        public void writeTo(ByteBuf byteBuf, LispReferral message)
+                                                throws LispWriterException {
+
+            serialize(byteBuf, message);
+        }
+    }
+}
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispReferralRecord.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispReferralRecord.java
new file mode 100644
index 0000000..976fdd7
--- /dev/null
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispReferralRecord.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright 2017-present 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.lisp.msg.protocols;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import io.netty.buffer.ByteBuf;
+import org.onlab.packet.DeserializationException;
+import org.onosproject.lisp.msg.exceptions.LispParseError;
+import org.onosproject.lisp.msg.exceptions.LispReaderException;
+import org.onosproject.lisp.msg.exceptions.LispWriterException;
+import org.onosproject.lisp.msg.types.LispAfiAddress;
+
+import java.util.List;
+
+import static com.google.common.base.MoreObjects.toStringHelper;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Default LISP referral record class.
+ */
+public final class DefaultLispReferralRecord extends AbstractLispRecord
+                                                implements LispReferralRecord {
+
+    private final boolean incomplete;
+    private final List<LispReferral> referrals;
+    private final List<LispSignature> signatures;
+
+    static final ReferralRecordWriter WRITER;
+    static {
+        WRITER = new ReferralRecordWriter();
+    }
+
+    /**
+     * A private constructor that protects object instantiation from external.
+     *
+     * @param recordTtl        record time-to-live value
+     * @param maskLength       mask length
+     * @param action           lisp map reply action
+     * @param authoritative    authoritative flag
+     * @param mapVersionNumber map version number
+     * @param eidPrefixAfi     EID prefix AFI address
+     * @param incomplete       incomplete flag value
+     * @param referrals        a collection referrals
+     * @param signatures       a collection signatures
+     */
+    private DefaultLispReferralRecord(int recordTtl, byte maskLength,
+                                      LispMapReplyAction action, boolean authoritative,
+                                      short mapVersionNumber, LispAfiAddress eidPrefixAfi,
+                                      boolean incomplete, List<LispReferral> referrals,
+                                      List<LispSignature> signatures) {
+        super(recordTtl, maskLength, action, authoritative, mapVersionNumber, eidPrefixAfi);
+        this.incomplete = incomplete;
+        this.referrals = referrals;
+        this.signatures = signatures;
+    }
+
+    @Override
+    public int getReferralCount() {
+        return referrals.size();
+    }
+
+    @Override
+    public int getSignatureCount() {
+        return signatures.size();
+    }
+
+    @Override
+    public boolean isIncomplete() {
+        return incomplete;
+    }
+
+    @Override
+    public List<LispReferral> getReferrals() {
+        return ImmutableList.copyOf(referrals);
+    }
+
+    @Override
+    public List<LispSignature> getSignatures() {
+        return ImmutableList.copyOf(signatures);
+    }
+
+    @Override
+    public void writeTo(ByteBuf byteBuf) throws LispWriterException {
+        WRITER.writeTo(byteBuf, this);
+    }
+
+    @Override
+    public String toString() {
+        return toStringHelper(this)
+                .add("record TTL", recordTtl)
+                .add("maskLength", maskLength)
+                .add("action", action)
+                .add("authoritative", authoritative)
+                .add("mapVersionNumber", mapVersionNumber)
+                .add("EID prefix AFI address", eidPrefixAfi)
+                .add("incomplete", incomplete)
+                .add("referrals", referrals)
+                .add("signatures", signatures)
+                .toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        DefaultLispReferralRecord that = (DefaultLispReferralRecord) o;
+        return Objects.equal(recordTtl, that.recordTtl) &&
+                Objects.equal(maskLength, that.maskLength) &&
+                Objects.equal(action, that.action) &&
+                Objects.equal(authoritative, that.authoritative) &&
+                Objects.equal(mapVersionNumber, that.mapVersionNumber) &&
+                Objects.equal(eidPrefixAfi, that.eidPrefixAfi) &&
+                Objects.equal(referrals, that.referrals) &&
+                Objects.equal(signatures, that.signatures);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(recordTtl, maskLength, action, authoritative,
+                mapVersionNumber, eidPrefixAfi, incomplete, referrals, signatures);
+    }
+
+    public static final class DefaultReferralRecordBuilder
+                                extends AbstractRecordBuilder<ReferralRecordBuilder>
+                                        implements ReferralRecordBuilder {
+
+        private boolean incomplete;
+        private List<LispReferral> referrals = Lists.newArrayList();
+        private List<LispSignature> signatures = Lists.newArrayList();
+
+        @Override
+        public ReferralRecordBuilder withReferrals(List<LispReferral> referrals) {
+            if (referrals != null) {
+                this.referrals = ImmutableList.copyOf(referrals);
+            }
+            return this;
+        }
+
+        @Override
+        public ReferralRecordBuilder withSignatures(List<LispSignature> signatures) {
+            if (signatures != null) {
+                this.signatures = ImmutableList.copyOf(signatures);
+            }
+            return this;
+        }
+
+        @Override
+        public ReferralRecordBuilder withIsIncomplete(boolean incomplete) {
+            this.incomplete = incomplete;
+            return this;
+        }
+
+        @Override
+        public LispReferralRecord build() {
+
+            checkNotNull(eidPrefixAfi, "Must specify an EID prefix");
+
+            return new DefaultLispReferralRecord(recordTtl, maskLength, action,
+                                authoritative, mapVersionNumber, eidPrefixAfi,
+                                incomplete, referrals, signatures);
+        }
+    }
+
+    public static final class ReferralRecordReader
+                                implements LispMessageReader<LispReferralRecord> {
+
+        @Override
+        public LispReferralRecord readFrom(ByteBuf byteBuf)
+                                            throws LispParseError, LispReaderException,
+                                                        DeserializationException {
+            // TODO: need to implement serialization logic
+            return null;
+        }
+    }
+
+    /**
+     * A LISP message writer for ReferralRecord portion.
+     */
+    public static final class ReferralRecordWriter
+                                implements LispMessageWriter<LispReferralRecord> {
+
+        @Override
+        public void writeTo(ByteBuf byteBuf, LispReferralRecord message)
+                                                    throws LispWriterException {
+            // TODO: need to implement serialization logic
+        }
+    }
+}
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispSignature.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispSignature.java
new file mode 100644
index 0000000..979e987
--- /dev/null
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/DefaultLispSignature.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2017-present 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.lisp.msg.protocols;
+
+/**
+ * Default LISP signature class.
+ */
+public class DefaultLispSignature implements LispSignature {
+}
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispLocatorRecord.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispGenericLocator.java
similarity index 69%
rename from protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispLocatorRecord.java
rename to protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispGenericLocator.java
index a38527b..99ec7b9 100644
--- a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispLocatorRecord.java
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispGenericLocator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-present Open Networking Laboratory
+ * Copyright 2017-present 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.
@@ -16,13 +16,13 @@
 package org.onosproject.lisp.msg.protocols;
 
 import io.netty.buffer.ByteBuf;
-import org.onosproject.lisp.msg.types.LispAfiAddress;
 import org.onosproject.lisp.msg.exceptions.LispWriterException;
+import org.onosproject.lisp.msg.types.LispAfiAddress;
 
 /**
- * LISP locator record section which is part of LISP map record.
+ * A generic LISP locator used for both location and referral purposes.
  */
-public interface LispLocatorRecord {
+public interface LispGenericLocator {
 
     /**
      * Obtains priority value.
@@ -89,79 +89,74 @@
     void writeTo(ByteBuf byteBuf) throws LispWriterException;
 
     /**
-     * A builder of LISP locator record.
+     * A builder of LISP generic locator.
+     *
+     * @param <T> sub-builder type
      */
-    interface LocatorRecordBuilder {
+    interface GenericLocatorBuilder<T> {
 
         /**
          * Sets priority value.
          *
          * @param priority priority
-         * @return LocatorRecordBuilder object
+         * @return parameterized object
          */
-        LocatorRecordBuilder withPriority(byte priority);
+        T withPriority(byte priority);
 
         /**
          * Sets weight value.
          *
          * @param weight weight
-         * @return LocatorRecordBuilder object
+         * @return parameterized object
          */
-        LocatorRecordBuilder withWeight(byte weight);
+        T withWeight(byte weight);
 
         /**
          * Sets multi-cast priority value.
          *
          * @param priority priority
-         * @return LocatorRecordBuilder object
+         * @return parameterized object
          */
-        LocatorRecordBuilder withMulticastPriority(byte priority);
+        T withMulticastPriority(byte priority);
 
         /**
          * Sets multi-cast weight value.
          *
          * @param weight weight
-         * @return LocatorRecordBuilder object
+         * @return parameterized object
          */
-        LocatorRecordBuilder withMulticastWeight(byte weight);
+        T withMulticastWeight(byte weight);
 
         /**
          * Sets local locator flag.
          *
          * @param localLocator local locator flag
-         * @return LocatorRecordBuilder object
+         * @return parameterized object
          */
-        LocatorRecordBuilder withLocalLocator(boolean localLocator);
+        T withLocalLocator(boolean localLocator);
 
         /**
          * Sets RLOC probed flag.
          *
          * @param rlocProbed RLOC probed flag
-         * @return LocatorRecordBuilder object
+         * @return parameterized object
          */
-        LocatorRecordBuilder withRlocProbed(boolean rlocProbed);
+        T withRlocProbed(boolean rlocProbed);
 
         /**
          * Sets routed flag.
          *
          * @param routed routed flag
-         * @return LocatorRecordBuilder object
+         * @return parameterized object
          */
-        LocatorRecordBuilder withRouted(boolean routed);
+        T withRouted(boolean routed);
 
         /**
          * Sets locator AFI.
          *
          * @param locatorAfi locator AFI
-         * @return LocatorRecordBuilder object
+         * @return parameterized object
          */
-        LocatorRecordBuilder withLocatorAfi(LispAfiAddress locatorAfi);
-
-        /**
-         * Builds locator record.
-         *
-         * @return locator record instance
-         */
-        LispLocatorRecord build();
+        T withLocatorAfi(LispAfiAddress locatorAfi);
     }
 }
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispLocator.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispLocator.java
new file mode 100644
index 0000000..0f198d2
--- /dev/null
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispLocator.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2016-present 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.lisp.msg.protocols;
+
+/**
+ * LISP locator section which is part of LISP map record.
+ */
+public interface LispLocator extends LispGenericLocator {
+
+    /**
+     * A builder of LISP locator.
+     */
+    interface LocatorBuilder extends GenericLocatorBuilder<LocatorBuilder> {
+
+        /**
+         * Builds locator.
+         *
+         * @return locator instance
+         */
+        LispLocator build();
+    }
+}
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispMapRecord.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispMapRecord.java
index ae7cb59..bd0b948 100644
--- a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispMapRecord.java
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispMapRecord.java
@@ -15,23 +15,12 @@
  */
 package org.onosproject.lisp.msg.protocols;
 
-import io.netty.buffer.ByteBuf;
-import org.onosproject.lisp.msg.exceptions.LispWriterException;
-import org.onosproject.lisp.msg.types.LispAfiAddress;
-
 import java.util.List;
 
 /**
- * LISP record section which is part of LISP map register message.
+ * LISP map record section which is part of LISP map register message.
  */
-public interface LispMapRecord {
-
-    /**
-     * Obtains record TTL value.
-     *
-     * @return record TTL value
-     */
-    int getRecordTtl();
+public interface LispMapRecord extends LispRecord {
 
     /**
      * Obtains locator count value.
@@ -41,120 +30,29 @@
     int getLocatorCount();
 
     /**
-     * Obtains address mask length.
+     * Obtains a collection of locators.
      *
-     * @return mask length
+     * @return a collection of locators
      */
-    byte getMaskLength();
-
-    /**
-     * Obtains LispMapReplyAction enum code.
-     *
-     * @return LispMapReplyAction enum code
-     */
-    LispMapReplyAction getAction();
-
-    /**
-     * Obtains authoritative flag.
-     *
-     * @return authoritative flag
-     */
-    boolean isAuthoritative();
-
-    /**
-     * Obtains map version number.
-     *
-     * @return map version number
-     */
-    short getMapVersionNumber();
-
-    /**
-     * Obtains EID prefix.
-     *
-     * @return EID prefix
-     */
-    LispAfiAddress getEidPrefixAfi();
-
-    /**
-     * Obtains a collection of locator records.
-     *
-     * @return a collection of locator records
-     */
-    List<LispLocatorRecord> getLocators();
-
-    /**
-     * Writes LISP message object into communication channel.
-     *
-     * @param byteBuf byte buffer
-     * @throws LispWriterException on error
-     */
-    void writeTo(ByteBuf byteBuf) throws LispWriterException;
+    List<LispLocator> getLocators();
 
     /**
      * A builder of LISP map record.
      */
-    interface MapRecordBuilder {
+    interface MapRecordBuilder extends RecordBuilder<MapRecordBuilder> {
 
         /**
-         * Sets record TTL value.
+         * Sets a collection of locators.
          *
-         * @param recordTtl record TTL
+         * @param locators a collection of locators
          * @return MapRecordBuilder object
          */
-        MapRecordBuilder withRecordTtl(int recordTtl);
+        MapRecordBuilder withLocators(List<LispLocator> locators);
 
         /**
-         * Sets mask length.
+         * Builds LISP map record object.
          *
-         * @param maskLength mask length
-         * @return MapRecordBuilder object
-         */
-        MapRecordBuilder withMaskLength(byte maskLength);
-
-        /**
-         * Sets LISP map reply action enum.
-         *
-         * @param action map reply action
-         * @return MapRecordBuilder object
-         */
-        MapRecordBuilder withAction(LispMapReplyAction action);
-
-        /**
-         * Sets authoritative flag.
-         *
-         * @param authoritative authoritative flag
-         * @return MapRecordBuilder object
-         */
-        MapRecordBuilder withAuthoritative(boolean authoritative);
-
-        /**
-         * Sets LISP map version number.
-         *
-         * @param mapVersionNumber map version number
-         * @return MapRecordBuilder object
-         */
-        MapRecordBuilder withMapVersionNumber(short mapVersionNumber);
-
-        /**
-         * Sets EID prefix.
-         *
-         * @param prefix EID prefix
-         * @return MapRecordBuilder object
-         */
-        MapRecordBuilder withEidPrefixAfi(LispAfiAddress prefix);
-
-        /**
-         * Sets a collection of locator records.
-         *
-         * @param records a collection of locator records
-         * @return MapRecordBuilder object
-         */
-        MapRecordBuilder withLocators(List<LispLocatorRecord> records);
-
-        /**
-         * Builds map record.
-         *
-         * @return map record instance
+         * @return LISP map record object
          */
         LispMapRecord build();
     }
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispMapReferral.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispMapReferral.java
new file mode 100644
index 0000000..e78cfc4
--- /dev/null
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispMapReferral.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2017-present 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.lisp.msg.protocols;
+
+/**
+ * LISP map referral message interface.
+ * <p>
+ * LISP map referral message format is defined in draft-ietf-lisp-ddt-09.
+ * https://tools.ietf.org/html/draft-ietf-lisp-ddt-09
+ *
+ * <pre>
+ * {@literal
+ *      0                   1                   2                   3
+ *      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |Type=6 |                Reserved               | Record Count  |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |                         Nonce . . .                           |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |                         . . . Nonce                           |
+ * +-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |   |                          Record  TTL                          |
+ * |   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * R   | Referral Count| EID mask-len  | ACT |A|I|     Reserved        |
+ * e   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * c   |SigCnt |   Map Version Number  |            EID-AFI            |
+ * o   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * r   |                          EID-prefix ...                       |
+ * d   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |  /|    Priority   |    Weight     |  M Priority   |   M Weight    |
+ * | R +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * | e |       Unused Flags      |L|p|R|            Loc-AFI            |
+ * | f +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |  \|                             Locator ...                       |
+ * |   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |   ~                          Sig section                          ~
+ * +-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * }</pre>
+ */
+public interface LispMapReferral {
+
+    // TODO: need to implement LispMapReferral
+}
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispRecord.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispRecord.java
new file mode 100644
index 0000000..e858b6e
--- /dev/null
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispRecord.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2017-present 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.lisp.msg.protocols;
+
+import io.netty.buffer.ByteBuf;
+import org.onosproject.lisp.msg.exceptions.LispWriterException;
+import org.onosproject.lisp.msg.types.LispAfiAddress;
+
+/**
+ * Generic LISP record interface.
+ */
+public interface LispRecord {
+
+    /**
+     * Obtains record TTL value.
+     *
+     * @return record TTL value
+     */
+    int getRecordTtl();
+
+    /**
+     * Obtains address mask length.
+     *
+     * @return mask length
+     */
+    byte getMaskLength();
+
+    /**
+     * Obtains LispMapReplyAction enum code.
+     *
+     * @return LispMapReplyAction enum code
+     */
+    LispMapReplyAction getAction();
+
+    /**
+     * Obtains authoritative flag.
+     *
+     * @return authoritative flag
+     */
+    boolean isAuthoritative();
+
+    /**
+     * Obtains map version number.
+     *
+     * @return map version number
+     */
+    short getMapVersionNumber();
+
+    /**
+     * Obtains EID prefix.
+     *
+     * @return EID prefix
+     */
+    LispAfiAddress getEidPrefixAfi();
+
+    /**
+     * Writes LISP message object into communication channel.
+     *
+     * @param byteBuf byte buffer
+     * @throws LispWriterException on error
+     */
+    void writeTo(ByteBuf byteBuf) throws LispWriterException;
+
+    /**
+     * A builder for LISP record.
+     *
+     * @param <T> sub-builder type
+     */
+    interface RecordBuilder<T> {
+
+        /**
+         * Sets record TTL value.
+         *
+         * @param recordTtl record TTL
+         * @return parameterized object
+         */
+        T withRecordTtl(int recordTtl);
+
+        /**
+         * Sets mask length.
+         *
+         * @param maskLength mask length
+         * @return parameterized object
+         */
+        T withMaskLength(byte maskLength);
+
+        /**
+         * Sets LISP map reply action enum.
+         *
+         * @param action map reply action
+         * @return parameterized object
+         */
+        T withAction(LispMapReplyAction action);
+
+        /**
+         * Sets authoritative flag.
+         *
+         * @param authoritative authoritative flag
+         * @return parameterized object
+         */
+        T withIsAuthoritative(boolean authoritative);
+
+        /**
+         * Sets LISP map version number.
+         *
+         * @param mapVersionNumber map version number
+         * @return parameterized object
+         */
+        T withMapVersionNumber(short mapVersionNumber);
+
+        /**
+         * Sets EID prefix.
+         *
+         * @param prefix EID prefix
+         * @return parameterized object
+         */
+        T withEidPrefixAfi(LispAfiAddress prefix);
+    }
+}
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispReferral.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispReferral.java
new file mode 100644
index 0000000..4611654
--- /dev/null
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispReferral.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2017-present 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.lisp.msg.protocols;
+
+/**
+ * LISP referral section which is part of LISP referral record.
+ */
+public interface LispReferral extends LispGenericLocator {
+
+    /**
+     * A builder of LISP referral.
+     */
+    interface ReferralBuilder extends GenericLocatorBuilder<ReferralBuilder> {
+
+        /**
+         * Builds referral.
+         *
+         * @return referral instance
+         */
+        LispReferral build();
+    }
+}
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispReferralRecord.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispReferralRecord.java
new file mode 100644
index 0000000..60cb914
--- /dev/null
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispReferralRecord.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2017-present 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.lisp.msg.protocols;
+
+import java.util.List;
+
+/**
+ * LISP referral record section which is part of LISP map referral message.
+ */
+public interface LispReferralRecord extends LispRecord {
+
+    /**
+     * Obtains referral count value.
+     *
+     * @return referral count value
+     */
+    int getReferralCount();
+
+    /**
+     * Obtains signature count value.
+     *
+     * @return signature count value
+     */
+    int getSignatureCount();
+
+    /**
+     * Obtains incomplete flag.
+     *
+     * @return incomplete flag
+     */
+    boolean isIncomplete();
+
+    /**
+     * Obtains a collection of referrals.
+     *
+     * @return a collection of referrals
+     */
+    List<LispReferral> getReferrals();
+
+    /**
+     * Obtains a collection of signatures.
+     *
+     * @return a collection of signatures
+     */
+    List<LispSignature> getSignatures();
+
+    /**
+     * A builder of LISP referral record.
+     */
+    interface ReferralRecordBuilder extends RecordBuilder<ReferralRecordBuilder> {
+
+        /**
+         * Sets a collection of referrals.
+         *
+         * @param referrals a collection of referrals
+         * @return ReferralRecordBuilder object
+         */
+        ReferralRecordBuilder withReferrals(List<LispReferral> referrals);
+
+        /**
+         * Sets a collection of signatures.
+         *
+         * @param signatures a collection of signatures
+         * @return ReferralRecordBuilder object
+         */
+        ReferralRecordBuilder withSignatures(List<LispSignature> signatures);
+
+        /**
+         * Sets incomplete flag.
+         *
+         * @param incomplete incomplete flag
+         * @return ReferralRecordBuilder object
+         */
+        ReferralRecordBuilder withIsIncomplete(boolean incomplete);
+
+        /**
+         * Builds LISP referral record object.
+         *
+         * @return LISP referral record object
+         */
+        LispReferralRecord build();
+    }
+}
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispSignature.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispSignature.java
new file mode 100644
index 0000000..291d9d7
--- /dev/null
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispSignature.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2017-present 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.lisp.msg.protocols;
+
+/**
+ * LISP signature interface.
+ *
+ * <p>
+ * LISP signature format is defined in draft-ietf-lisp-ddt-09.
+ * https://tools.ietf.org/html/draft-ietf-lisp-ddt-09#page-14
+ *
+ * <pre>
+ * {@literal
+ *      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
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *    /|                      Original Record TTL                      |
+ *   / +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *  /  |                      Signature Expiration                     |
+ * |   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * s   |                      Signature Inception                      |
+ * i   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * g   |            Key Tag            |           Sig Length          |
+ * |   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * \   | Sig-Algorithm |    Reserved   |            Reserved           |
+ *  \  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *   \ ~                             Signature                         ~
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * }</pre>
+ */
+public interface LispSignature {
+
+    // TODO: need to implement LispSignature
+}
diff --git a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispType.java b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispType.java
index b039ac7..e18d709 100644
--- a/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispType.java
+++ b/protocols/lisp/msg/src/main/java/org/onosproject/lisp/msg/protocols/LispType.java
@@ -35,6 +35,9 @@
     /** LISP Map-Notify Message. */
     LISP_MAP_NOTIFY(4),
 
+    /** LISP Map-Referral Message. */
+    LISP_MAP_REFERRAL(5),
+
     /** LISP Info-Request or Info-Reply Message. */
     LISP_INFO(7),