diff --git a/protocols/isis/isisio/src/main/java/org/onosproject/isis/io/isispacket/tlv/NeighborForExtendedIs.java b/protocols/isis/isisio/src/main/java/org/onosproject/isis/io/isispacket/tlv/NeighborForExtendedIs.java
index 88b8462..0bc57b4 100644
--- a/protocols/isis/isisio/src/main/java/org/onosproject/isis/io/isispacket/tlv/NeighborForExtendedIs.java
+++ b/protocols/isis/isisio/src/main/java/org/onosproject/isis/io/isispacket/tlv/NeighborForExtendedIs.java
@@ -101,8 +101,11 @@
                 int tlvLength = tlvHeader.tlvLength();
                 if (tlvValue != null) {
                     if (channelBuffer.readableBytes() >= tlvLength) {
-                        this.addSubTlv(SubTlvFinder.findSubTlv(tlvHeader,
-                                                               channelBuffer.readBytes(tlvHeader.tlvLength())));
+                        TrafficEngineeringSubTlv subTlv =
+                                SubTlvFinder.findSubTlv(tlvHeader, channelBuffer.readBytes(tlvHeader.tlvLength()));
+                        if (subTlv != null) {
+                            this.addSubTlv(subTlv);
+                        }
                     }
                 } else {
                     if (channelBuffer.readableBytes() >= tlvLength) {
