diff --git a/model/ccnx-l3-protocol.cc b/model/ccnx-l3-protocol.cc
index 8cebc00..312404d 100644
--- a/model/ccnx-l3-protocol.cc
+++ b/model/ccnx-l3-protocol.cc
@@ -29,27 +29,22 @@
 #include "ns3/trace-source-accessor.h"
 #include "ns3/object-vector.h"
 #include "ns3/pointer.h"
-#include "ns3/boolean.h"
-#include "ns3/string.h"
 #include "ns3/simulator.h"
 #include "ns3/random-variable.h"
 
 #include "ns3/ccnx-header-helper.h"
+#include "ns3/ccnx-pit.h"
+#include "ns3/ccnx-interest-header.h"
+#include "ns3/ccnx-content-object-header.h"
 
-#include "ccnx-face.h"
-#include "ccnx-forwarding-strategy.h"
-#include "ccnx-interest-header.h"
-#include "ccnx-content-object-header.h"
-#include "ccnx-fib-impl.h"
+#include "ns3/ccnx-face.h"
+#include "ns3/ccnx-forwarding-strategy.h"
+
+// #include "fib/ccnx-fib-impl.h"
 
 #include "ccnx-net-device-face.h"
 
 #include <boost/foreach.hpp>
-#include <boost/lambda/lambda.hpp>
-#include <boost/lambda/bind.hpp>
-
-using namespace boost::tuples;
-namespace ll = boost::lambda;
 
 NS_LOG_COMPONENT_DEFINE ("CcnxL3Protocol");
 
@@ -71,15 +66,6 @@
                    ObjectVectorValue (),
                    MakeObjectVectorAccessor (&CcnxL3Protocol::m_faces),
                    MakeObjectVectorChecker<CcnxFace> ())
-
-    .AddAttribute ("EnableNACKs", "Enabling support of NACKs",
-                   BooleanValue (false),
-                   MakeBooleanAccessor (&CcnxL3Protocol::m_nacksEnabled),
-                   MakeBooleanChecker ())
-    .AddAttribute ("CacheUnsolicitedData", "Cache overheard data that have not been requested",
-                   BooleanValue (false),
-                   MakeBooleanAccessor (&CcnxL3Protocol::m_cacheUnsolicitedData),
-                   MakeBooleanChecker ())
   ;
   return tid;
 }
@@ -108,26 +94,28 @@
       m_node = GetObject<Node> ();
       if (m_node != 0)
         {
-          NS_ASSERT_MSG (m_pit != 0 && m_fib != 0 && m_contentStore != 0 && m_forwardingStrategy != 0,
-                         "PIT, FIB, and ContentStore should be aggregated before CcnxL3Protocol");
+          // NS_ASSERT_MSG (m_pit != 0 && m_fib != 0 && m_contentStore != 0 && m_forwardingStrategy != 0,
+          //                "PIT, FIB, and ContentStore should be aggregated before CcnxL3Protocol");
+          NS_ASSERT_MSG (m_forwardingStrategy != 0,
+                         "Forwarding strategy should be aggregated before CcnxL3Protocol");
         }
     }
-  if (m_pit == 0)
-    {
-      m_pit = GetObject<CcnxPit> ();
-    }
-  if (m_fib == 0)
-    {
-      m_fib = GetObject<CcnxFib> ();
-    }
+  // if (m_pit == 0)
+  //   {
+  //     m_pit = GetObject<CcnxPit> ();
+  //   }
+  // if (m_fib == 0)
+  //   {
+  //     m_fib = GetObject<CcnxFib> ();
+  //   }
   if (m_forwardingStrategy == 0)
     {
       m_forwardingStrategy = GetObject<CcnxForwardingStrategy> ();
     }
-  if (m_contentStore == 0)
-    {
-      m_contentStore = GetObject<CcnxContentStore> ();
-    }
+  // if (m_contentStore == 0)
+  //   {
+  //     m_contentStore = GetObject<CcnxContentStore> ();
+  //   }
 
   Object::NotifyNewAggregate ();
 }
@@ -146,9 +134,6 @@
 
   // Force delete on objects
   m_forwardingStrategy = 0; // there is a reference to PIT stored in here
-  m_pit = 0;
-  m_contentStore = 0;
-  m_fib = 0;
 
   Object::DoDispose ();
 }
@@ -173,10 +158,11 @@
 {
   // ask face to register in lower-layer stack
   face->RegisterProtocolHandler (MakeNullCallback<void,const Ptr<CcnxFace>&,const Ptr<const Packet>&> ());
+  Ptr<CcnxPit> pit = GetObject<CcnxPit> ();
 
   // just to be on a safe side. Do the process in two steps
   std::list< Ptr<CcnxPitEntry> > entriesToRemoves;
-  for (Ptr<CcnxPitEntry> pitEntry = m_pit->Begin (); pitEntry != 0; pitEntry = m_pit->Next (pitEntry))
+  for (Ptr<CcnxPitEntry> pitEntry = pit->Begin (); pitEntry != 0; pitEntry = pit->Next (pitEntry))
     {
       pitEntry->RemoveAllReferencesToFace (face);
       
@@ -190,7 +176,7 @@
     }
   BOOST_FOREACH (Ptr<CcnxPitEntry> removedEntry, entriesToRemoves)
     {
-      m_pit->MarkErased (removedEntry);
+      pit->MarkErased (removedEntry);
     }
 
   CcnxFaceList::iterator face_it = find (m_faces.begin(), m_faces.end(), face);
@@ -254,10 +240,11 @@
             packet->RemoveHeader (*header);
             NS_ASSERT_MSG (packet->GetSize () == 0, "Payload of Interests should be zero");
 
-            if (header->GetNack () > 0)
-              OnNack (face, header, p/*original packet*/);
-            else
-              OnInterest (face, header, p/*original packet*/);  
+            m_forwardingStrategy->OnInterest (face, header, p/*original packet*/);
+            // if (header->GetNack () > 0)
+            //   OnNack (face, header, p/*original packet*/);
+            // else
+            //   OnInterest (face, header, p/*original packet*/);  
             break;
           }
         case CcnxHeaderHelper::CONTENT_OBJECT:
@@ -270,7 +257,7 @@
             packet->RemoveHeader (*header);
             packet->RemoveTrailer (contentObjectTrailer);
 
-            OnData (face, header, packet/*payload*/, p/*original packet*/);  
+            m_forwardingStrategy->OnData (face, header, packet/*payload*/, p/*original packet*/);  
             break;
           }
         }
@@ -285,405 +272,405 @@
     }
 }
 
-void
-CcnxL3Protocol::OnNack (const Ptr<CcnxFace> &incomingFace,
-                        Ptr<CcnxInterestHeader> &header,
-                        const Ptr<const Packet> &packet)
-{
-  NS_LOG_FUNCTION (incomingFace << header << packet);
-  m_inNacks (header, incomingFace);
+// void
+// CcnxL3Protocol::OnNack (const Ptr<CcnxFace> &incomingFace,
+//                         Ptr<CcnxInterestHeader> &header,
+//                         const Ptr<const Packet> &packet)
+// {
+//   NS_LOG_FUNCTION (incomingFace << header << packet);
+//   m_inNacks (header, incomingFace);
 
-  Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
-  if (pitEntry == 0)
-    {
-      // somebody is doing something bad
-      m_dropNacks (header, NON_DUPLICATED, incomingFace);
-      return;
-    }
+//   Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
+//   if (pitEntry == 0)
+//     {
+//       // somebody is doing something bad
+//       m_dropNacks (header, NON_DUPLICATED, incomingFace);
+//       return;
+//     }
   
-  // CcnxPitEntryIncomingFaceContainer::type::iterator inFace = pitEntry->GetIncoming ().find (incomingFace);
-  CcnxPitEntryOutgoingFaceContainer::type::iterator outFace = pitEntry->GetOutgoing ().find (incomingFace);
+//   // CcnxPitEntryIncomingFaceContainer::type::iterator inFace = pitEntry->GetIncoming ().find (incomingFace);
+//   CcnxPitEntryOutgoingFaceContainer::type::iterator outFace = pitEntry->GetOutgoing ().find (incomingFace);
 
-  if (outFace == pitEntry->GetOutgoing ().end ())
-    {
-//      NS_ASSERT_MSG (false,
-//                     "Node " << GetObject<Node> ()->GetId () << ", outgoing entry should exist for face " << boost::cref(*incomingFace) << "\n" <<
-//                     "size: " << pitEntry.GetOutgoing ().size ());
+//   if (outFace == pitEntry->GetOutgoing ().end ())
+//     {
+// //      NS_ASSERT_MSG (false,
+// //                     "Node " << GetObject<Node> ()->GetId () << ", outgoing entry should exist for face " << boost::cref(*incomingFace) << "\n" <<
+// //                     "size: " << pitEntry.GetOutgoing ().size ());
       
-      // m_dropNacks (header, NON_DUPLICATE, incomingFace);
-      return;
-    }
+//       // m_dropNacks (header, NON_DUPLICATE, incomingFace);
+//       return;
+//     }
 
-  // This was done in error. Never, never do anything, except normal leakage. This way we ensure that we will not have losses,
-  // at least when there is only one client
-  //
-  // incomingFace->LeakBucketByOnePacket ();
+//   // This was done in error. Never, never do anything, except normal leakage. This way we ensure that we will not have losses,
+//   // at least when there is only one client
+//   //
+//   // incomingFace->LeakBucketByOnePacket ();
 
-  NS_LOG_ERROR ("Nack on " << boost::cref(*incomingFace));
+//   NS_LOG_ERROR ("Nack on " << boost::cref(*incomingFace));
   
-  pitEntry->SetWaitingInVain (outFace);
+//   pitEntry->SetWaitingInVain (outFace);
 
-  // If NACK is NACK_GIVEUP_PIT, then neighbor gave up trying to and removed it's PIT entry.
-  // So, if we had an incoming entry to this neighbor, then we can remove it now
+//   // If NACK is NACK_GIVEUP_PIT, then neighbor gave up trying to and removed it's PIT entry.
+//   // So, if we had an incoming entry to this neighbor, then we can remove it now
 
-  if (header->GetNack () == CcnxInterestHeader::NACK_GIVEUP_PIT)
-    {
-      pitEntry->RemoveIncoming (incomingFace);
-    }
+//   if (header->GetNack () == CcnxInterestHeader::NACK_GIVEUP_PIT)
+//     {
+//       pitEntry->RemoveIncoming (incomingFace);
+//     }
 
-  pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW);
-  // StaticCast<CcnxFibImpl> (m_fib)->modify (pitEntry->GetFibEntry (),
-  //                                           ll::bind (&CcnxFibEntry::UpdateStatus,
-  //                                                     ll::_1, incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW));
+//   pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW);
+//   // StaticCast<CcnxFibImpl> (m_fib)->modify (pitEntry->GetFibEntry (),
+//   //                                           ll::bind (&CcnxFibEntry::UpdateStatus,
+//   //                                                     ll::_1, incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW));
 
-  if (pitEntry->GetIncoming ().size () == 0) // interest was actually satisfied
-    {
-      // no need to do anything
-      m_dropNacks (header, AFTER_SATISFIED, incomingFace);
-      return;
-    }
+//   if (pitEntry->GetIncoming ().size () == 0) // interest was actually satisfied
+//     {
+//       // no need to do anything
+//       m_dropNacks (header, AFTER_SATISFIED, incomingFace);
+//       return;
+//     }
 
-  if (!pitEntry->AreAllOutgoingInVain ()) // not all ougtoing are in vain
-    {
-      NS_LOG_DEBUG ("Not all outgoing are in vain");
-      // suppress
-      // Don't do anything, we are still expecting data from some other face
-      m_dropNacks (header, SUPPRESSED, incomingFace);
-      return;
-    }
+//   if (!pitEntry->AreAllOutgoingInVain ()) // not all ougtoing are in vain
+//     {
+//       NS_LOG_DEBUG ("Not all outgoing are in vain");
+//       // suppress
+//       // Don't do anything, we are still expecting data from some other face
+//       m_dropNacks (header, SUPPRESSED, incomingFace);
+//       return;
+//     }
   
-  Ptr<Packet> nonNackInterest = Create<Packet> ();
-  header->SetNack (CcnxInterestHeader::NORMAL_INTEREST);
-  nonNackInterest->AddHeader (*header);
+//   Ptr<Packet> nonNackInterest = Create<Packet> ();
+//   header->SetNack (CcnxInterestHeader::NORMAL_INTEREST);
+//   nonNackInterest->AddHeader (*header);
   
-  bool propagated = m_forwardingStrategy->
-    PropagateInterest (pitEntry, incomingFace, header, nonNackInterest);
+//   bool propagated = m_forwardingStrategy->
+//     PropagateInterest (pitEntry, incomingFace, header, nonNackInterest);
 
-  // // ForwardingStrategy will try its best to forward packet to at least one interface.
-  // // If no interests was propagated, then there is not other option for forwarding or
-  // // ForwardingStrategy failed to find it. 
-  if (!propagated)
-    {
-      m_dropNacks (header, NO_FACES, incomingFace); // this headers doesn't have NACK flag set
-      GiveUpInterest (pitEntry, header);
-    }
-}
+//   // // ForwardingStrategy will try its best to forward packet to at least one interface.
+//   // // If no interests was propagated, then there is not other option for forwarding or
+//   // // ForwardingStrategy failed to find it. 
+//   if (!propagated)
+//     {
+//       m_dropNacks (header, NO_FACES, incomingFace); // this headers doesn't have NACK flag set
+//       GiveUpInterest (pitEntry, header);
+//     }
+// }
 
 // Processing Interests
 //
-// !!! Key point.
-// !!! All interests should be answerred!!! Either later with data, immediately with data, or immediately with NACK
-void CcnxL3Protocol::OnInterest (const Ptr<CcnxFace> &incomingFace,
-                                 Ptr<CcnxInterestHeader> &header,
-                                 const Ptr<const Packet> &packet)
-{
-  m_inInterests (header, incomingFace);
+// // !!! Key point.
+// // !!! All interests should be answerred!!! Either later with data, immediately with data, or immediately with NACK
+// void CcnxL3Protocol::OnInterest (const Ptr<CcnxFace> &incomingFace,
+//                                  Ptr<CcnxInterestHeader> &header,
+//                                  const Ptr<const Packet> &packet)
+// {
+//   m_inInterests (header, incomingFace);
 
-  Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
-  if (pitEntry == 0)
-    {
-      pitEntry = m_pit->Create (header);
-    }
+//   Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
+//   if (pitEntry == 0)
+//     {
+//       pitEntry = m_pit->Create (header);
+//     }
 
-  if (pitEntry == 0)
-    {
-      // if it is still not created, then give up processing
-      m_dropInterests (header, PIT_LIMIT, incomingFace);
-      return;
-    }
+//   if (pitEntry == 0)
+//     {
+//       // if it is still not created, then give up processing
+//       m_dropInterests (header, PIT_LIMIT, incomingFace);
+//       return;
+//     }
   
-  bool isNew = pitEntry->GetIncoming ().size () == 0 && pitEntry->GetOutgoing ().size () == 0;
-  bool isDuplicated = true;
-  if (!pitEntry->IsNonceSeen (header->GetNonce ()))
-    {
-      pitEntry->AddSeenNonce (header->GetNonce ());
-      isDuplicated = false;
-    }
+//   bool isNew = pitEntry->GetIncoming ().size () == 0 && pitEntry->GetOutgoing ().size () == 0;
+//   bool isDuplicated = true;
+//   if (!pitEntry->IsNonceSeen (header->GetNonce ()))
+//     {
+//       pitEntry->AddSeenNonce (header->GetNonce ());
+//       isDuplicated = false;
+//     }
 
-  NS_LOG_FUNCTION (header->GetName () << header->GetNonce () << boost::cref (*incomingFace) << isDuplicated);
+//   NS_LOG_FUNCTION (header->GetName () << header->GetNonce () << boost::cref (*incomingFace) << isDuplicated);
 
-  /////////////////////////////////////////////////////////////////////////////////////////
-  /////////////////////////////////////////////////////////////////////////////////////////
-  /////////////////////////////////////////////////////////////////////////////////////////
-  //                                                                                     //
-  // !!!! IMPORTANT CHANGE !!!! Duplicate interests will create incoming face entry !!!! //
-  //                                                                                     //
-  /////////////////////////////////////////////////////////////////////////////////////////
-  /////////////////////////////////////////////////////////////////////////////////////////
-  /////////////////////////////////////////////////////////////////////////////////////////
+//   /////////////////////////////////////////////////////////////////////////////////////////
+//   /////////////////////////////////////////////////////////////////////////////////////////
+//   /////////////////////////////////////////////////////////////////////////////////////////
+//   //                                                                                     //
+//   // !!!! IMPORTANT CHANGE !!!! Duplicate interests will create incoming face entry !!!! //
+//   //                                                                                     //
+//   /////////////////////////////////////////////////////////////////////////////////////////
+//   /////////////////////////////////////////////////////////////////////////////////////////
+//   /////////////////////////////////////////////////////////////////////////////////////////
   
-  // Data is not in cache
-  CcnxPitEntry::in_iterator inFace   = pitEntry->GetIncoming ().find (incomingFace);
-  CcnxPitEntry::out_iterator outFace = pitEntry->GetOutgoing ().find (incomingFace);
+//   // Data is not in cache
+//   CcnxPitEntry::in_iterator inFace   = pitEntry->GetIncoming ().find (incomingFace);
+//   CcnxPitEntry::out_iterator outFace = pitEntry->GetOutgoing ().find (incomingFace);
 
-  bool isRetransmitted = false;
+//   bool isRetransmitted = false;
   
-  if (inFace != pitEntry->GetIncoming ().end ())
-    {
-      // CcnxPitEntryIncomingFace.m_arrivalTime keeps track arrival time of the first packet... why?
+//   if (inFace != pitEntry->GetIncoming ().end ())
+//     {
+//       // CcnxPitEntryIncomingFace.m_arrivalTime keeps track arrival time of the first packet... why?
 
-      isRetransmitted = true;
-      // this is almost definitely a retransmission. But should we trust the user on that?
-    }
-  else
-    {
-      inFace = pitEntry->AddIncoming (incomingFace);
-    }
-  //////////////////////////////////////////////////////////////////////////////////
-  //////////////////////////////////////////////////////////////////////////////////
-  //////////////////////////////////////////////////////////////////////////////////
+//       isRetransmitted = true;
+//       // this is almost definitely a retransmission. But should we trust the user on that?
+//     }
+//   else
+//     {
+//       inFace = pitEntry->AddIncoming (incomingFace);
+//     }
+//   //////////////////////////////////////////////////////////////////////////////////
+//   //////////////////////////////////////////////////////////////////////////////////
+//   //////////////////////////////////////////////////////////////////////////////////
   
-  if (isDuplicated) 
-    {
-      NS_LOG_DEBUG ("Received duplicatie interest on " << *incomingFace);
-      m_dropInterests (header, DUPLICATED, incomingFace);
+//   if (isDuplicated) 
+//     {
+//       NS_LOG_DEBUG ("Received duplicatie interest on " << *incomingFace);
+//       m_dropInterests (header, DUPLICATED, incomingFace);
 
-      /**
-       * This condition will handle "routing" loops and also recently satisfied interests.
-       * Every time interest is satisfied, PIT entry (with empty incoming and outgoing faces)
-       * is kept for another small chunk of time.
-       */
+//       /**
+//        * This condition will handle "routing" loops and also recently satisfied interests.
+//        * Every time interest is satisfied, PIT entry (with empty incoming and outgoing faces)
+//        * is kept for another small chunk of time.
+//        */
 
-      if (m_nacksEnabled)
-        {
-          NS_LOG_DEBUG ("Sending NACK_LOOP");
-          header->SetNack (CcnxInterestHeader::NACK_LOOP);
-          Ptr<Packet> nack = Create<Packet> ();
-          nack->AddHeader (*header);
+//       if (m_nacksEnabled)
+//         {
+//           NS_LOG_DEBUG ("Sending NACK_LOOP");
+//           header->SetNack (CcnxInterestHeader::NACK_LOOP);
+//           Ptr<Packet> nack = Create<Packet> ();
+//           nack->AddHeader (*header);
 
-          incomingFace->Send (nack);
-          m_outNacks (header, incomingFace);
-        }
+//           incomingFace->Send (nack);
+//           m_outNacks (header, incomingFace);
+//         }
       
-      return;
-    }
+//       return;
+//     }
 
-  Ptr<Packet> contentObject;
-  Ptr<const CcnxContentObjectHeader> contentObjectHeader; // used for tracing
-  Ptr<const Packet> payload; // used for tracing
-  tie (contentObject, contentObjectHeader, payload) = m_contentStore->Lookup (header);
-  if (contentObject != 0)
-    {
-      NS_ASSERT (contentObjectHeader != 0);      
-      NS_LOG_LOGIC("Found in cache");
+//   Ptr<Packet> contentObject;
+//   Ptr<const CcnxContentObjectHeader> contentObjectHeader; // used for tracing
+//   Ptr<const Packet> payload; // used for tracing
+//   tie (contentObject, contentObjectHeader, payload) = m_contentStore->Lookup (header);
+//   if (contentObject != 0)
+//     {
+//       NS_ASSERT (contentObjectHeader != 0);      
+//       NS_LOG_LOGIC("Found in cache");
 
-      OnDataDelayed (contentObjectHeader, payload, contentObject);
-      return;
-    }
+//       OnDataDelayed (contentObjectHeader, payload, contentObject);
+//       return;
+//     }
 
-  // update PIT entry lifetime
-  pitEntry->UpdateLifetime (header->GetInterestLifetime ());
+//   // update PIT entry lifetime
+//   pitEntry->UpdateLifetime (header->GetInterestLifetime ());
   
-  if (outFace != pitEntry->GetOutgoing ().end ())
-    {
-      NS_LOG_DEBUG ("Non duplicate interests from the face we have sent interest to. Don't suppress");
-      // got a non-duplicate interest from the face we have sent interest to
-      // Probably, there is no point in waiting data from that face... Not sure yet
+//   if (outFace != pitEntry->GetOutgoing ().end ())
+//     {
+//       NS_LOG_DEBUG ("Non duplicate interests from the face we have sent interest to. Don't suppress");
+//       // got a non-duplicate interest from the face we have sent interest to
+//       // Probably, there is no point in waiting data from that face... Not sure yet
 
-      // If we're expecting data from the interface we got the interest from ("producer" asks us for "his own" data)
-      // Mark interface YELLOW, but keep a small hope that data will come eventually.
+//       // If we're expecting data from the interface we got the interest from ("producer" asks us for "his own" data)
+//       // Mark interface YELLOW, but keep a small hope that data will come eventually.
 
-      // ?? not sure if we need to do that ?? ...
+//       // ?? not sure if we need to do that ?? ...
       
-      pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW);
-      // StaticCast<CcnxFibImpl> (m_fib)->modify(pitEntry->GetFibEntry (),
-      //                                          ll::bind (&CcnxFibEntry::UpdateStatus,
-      //                                                    ll::_1, incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW));
-    }
-  else
-    if (!isNew && !isRetransmitted)
-      {
-        // Suppress this interest if we're still expecting data from some other face
-        NS_LOG_DEBUG ("Suppress interests");
-        m_dropInterests (header, SUPPRESSED, incomingFace);
-        return;
-      }
+//       pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW);
+//       // StaticCast<CcnxFibImpl> (m_fib)->modify(pitEntry->GetFibEntry (),
+//       //                                          ll::bind (&CcnxFibEntry::UpdateStatus,
+//       //                                                    ll::_1, incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW));
+//     }
+//   else
+//     if (!isNew && !isRetransmitted)
+//       {
+//         // Suppress this interest if we're still expecting data from some other face
+//         NS_LOG_DEBUG ("Suppress interests");
+//         m_dropInterests (header, SUPPRESSED, incomingFace);
+//         return;
+//       }
   
-  /////////////////////////////////////////////////////////////////////
-  // Propagate
-  /////////////////////////////////////////////////////////////////////
+//   /////////////////////////////////////////////////////////////////////
+//   // Propagate
+//   /////////////////////////////////////////////////////////////////////
   
-  bool propagated = m_forwardingStrategy->
-    PropagateInterest (pitEntry, incomingFace, header, packet);
+//   bool propagated = m_forwardingStrategy->
+//     PropagateInterest (pitEntry, incomingFace, header, packet);
 
-  if (!propagated && isRetransmitted) //give another chance if retransmitted
-    {
-      // increase max number of allowed retransmissions
-      pitEntry->IncreaseAllowedRetxCount ();
+//   if (!propagated && isRetransmitted) //give another chance if retransmitted
+//     {
+//       // increase max number of allowed retransmissions
+//       pitEntry->IncreaseAllowedRetxCount ();
 
-      // try again
-      propagated = m_forwardingStrategy->
-        PropagateInterest (pitEntry, incomingFace, header, packet);
-    }
+//       // try again
+//       propagated = m_forwardingStrategy->
+//         PropagateInterest (pitEntry, incomingFace, header, packet);
+//     }
   
-  // ForwardingStrategy will try its best to forward packet to at least one interface.
-  // If no interests was propagated, then there is not other option for forwarding or
-  // ForwardingStrategy failed to find it. 
-  if (!propagated)
-    {
-      NS_LOG_DEBUG ("Not propagated");
-      m_dropInterests (header, NO_FACES, incomingFace);
-      GiveUpInterest (pitEntry, header);
-    }
-}
+//   // ForwardingStrategy will try its best to forward packet to at least one interface.
+//   // If no interests was propagated, then there is not other option for forwarding or
+//   // ForwardingStrategy failed to find it. 
+//   if (!propagated)
+//     {
+//       NS_LOG_DEBUG ("Not propagated");
+//       m_dropInterests (header, NO_FACES, incomingFace);
+//       GiveUpInterest (pitEntry, header);
+//     }
+// }
 
-void
-CcnxL3Protocol::OnDataDelayed (Ptr<const CcnxContentObjectHeader> header,
-                               Ptr<const Packet> payload,
-                               const Ptr<const Packet> &packet)
-{
-  // 1. Lookup PIT entry
-  Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
-  if (pitEntry != 0)
-    {
-      //satisfy all pending incoming Interests
-      BOOST_FOREACH (const CcnxPitEntryIncomingFace &incoming, pitEntry->GetIncoming ())
-        {
-          incoming.m_face->Send (packet->Copy ());
-          m_outData (header, payload, false, incoming.m_face);
-          NS_LOG_DEBUG ("Satisfy " << *incoming.m_face);
+// void
+// CcnxL3Protocol::OnDataDelayed (Ptr<const CcnxContentObjectHeader> header,
+//                                Ptr<const Packet> payload,
+//                                const Ptr<const Packet> &packet)
+// {
+//   // 1. Lookup PIT entry
+//   Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
+//   if (pitEntry != 0)
+//     {
+//       //satisfy all pending incoming Interests
+//       BOOST_FOREACH (const CcnxPitEntryIncomingFace &incoming, pitEntry->GetIncoming ())
+//         {
+//           incoming.m_face->Send (packet->Copy ());
+//           m_outData (header, payload, false, incoming.m_face);
+//           NS_LOG_DEBUG ("Satisfy " << *incoming.m_face);
           
-          // successfull forwarded data trace
-        }
+//           // successfull forwarded data trace
+//         }
 
-      if (pitEntry->GetIncoming ().size () > 0)
-        {
-          // All incoming interests are satisfied. Remove them
-          pitEntry->ClearIncoming ();
+//       if (pitEntry->GetIncoming ().size () > 0)
+//         {
+//           // All incoming interests are satisfied. Remove them
+//           pitEntry->ClearIncoming ();
 
-          // Remove all outgoing faces
-          pitEntry->ClearOutgoing ();
+//           // Remove all outgoing faces
+//           pitEntry->ClearOutgoing ();
           
-          // Set pruning timout on PIT entry (instead of deleting the record)
-          m_pit->MarkErased (pitEntry);
-        }
-    }
-  else
-    {
-      NS_LOG_DEBUG ("Pit entry not found (was satisfied and removed before)");
-      return; // do not process unsoliced data packets
-    }
-}
+//           // Set pruning timout on PIT entry (instead of deleting the record)
+//           m_pit->MarkErased (pitEntry);
+//         }
+//     }
+//   else
+//     {
+//       NS_LOG_DEBUG ("Pit entry not found (was satisfied and removed before)");
+//       return; // do not process unsoliced data packets
+//     }
+// }
 
-// Processing ContentObjects
-void
-CcnxL3Protocol::OnData (const Ptr<CcnxFace> &incomingFace,
-                        Ptr<CcnxContentObjectHeader> &header,
-                        Ptr<Packet> &payload,
-                        const Ptr<const Packet> &packet)
-{
+// // Processing ContentObjects
+// void
+// CcnxL3Protocol::OnData (const Ptr<CcnxFace> &incomingFace,
+//                         Ptr<CcnxContentObjectHeader> &header,
+//                         Ptr<Packet> &payload,
+//                         const Ptr<const Packet> &packet)
+// {
     
-  NS_LOG_FUNCTION (incomingFace << header->GetName () << payload << packet);
-  m_inData (header, payload, incomingFace);
+//   NS_LOG_FUNCTION (incomingFace << header->GetName () << payload << packet);
+//   m_inData (header, payload, incomingFace);
   
-  // 1. Lookup PIT entry
-  Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
-  if (pitEntry != 0)
-    {
-      // Note that with MultiIndex we need to modify entries indirectly
+//   // 1. Lookup PIT entry
+//   Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
+//   if (pitEntry != 0)
+//     {
+//       // Note that with MultiIndex we need to modify entries indirectly
 
-      CcnxPitEntry::out_iterator out = pitEntry->GetOutgoing ().find (incomingFace);
+//       CcnxPitEntry::out_iterator out = pitEntry->GetOutgoing ().find (incomingFace);
   
-      // If we have sent interest for this data via this face, then update stats.
-      if (out != pitEntry->GetOutgoing ().end ())
-        {
-          pitEntry->GetFibEntry ()->UpdateFaceRtt (incomingFace, Simulator::Now () - out->m_sendTime);
-          // StaticCast<CcnxFibImpl> (m_fib)->modify (pitEntry->GetFibEntry (),
-          //                                          ll::bind (&CcnxFibEntry::UpdateFaceRtt,
-          //                                                    ll::_1,
-          //                                                    incomingFace,
-          //                                                    Simulator::Now () - out->m_sendTime));
-        }
-      else
-        {
-          // Unsolicited data, but we're interested in it... should we get it?
-          // Potential hole for attacks
+//       // If we have sent interest for this data via this face, then update stats.
+//       if (out != pitEntry->GetOutgoing ().end ())
+//         {
+//           pitEntry->GetFibEntry ()->UpdateFaceRtt (incomingFace, Simulator::Now () - out->m_sendTime);
+//           // StaticCast<CcnxFibImpl> (m_fib)->modify (pitEntry->GetFibEntry (),
+//           //                                          ll::bind (&CcnxFibEntry::UpdateFaceRtt,
+//           //                                                    ll::_1,
+//           //                                                    incomingFace,
+//           //                                                    Simulator::Now () - out->m_sendTime));
+//         }
+//       else
+//         {
+//           // Unsolicited data, but we're interested in it... should we get it?
+//           // Potential hole for attacks
 
-          if (m_cacheUnsolicitedData)
-            {
-              // Optimistically add or update entry in the content store
-              m_contentStore->Add (header, payload);
-            }
-          else
-            {
-              NS_LOG_ERROR ("Node "<< m_node->GetId() <<
-                            ". PIT entry for "<< header->GetName ()<<" is valid, "
-                            "but outgoing entry for interface "<< boost::cref(*incomingFace) <<" doesn't exist\n");
-            }
-          // ignore unsolicited data
-          return;
-        }
+//           if (m_cacheUnsolicitedData)
+//             {
+//               // Optimistically add or update entry in the content store
+//               m_contentStore->Add (header, payload);
+//             }
+//           else
+//             {
+//               NS_LOG_ERROR ("Node "<< m_node->GetId() <<
+//                             ". PIT entry for "<< header->GetName ()<<" is valid, "
+//                             "but outgoing entry for interface "<< boost::cref(*incomingFace) <<" doesn't exist\n");
+//             }
+//           // ignore unsolicited data
+//           return;
+//         }
 
-      // Update metric status for the incoming interface in the corresponding FIB entry
-      pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_GREEN);
-      // StaticCast<CcnxFibImpl>(m_fib)->modify (pitEntry->GetFibEntry (),
-      //                                          ll::bind (&CcnxFibEntry::UpdateStatus, ll::_1,
-      //                                                    incomingFace, CcnxFibFaceMetric::NDN_FIB_GREEN));
+//       // Update metric status for the incoming interface in the corresponding FIB entry
+//       pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_GREEN);
+//       // StaticCast<CcnxFibImpl>(m_fib)->modify (pitEntry->GetFibEntry (),
+//       //                                          ll::bind (&CcnxFibEntry::UpdateStatus, ll::_1,
+//       //                                                    incomingFace, CcnxFibFaceMetric::NDN_FIB_GREEN));
   
-      // Add or update entry in the content store
-      m_contentStore->Add (header, payload);
+//       // Add or update entry in the content store
+//       m_contentStore->Add (header, payload);
 
-      pitEntry->RemoveIncoming (incomingFace);
+//       pitEntry->RemoveIncoming (incomingFace);
 
-      if (pitEntry->GetIncoming ().size () == 0)
-        {
-          // Set pruning timout on PIT entry (instead of deleting the record)
-          m_pit->MarkErased (pitEntry);
-        }
-      else
-        {
-          OnDataDelayed (header, payload, packet);
-        }
-    }
-  else
-    {
-      NS_LOG_DEBUG ("Pit entry not found");
-      if (m_cacheUnsolicitedData)
-        {
-          // Optimistically add or update entry in the content store
-          m_contentStore->Add (header, payload);
-        }
-      else
-        {
-          // Drop data packet if PIT entry is not found
-          // (unsolicited data packets should not "poison" content store)
+//       if (pitEntry->GetIncoming ().size () == 0)
+//         {
+//           // Set pruning timout on PIT entry (instead of deleting the record)
+//           m_pit->MarkErased (pitEntry);
+//         }
+//       else
+//         {
+//           OnDataDelayed (header, payload, packet);
+//         }
+//     }
+//   else
+//     {
+//       NS_LOG_DEBUG ("Pit entry not found");
+//       if (m_cacheUnsolicitedData)
+//         {
+//           // Optimistically add or update entry in the content store
+//           m_contentStore->Add (header, payload);
+//         }
+//       else
+//         {
+//           // Drop data packet if PIT entry is not found
+//           // (unsolicited data packets should not "poison" content store)
       
-          //drop dulicated or not requested data packet
-          m_dropData (header, payload, UNSOLICITED, incomingFace);
-        }
-      return; // do not process unsoliced data packets
-    }
-}
+//           //drop dulicated or not requested data packet
+//           m_dropData (header, payload, UNSOLICITED, incomingFace);
+//         }
+//       return; // do not process unsoliced data packets
+//     }
+// }
 
-void
-CcnxL3Protocol::GiveUpInterest (Ptr<CcnxPitEntry> pitEntry,
-                                Ptr<CcnxInterestHeader> header)
-{
-  NS_LOG_FUNCTION (this);
+// void
+// CcnxL3Protocol::GiveUpInterest (Ptr<CcnxPitEntry> pitEntry,
+//                                 Ptr<CcnxInterestHeader> header)
+// {
+//   NS_LOG_FUNCTION (this);
 
-  if (m_nacksEnabled)
-    {
-      Ptr<Packet> packet = Create<Packet> ();
-      header->SetNack (CcnxInterestHeader::NACK_GIVEUP_PIT);
-      packet->AddHeader (*header);
+//   if (m_nacksEnabled)
+//     {
+//       Ptr<Packet> packet = Create<Packet> ();
+//       header->SetNack (CcnxInterestHeader::NACK_GIVEUP_PIT);
+//       packet->AddHeader (*header);
 
-      BOOST_FOREACH (const CcnxPitEntryIncomingFace &incoming, pitEntry->GetIncoming ())
-        {
-          NS_LOG_DEBUG ("Send NACK for " << boost::cref (header->GetName ()) << " to " << boost::cref (*incoming.m_face));
-          incoming.m_face->Send (packet->Copy ());
+//       BOOST_FOREACH (const CcnxPitEntryIncomingFace &incoming, pitEntry->GetIncoming ())
+//         {
+//           NS_LOG_DEBUG ("Send NACK for " << boost::cref (header->GetName ()) << " to " << boost::cref (*incoming.m_face));
+//           incoming.m_face->Send (packet->Copy ());
 
-          m_outNacks (header, incoming.m_face);
-        }
+//           m_outNacks (header, incoming.m_face);
+//         }
   
-      // All incoming interests cannot be satisfied. Remove them
-      pitEntry->ClearIncoming ();
+//       // All incoming interests cannot be satisfied. Remove them
+//       pitEntry->ClearIncoming ();
 
-      // Remove also outgoing
-      pitEntry->ClearOutgoing ();
+//       // Remove also outgoing
+//       pitEntry->ClearOutgoing ();
   
-      // Set pruning timout on PIT entry (instead of deleting the record)
-      m_pit->MarkErased (pitEntry);
-    }
-}
+//       // Set pruning timout on PIT entry (instead of deleting the record)
+//       m_pit->MarkErased (pitEntry);
+//     }
+// }
 
 } //namespace ns3