diff --git a/model/ccnx-bestroute-strategy.cc b/model/ccnx-bestroute-strategy.cc
index 4e592c7..cad2d67 100644
--- a/model/ccnx-bestroute-strategy.cc
+++ b/model/ccnx-bestroute-strategy.cc
@@ -48,8 +48,7 @@
 CcnxBestRouteStrategy::PropagateInterest (const CcnxPitEntry  &pitEntry, 
                                           const Ptr<CcnxFace> &incomingFace,
                                           Ptr<CcnxInterestHeader> &header,
-                                          const Ptr<const Packet> &packet,
-                                          SendCallback sendCallback)
+                                          const Ptr<const Packet> &packet)
 {
   NS_LOG_FUNCTION (this);
   bool forwardedCount = 0;
@@ -66,11 +65,13 @@
           if (pitEntry.m_outgoing.find (bestMetric.m_face) != pitEntry.m_outgoing.end ()) // already forwarded before
             continue;
 
-          bool faceAvailable = m_pit->TryAddOutgoing (pitEntry, bestMetric.m_face);
+          bool faceAvailable = bestMetric.m_face->SendWithLimit (packet->Copy ());
           if (!faceAvailable) // huh...
             continue;
 
-          sendCallback (bestMetric.m_face, header, packet->Copy());
+          m_pit->modify (m_pit->iterator_to (pitEntry),
+                         bind(&CcnxPitEntry::AddOutgoing, lambda::_1, bestMetric.m_face));
+
           forwardedCount++;
           break; // if we succeeded in sending one packet, stop
         }
diff --git a/model/ccnx-bestroute-strategy.h b/model/ccnx-bestroute-strategy.h
index 4e5eb6c..f2d591b 100644
--- a/model/ccnx-bestroute-strategy.h
+++ b/model/ccnx-bestroute-strategy.h
@@ -51,8 +51,7 @@
   PropagateInterest (const CcnxPitEntry  &pitEntry, 
                      const Ptr<CcnxFace> &incomingFace,
                      Ptr<CcnxInterestHeader> &header,
-                     const Ptr<const Packet> &packet,
-                     SendCallback sendCallback);
+                     const Ptr<const Packet> &packet);
 };
 
 } //namespace ns3
diff --git a/model/ccnx-face.cc b/model/ccnx-face.cc
index 19eb21d..1bb55ab 100644
--- a/model/ccnx-face.cc
+++ b/model/ccnx-face.cc
@@ -34,9 +34,12 @@
  *  with no IP addresses.  Before becoming useable, the user must 
  * invoke SetUp on them once an Ccnx address and mask have been set.
  */
-CcnxFace::CcnxFace () 
-  // : m_metric (1)
-  : m_node (0)
+CcnxFace::CcnxFace (Ptr<Node> node) 
+  : m_node (Ptr<Node> node)
+  , m_bucket (0.0)
+  , m_bucketMax (-1.0)
+  , m_bucketLeak (0.0)
+  , m_protocolHandler (MakeNullCallback<void,const Ptr<CcnxFace>&,const Ptr<const Packet>&> ())
   , m_ifup (false)
   , m_id ((uint32_t)-1)
 {
@@ -57,10 +60,53 @@
   return *this;
 }
 
-void 
-CcnxFace::SetNode (Ptr<Node> node)
+void
+CcnxFace::RegisterProtocolHandler (ProtocolHandler handler)
 {
-  m_node = node;
+  m_protocolHandler = handler;
+}
+
+bool
+CcnxFace::SendWithLimit (Ptr<Packet> packet)
+{
+  /// \todo Implement tracing, if requested
+  
+  if (!IsUp ())
+    return false;
+
+  if (m_bucketMax > 0)
+    {
+      if (m_bucket+1.0 > m_bucketMax)
+        return false;
+      
+      m_bucket += 1.0;
+    }
+
+  SendImpl (packet);
+  return true;
+}
+
+bool
+CcnxFace::SendWithoutLimits (Ptr<Packet> packet)
+{
+  /// \todo Implement tracing, if requested
+
+  if (!IsUp ())
+    return false;
+
+  SendImpl (packet);
+  return true;
+}
+
+bool
+CcnxFace::Receive (Ptr<const Packet> packet)
+{
+  /// \todo Implement tracing, if requested
+
+  if (!IsUp ())
+    return false;
+
+  m_protocolHandler (this, packet);
 }
 
 // void
@@ -89,25 +135,11 @@
   return m_ifup;
 }
 
-bool 
-CcnxFace::IsDown (void) const
-{
-  NS_LOG_FUNCTION_NOARGS ();
-  return !m_ifup;
-}
-
 void 
-CcnxFace::SetUp (void)
+CcnxFace::SetUp (bool up/* = true*/)
 {
   NS_LOG_FUNCTION_NOARGS ();
-  m_ifup = true;
-}
-
-void 
-CcnxFace::SetDown (void)
-{
-  NS_LOG_FUNCTION_NOARGS ();
-  m_ifup = false;
+  m_ifup = up;
 }
 
 bool
diff --git a/model/ccnx-face.h b/model/ccnx-face.h
index 81700df..bc6769e 100644
--- a/model/ccnx-face.h
+++ b/model/ccnx-face.h
@@ -24,14 +24,12 @@
 #include <ostream>
 
 #include "ns3/ptr.h"
-#include "ns3/simple-ref-count.h"
-#include "ns3/callback.h"
+#include "ns3/ccnx.h"
 
 namespace ns3 {
 
 class Packet;
 class Node;
-
   
 /**
  * \ingroup ccnx
@@ -54,14 +52,14 @@
    * \brief Ccnx protocol hanler
    *
    * \param face Face from which packet has been received
-   * \param packet Received packet
+   * \param packet Original packet
    */
   typedef Callback<void,const Ptr<CcnxFace>&,const Ptr<const Packet>& > ProtocolHandler;
 
   /**
    * \brief Default constructor
    */
-  CcnxFace ();
+  CcnxFace (Ptr<Node> node);
   virtual ~CcnxFace();
 
   ////////////////////////////////////////////////////////////////////
@@ -71,23 +69,43 @@
    *
    * This method should call protocol-dependent registration function
    */
-  virtual void RegisterProtocolHandler (ProtocolHandler handler) = 0;
+  virtual void
+  RegisterProtocolHandler (ProtocolHandler handler);
   
   /**
-   * \brief Send packet on a face
+   * \brief Send packet on a face with regard Interest limits
+   *
+   * This method will be called by lower layers to send data to device or application
    *
    * \param p smart pointer to a packet to send
+   *
+   * @return false if either limit is reached or face is down
    */ 
-  virtual void Send (Ptr<Packet> p) = 0;
-
-  ////////////////////////////////////////////////////////////////////
+  bool
+  SendWithLimit (Ptr<Packet> p);
 
   /**
-   * \brief Associate Node object with face
+   * \brief Send content packet on a face without regard to limits
    *
-   * \param node smart pointer to a Node object
+   * This method will be called by lower layers to send data to device or application
+   *
+   * !!! The only difference between this call and SendInterest is that the former check Interest limit !!!
+   *
+   * \param p smart pointer to a packet to send
+   *
+   * @return false if face is down
+   */ 
+  bool
+  SendWithoutLimits (Ptr<Packet> p);
+
+  /**
+   * \brief Receive packet from application or another node and forward it to the CCNx stack
+   *
+   * \todo The only reason for this call is to handle tracing, if requested
    */
-  virtual void SetNode (Ptr<Node> node);
+  void
+  Receive (Ptr<const Packet> p);
+  ////////////////////////////////////////////////////////////////////
 
   // /**
   //  * \Brief Assign routing/forwarding metric with face
@@ -110,24 +128,16 @@
    */
   
   /**
-   * \brief Enable this face
+   * \brief Enable or disable this face
    */
-  virtual void SetUp ();
-
-  /**
-   * \brief Disable this face
-   */
-  virtual void SetDown (void);
+  virtual void
+  SetUp (bool up = true);
 
   /**
    * \brief Returns true if this face is enabled, false otherwise.
    */
-  virtual bool IsUp () const;
-
-  /**
-   * \brief Returns true if this face is disabled, false otherwise.
-   */
-  virtual bool IsDown () const;
+  virtual bool
+  IsUp () const;
   
   virtual std::ostream&
   Print (std::ostream &os) const;
@@ -153,6 +163,22 @@
   GetId () const;
 
   /**
+   * @brief Set maximum value for Interest allowance
+   *
+   * @param bucket maximum value for Interest allowance. If < 0, then limit will be disabled
+   */
+  inline void
+  SetBucketMax (double bucket);
+
+  /**
+   * @brief Leak the Interest allowance bucket by (1/interval) * m_bucketMax amount
+   *
+   * @param interval Time interval with which the bucket is leaked
+   */
+  inline void
+  LeakBucket (const Time &interval);
+  
+  /**
    * \brief Compare two faces. Only two faces on the same node could be compared.
    *
    * Internal index is used for comparison.
@@ -168,6 +194,15 @@
   bool
   operator< (const CcnxFace &face) const;
 
+protected:
+  /**
+   * \brief Send packet on a face (actual implementation)
+   *
+   * \param p smart pointer to a packet to send
+   */
+  virtual void
+  SendImpl (Ptr<Packet> p) = 0;  
+
 private:
   CcnxFace (const CcnxFace &); ///< \brief Disabled copy constructor
   CcnxFace& operator= (const CcnxFace &); ///< \brief Disabled copy operator
@@ -175,9 +210,13 @@
 protected:
   // uint16_t m_metric; ///< \brief Routing/forwarding metric
   Ptr<Node> m_node; ///< \brief Smart pointer to Node
-  ProtocolHandler m_protocolHandler; ///< Callback via which packets are getting send to CCNx stack
 
+  double m_bucket; ///< \brief Value representing current size of the Interest allowance for this face
+  double m_bucketMax;  ///< \brief Maximum Interest allowance for this face
+  double m_bucketLeak; ///< \brief Normalized amount that should be leaked every second
+  
 private:
+  ProtocolHandler m_protocolHandler; ///< Callback via which packets are getting send to CCNx stack
   bool m_ifup; ///< \brief flag indicating that the interface is UP 
   uint32_t m_id; ///< \brief id of the interface in CCNx stack (per-node uniqueness)  
 };
@@ -202,6 +241,20 @@
   return m_id;
 }
 
+void
+CcnxFace::SetBucketMax (double bucket)
+{
+  m_bucketMax = bucket;
+}
+
+void
+CcnxFace::LeakBucket (const Time &interval)
+{
+  const double leak = m_bucketLeak * 1.0 / interval.ToDouble (Time::S);
+  m_bucket -= std::max (0, m_bucket-leak); 
+}
+
+
 } // namespace ns3
 
 #endif //CCNX_FACE_H
diff --git a/model/ccnx-fib.cc b/model/ccnx-fib.cc
index a2d8b4b..bd3cd67 100644
--- a/model/ccnx-fib.cc
+++ b/model/ccnx-fib.cc
@@ -216,6 +216,27 @@
   return entry;
 }
     
+void
+CcnxFib::Delete (const CcnxNameComponents &prefix, Ptr<CcnxFace> face)
+{
+  NS_LOG_FUNCTION (this << prefix << face);
+
+  CcnxFibEntryContainer::type::iterator entry = find (prefix);
+  if (entry == end ())
+    return;
+
+  modify (entry,
+          bind (&CcnxFibEntry::RemoveFace, _1, face));
+  if (entry->m_faces.size () == 0)
+    {
+      erase (entry);
+    }
+}
+
+void
+CcnxFib::DeleteFromAll (Ptr<CcnxFace> face)
+{
+}
 
 std::ostream& operator<< (std::ostream& os, const CcnxFib &fib)
 {
diff --git a/model/ccnx-fib.h b/model/ccnx-fib.h
index 2bd131c..84d618d 100644
--- a/model/ccnx-fib.h
+++ b/model/ccnx-fib.h
@@ -277,7 +277,19 @@
   CcnxFibEntryContainer::type::iterator
   Add (const CcnxNameComponents &prefix, Ptr<CcnxFace> face, int32_t metric);
 
-  // void resetProbing();    //reset needsProbing field for every FibEntry
+  /**
+   * @brief Remove reference to a face from the entry for `prefix`. If entry had only this face, the whole
+   * entry will be removed
+   */
+  void
+  Delete (const CcnxNameComponents &prefix, Ptr<CcnxFace> face);
+
+  /**
+   * @brief Remove all references to a face from FIB.  If for some enty that face was the only element,
+   * this FIB entry will be removed.
+   */
+  void
+  DeleteFromAll (Ptr<CcnxFace> face);
 
 protected:
   // inherited from Object class
diff --git a/model/ccnx-flooding-strategy.cc b/model/ccnx-flooding-strategy.cc
index d7f6827..1fa7a93 100644
--- a/model/ccnx-flooding-strategy.cc
+++ b/model/ccnx-flooding-strategy.cc
@@ -49,8 +49,7 @@
 CcnxFloodingStrategy::PropagateInterest (const CcnxPitEntry  &pitEntry, 
                                          const Ptr<CcnxFace> &incomingFace,
                                          Ptr<CcnxInterestHeader> &header,
-                                         const Ptr<const Packet> &packet,
-                                         SendCallback sendCallback)
+                                         const Ptr<const Packet> &packet)
 {
   NS_LOG_FUNCTION (this);
     
@@ -66,11 +65,13 @@
       if (pitEntry.m_outgoing.find (metricFace.m_face) != pitEntry.m_outgoing.end ()) // already forwarded before
         continue;
 
-      bool faceAvailable = m_pit->TryAddOutgoing (pitEntry, metricFace.m_face);
+      bool faceAvailable = metricFace.m_face->SendWithLimit (packet->Copy ());
       if (!faceAvailable) // huh...
-          continue;
+        continue;
+
+      m_pit->modify (m_pit->iterator_to (pitEntry),
+                     bind(&CcnxPitEntry::AddOutgoing, lambda::_1, metricFace.m_face));
         
-      sendCallback (metricFace.m_face, header, packet->Copy());
       propagatedCount++;
     }
 
diff --git a/model/ccnx-flooding-strategy.h b/model/ccnx-flooding-strategy.h
index 0d43b6a..8be12e9 100644
--- a/model/ccnx-flooding-strategy.h
+++ b/model/ccnx-flooding-strategy.h
@@ -50,8 +50,7 @@
   PropagateInterest (const CcnxPitEntry  &pitEntry, 
                      const Ptr<CcnxFace> &incomingFace,
                      Ptr<CcnxInterestHeader> &header,
-                     const Ptr<const Packet> &packet,
-                     SendCallback sendCallback);
+                     const Ptr<const Packet> &packet);
 };
     
 } //namespace ns3
diff --git a/model/ccnx-forwarding-strategy.h b/model/ccnx-forwarding-strategy.h
index b8bbc5b..d7a5ab5 100644
--- a/model/ccnx-forwarding-strategy.h
+++ b/model/ccnx-forwarding-strategy.h
@@ -42,10 +42,6 @@
 class CcnxForwardingStrategy : public Object
 {
 public:
-  typedef
-  Callback<void, const Ptr<CcnxFace> &, const Ptr<const CcnxInterestHeader> &, const Ptr<Packet> &>
-  SendCallback;
-
   static TypeId GetTypeId (void);
 
   /**
@@ -69,8 +65,7 @@
   PropagateInterest (const CcnxPitEntry  &pitEntry, 
                      const Ptr<CcnxFace> &incomingFace,
                      Ptr<CcnxInterestHeader> &header,
-                     const Ptr<const Packet> &packet,
-                     SendCallback sendCallback) = 0;
+                     const Ptr<const Packet> &packe) = 0;
     
   /**
    * @brief Set link to PIT for the forwarding strategy
diff --git a/model/ccnx-l3-protocol.cc b/model/ccnx-l3-protocol.cc
index b719e99..1d4c548 100644
--- a/model/ccnx-l3-protocol.cc
+++ b/model/ccnx-l3-protocol.cc
@@ -61,20 +61,11 @@
     .SetParent<Ccnx> ()
     .SetGroupName ("Ccnx")
     .AddConstructor<CcnxL3Protocol> ()
-    // .AddTraceSource ("Tx", "Send ccnx packet to outgoing interface.",
-    //                  MakeTraceSourceAccessor (&CcnxL3Protocol::m_txTrace))
-    // .AddTraceSource ("Rx", "Receive ccnx packet from incoming interface.",
-    //                  MakeTraceSourceAccessor (&CcnxL3Protocol::m_rxTrace))
-    // .AddTraceSource ("Drop", "Drop ccnx packet",
-    //                  MakeTraceSourceAccessor (&CcnxL3Protocol::m_dropTrace))
-    // .AddAttribute ("InterfaceList", "The set of Ccnx interfaces associated to this Ccnx stack.",
-    //                ObjectVectorValue (),
-    //                MakeObjectVectorAccessor (&CcnxL3Protocol::m_faces),
-    //                MakeObjectVectorChecker<CcnxFace> ())
-
-    // .AddTraceSource ("SendOutgoing", "A newly-generated packet by this node is about to be queued for transmission",
-    //                  MakeTraceSourceAccessor (&CcnxL3Protocol::m_sendOutgoingTrace))
-
+    .AddAttribute ("BucketLeakInterval",
+                   "Interval to leak buckets",
+                   StringValue ("10ms"),
+                   MakeTimeAccessor (&CcnxPit::GetBucketLeakInterval, &CcnxPit::SetBucketLeakInterval),
+                   MakeTimeChecker ())
   ;
   return tid;
 }
@@ -128,6 +119,9 @@
 {
   NS_LOG_FUNCTION (this);
 
+  if (m_bucketLeakEvent.IsRunning ())
+    m_bucketLeakEvent.Cancel ();
+  
   for (CcnxFaceList::iterator i = m_faces.begin (); i != m_faces.end (); ++i)
     {
       *i = 0;
@@ -171,7 +165,7 @@
   face->RegisterProtocolHandler (MakeCallback (&CcnxL3Protocol::Receive, this));
 
   m_faces.push_back (face);
-  m_faceCounter ++;
+  m_faceCounter++;
   return face->GetId ();
 }
 
@@ -180,6 +174,27 @@
 {
   // ask face to register in lower-layer stack
   face->RegisterProtocolHandler (MakeNullCallback<void,const Ptr<CcnxFace>&,const Ptr<const Packet>&> ());
+
+  // just to be on a safe side. Do the process in two steps
+  list<CcnxPitEntryContainer::type::iterator> entriesToRemoves; 
+  BOOST_FOREACH (const CcnxPitEntry &pitEntry, *m_pit)
+    {
+      m_pit->modify (m_pit->iterator_to (pitEntry),
+                     ll::bind (CcnxPitEntry::RemoveAllReferencesToFace, ll::_1, face));
+
+      // If this face is the only for the associated FIB entry, then FIB entry will be removed soon.
+      // Thus, we have to remove the whole PIT entry
+      if (m_pit->m_fibEntry.size () == 1 &&
+          m_pit->m_fibEntry.m_faces.begin ()->m_face == face)
+        {
+          entriesToRemoves.push_back (m_pit->iterator_to (pitEntry));
+        }
+    }
+  BOOST_FOREACH (CcnxPitEntryContainer::type::iterator entry, entriesToRemoves)
+    {
+      m_pit->erase (entry);
+    }
+
   CcnxFaceList::iterator face_it = find (m_faces.begin(), m_faces.end(), face);
   NS_ASSERT_MSG (face_it != m_faces.end (), "Attempt to remove face that doesn't exist");
   m_faces.erase (face_it);
@@ -216,24 +231,6 @@
   return m_faces.size ();
 }
 
-void
-CcnxL3Protocol::TransmittedDataTrace (Ptr<Packet> packet,
-                                      ContentObjectSource type,
-                                      Ptr<Ccnx> ccnx, Ptr<const CcnxFace> face)
-{
-  // a "small" inefficiency for logging purposes
-  Ptr<CcnxContentObjectHeader> header = Create<CcnxContentObjectHeader> ();
-  static CcnxContentObjectTail tail;
-  packet->RemoveHeader (*header);
-  packet->RemoveTrailer (tail);
-      
-  m_transmittedDataTrace (header, packet/*payload*/, type, ccnx, face);
-  
-  packet->AddHeader (*header);
-  packet->AddTrailer (tail);
-}
-
-
 // Callback from lower layer
 void 
 CcnxL3Protocol::Receive (const Ptr<CcnxFace> &face, const Ptr<const Packet> &p)
@@ -333,7 +330,7 @@
   //               {
   //                 header->SetNonce(it->m_nonce);
   //                 header->SetNack(true);
-  //                 SendInterest(face.m_face, header, packet->Copy());
+  //                 face.m_face->SendWithoutLimit (packet->Copy());
   //               }
   //           }
   //       }
@@ -376,7 +373,7 @@
       Ptr<Packet> packet = Create<Packet> ();
       packet->AddHeader (*header);
 
-      SendInterest (incomingFace, header, packet);
+      incomingFace->SendWithoutLimit (packet);
       
       // //Trace duplicate interest  
       // m_droppedInterestsTrace (header, NDN_DUPLICATE_INTEREST, m_node->GetObject<Ccnx> (), incomingFace);
@@ -384,19 +381,17 @@
     }
 
   Ptr<Packet> contentObject;
-  Ptr<const CcnxContentObjectHeader> contentObjectHeader;
+  Ptr<const CcnxContentObjectHeader> contentObjectHeader; // unused for now
   tie (contentObject, contentObjectHeader) = m_contentStore->Lookup (header);
   if (contentObject != 0)
     {
-      // NS_ASSERT_MSG (pitEntry.m_incoming.size () == 0,
-      //                "Something strange. Data is cached, but size of incoming interests is not zero...");
       NS_ASSERT (contentObjectHeader != 0);
       
       NS_LOG_LOGIC("Found in cache");
         
       // TransmittedDataTrace (contentObject, CACHED,
       //                       m_node->GetObject<Ccnx> (), incomingFace);
-      SendContentObject (incomingFace, contentObjectHeader, contentObject);
+      incomingFace->SendWithoutLimit (contentObject);
 
       // Set pruning timout on PIT entry (instead of deleting the record)
       m_pit->modify (m_pit->iterator_to (pitEntry),
@@ -454,9 +449,7 @@
   NS_ASSERT_MSG (m_forwardingStrategy != 0, "Need a forwarding protocol object to process packets");
   
   bool propagated = m_forwardingStrategy->
-    PropagateInterest (pitEntry, incomingFace, header, packet,
-                       MakeCallback (&CcnxL3Protocol::SendInterest, this)
-                       );
+    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
@@ -469,7 +462,7 @@
 
       BOOST_FOREACH (const CcnxPitEntryIncomingFace &incoming, pitEntry.m_incoming)
         {
-          SendInterest (incoming.m_face, header, packet->Copy ());
+          incoming.m_face->SendWithoutLimit (packet->Copy ());
 
           // m_droppedInterestsTrace (header, DROP_CONGESTION,
           //                          m_node->GetObject<Ccnx> (), incomingFace);
@@ -537,7 +530,7 @@
       BOOST_FOREACH (const CcnxPitEntryIncomingFace &incoming, pitEntry.m_incoming)
         {
           if (incoming.m_face != incomingFace)
-            SendContentObject (incoming.m_face, header, packet->Copy ());
+            incoming.m_face->SendWithoutLimit (packet->Copy ());
 
           // successfull forwarded data trace
         }
@@ -562,59 +555,33 @@
 }
 
 void
-CcnxL3Protocol::SendInterest (const Ptr<CcnxFace> &face,
-                              const Ptr<const CcnxInterestHeader> &header,
-                              const Ptr<Packet> &packet)
+CcnxL3Protocol::SetBucketLeakInterval (Time interval)
 {
-  NS_LOG_FUNCTION (this << "packet: " << &packet << ", face: "<< &face);
-  NS_ASSERT_MSG (face != 0, "Face should never be NULL");
+  m_bucketLeakInterval = interval;
+  
+  if (m_bucketLeakEvent.IsRunning ())
+    m_bucketLeakEvent.Cancel ();
 
-  if (face->IsUp ())
-    {
-      NS_LOG_LOGIC ("Sending via face " << &face); //
-      // m_transmittedInterestsTrace (header, m_node->GetObject<Ccnx> (), face);
-      face->Send (packet);
-    }
-  else
-    {
-      NS_LOG_LOGIC ("Dropping -- outgoing interface is down: " << &face);
-      // m_droppedInterestsTrace (header, INTERFACE_DOWN, m_node->GetObject<Ccnx> (), face);
-    }
+  m_bucketLeakEvent = Simulator::Schedule (m_bucketLeakInterval,
+                                           &CcnxL3Protocol::LeakBuckets, this);
 }
 
-void
-CcnxL3Protocol::SendContentObject (const Ptr<CcnxFace> &face,
-                                   const Ptr<const CcnxContentObjectHeader> &header,
-                                   const Ptr<Packet> &packet)
+Time
+CcnxL3Protocol::GetBucketLeakInterval () const
 {
-  NS_LOG_FUNCTION (this << "packet: " << &packet << ", face: "<< &face);
-  NS_ASSERT_MSG (face != 0, "Face should never be NULL");
-
-  if (face->IsUp ())
-    {
-      NS_LOG_LOGIC ("Sending via face " << &face); //
-      // m_txTrace (packet, m_node->GetObject<Ccnx> (), face);
-      face->Send (packet);
-    }
-  else
-    {
-      NS_LOG_LOGIC ("Dropping -- outgoing interface is down: " << &face);
-      // m_dropTrace (packet, INTERFACE_DOWN, m_node->GetObject<Ccnx> (), face);
-    }
+  return m_bucketLeakInterval;
 }
 
-Ptr<CcnxPit>
-CcnxL3Protocol::GetPit()
+void 
+CcnxPit::LeakBuckets ()
 {
-    return m_pit;
+  BOOST_FOREACH (const Ptr<CcnxFace> &face, m_faces)
+    {
+      face->LeakBucket (m_bucketLeakInterval);
+    }
+
+  m_bucketLeakEvent = Simulator::Schedule (m_bucketLeakInterval,
+                                           &CcnxL3Protocol::LeakBuckets, this);
 }
 
-// void
-// CcnxL3Protocol::ScheduleLeakage()
-// {
-//     m_pit->LeakBuckets();
-//     Time interval = MilliSeconds (NDN_INTEREST_RESET_PERIOD);
-    
-//     Simulator::Schedule (interval, &CcnxL3Protocol::ScheduleLeakage, this);
-// }
 } //namespace ns3
diff --git a/model/ccnx-l3-protocol.h b/model/ccnx-l3-protocol.h
index c470959..272a0be 100644
--- a/model/ccnx-l3-protocol.h
+++ b/model/ccnx-l3-protocol.h
@@ -127,13 +127,12 @@
   void SetForwardingStrategy (Ptr<CcnxForwardingStrategy> forwardingStrategy);
   Ptr<CcnxForwardingStrategy> GetForwardingStrategy () const;
 
-  virtual void SendInterest (const Ptr<CcnxFace> &face,
-                             const Ptr<const CcnxInterestHeader> &header,
-                             const Ptr<Packet> &packet);
-  virtual void SendContentObject (const Ptr<CcnxFace> &face,
-                                  const Ptr<const CcnxContentObjectHeader> &header,
-                                  const Ptr<Packet> &packet);
-  virtual void Receive (const Ptr<CcnxFace> &face, const Ptr<const Packet> &p);
+  // virtual void SendInterest (const Ptr<CcnxFace> &face,
+  //                            const Ptr<const CcnxInterestHeader> &header,
+  //                            const Ptr<Packet> &packet);
+  // virtual void SendContentObject (const Ptr<CcnxFace> &face,
+  //                                 const Ptr<const CcnxContentObjectHeader> &header,
+  //                                 const Ptr<Packet> &packet);
 
   virtual uint32_t
   AddFace (const Ptr<CcnxFace> &face);
@@ -153,7 +152,10 @@
   Ptr<CcnxPit> GetPit();
   
   // void ScheduleLeakage();
-protected:
+private:
+  void
+  Receive (const Ptr<CcnxFace> &face, const Ptr<const Packet> &p);
+
   /**
    * \brief Actual processing of incoming CCNx interests. Note, interests do not have payload
    * 
@@ -162,7 +164,7 @@
    * @param header  deserialized Interest header
    * @param packet  original packet
    */
-  virtual void
+  void
   OnInterest (const Ptr<CcnxFace> &face,
               Ptr<CcnxInterestHeader> &header,
               const Ptr<const Packet> &p);
@@ -175,7 +177,7 @@
    * @param header  deserialized Interest header
    * @param packet  original packet
    */
-  virtual void
+  void
   OnNack (const Ptr<CcnxFace> &face,
           Ptr<CcnxInterestHeader> &header,
           const Ptr<const Packet> &p);
@@ -189,7 +191,7 @@
    * @param payload data packet payload
    * @param packet  original packet
    */
-  virtual void
+  void
   OnData (const Ptr<CcnxFace> &face,
           Ptr<CcnxContentObjectHeader> &header,
           Ptr<Packet> &payload,
@@ -208,14 +210,17 @@
   CcnxL3Protocol(const CcnxL3Protocol &); ///< copy constructor is disabled
   CcnxL3Protocol &operator = (const CcnxL3Protocol &); ///< copy operator is disabled
 
-  /**
-   * \brief A helper function
-   */
-  void TransmittedDataTrace (Ptr<Packet>,
-                             ContentObjectSource,
-                             Ptr<Ccnx>, Ptr<const CcnxFace>);
+  /// \brief Set buckets leak interval
+  void
+  SetBucketLeakInterval (Time interval);
+
+  /// \brief Get buckets leak interval
+  Time
+  GetBucketLeakInterval () const;
   
-  
+  /// \brief Periodically generate pre-calculated number of tokens (leak buckets)
+  void LeakBuckets( );
+
 private:
   uint32_t m_faceCounter; ///< \brief counter of faces. Increased every time a new face is added to the stack
   typedef std::vector<Ptr<CcnxFace> > CcnxFaceList;
@@ -228,32 +233,29 @@
   Ptr<CcnxPit> m_pit; ///< \brief PIT (pending interest table)
   Ptr<CcnxFib> m_fib; ///< \brief FIB  
   Ptr<CcnxContentStore> m_contentStore; ///< \brief Content store (for caching purposes only)
-  
-  TracedCallback<Ptr<const CcnxInterestHeader>,
-                 Ptr<Ccnx>, Ptr<const CcnxFace> > m_receivedInterestsTrace;
-  TracedCallback<Ptr<const CcnxInterestHeader>,
-                 Ptr<Ccnx>, Ptr<const CcnxFace> > m_transmittedInterestsTrace;
-  TracedCallback<Ptr<const CcnxInterestHeader>,
-                 DropReason,
-                 Ptr<Ccnx>, Ptr<const CcnxFace> > m_droppedInterestsTrace;
 
-  TracedCallback<Ptr<const CcnxContentObjectHeader>,
-                 Ptr<const Packet>,/*payload*/
-                 Ptr<Ccnx>, Ptr<const CcnxFace> > m_receivedDataTrace;
-  TracedCallback<Ptr<const CcnxContentObjectHeader>,
-                 Ptr<const Packet>,/*payload*/
-                 ContentObjectSource,
-                 Ptr<Ccnx>, Ptr<const CcnxFace> > m_transmittedDataTrace;
-  TracedCallback<Ptr<const CcnxContentObjectHeader>,
-                 Ptr<const Packet>,/*payload*/
-                 DropReason,
-                 Ptr<Ccnx>, Ptr<const CcnxFace> > m_droppedDataTrace;
+  Time    m_bucketLeakInterval;
+  EventId m_bucketLeakEvent;
   
-  /**
-   * \brief Trace of dropped packets, including reason and all headers
-   * \internal
-   */
-  // TracedCallback<Ptr<const Packet>, DropReason, Ptr<const Ccnx>, Ptr<const CcnxFace> > m_dropTrace;
+  // TracedCallback<Ptr<const CcnxInterestHeader>,
+  //                Ptr<Ccnx>, Ptr<const CcnxFace> > m_receivedInterestsTrace;
+  // TracedCallback<Ptr<const CcnxInterestHeader>,
+  //                Ptr<Ccnx>, Ptr<const CcnxFace> > m_transmittedInterestsTrace;
+  // TracedCallback<Ptr<const CcnxInterestHeader>,
+  //                DropReason,
+  //                Ptr<Ccnx>, Ptr<const CcnxFace> > m_droppedInterestsTrace;
+
+  // TracedCallback<Ptr<const CcnxContentObjectHeader>,
+  //                Ptr<const Packet>,/*payload*/
+  //                Ptr<Ccnx>, Ptr<const CcnxFace> > m_receivedDataTrace;
+  // TracedCallback<Ptr<const CcnxContentObjectHeader>,
+  //                Ptr<const Packet>,/*payload*/
+  //                ContentObjectSource,
+  //                Ptr<Ccnx>, Ptr<const CcnxFace> > m_transmittedDataTrace;
+  // TracedCallback<Ptr<const CcnxContentObjectHeader>,
+  //                Ptr<const Packet>,/*payload*/
+  //                DropReason,
+  //                Ptr<Ccnx>, Ptr<const CcnxFace> > m_droppedDataTrace;
 };
   
 } // Namespace ns3
diff --git a/model/ccnx-local-face.cc b/model/ccnx-local-face.cc
index fc4dd11..4a7c777 100644
--- a/model/ccnx-local-face.cc
+++ b/model/ccnx-local-face.cc
@@ -25,7 +25,6 @@
 #include "ns3/log.h"
 #include "ns3/packet.h"
 #include "ns3/node.h"
-#include "ns3/pointer.h"
 #include "ns3/assert.h"
 
 #include "ns3/ccnx-header-helper.h"
@@ -37,23 +36,13 @@
 namespace ns3 
 {
 
-// NS_OBJECT_ENSURE_REGISTERED (CcnxLocalFace);
-
-// TypeId 
-// CcnxLocalFace::GetTypeId (void)
-// {
-//   static TypeId tid = TypeId ("ns3::CcnxLocalFace")
-//     .SetGroupName ("Ccnx")
-//     .SetParent<CcnxFace> ()
-//   ;
-//   return tid;
-// }
-
-CcnxLocalFace::CcnxLocalFace () 
-  : m_onInterest (0)
-  , m_onContentObject (0)
+CcnxLocalFace::CcnxLocalFace (Ptr<CcnxApp> app)
+  : CcnxFace (app->GetObject<Node> ())
+  , m_app (app)
 {
-  NS_LOG_FUNCTION (this);
+  NS_LOG_FUNCTION (this << app);
+  
+  NS_ASSERT (app != 0);
 }
 
 CcnxLocalFace::~CcnxLocalFace ()
@@ -64,30 +53,17 @@
 void
 CcnxLocalFace::RegisterProtocolHandler (ProtocolHandler handler)
 {
-  m_protocolHandler = handler;
-}
+  NS_LOG_FUNCTION (this << handler);
 
-void
-CcnxLocalFace::SetInterestHandler (InterestHandler onInterest)
-{
-  m_onInterest = onInterest;
-}
+  CcnxFace::RegisterProtocolHandler (handler);
 
-void
-CcnxLocalFace::SetContentObjectHandler (ContentObjectHandler onContentObject)
-{
-  m_onContentObject = onContentObject;
+  app->RegisterProtocolHandler (MakeCallback (&CcnxFace::Receive, this));
 }
     
 void
-CcnxLocalFace::Send (Ptr<Packet> p)
+CcnxLocalFace::SendImpl (Ptr<Packet> p)
 {
-  NS_LOG_FUNCTION("Local face send");
-  NS_LOG_FUNCTION (*p);
-  if (!IsUp ())
-    {
-      return;
-    }
+  NS_LOG_FUNCTION (this << p);
 
   try
     {
@@ -99,7 +75,7 @@
             {
               Ptr<CcnxInterestHeader> header = Create<CcnxInterestHeader> ();
               p->RemoveHeader (*header);
-              m_onInterest (header);
+              app->OnInterest (header);
             }
           break;
         case CcnxHeaderHelper::CONTENT_OBJECT:
@@ -109,7 +85,7 @@
               Ptr<CcnxContentObjectHeader> header = Create<CcnxContentObjectHeader> ();
               p->RemoveHeader (*header);
               p->RemoveTrailer (tail);
-              m_onContentObject (header, p/*payload*/);
+              app->OnContentObject (header, p/*payload*/);
             }
           break;
         }
@@ -120,13 +96,6 @@
     }
 }
 
-// propagate interest down to ccnx stack
-void
-CcnxLocalFace::ReceiveFromApplication (Ptr<Packet> p)
-{
-  m_protocolHandler (Ptr<CcnxFace>(this), p);
-}
-
 std::ostream& CcnxLocalFace::Print (std::ostream& os) const
 {
   os << "dev=local(" << GetId() << ")";
diff --git a/model/ccnx-local-face.h b/model/ccnx-local-face.h
index 664130c..a7705ed 100644
--- a/model/ccnx-local-face.h
+++ b/model/ccnx-local-face.h
@@ -44,61 +44,32 @@
 class CcnxLocalFace  : public CcnxFace
 {
 public:
-  typedef Callback<void,const Ptr<const CcnxInterestHeader> &> InterestHandler;
-  typedef Callback<void,const Ptr<const CcnxContentObjectHeader> &,
-                        const Ptr<const Packet> &> ContentObjectHandler;
-
   /**
    * \brief Default constructor
    */
-  CcnxLocalFace ();
+  CcnxLocalFace (Ptr<CcnxApp> app);
   virtual ~CcnxLocalFace();
   
   ////////////////////////////////////////////////////////////////////
   // methods overloaded from CcnxFace
-
-  /**
-   * \brief This method should be called to establish link with lower layers
-   */
   virtual void
   RegisterProtocolHandler (ProtocolHandler handler);
 
-  /**
-   * \brief This method will be called by lower layers to send data to *application*
-   */
+protected:
   virtual void
-  Send (Ptr<Packet> p);
-    
+  SendImpl (Ptr<Packet> p);
+
+public:
   virtual std::ostream&
   Print (std::ostream &os) const;
   ////////////////////////////////////////////////////////////////////
-
-   /**
-   * \brief This method will be called by higher layers to send data to *ccnx stack*
-   */
-  void ReceiveFromApplication (Ptr<Packet> p);
-
-  /**
-   * \brief Set callback to application
-   *
-   * \param onInterest InterestHandler to be called when interest arrives on the face. Will be disabled if 0
-   */
-  void SetInterestHandler (InterestHandler onInterest);
-
-    /**
-   * \brief Set callback to application
-   *
-   * \param onContentObject ContentObjectHandler to be called when data arrives. Will be disabled if 0
-   */
-  void SetContentObjectHandler (ContentObjectHandler onContentObject);
  
 private:
   CcnxLocalFace (const CcnxLocalFace &); ///< \brief Disabled copy constructor
   CcnxLocalFace& operator= (const CcnxLocalFace &); ///< \brief Disabled copy operator
 
 private:
-  InterestHandler m_onInterest;
-  ContentObjectHandler m_onContentObject;
+  Ptr<CcnxApp> m_application;
 };
 
 std::ostream& operator<< (std::ostream& os, const CcnxLocalFace &localFace);
diff --git a/model/ccnx-name-components.cc b/model/ccnx-name-components.cc
index 438e179..b551733 100644
--- a/model/ccnx-name-components.cc
+++ b/model/ccnx-name-components.cc
@@ -69,25 +69,6 @@
     
   return subComponents;
 }
-  
-// const ccn_charbuf*
-// Components::GetName () const
-// {
-//   return m_value;
-// }
-
-CcnxNameComponents&
-CcnxNameComponents::operator () (const string &s)
-{
-  // ccn_name_append_str (m_value,s.c_str());
-  m_prefix.push_back (s);
-  return *this;
-}
-
-// Components::operator const unsigned char* ()
-// {
-//   return m_value->buf;
-// }
 
 void
 CcnxNameComponents::Print (std::ostream &os) const
diff --git a/model/ccnx-name-components.h b/model/ccnx-name-components.h
index ea64635..5dafcfc 100644
--- a/model/ccnx-name-components.h
+++ b/model/ccnx-name-components.h
@@ -43,12 +43,14 @@
   CcnxNameComponents ();
   // CcnxNameComponents (const std::string &s);
   CcnxNameComponents (const std::list<boost::reference_wrapper<const std::string> > &components);
-  
+
+  template<class T>
   inline void
-  Add (const std::string &s);
-       
-  CcnxNameComponents&
-  operator () (const std::string &s);
+  Add (const T &value);
+  
+  template<class T>
+  inline CcnxNameComponents&
+  operator () (const T &value);
 
   const std::list<std::string> &
   GetComponents () const;
@@ -108,11 +110,29 @@
 {
   return m_prefix.size ();
 }
-  
-void
-CcnxNameComponents::Add (const std::string &s)
+
+template<class T>
+CcnxNameComponents&
+CcnxNameComponents::operator () (const T &value)
 {
-  (*this) (s);
+  Add (value);
+  return *this;
+}
+
+template<class T>
+void
+CcnxNameComponents::Add (const T &value)
+{
+  std::ostringstream os;
+  os << value;
+  m_prefix.push_back (os.str ());
+}
+
+template<class T=std::string>
+void
+CcnxNameComponents::Add (const T &string)
+{
+  m_prefix.push_back (string);
 }
 
 bool
diff --git a/model/ccnx-net-device-face.cc b/model/ccnx-net-device-face.cc
index 12cb272..72aa14a 100644
--- a/model/ccnx-net-device-face.cc
+++ b/model/ccnx-net-device-face.cc
@@ -36,11 +36,13 @@
  * By default, Ccnx face are created in the "down" state.  Before
  * becoming useable, the user must invoke SetUp on the face
  */
-CcnxNetDeviceFace::CcnxNetDeviceFace (const Ptr<NetDevice> &netDevice) 
+CcnxNetDeviceFace::CcnxNetDeviceFace (Ptr<Node> node, const Ptr<NetDevice> &netDevice)
+  : CcnxFace (node)
+  , m_netDevice (netDevice)
 {
-  NS_LOG_FUNCTION (this);
+  NS_LOG_FUNCTION (this << netDevice);
 
-  m_netDevice = netDevice;
+  NS_ASSERT_MSG (m_netDevice != 0, "CcnxNetDeviceFace needs to be assigned a valid NetDevice");
 }
 
 CcnxNetDeviceFace::~CcnxNetDeviceFace ()
@@ -66,11 +68,10 @@
 void
 CcnxNetDeviceFace::RegisterProtocolHandler (ProtocolHandler handler)
 {
-  NS_LOG_FUNCTION(this);
-  NS_ASSERT_MSG (m_netDevice != 0, "CcnxNetDeviceFace needs to be assigned NetDevice first");
-  
-  m_protocolHandler = handler;
+  NS_LOG_FUNCTION (this << handler);
 
+  CcnxFace::RegisterProtocolHandler (handler);
+  
   m_node->RegisterProtocolHandler (MakeCallback (&CcnxNetDeviceFace::ReceiveFromNetDevice, this),
                                    CcnxL3Protocol::ETHERNET_FRAME_TYPE, m_netDevice, true/*promiscuous mode*/);
 }
@@ -78,17 +79,13 @@
 void
 CcnxNetDeviceFace::Send (Ptr<Packet> packet)
 {
+  NS_LOG_FUNCTION (this << packet);
+  
   NS_ASSERT_MSG (packet->GetSize () <= m_netDevice->GetMtu (), 
                  "Packet size " << packet->GetSize () << " exceeds device MTU "
                  << m_netDevice->GetMtu ()
                  << " for Ccnx; fragmentation not supported");
 
-  NS_LOG_FUNCTION (*packet);
-  if (!IsUp ())
-    {
-      return;
-    }
-
   m_netDevice->Send (packet, m_netDevice->GetBroadcast (), 
                      CcnxL3Protocol::ETHERNET_FRAME_TYPE);
 }
@@ -102,7 +99,7 @@
                                          const Address &to,
                                          NetDevice::PacketType packetType)
 {
-  m_protocolHandler (Ptr<CcnxFace>(this), p);
+  Receive (p);
 }
 
 
diff --git a/model/ccnx-net-device-face.h b/model/ccnx-net-device-face.h
index e6fbc12..482d5d3 100644
--- a/model/ccnx-net-device-face.h
+++ b/model/ccnx-net-device-face.h
@@ -45,31 +45,26 @@
 class CcnxNetDeviceFace  : public CcnxFace
 {
 public:
-  // /**
-  //  * \brief Interface ID
-  //  *
-  //  * \return interface ID
-  //  */
-  // static TypeId GetTypeId (void);
-
   /**
    * \brief Constructor
    *
    * \param netDevice a smart pointer to NetDevice object to which
    * this face will be associate
    */
-  CcnxNetDeviceFace (const Ptr<NetDevice> &netDevice);
+  CcnxNetDeviceFace (Ptr<Node> node, const Ptr<NetDevice> &netDevice);
   virtual ~CcnxNetDeviceFace();
 
   ////////////////////////////////////////////////////////////////////
   // methods overloaded from CcnxFace
-  
   virtual void
   RegisterProtocolHandler (ProtocolHandler handler);
 
+protected:
+  // also from CcnxFace
   virtual void
-  Send (Ptr<Packet> p);
-  
+  SendImpl (Ptr<Packet> p);
+
+public:
   virtual std::ostream&
   Print (std::ostream &os) const;
   ////////////////////////////////////////////////////////////////////
diff --git a/model/ccnx-pit-entry.cc b/model/ccnx-pit-entry.cc
index 7b8f489..cd6d854 100644
--- a/model/ccnx-pit-entry.cc
+++ b/model/ccnx-pit-entry.cc
@@ -66,27 +66,20 @@
   return ret.first;
 }
 
+void
+CcnxPitEntry::RemoveAllReferencesToFace (Ptr<CcnxFace> face)
+{
+  CcnxPitEntryIncomingFaceContainer::type::iterator incoming =
+    m_incoming.find (face);
 
-// void
-// CcnxPitEntry::UpdateFibStatus::operator() (CcnxPitEntry &entry)
-// {
-//   NS_ASSERT_MSG (false, "Broken");
-//   m_fib->modify (m_fib->iterator_to (entry.m_fibEntry),
-//                  CcnxFibEntry::UpdateStatus (m_face, m_status));
-// }
+  if (incoming != m_incoming.end ())
+    m_incoming.erase (incoming);
 
-// void
-// CcnxPitEntry::EstimateRttAndRemoveFace::operator() (CcnxPitEntry &entry)
-// {
-//   // similar to Karn's Algorithm, we don't use RTT measurements for retx packets
-//   if (m_outFace->m_retxNum>0)
-//     return;
+  CcnxPitEntryOutgoingFaceContainer::type::iterator outgoing =
+    m_outgoing.find (face);
 
-//   m_fib->modify (m_fib->iterator_to (entry.m_fibEntry),
-//                 CcnxFibEntry::UpdateFaceRtt (m_outFace->m_face,
-//                                              Simulator::Now() - m_outFace->m_sendTime));
-
-//   entry.m_outgoing.erase (m_outFace);
-// }
+  if (outgoing != m_outgoing.end ())
+    m_outgoing.erase (outgoing);
+}
 
 }  
diff --git a/model/ccnx-pit-entry.h b/model/ccnx-pit-entry.h
index ac1b277..52e7921 100644
--- a/model/ccnx-pit-entry.h
+++ b/model/ccnx-pit-entry.h
@@ -108,36 +108,84 @@
   // // Get number of outgoing interests that we're expecting data from
   // inline size_t numberOfPromisingInterests( ) const; 
 
-  const CcnxNameComponents &
-  GetPrefix () const;
+  // const CcnxNameComponents &
+  // GetPrefix () const;
 
+  /**
+   * @brief Get current expiration time of the record
+   *
+   * @returns current expiration time of the record
+   */
   const Time &
   GetExpireTime () const
   { return m_expireTime; }
 
+  /**
+   * @brief Set expiration time on record as `expireTime` (absolute time)
+   *
+   * @param expireTime absolute simulation time of when the record should expire
+   */
   void
   SetExpireTime (const Time &expireTime)
   {
     m_expireTime = expireTime;
   }
   
+  /**
+   * @brief Check if nonce `nonce` for the same prefix has already been seen
+   *
+   * @param nonce Nonce to check
+   */
   bool
   IsNonceSeen (uint32_t nonce) const
   { return m_seenNonces.find (nonce) != m_seenNonces.end (); }
 
+  /**
+   * @brief Add `nonce` to the list of seen nonces
+   *
+   * @param nonce nonce to add to the list of seen nonces
+   *
+   * All nonces are stored for the lifetime of the PIT entry
+   */
   void
   AddSeenNonce (uint32_t nonce)
   { m_seenNonces.insert (nonce); }
 
+  /**
+   * @brief Add `face` to the list of incoming faces
+   *
+   * @param face Face to add to the list of incoming faces
+   * @returns iterator to the added entry
+   */
   CcnxPitEntryIncomingFaceContainer::type::iterator
   AddIncoming (Ptr<CcnxFace> face);
 
+  /**
+   * @brief Clear all incoming faces either after all of them were satisfied or NACKed
+   */
   void
   ClearIncoming ()
   { m_incoming.clear (); }
 
+  /**
+   * @brief Add `face` to the list of outgoing faces
+   *
+   * @param face Face to add to the list of outgoing faces
+   * @returns iterator to the added entry
+   */
   CcnxPitEntryOutgoingFaceContainer::type::iterator
   AddOutgoing (Ptr<CcnxFace> face);
+
+  /**
+   * @brief Remove all references to face.
+   * 
+   * This method should be called before face is completely removed from the stack.
+   * Face is removed from the lists of incoming and outgoing faces
+   */
+  void
+  RemoveAllReferencesToFace (Ptr<CcnxFace> face);
+
+protected:
   
 private:
   friend std::ostream& operator<< (std::ostream& os, const CcnxPitEntry &entry);
diff --git a/model/ccnx-pit.cc b/model/ccnx-pit.cc
index 85b4ecb..63e1db8 100644
--- a/model/ccnx-pit.cc
+++ b/model/ccnx-pit.cc
@@ -48,7 +48,7 @@
     .AddConstructor<CcnxPit> ()
     .AddAttribute ("CleanupTimeout",
                    "Timeout defining how frequent RIT should be cleaned up",
-                   TimeValue (Seconds (1)),
+                   StringValue ("1s"),
                    MakeTimeAccessor (&CcnxPit::GetCleanupTimeout, &CcnxPit::SetCleanupTimeout),
                    MakeTimeChecker ())
     .AddAttribute ("PitEntryPruningTimout",
@@ -72,10 +72,7 @@
 
 CcnxPit::~CcnxPit ()
 {
-  if (m_cleanupEvent.IsRunning ())
-    m_cleanupEvent.Cancel (); // cancel any scheduled cleanup events
-
-  clear ();
+  DoDispose ();
 }
 
 void 
@@ -87,7 +84,10 @@
 CcnxPit::DoDispose ()
 {
   if (m_cleanupEvent.IsRunning ())
-    m_cleanupEvent.Cancel (); // cancel any scheduled cleanup events
+    m_cleanupEvent.Cancel ();
+
+  if (m_PitBucketLeakEvent.IsRunning ())
+    m_PitBucketLeakEvent.Cancel ();
 
   clear ();
 }
@@ -116,11 +116,11 @@
   Time now = Simulator::Now ();
 
   uint32_t count = 0;
-  while( !empty() )
+  while (!empty ())
     {
-      if( get<i_timestamp> ().front ().GetExpireTime () <= now ) // is the record stale?
+      if (get<i_timestamp> ().front ().GetExpireTime () <= now) // is the record stale?
         {
-          get<i_timestamp> ().pop_front( );
+          get<i_timestamp> ().pop_front ();
           count ++;
         }
       else
@@ -140,26 +140,6 @@
   m_fib = fib;
 }
 
-bool
-CcnxPit::TryAddOutgoing (const CcnxPitEntry &pitEntry, Ptr<CcnxFace> face)
-{
-  NS_LOG_FUNCTION ("Face has " << m_bucketsPerFace[face->GetId()] <<
-               " packets with max allowance " << maxBucketsPerFace[face->GetId()]); 
-    
-  if (m_bucketsPerFace[face->GetId()]+1.0 >= maxBucketsPerFace[face->GetId()])
-    {
-      NS_LOG_INFO("************ LIMIT **************");
-      return false;
-    }
-    
-  m_bucketsPerFace[face->GetId()] = m_bucketsPerFace[face->GetId()] + 1.0;
-
-  modify (iterator_to (pitEntry),
-          bind(&CcnxPitEntry::AddOutgoing, lambda::_1, face));
-          
-  return true;
-}
-
 const CcnxPitEntry&
 CcnxPit::Lookup (const CcnxContentObjectHeader &header) const
 {
@@ -217,24 +197,4 @@
   return make_tuple (cref(*entry), isNew, isDuplicate);
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////
-
-void 
-CcnxPit::LeakBuckets ()
-{
-  for (PitBucketIterator it = m_bucketsPerFace.begin(); 
-       it != m_bucketsPerFace.end();
-       it++)
-    {
-      it->second = std::max (0.0, it->second - leakSize[it->first]);
-    }
-}
-    
-void 
-CcnxPit::LeakBucket (Ptr<CcnxFace> face, int amount)
-{
-  m_bucketsPerFace[face->GetId()] = std::max (0.0, m_bucketsPerFace[face->GetId()] - amount);
-}
-
-
 } // namespace ns3
diff --git a/model/ccnx-pit.h b/model/ccnx-pit.h
index 7c8785c..0d1132e 100644
--- a/model/ccnx-pit.h
+++ b/model/ccnx-pit.h
@@ -92,9 +92,8 @@
 // typedef std::map<int,int> PitCounter;
 // typedef std::map<int,int>::iterator PitCounterIterator;
 
- typedef std::map<int,double> PitBucket;
- typedef std::map<int,double>::iterator PitBucketIterator;
-
+typedef std::map<int,double> PitBucket;
+typedef std::map<int,double>::iterator PitBucketIterator;
 
 ////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////
@@ -122,17 +121,6 @@
    * \brief Destructor
    */
   virtual ~CcnxPit ();
-
-  /**
-   * @brief Try to add outgoing entry to PIT entry.
-   * Will fail if there were too much (other) interests forwarded to this face
-   *
-   * @param pitEntry PIT entry
-   * @param face     face
-   * @returns false if rate limit is imposed and no outgoing entry was created. True otherwise
-   */
-  bool
-  TryAddOutgoing(const CcnxPitEntry &pitEntry, Ptr<CcnxFace> face);
   
   /**
    * \brief Find corresponding PIT entry for the given content name
@@ -155,21 +143,25 @@
   boost::tuple<const CcnxPitEntry&, bool, bool>
   Lookup (const CcnxInterestHeader &header);
   
-  // remove a PIT entry
-  //void erase (const string &contentName);
-	
-  // Reset pending state in outgoing interests
-  // void resetPendingState( PitEntry &pe );
+  Time GetPitEntryPruningTimeout () const
+  {
+    return m_PitEntryPruningTimout;
+  }
+  
+  /**
+   * \brief Set FIB table
+   */
+  void SetFib (Ptr<CcnxFib> fib);
 
-  //	// Check if there are any interfaces that we haven't sent data to yet
-  //	bool areFreeInterfaces( PitEntry &pe, int interface );
+protected:
+  // inherited from Object class                                                                                                                                                        
+  virtual void NotifyNewAggregate ();
+  virtual void DoDispose ();
+  	
+private:
+  /** \brief Remove expired records from PIT */
+  void CleanExpired ();
 
-  // Periodically generate pre-calculated number of tokens (leak buckets)
-  void LeakBuckets( );
-	
-  // Selectively leak a bucket
-  void LeakBucket (Ptr<CcnxFace> face, int amount);
-	
   /**
    * \brief Set cleanup timeout
    *
@@ -186,40 +178,26 @@
    */
   Time GetCleanupTimeout () const;
 
-  Time GetPitEntryPruningTimeout () const
-  {
-    return m_PitEntryPruningTimout;
-  }
-  
-  /**
-   * \brief Set FIB table
-   */
-  void SetFib (Ptr<CcnxFib> fib);
-
-protected:
-  // inherited from Object class                                                                                                                                                        
-  virtual void NotifyNewAggregate ();
-  virtual void DoDispose ();
-
-public:
-   PitBucket				 maxBucketsPerFace; // maximum number of buckets. Automatically computed based on link capacity
-  // // averaging over 1 second (bandwidth * 1second)
-   PitBucket				 leakSize;				 // size of a periodic bucket leak
-	
-private:
-  /** \brief Remove expired records from PIT */
-  void CleanExpired ();
-
   friend std::ostream& operator<< (std::ostream& os, const CcnxPit &fib);
   
 private:
   Time    m_cleanupTimeout; ///< \brief Configurable timeout of how often cleanup events are working
   EventId m_cleanupEvent;   ///< \brief Cleanup event
+
+  // configuration variables. Check implementation of GetTypeId for more details
   Time    m_PitEntryPruningTimout;
-  Time    m_PitEntryDefaultLifetime; 
+  Time    m_PitEntryDefaultLifetime;
 
   Ptr<CcnxFib> m_fib; ///< \brief Link to FIB table
-  PitBucket    m_bucketsPerFace; ///< \brief pending interface counter per face
+  // PitBucket    m_bucketsPerFace; ///< \brief pending interface counter per face
+
+  // /**
+  //  * \brief maximum number of buckets. Automatically computed based on link capacity
+  //  * averaging over 1 second (bandwidth * 1second)
+  //  */
+  // PitBucket    maxBucketsPerFace;
+  
+  // PitBucket    leakSize; ///< size of a periodic bucket leak
 };
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/model/ccnx.h b/model/ccnx.h
index 4d6f636..38c2f74 100644
--- a/model/ccnx.h
+++ b/model/ccnx.h
@@ -22,7 +22,6 @@
 #define _CCNX_H_
 
 #include "ns3/object.h"
-#include "ns3/socket.h"
 #include "ns3/callback.h"
 
 namespace ns3 {
@@ -80,13 +79,13 @@
 class Ccnx : public Object
 {
 public:
-    enum ForwardingStrategy
+  enum ForwardingStrategy
     { 
-        NDN_FLOODING = 1,
-        NDN_BESTROUTE = 2,
-        NDN_RANKING = 3 
+      NDN_FLOODING = 1,
+      NDN_BESTROUTE = 2,
+      NDN_RANKING = 3 
     };
-    
+
   /**
    * \brief Interface ID
    *
@@ -95,47 +94,47 @@
   static TypeId GetTypeId ();
   virtual ~Ccnx ();
 
-  /**
-   * \brief Send an Interest packet to a specified face
-   *
-   * \param face face where to send this packet
-   * \param header Interest header
-   * \param packet fully prepared CCNx packet to send
-   *
-   * Higher-level layers (forwarding strategy in particular) call this
-   * method to send a packet down the stack to the MAC and PHY layers.
-   */
-  virtual void
-  SendInterest (const Ptr<CcnxFace> &face,
-                const Ptr<const CcnxInterestHeader> &header,
-                const Ptr<Packet> &packet) = 0;
+  // /**
+  //  * \brief Send an Interest packet to a specified face
+  //  *
+  //  * \param face face where to send this packet
+  //  * \param header Interest header
+  //  * \param packet fully prepared CCNx packet to send
+  //  *
+  //  * Higher-level layers (forwarding strategy in particular) call this
+  //  * method to send a packet down the stack to the MAC and PHY layers.
+  //  */
+  // virtual void
+  // SendInterest (const Ptr<CcnxFace> &face,
+  //               const Ptr<const CcnxInterestHeader> &header,
+  //               const Ptr<Packet> &packet) = 0;
 
-  /**
-   * \brief Send a ContentObject packet to a specified face
-   *
-   * \param face face where to send this packet
-   * \param header ContentObject header
-   * \param packet fully prepared CCNx packet to send
-   *
-   * Higher-level layers (forwarding strategy in particular) call this
-   * method to send a packet down the stack to the MAC and PHY layers.
-   */
-  virtual void
-  SendContentObject (const Ptr<CcnxFace> &face,
-                     const Ptr<const CcnxContentObjectHeader> &header,
-                     const Ptr<Packet> &packet) = 0;
+  // /**
+  //  * \brief Send a ContentObject packet to a specified face
+  //  *
+  //  * \param face face where to send this packet
+  //  * \param header ContentObject header
+  //  * \param packet fully prepared CCNx packet to send
+  //  *
+  //  * Higher-level layers (forwarding strategy in particular) call this
+  //  * method to send a packet down the stack to the MAC and PHY layers.
+  //  */
+  // virtual void
+  // SendContentObject (const Ptr<CcnxFace> &face,
+  //                    const Ptr<const CcnxContentObjectHeader> &header,
+  //                    const Ptr<Packet> &packet) = 0;
 
-  /**
-   * \brief Lower layers calls this method after demultiplexing
-   *
-   * Lower-layer-dependent implementation of CcnxFace will do actual work
-   * to set up demultiplexing and call this function as a callback
-   *
-   * \param face face from which packet came from
-   * \param p the packet
-   */
-  virtual void
-  Receive (const Ptr<CcnxFace> &face, const Ptr<const Packet> &p) = 0;
+  // /**
+  //  * \brief Lower layers calls this method after demultiplexing
+  //  *
+  //  * Lower-layer-dependent implementation of CcnxFace will do actual work
+  //  * to set up demultiplexing and call this function as a callback
+  //  *
+  //  * \param face face from which packet came from
+  //  * \param p the packet
+  //  */
+  // virtual void
+  // Receive (const Ptr<CcnxFace> &face, const Ptr<const Packet> &p) = 0;
 
   /**
    * \brief Register a new forwarding strategy to be used by this Ccnx