diff --git a/daemon/face/generic-link-service.cpp b/daemon/face/generic-link-service.cpp
index c634484..d7ebc7c 100644
--- a/daemon/face/generic-link-service.cpp
+++ b/daemon/face/generic-link-service.cpp
@@ -43,6 +43,7 @@
   , allowCongestionMarking(false)
   , baseCongestionMarkingInterval(time::milliseconds(100)) // Interval from RFC 8289 (CoDel)
   , defaultCongestionThreshold(65536) // This default value works well for a queue capacity of 200KiB
+  , allowSelfLearning(false)
 {
 }
 
@@ -145,6 +146,18 @@
   if (congestionMarkTag != nullptr) {
     lpPacket.add<lp::CongestionMarkField>(*congestionMarkTag);
   }
+
+  if (m_options.allowSelfLearning) {
+    shared_ptr<lp::NonDiscoveryTag> nonDiscoveryTag = netPkt.getTag<lp::NonDiscoveryTag>();
+    if (nonDiscoveryTag != nullptr) {
+      lpPacket.add<lp::NonDiscoveryField>(*nonDiscoveryTag);
+    }
+
+    shared_ptr<lp::PrefixAnnouncementTag> prefixAnnouncementTag = netPkt.getTag<lp::PrefixAnnouncementTag>();
+    if (prefixAnnouncementTag != nullptr) {
+      lpPacket.add<lp::PrefixAnnouncementField>(*prefixAnnouncementTag);
+    }
+  }
 }
 
 void
@@ -366,6 +379,21 @@
     interest->setTag(make_shared<lp::CongestionMarkTag>(firstPkt.get<lp::CongestionMarkField>()));
   }
 
+  if (firstPkt.has<lp::NonDiscoveryField>()) {
+    if (m_options.allowSelfLearning) {
+      interest->setTag(make_shared<lp::NonDiscoveryTag>(firstPkt.get<lp::NonDiscoveryField>()));
+    }
+    else {
+      NFD_LOG_FACE_WARN("received NonDiscovery, but self-learning disabled: IGNORE");
+    }
+  }
+
+  if (firstPkt.has<lp::PrefixAnnouncementField>()) {
+    ++this->nInNetInvalid;
+    NFD_LOG_FACE_WARN("received PrefixAnnouncement with Interest: DROP");
+    return;
+  }
+
   this->receiveInterest(*interest);
 }
 
@@ -404,6 +432,21 @@
     data->setTag(make_shared<lp::CongestionMarkTag>(firstPkt.get<lp::CongestionMarkField>()));
   }
 
+  if (firstPkt.has<lp::NonDiscoveryField>()) {
+    ++this->nInNetInvalid;
+    NFD_LOG_FACE_WARN("received NonDiscovery with Data: DROP");
+    return;
+  }
+
+  if (firstPkt.has<lp::PrefixAnnouncementField>()) {
+    if (m_options.allowSelfLearning) {
+      data->setTag(make_shared<lp::PrefixAnnouncementTag>(firstPkt.get<lp::PrefixAnnouncementField>()));
+    }
+    else {
+      NFD_LOG_FACE_WARN("received PrefixAnnouncement, but self-learning disabled: IGNORE");
+    }
+  }
+
   this->receiveData(*data);
 }
 
@@ -436,6 +479,18 @@
     nack.setTag(make_shared<lp::CongestionMarkTag>(firstPkt.get<lp::CongestionMarkField>()));
   }
 
+  if (firstPkt.has<lp::NonDiscoveryField>()) {
+    ++this->nInNetInvalid;
+    NFD_LOG_FACE_WARN("received NonDiscovery with Nack: DROP");
+    return;
+  }
+
+  if (firstPkt.has<lp::PrefixAnnouncementField>()) {
+    ++this->nInNetInvalid;
+    NFD_LOG_FACE_WARN("received PrefixAnnouncement with Nack: DROP");
+    return;
+  }
+
   this->receiveNack(nack);
 }
 
diff --git a/daemon/face/generic-link-service.hpp b/daemon/face/generic-link-service.hpp
index d74b1f2..d0eb3dd 100644
--- a/daemon/face/generic-link-service.hpp
+++ b/daemon/face/generic-link-service.hpp
@@ -136,6 +136,10 @@
     /** \brief default congestion threshold in bytes
      */
     size_t defaultCongestionThreshold;
+
+    /** \brief enables self-learning forwarding support
+     */
+    bool allowSelfLearning;
   };
 
   /** \brief counters provided by GenericLinkService
diff --git a/tests/daemon/face/generic-link-service.t.cpp b/tests/daemon/face/generic-link-service.t.cpp
index 98801c6..3d803a1 100644
--- a/tests/daemon/face/generic-link-service.t.cpp
+++ b/tests/daemon/face/generic-link-service.t.cpp
@@ -29,6 +29,8 @@
 #include "test-common.hpp"
 #include "dummy-transport.hpp"
 
+#include <ndn-cxx/lp/empty-value.hpp>
+#include <ndn-cxx/lp/prefix-announcement.hpp>
 #include <ndn-cxx/lp/tags.hpp>
 
 namespace nfd {
@@ -37,6 +39,13 @@
 
 using namespace nfd::tests;
 
+static lp::PrefixAnnouncement
+makePrefixAnnouncement(Name announcedName)
+{
+  Name paName = Name("self-learning").append(announcedName).appendVersion();
+  return lp::PrefixAnnouncement(makeData(paName));
+}
+
 BOOST_AUTO_TEST_SUITE(Face)
 
 using nfd::Face;
@@ -1125,6 +1134,218 @@
   BOOST_CHECK_EQUAL(*tag, 1);
 }
 
+BOOST_AUTO_TEST_CASE(SendNonDiscovery)
+{
+  GenericLinkService::Options options;
+  options.allowSelfLearning = true;
+  initialize(options);
+
+  shared_ptr<Interest> interest = makeInterest("/12345678");
+  interest->setTag(make_shared<lp::NonDiscoveryTag>(lp::EmptyValue{}));
+
+  face->sendInterest(*interest);
+
+  BOOST_REQUIRE_EQUAL(transport->sentPackets.size(), 1);
+  lp::Packet sent(transport->sentPackets.back().packet);
+  BOOST_CHECK(sent.has<lp::NonDiscoveryField>());
+}
+
+BOOST_AUTO_TEST_CASE(SendNonDiscoveryDisabled)
+{
+  GenericLinkService::Options options;
+  options.allowSelfLearning = false;
+  initialize(options);
+
+  shared_ptr<Interest> interest = makeInterest("/12345678");
+  interest->setTag(make_shared<lp::NonDiscoveryTag>(lp::EmptyValue{}));
+
+  face->sendInterest(*interest);
+
+  BOOST_REQUIRE_EQUAL(transport->sentPackets.size(), 1);
+  lp::Packet sent(transport->sentPackets.back().packet);
+  BOOST_CHECK(!sent.has<lp::NonDiscoveryField>());
+}
+
+BOOST_AUTO_TEST_CASE(ReceiveNonDiscovery)
+{
+  GenericLinkService::Options options;
+  options.allowSelfLearning = true;
+  initialize(options);
+
+  shared_ptr<Interest> interest = makeInterest("/12345678");
+  lp::Packet packet(interest->wireEncode());
+  packet.set<lp::NonDiscoveryField>(lp::EmptyValue{});
+
+  transport->receivePacket(packet.wireEncode());
+
+  BOOST_REQUIRE_EQUAL(receivedInterests.size(), 1);
+  shared_ptr<lp::NonDiscoveryTag> tag = receivedInterests.back().getTag<lp::NonDiscoveryTag>();
+  BOOST_CHECK(tag != nullptr);
+}
+
+BOOST_AUTO_TEST_CASE(ReceiveNonDiscoveryDisabled)
+{
+  GenericLinkService::Options options;
+  options.allowSelfLearning = false;
+  initialize(options);
+
+  shared_ptr<Interest> interest = makeInterest("/12345678");
+  lp::Packet packet(interest->wireEncode());
+  packet.set<lp::NonDiscoveryField>(lp::EmptyValue{});
+
+  transport->receivePacket(packet.wireEncode());
+
+  BOOST_CHECK_EQUAL(service->getCounters().nInNetInvalid, 0); // not an error
+  BOOST_CHECK_EQUAL(receivedInterests.size(), 1);
+
+  shared_ptr<lp::NonDiscoveryTag> tag = receivedInterests.back().getTag<lp::NonDiscoveryTag>();
+  BOOST_CHECK(tag == nullptr);
+}
+
+BOOST_AUTO_TEST_CASE(ReceiveNonDiscoveryDropData)
+{
+  GenericLinkService::Options options;
+  options.allowSelfLearning = true;
+  initialize(options);
+
+  shared_ptr<Data> data = makeData("/12345678");
+  lp::Packet packet(data->wireEncode());
+  packet.set<lp::NonDiscoveryField>(lp::EmptyValue{});
+
+  transport->receivePacket(packet.wireEncode());
+
+  BOOST_CHECK_EQUAL(service->getCounters().nInNetInvalid, 1);
+  BOOST_CHECK(receivedData.empty());
+}
+
+BOOST_AUTO_TEST_CASE(ReceiveNonDiscoveryDropNack)
+{
+  GenericLinkService::Options options;
+  options.allowSelfLearning = true;
+  initialize(options);
+
+  lp::Nack nack = makeNack("/localhost/test", 123, lp::NackReason::NO_ROUTE);
+  lp::Packet packet;
+  packet.set<lp::FragmentField>(std::make_pair(
+    nack.getInterest().wireEncode().begin(), nack.getInterest().wireEncode().end()));
+  packet.set<lp::NackField>(nack.getHeader());
+  packet.set<lp::NonDiscoveryField>(lp::EmptyValue{});
+
+  transport->receivePacket(packet.wireEncode());
+
+  BOOST_CHECK_EQUAL(service->getCounters().nInNetInvalid, 1);
+  BOOST_CHECK(receivedNacks.empty());
+}
+
+BOOST_AUTO_TEST_CASE(SendPrefixAnnouncement)
+{
+  GenericLinkService::Options options;
+  options.allowSelfLearning = true;
+  initialize(options);
+
+  shared_ptr<Data> data = makeData("/12345678");
+  lp::PrefixAnnouncement pa = makePrefixAnnouncement("/local/ndn/prefix");
+  data->setTag(make_shared<lp::PrefixAnnouncementTag>(pa));
+
+  face->sendData(*data);
+
+  BOOST_REQUIRE_EQUAL(transport->sentPackets.size(), 1);
+  lp::Packet sent(transport->sentPackets.back().packet);
+  BOOST_CHECK(sent.has<lp::PrefixAnnouncementField>());
+}
+
+BOOST_AUTO_TEST_CASE(SendPrefixAnnouncementDisabled)
+{
+  GenericLinkService::Options options;
+  options.allowSelfLearning = false;
+  initialize(options);
+
+  shared_ptr<Data> data = makeData("/12345678");
+  lp::PrefixAnnouncement pa = makePrefixAnnouncement("/local/ndn/prefix");
+  data->setTag(make_shared<lp::PrefixAnnouncementTag>(pa));
+
+  face->sendData(*data);
+
+  BOOST_REQUIRE_EQUAL(transport->sentPackets.size(), 1);
+  lp::Packet sent(transport->sentPackets.back().packet);
+  BOOST_CHECK(!sent.has<lp::PrefixAnnouncementField>());
+}
+
+BOOST_AUTO_TEST_CASE(ReceivePrefixAnnouncement)
+{
+  GenericLinkService::Options options;
+  options.allowSelfLearning = true;
+  initialize(options);
+
+  shared_ptr<Data> data = makeData("/12345678");
+  lp::PrefixAnnouncement pa = makePrefixAnnouncement("/local/ndn/prefix");
+  lp::Packet packet(data->wireEncode());
+  packet.set<lp::PrefixAnnouncementField>(pa);
+
+  transport->receivePacket(packet.wireEncode());
+
+  BOOST_REQUIRE_EQUAL(receivedData.size(), 1);
+  shared_ptr<lp::PrefixAnnouncementTag> tag = receivedData.back().getTag<lp::PrefixAnnouncementTag>();
+  BOOST_REQUIRE_EQUAL(tag->get().getAnnouncedName(), "/local/ndn/prefix");
+}
+
+BOOST_AUTO_TEST_CASE(ReceivePrefixAnnouncementDisabled)
+{
+  GenericLinkService::Options options;
+  options.allowSelfLearning = false;
+  initialize(options);
+
+  shared_ptr<Data> data = makeData("/12345678");
+  lp::PrefixAnnouncement pa = makePrefixAnnouncement("/local/ndn/prefix");
+  lp::Packet packet(data->wireEncode());
+  packet.set<lp::PrefixAnnouncementField>(pa);
+
+  transport->receivePacket(packet.wireEncode());
+
+  BOOST_CHECK_EQUAL(service->getCounters().nInNetInvalid, 0); // not an error
+  BOOST_CHECK_EQUAL(receivedData.size(), 1);
+
+  shared_ptr<lp::NonDiscoveryTag> tag = receivedData.back().getTag<lp::NonDiscoveryTag>();
+  BOOST_CHECK(tag == nullptr);
+}
+
+BOOST_AUTO_TEST_CASE(ReceivePrefixAnnouncementDropInterest)
+{
+  GenericLinkService::Options options;
+  options.allowSelfLearning = true;
+  initialize(options);
+
+  shared_ptr<Interest> interest = makeInterest("/12345678");
+  lp::PrefixAnnouncement pa = makePrefixAnnouncement("/local/ndn/prefix");
+  lp::Packet packet(interest->wireEncode());
+  packet.set<lp::PrefixAnnouncementField>(pa);
+
+  transport->receivePacket(packet.wireEncode());
+
+  BOOST_CHECK_EQUAL(service->getCounters().nInNetInvalid, 1);
+  BOOST_CHECK(receivedInterests.empty());
+}
+
+BOOST_AUTO_TEST_CASE(ReceivePrefixAnnouncementDropNack)
+{
+  GenericLinkService::Options options;
+  options.allowSelfLearning = true;
+  initialize(options);
+
+  lp::Nack nack = makeNack("/localhost/test", 123, lp::NackReason::NO_ROUTE);
+  lp::PrefixAnnouncement pa = makePrefixAnnouncement("/local/ndn/prefix");
+  lp::Packet packet;
+  packet.set<lp::FragmentField>(std::make_pair(
+    nack.getInterest().wireEncode().begin(), nack.getInterest().wireEncode().end()));
+  packet.set<lp::NackField>(nack.getHeader());
+  packet.set<lp::PrefixAnnouncementField>(pa);
+
+  transport->receivePacket(packet.wireEncode());
+
+  BOOST_CHECK_EQUAL(service->getCounters().nInNetInvalid, 1);
+  BOOST_CHECK(receivedNacks.empty());
+}
+
 BOOST_AUTO_TEST_SUITE_END() // LpFields
 
 BOOST_AUTO_TEST_SUITE(Malformed) // receive malformed packets