diff --git a/model/pit/ccnx-pit-entry-impl.h b/model/pit/ndn-pit-entry-impl.h
similarity index 82%
rename from model/pit/ccnx-pit-entry-impl.h
rename to model/pit/ndn-pit-entry-impl.h
index 4b49cbd..13cceb5 100644
--- a/model/pit/ccnx-pit-entry-impl.h
+++ b/model/pit/ndn-pit-entry-impl.h
@@ -18,33 +18,33 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef _CCNX_PIT_ENTRY_IMPL_H_
-#define	_CCNX_PIT_ENTRY_IMPL_H_
+#ifndef _NDN_PIT_ENTRY_IMPL_H_
+#define	_NDN_PIT_ENTRY_IMPL_H_
 
 namespace ns3 {
 
-class CcnxPit;
-class CcnxInterestHeader;
-class CcnxFibEntry;
+class NdnPit;
+class NdnInterestHeader;
+class NdnFibEntry;
 
 template<class Pit>
-class CcnxPitEntryImpl : public CcnxPitEntry
+class NdnPitEntryImpl : public NdnPitEntry
 {
-  typedef CcnxPitEntry super;
+  typedef NdnPitEntry super;
   #define CONTAINER static_cast<Pit&> (m_container)
   
 public:
-  CcnxPitEntryImpl (CcnxPit &pit,
-                    Ptr<const CcnxInterestHeader> header,
-                    Ptr<CcnxFibEntry> fibEntry)
-  : CcnxPitEntry (pit, header, fibEntry)
+  NdnPitEntryImpl (NdnPit &pit,
+                    Ptr<const NdnInterestHeader> header,
+                    Ptr<NdnFibEntry> fibEntry)
+  : NdnPitEntry (pit, header, fibEntry)
   , item_ (0)
   {
     CONTAINER.i_time.insert (*this);
     CONTAINER.RescheduleCleaning ();
   }
   
-  virtual ~CcnxPitEntryImpl ()
+  virtual ~NdnPitEntryImpl ()
   {
     CONTAINER.i_time.erase (Pit::time_index::s_iterator_to (*this));
     
diff --git a/model/pit/ccnx-pit-entry-incoming-face.cc b/model/pit/ndn-pit-entry-incoming-face.cc
similarity index 81%
rename from model/pit/ccnx-pit-entry-incoming-face.cc
rename to model/pit/ndn-pit-entry-incoming-face.cc
index 23f3c40..28408ed 100644
--- a/model/pit/ccnx-pit-entry-incoming-face.cc
+++ b/model/pit/ndn-pit-entry-incoming-face.cc
@@ -18,20 +18,20 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#include "ccnx-pit-entry-incoming-face.h"
+#include "ndn-pit-entry-incoming-face.h"
 
 #include "ns3/simulator.h"
 
 namespace ns3 {
 
-CcnxPitEntryIncomingFace::CcnxPitEntryIncomingFace (Ptr<CcnxFace> face)
+NdnPitEntryIncomingFace::NdnPitEntryIncomingFace (Ptr<NdnFace> face)
   : m_face (face)
   , m_arrivalTime (Simulator::Now ())
   // , m_nonce (nonce)
 {
 }
 
-CcnxPitEntryIncomingFace::CcnxPitEntryIncomingFace ()
+NdnPitEntryIncomingFace::NdnPitEntryIncomingFace ()
   : m_face (0)
   , m_arrivalTime (0)
 {
@@ -40,8 +40,8 @@
 /**
  * @brie Copy operator
  */
-CcnxPitEntryIncomingFace &
-CcnxPitEntryIncomingFace::operator = (CcnxPitEntryIncomingFace &other)
+NdnPitEntryIncomingFace &
+NdnPitEntryIncomingFace::operator = (NdnPitEntryIncomingFace &other)
 {
   m_face = other.m_face;
   m_arrivalTime = other.m_arrivalTime;
diff --git a/model/pit/ccnx-pit-entry-incoming-face.h b/model/pit/ndn-pit-entry-incoming-face.h
similarity index 65%
rename from model/pit/ccnx-pit-entry-incoming-face.h
rename to model/pit/ndn-pit-entry-incoming-face.h
index 7c5e17d..947271b 100644
--- a/model/pit/ccnx-pit-entry-incoming-face.h
+++ b/model/pit/ndn-pit-entry-incoming-face.h
@@ -18,24 +18,24 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef _CCNX_PIT_ENTRY_INCOMING_FACE_H_
-#define	_CCNX_PIT_ENTRY_INCOMING_FACE_H_
+#ifndef _NDN_PIT_ENTRY_INCOMING_FACE_H_
+#define	_NDN_PIT_ENTRY_INCOMING_FACE_H_
 
 #include "ns3/nstime.h"
 #include "ns3/ptr.h"
 
-#include "ns3/ccnx-face.h"
+#include "ns3/ndn-face.h"
 // #include <iostream>
 
 namespace ns3 {
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief PIT state component for each incoming interest (not including duplicates)
  */
-struct CcnxPitEntryIncomingFace
+struct NdnPitEntryIncomingFace
 {
-  Ptr<CcnxFace> m_face; ///< \brief face of the incoming Interest
+  Ptr<NdnFace> m_face; ///< \brief face of the incoming Interest
   Time m_arrivalTime;   ///< \brief arrival time of the incoming Interest
 
 public:
@@ -44,36 +44,36 @@
    * \param face face of the incoming interest
    * \param lifetime lifetime of the incoming interest
    */
-  CcnxPitEntryIncomingFace (Ptr<CcnxFace> face);
+  NdnPitEntryIncomingFace (Ptr<NdnFace> face);
 
   /**
    * @brief Default constructor, necessary for Python bindings, but should not be used anywhere else.
    */
-  CcnxPitEntryIncomingFace ();
+  NdnPitEntryIncomingFace ();
   /**
    * @brie Copy operator
    */
-  CcnxPitEntryIncomingFace &
-  operator = (CcnxPitEntryIncomingFace &other);
+  NdnPitEntryIncomingFace &
+  operator = (NdnPitEntryIncomingFace &other);
 
   /**
-   * @brief Compare two CcnxPitEntryIncomingFace
+   * @brief Compare two NdnPitEntryIncomingFace
    */
-  bool operator== (const CcnxPitEntryIncomingFace &dst) { return *m_face==*(dst.m_face); }
+  bool operator== (const NdnPitEntryIncomingFace &dst) { return *m_face==*(dst.m_face); }
 
   /**
-   * @brief Compare CcnxPitEntryIncomingFace with CcnxFace
+   * @brief Compare NdnPitEntryIncomingFace with NdnFace
    */
-  bool operator== (Ptr<CcnxFace> face) { return *m_face==*face; }
+  bool operator== (Ptr<NdnFace> face) { return *m_face==*face; }
 
   /**
    * \brief Comparison operator used by boost::multi_index::identity<>
    */
   bool
-  operator< (const CcnxPitEntryIncomingFace &m) const { return *m_face < *(m.m_face); } // return identity of the face
+  operator< (const NdnPitEntryIncomingFace &m) const { return *m_face < *(m.m_face); } // return identity of the face
 };
 
 
 } // namespace ns3
 
-#endif	/* CCNX_PIT_ENTRY_INCOMING_FACE_H */
+#endif	/* NDN_PIT_ENTRY_INCOMING_FACE_H */
diff --git a/model/pit/ccnx-pit-entry-outgoing-face.cc b/model/pit/ndn-pit-entry-outgoing-face.cc
similarity index 87%
rename from model/pit/ccnx-pit-entry-outgoing-face.cc
rename to model/pit/ndn-pit-entry-outgoing-face.cc
index 8527779..9829eaa 100644
--- a/model/pit/ccnx-pit-entry-outgoing-face.cc
+++ b/model/pit/ndn-pit-entry-outgoing-face.cc
@@ -18,13 +18,13 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#include "ccnx-pit-entry-outgoing-face.h"
+#include "ndn-pit-entry-outgoing-face.h"
 
 #include "ns3/simulator.h"
 
 namespace ns3 {
 
-CcnxPitEntryOutgoingFace::CcnxPitEntryOutgoingFace (Ptr<CcnxFace> face)
+NdnPitEntryOutgoingFace::NdnPitEntryOutgoingFace (Ptr<NdnFace> face)
   : m_face (face)
   , m_sendTime (Simulator::Now ())
   , m_retxCount (0)
@@ -33,7 +33,7 @@
 }
 
 void
-CcnxPitEntryOutgoingFace::UpdateOnRetransmit ()
+NdnPitEntryOutgoingFace::UpdateOnRetransmit ()
 {
   m_sendTime = Simulator::Now ();
   m_retxCount++;
diff --git a/model/pit/ccnx-pit-entry-outgoing-face.h b/model/pit/ndn-pit-entry-outgoing-face.h
similarity index 71%
rename from model/pit/ccnx-pit-entry-outgoing-face.h
rename to model/pit/ndn-pit-entry-outgoing-face.h
index b16b4fd..c9d1357 100644
--- a/model/pit/ccnx-pit-entry-outgoing-face.h
+++ b/model/pit/ndn-pit-entry-outgoing-face.h
@@ -18,23 +18,23 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef _CCNX_PIT_ENTRY_OUTGOING_FACE_H_
-#define	_CCNX_PIT_ENTRY_OUTGOING_FACE_H_
+#ifndef _NDN_PIT_ENTRY_OUTGOING_FACE_H_
+#define	_NDN_PIT_ENTRY_OUTGOING_FACE_H_
 
 #include "ns3/nstime.h"
 #include "ns3/ptr.h"
 
-#include "ns3/ccnx-face.h"
+#include "ns3/ndn-face.h"
 
 namespace ns3 {
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief PIT state component for each outgoing interest
  */
-struct CcnxPitEntryOutgoingFace
+struct NdnPitEntryOutgoingFace
 {
-  Ptr<CcnxFace> m_face;     ///< \brief face of the outgoing Interest
+  Ptr<NdnFace> m_face;     ///< \brief face of the outgoing Interest
   Time m_sendTime;          ///< \brief time when the first outgoing interest is sent (for RTT measurements)
                             ///< \todo handle problem of retransmitted interests... Probably, we should include something similar
                             ///<       to TimeStamp TCP option for retransmitted (i.e., only lost interests will suffer)
@@ -43,10 +43,10 @@
 	
 public:
   /**
-   * @brief Constructor to create CcnxPitEntryOutgoingFace
+   * @brief Constructor to create NdnPitEntryOutgoingFace
    * \param face face of the outgoing interest
    */
-  CcnxPitEntryOutgoingFace (Ptr<CcnxFace> face);
+  NdnPitEntryOutgoingFace (Ptr<NdnFace> face);
 
   /**
    * @brief Update outgoing entry upon retransmission
@@ -55,23 +55,23 @@
   UpdateOnRetransmit ();
 
   /**
-   * @brief Compare to CcnxPitEntryOutgoingFace
+   * @brief Compare to NdnPitEntryOutgoingFace
    */
-  bool operator== (const CcnxPitEntryOutgoingFace &dst) { return *m_face==*dst.m_face; }
+  bool operator== (const NdnPitEntryOutgoingFace &dst) { return *m_face==*dst.m_face; }
 
   /**
-   * @brief Compare CcnxPitEntryOutgoingFace with CcnxFace
+   * @brief Compare NdnPitEntryOutgoingFace with NdnFace
    */
-  bool operator== (Ptr<CcnxFace> face) { return *m_face==*face; }
+  bool operator== (Ptr<NdnFace> face) { return *m_face==*face; }
 
   /**
    * \brief Comparison operator used by boost::multi_index::identity<>
    */
   bool
-  operator< (const CcnxPitEntryOutgoingFace &m) const { return *m_face < *(m.m_face); } // return identity of the face
+  operator< (const NdnPitEntryOutgoingFace &m) const { return *m_face < *(m.m_face); } // return identity of the face
 };
 
 
 } // namespace ns3
 
-#endif	/* CCNX_PIT_ENTRY_OUTGOING_FACE_H */
+#endif	/* NDN_PIT_ENTRY_OUTGOING_FACE_H */
diff --git a/model/pit/ccnx-pit-entry.cc b/model/pit/ndn-pit-entry.cc
similarity index 67%
rename from model/pit/ccnx-pit-entry.cc
rename to model/pit/ndn-pit-entry.cc
index 9e45258..bc6ca0e 100644
--- a/model/pit/ccnx-pit-entry.cc
+++ b/model/pit/ndn-pit-entry.cc
@@ -18,11 +18,11 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#include "ccnx-pit-entry.h"
+#include "ndn-pit-entry.h"
 
-#include "ns3/ccnx-fib.h"
-#include "ns3/ccnx-name-components.h"
-#include "ns3/ccnx-interest-header.h"
+#include "ns3/ndn-fib.h"
+#include "ns3/ndn-name-components.h"
+#include "ns3/ndn-interest-header.h"
 
 #include "ns3/simulator.h"
 #include "ns3/log.h"
@@ -32,14 +32,14 @@
 #include <boost/foreach.hpp>
 namespace ll = boost::lambda;
 
-NS_LOG_COMPONENT_DEFINE ("CcnxPitEntry");
+NS_LOG_COMPONENT_DEFINE ("NdnPitEntry");
 
 namespace ns3
 {
 
-CcnxPitEntry::CcnxPitEntry (CcnxPit &container,
-                            Ptr<const CcnxInterestHeader> header,
-                            Ptr<CcnxFibEntry> fibEntry)
+NdnPitEntry::NdnPitEntry (NdnPit &container,
+                            Ptr<const NdnInterestHeader> header,
+                            Ptr<NdnFibEntry> fibEntry)
   : m_container (container)
   , m_prefix (header->GetNamePtr ())
   , m_fibEntry (fibEntry)
@@ -52,7 +52,7 @@
 }
 
 void
-CcnxPitEntry::UpdateLifetime (const Time &offsetTime)
+NdnPitEntry::UpdateLifetime (const Time &offsetTime)
 {
   NS_LOG_FUNCTION (offsetTime.ToDouble (Time::S));
   
@@ -63,11 +63,11 @@
   NS_LOG_INFO ("Updated lifetime to " << m_expireTime.ToDouble (Time::S));
 }
 
-CcnxPitEntry::in_iterator
-CcnxPitEntry::AddIncoming (Ptr<CcnxFace> face)
+NdnPitEntry::in_iterator
+NdnPitEntry::AddIncoming (Ptr<NdnFace> face)
 {
   std::pair<in_iterator,bool> ret = 
-    m_incoming.insert (CcnxPitEntryIncomingFace (face));
+    m_incoming.insert (NdnPitEntryIncomingFace (face));
 
   // NS_ASSERT_MSG (ret.second, "Something is wrong");
 
@@ -75,29 +75,29 @@
 }
 
 void
-CcnxPitEntry::RemoveIncoming (Ptr<CcnxFace> face)
+NdnPitEntry::RemoveIncoming (Ptr<NdnFace> face)
 {
   m_incoming.erase (face);
 }
 
 
-CcnxPitEntry::out_iterator
-CcnxPitEntry::AddOutgoing (Ptr<CcnxFace> face)
+NdnPitEntry::out_iterator
+NdnPitEntry::AddOutgoing (Ptr<NdnFace> face)
 {
   std::pair<out_iterator,bool> ret =
-    m_outgoing.insert (CcnxPitEntryOutgoingFace (face));
+    m_outgoing.insert (NdnPitEntryOutgoingFace (face));
 
   if (!ret.second)
     { // outgoing face already exists
       m_outgoing.modify (ret.first,
-                         ll::bind (&CcnxPitEntryOutgoingFace::UpdateOnRetransmit, ll::_1));
+                         ll::bind (&NdnPitEntryOutgoingFace::UpdateOnRetransmit, ll::_1));
     }
 
   return ret.first;
 }
 
 void
-CcnxPitEntry::RemoveAllReferencesToFace (Ptr<CcnxFace> face)
+NdnPitEntry::RemoveAllReferencesToFace (Ptr<NdnFace> face)
 {
   in_iterator incoming = m_incoming.find (face);
 
@@ -112,16 +112,16 @@
 }
 
 // void
-// CcnxPitEntry::SetWaitingInVain (CcnxPitEntry::out_iterator face)
+// NdnPitEntry::SetWaitingInVain (NdnPitEntry::out_iterator face)
 // {
 //   NS_LOG_DEBUG (boost::cref (*face->m_face));
 
 //   m_outgoing.modify (face,
-//                      (&ll::_1)->*&CcnxPitEntryOutgoingFace::m_waitingInVain = true);
+//                      (&ll::_1)->*&NdnPitEntryOutgoingFace::m_waitingInVain = true);
 // }
 
 void
-CcnxPitEntry::SetWaitingInVain (Ptr<CcnxFace> face)
+NdnPitEntry::SetWaitingInVain (Ptr<NdnFace> face)
 {
   // NS_LOG_DEBUG (boost::cref (*face->m_face));
 
@@ -130,37 +130,37 @@
     return;
   
   m_outgoing.modify (item,
-                     (&ll::_1)->*&CcnxPitEntryOutgoingFace::m_waitingInVain = true);
+                     (&ll::_1)->*&NdnPitEntryOutgoingFace::m_waitingInVain = true);
 }
 
 
 bool
-CcnxPitEntry::AreAllOutgoingInVain () const
+NdnPitEntry::AreAllOutgoingInVain () const
 {
   NS_LOG_DEBUG (m_outgoing.size ());
 
   bool inVain = true;
   std::for_each (m_outgoing.begin (), m_outgoing.end (),
-                 ll::var(inVain) &= (&ll::_1)->*&CcnxPitEntryOutgoingFace::m_waitingInVain);
+                 ll::var(inVain) &= (&ll::_1)->*&NdnPitEntryOutgoingFace::m_waitingInVain);
 
   NS_LOG_DEBUG ("inVain " << inVain);
   return inVain;
 }
 
 bool
-CcnxPitEntry::AreTherePromisingOutgoingFacesExcept (Ptr<CcnxFace> face) const
+NdnPitEntry::AreTherePromisingOutgoingFacesExcept (Ptr<NdnFace> face) const
 {
   bool inVain = true;
   std::for_each (m_outgoing.begin (), m_outgoing.end (),
                  ll::var(inVain) &=
-                 ((&ll::_1)->*&CcnxPitEntryOutgoingFace::m_face == face ||
-                  (&ll::_1)->*&CcnxPitEntryOutgoingFace::m_waitingInVain));
+                 ((&ll::_1)->*&NdnPitEntryOutgoingFace::m_face == face ||
+                  (&ll::_1)->*&NdnPitEntryOutgoingFace::m_waitingInVain));
 
   return !inVain;
 }
 
 void
-CcnxPitEntry::IncreaseAllowedRetxCount ()
+NdnPitEntry::IncreaseAllowedRetxCount ()
 {
   NS_LOG_ERROR (this);
   if (Simulator::Now () - m_lastRetransmission >= MilliSeconds (100))
@@ -172,12 +172,12 @@
     }
 }
 
-std::ostream& operator<< (std::ostream& os, const CcnxPitEntry &entry)
+std::ostream& operator<< (std::ostream& os, const NdnPitEntry &entry)
 {
   os << "Prefix: " << *entry.m_prefix << "\n";
   os << "In: ";
   bool first = true;
-  BOOST_FOREACH (const CcnxPitEntryIncomingFace &face, entry.m_incoming)
+  BOOST_FOREACH (const NdnPitEntryIncomingFace &face, entry.m_incoming)
     {
       if (!first)
         os << ",";
@@ -189,7 +189,7 @@
 
   os << "\nOut: ";
   first = true;
-  BOOST_FOREACH (const CcnxPitEntryOutgoingFace &face, entry.m_outgoing)
+  BOOST_FOREACH (const NdnPitEntryOutgoingFace &face, entry.m_outgoing)
     {
       if (!first)
         os << ",";
diff --git a/model/pit/ccnx-pit-entry.h b/model/pit/ndn-pit-entry.h
similarity index 75%
rename from model/pit/ccnx-pit-entry.h
rename to model/pit/ndn-pit-entry.h
index 4cbae2e..c14b93c 100644
--- a/model/pit/ccnx-pit-entry.h
+++ b/model/pit/ndn-pit-entry.h
@@ -18,15 +18,15 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef _CCNX_PIT_ENTRY_H_
-#define _CCNX_PIT_ENTRY_H_
+#ifndef _NDN_PIT_ENTRY_H_
+#define _NDN_PIT_ENTRY_H_
 
 #include "ns3/ptr.h"
 #include "ns3/simple-ref-count.h"
 
-#include "ns3/ccnx-fib.h"
-#include "ccnx-pit-entry-incoming-face.h"
-#include "ccnx-pit-entry-outgoing-face.h"
+#include "ns3/ndn-fib.h"
+#include "ndn-pit-entry-incoming-face.h"
+#include "ndn-pit-entry-outgoing-face.h"
 
 #include <boost/multi_index_container.hpp>
 #include <boost/multi_index/tag.hpp>
@@ -39,38 +39,38 @@
 
 namespace ns3 {
 
-class CcnxFace;
-class CcnxNameComponents;
-class CcnxPit;
+class NdnFace;
+class NdnNameComponents;
+class NdnPit;
 
 /// @cond include_hidden
-namespace __ccnx_private
+namespace __ndn_private
 {
 class i_retx {};
 }
 /// @endcond
 
 /**
- * \ingroup ccnx
- * \brief Typedef for indexed face container of CcnxPitEntryOutgoingFace
+ * \ingroup ndn
+ * \brief Typedef for indexed face container of NdnPitEntryOutgoingFace
  *
  * Indexes:
  * - by face (may be it will be possible to replace with just the std::map)
  */
-struct CcnxPitEntryOutgoingFaceContainer
+struct NdnPitEntryOutgoingFaceContainer
 {
   /// @cond include_hidden
   typedef boost::multi_index::multi_index_container<
-    CcnxPitEntryOutgoingFace,
+    NdnPitEntryOutgoingFace,
     boost::multi_index::indexed_by<
-      // For fast access to elements using CcnxFace
+      // For fast access to elements using NdnFace
       boost::multi_index::ordered_unique<
-        boost::multi_index::tag<__ccnx_private::i_face>,
-        boost::multi_index::member<CcnxPitEntryOutgoingFace, Ptr<CcnxFace>, &CcnxPitEntryOutgoingFace::m_face>
+        boost::multi_index::tag<__ndn_private::i_face>,
+        boost::multi_index::member<NdnPitEntryOutgoingFace, Ptr<NdnFace>, &NdnPitEntryOutgoingFace::m_face>
       >,
       boost::multi_index::ordered_non_unique<
-        boost::multi_index::tag<__ccnx_private::i_retx>,
-        boost::multi_index::member<CcnxPitEntryOutgoingFace, uint32_t, &CcnxPitEntryOutgoingFace::m_retxCount>
+        boost::multi_index::tag<__ndn_private::i_retx>,
+        boost::multi_index::member<NdnPitEntryOutgoingFace, uint32_t, &NdnPitEntryOutgoingFace::m_retxCount>
       >    
     >
    > type;
@@ -79,18 +79,18 @@
 
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief structure for PIT entry
  *
  * All set-methods are virtual, in case index rearrangement is necessary in the derived classes
  */
-class CcnxPitEntry : public SimpleRefCount<CcnxPitEntry>
+class NdnPitEntry : public SimpleRefCount<NdnPitEntry>
 {
 public:
-  typedef std::set< CcnxPitEntryIncomingFace > in_container; ///< @brief incoming faces container type
+  typedef std::set< NdnPitEntryIncomingFace > in_container; ///< @brief incoming faces container type
   typedef in_container::iterator in_iterator;                ///< @brief iterator to incoming faces
 
-  typedef CcnxPitEntryOutgoingFaceContainer::type out_container; ///< @brief outgoing faces container type
+  typedef NdnPitEntryOutgoingFaceContainer::type out_container; ///< @brief outgoing faces container type
   typedef out_container::iterator out_iterator;              ///< @brief iterator to outgoing faces
 
   typedef std::set< uint32_t > nonce_container;  ///< @brief nonce container type
@@ -101,12 +101,12 @@
    * \param offsetTime Relative time to the current moment, representing PIT entry lifetime
    * \param fibEntry A FIB entry associated with the PIT entry
    */
-  CcnxPitEntry (CcnxPit &container, Ptr<const CcnxInterestHeader> header, Ptr<CcnxFibEntry> fibEntry);
+  NdnPitEntry (NdnPit &container, Ptr<const NdnInterestHeader> header, Ptr<NdnFibEntry> fibEntry);
 
   /**
    * @brief Virtual destructor
    */
-  virtual ~CcnxPitEntry () {}
+  virtual ~NdnPitEntry () {}
   
   /**
    * @brief Update lifetime of PIT entry
@@ -122,7 +122,7 @@
   /**
    * @brief Get prefix of the PIT entry
    */
-  const CcnxNameComponents &
+  const NdnNameComponents &
   GetPrefix () const
   { return *m_prefix; }
 
@@ -162,13 +162,13 @@
    * @returns iterator to the added entry
    */
   virtual in_iterator
-  AddIncoming (Ptr<CcnxFace> face);
+  AddIncoming (Ptr<NdnFace> face);
 
   /**
    * @brief Remove incoming entry for face `face`
    */
   virtual void
-  RemoveIncoming (Ptr<CcnxFace> face);
+  RemoveIncoming (Ptr<NdnFace> face);
 
   /**
    * @brief Clear all incoming faces either after all of them were satisfied or NACKed
@@ -184,7 +184,7 @@
    * @returns iterator to the added entry
    */
   virtual out_iterator
-  AddOutgoing (Ptr<CcnxFace> face);
+  AddOutgoing (Ptr<NdnFace> face);
 
   /**
    * @brief Clear all incoming faces either after all of them were satisfied or NACKed
@@ -200,7 +200,7 @@
    * Face is removed from the lists of incoming and outgoing faces
    */
   virtual void
-  RemoveAllReferencesToFace (Ptr<CcnxFace> face);
+  RemoveAllReferencesToFace (Ptr<NdnFace> face);
 
   /**
    * @brief Flag outgoing face as hopeless
@@ -208,7 +208,7 @@
   // virtual void
   // SetWaitingInVain (out_iterator face);
   virtual void
-  SetWaitingInVain (Ptr<CcnxFace> face);
+  SetWaitingInVain (Ptr<NdnFace> face);
   
   /**
    * @brief Check if all outgoing faces are NACKed
@@ -221,7 +221,7 @@
    * \see AreAllOutgoingInVain
    **/
   bool
-  AreTherePromisingOutgoingFacesExcept (Ptr<CcnxFace> face) const;
+  AreTherePromisingOutgoingFacesExcept (Ptr<NdnFace> face) const;
 
   /**
    * @brief Increase maximum limit of allowed retransmission per outgoing face
@@ -229,7 +229,7 @@
   virtual void
   IncreaseAllowedRetxCount ();
 
-  Ptr<CcnxFibEntry>
+  Ptr<NdnFibEntry>
   GetFibEntry () { return m_fibEntry; };
 
   const in_container &
@@ -242,13 +242,13 @@
   GetMaxRetxCount () const { return m_maxRetxCount; }
 
 private:
-  friend std::ostream& operator<< (std::ostream& os, const CcnxPitEntry &entry);
+  friend std::ostream& operator<< (std::ostream& os, const NdnPitEntry &entry);
   
 protected:
-  CcnxPit &m_container; ///< @brief Reference to the container (to rearrange indexes, if necessary)
+  NdnPit &m_container; ///< @brief Reference to the container (to rearrange indexes, if necessary)
   
-  Ptr<const CcnxNameComponents> m_prefix; ///< \brief Prefix of the PIT entry
-  Ptr<CcnxFibEntry> m_fibEntry;     ///< \brief FIB entry related to this prefix
+  Ptr<const NdnNameComponents> m_prefix; ///< \brief Prefix of the PIT entry
+  Ptr<NdnFibEntry> m_fibEntry;     ///< \brief FIB entry related to this prefix
   
   nonce_container m_seenNonces;  ///< \brief map of nonces that were seen for this prefix  
   in_container  m_incoming;      ///< \brief container for incoming interests
@@ -260,8 +260,8 @@
   uint32_t m_maxRetxCount;   ///< @brief Maximum allowed number of retransmissions via outgoing faces
 };
 
-std::ostream& operator<< (std::ostream& os, const CcnxPitEntry &entry);
+std::ostream& operator<< (std::ostream& os, const NdnPitEntry &entry);
 
 } // namespace ns3
 
-#endif // _CCNX_PIT_ENTRY_H_
+#endif // _NDN_PIT_ENTRY_H_
diff --git a/model/pit/ccnx-pit-impl.cc b/model/pit/ndn-pit-impl.cc
similarity index 67%
rename from model/pit/ccnx-pit-impl.cc
rename to model/pit/ndn-pit-impl.cc
index 222b3c9..dcf6ada 100644
--- a/model/pit/ccnx-pit-impl.cc
+++ b/model/pit/ndn-pit-impl.cc
@@ -18,11 +18,11 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#include "ccnx-pit-impl.h"
+#include "ndn-pit-impl.h"
 
-#include "ns3/ccnx-interest-header.h"
-#include "ns3/ccnx-content-object-header.h"
-#include "ns3/ccnx-forwarding-strategy.h"
+#include "ns3/ndn-interest-header.h"
+#include "ns3/ndn-content-object-header.h"
+#include "ns3/ndn-forwarding-strategy.h"
 
 #include "../../utils/empty-policy.h"
 #include "../../utils/persistent-policy.h"
@@ -37,7 +37,7 @@
 #include <boost/lambda/bind.hpp>
 #include <boost/lambda/lambda.hpp>
 
-NS_LOG_COMPONENT_DEFINE ("CcnxPitImpl");
+NS_LOG_COMPONENT_DEFINE ("NdnPitImpl");
 
 using namespace boost::tuples;
 using namespace boost;
@@ -57,17 +57,17 @@
 
 template<>
 TypeId
-CcnxPitImpl<persistent_policy_traits>::GetTypeId ()
+NdnPitImpl<persistent_policy_traits>::GetTypeId ()
 {
-  static TypeId tid = TypeId ("ns3::CcnxPit")
-    .SetGroupName ("Ccnx")
-    .SetParent<CcnxPit> ()
-    .AddConstructor< CcnxPitImpl< persistent_policy_traits > > ()
+  static TypeId tid = TypeId ("ns3::NdnPit")
+    .SetGroupName ("Ndn")
+    .SetParent<NdnPit> ()
+    .AddConstructor< NdnPitImpl< persistent_policy_traits > > ()
     .AddAttribute ("MaxSize",
                    "Set maximum number of entries in PIT. If 0, limit is not enforced",
                    StringValue ("0"),
-                   MakeUintegerAccessor (&CcnxPitImpl< persistent_policy_traits >::GetMaxSize,
-                                         &CcnxPitImpl< persistent_policy_traits >::SetMaxSize),
+                   MakeUintegerAccessor (&NdnPitImpl< persistent_policy_traits >::GetMaxSize,
+                                         &NdnPitImpl< persistent_policy_traits >::SetMaxSize),
                    MakeUintegerChecker<uint32_t> ())
     ;
 
@@ -76,17 +76,17 @@
 
 template<>
 TypeId
-CcnxPitImpl<random_policy_traits>::GetTypeId ()
+NdnPitImpl<random_policy_traits>::GetTypeId ()
 {
-  static TypeId tid = TypeId ("ns3::CcnxPitRandom")
-    .SetGroupName ("Ccnx")
-    .SetParent<CcnxPit> ()
-    .AddConstructor< CcnxPitImpl< random_policy_traits > > ()
+  static TypeId tid = TypeId ("ns3::NdnPitRandom")
+    .SetGroupName ("Ndn")
+    .SetParent<NdnPit> ()
+    .AddConstructor< NdnPitImpl< random_policy_traits > > ()
     .AddAttribute ("MaxSize",
                    "Set maximum number of entries in PIT. If 0, limit is not enforced",
                    StringValue ("0"),
-                   MakeUintegerAccessor (&CcnxPitImpl< random_policy_traits >::GetMaxSize,
-                                         &CcnxPitImpl< random_policy_traits >::SetMaxSize),
+                   MakeUintegerAccessor (&NdnPitImpl< random_policy_traits >::GetMaxSize,
+                                         &NdnPitImpl< random_policy_traits >::SetMaxSize),
                    MakeUintegerChecker<uint32_t> ())
     ;
 
@@ -95,17 +95,17 @@
 
 template<>
 TypeId
-CcnxPitImpl<lru_policy_traits>::GetTypeId ()
+NdnPitImpl<lru_policy_traits>::GetTypeId ()
 {
-  static TypeId tid = TypeId ("ns3::CcnxPitLru")
-    .SetGroupName ("Ccnx")
-    .SetParent<CcnxPit> ()
-    .AddConstructor< CcnxPitImpl< lru_policy_traits > > ()
+  static TypeId tid = TypeId ("ns3::NdnPitLru")
+    .SetGroupName ("Ndn")
+    .SetParent<NdnPit> ()
+    .AddConstructor< NdnPitImpl< lru_policy_traits > > ()
     .AddAttribute ("MaxSize",
                    "Set maximum number of entries in PIT. If 0, limit is not enforced",
                    StringValue ("0"),
-                   MakeUintegerAccessor (&CcnxPitImpl< lru_policy_traits >::GetMaxSize,
-                                         &CcnxPitImpl< lru_policy_traits >::SetMaxSize),
+                   MakeUintegerAccessor (&NdnPitImpl< lru_policy_traits >::GetMaxSize,
+                                         &NdnPitImpl< lru_policy_traits >::SetMaxSize),
                    MakeUintegerChecker<uint32_t> ())
     ;
 
@@ -114,38 +114,38 @@
 
 // template<class Policy>
 // TypeId
-// CcnxPitImpl<Policy>::GetTypeId ()
+// NdnPitImpl<Policy>::GetTypeId ()
 // {
 //   static TypeId tid = TypeId ("ns3::UnknownPitPolicy");
 
 //   return tid;
 // }
 
-// CcnxPitEntryImpl::CcnxPitEntryImpl (CcnxPit &pit,
-//                                     Ptr<const CcnxInterestHeader> header,
-//                                     Ptr<CcnxFibEntry> fibEntry)
-//   : CcnxPitEntry (pit, header, fibEntry)
+// NdnPitEntryImpl::NdnPitEntryImpl (NdnPit &pit,
+//                                     Ptr<const NdnInterestHeader> header,
+//                                     Ptr<NdnFibEntry> fibEntry)
+//   : NdnPitEntry (pit, header, fibEntry)
 //   , item_ (0)
 // {
-//   static_cast<CcnxPitImpl&> (m_container).i_time.insert (*this);
+//   static_cast<NdnPitImpl&> (m_container).i_time.insert (*this);
 // }
 
-// CcnxPitEntryImpl::~CcnxPitEntryImpl ()
+// NdnPitEntryImpl::~NdnPitEntryImpl ()
 // {
-//   static_cast<CcnxPitImpl&> (m_container).i_time.erase (*this);
+//   static_cast<NdnPitImpl&> (m_container).i_time.erase (*this);
 // }
 
 // TypeId
-// CcnxPitImpl::GetTypeId ()
+// NdnPitImpl::GetTypeId ()
 // {
-//   static TypeId tid = TypeId ("ns3::CcnxPit")
-//     .SetGroupName ("Ccnx")
-//     .SetParent<CcnxPit> ()
-//     .AddConstructor<CcnxPitImpl> ()
+//   static TypeId tid = TypeId ("ns3::NdnPit")
+//     .SetGroupName ("Ndn")
+//     .SetParent<NdnPit> ()
+//     .AddConstructor<NdnPitImpl> ()
 //     .AddAttribute ("MaxSize",
 //                    "Set maximum number of entries in PIT. If 0, limit is not enforced",
 //                    StringValue ("0"),
-//                    MakeUintegerAccessor (&CcnxPitImpl::GetMaxSize, &CcnxPitImpl::SetMaxSize),
+//                    MakeUintegerAccessor (&NdnPitImpl::GetMaxSize, &NdnPitImpl::SetMaxSize),
 //                    MakeUintegerChecker<uint32_t> ())
 //     ;
 
@@ -155,17 +155,17 @@
 
 // template<class AcceptanceAndReplacementPolicy>
 // TypeId
-// CcnxPitImpl::GetTypeId ()
+// NdnPitImpl::GetTypeId ()
 // {
 //   #error "Not specialized version is not supported"
-//   // static TypeId tid = TypeId ("ns3::CcnxPit")
-//   //   .SetGroupName ("Ccnx")
-//   //   .SetParent<CcnxPit> ()
-//   //   .AddConstructor<CcnxPitImpl> ()
+//   // static TypeId tid = TypeId ("ns3::NdnPit")
+//   //   .SetGroupName ("Ndn")
+//   //   .SetParent<NdnPit> ()
+//   //   .AddConstructor<NdnPitImpl> ()
 //   //   .AddAttribute ("MaxSize",
 //   //                  "Set maximum number of entries in PIT. If 0, limit is not enforced",
 //   //                  StringValue ("0"),
-//   //                  MakeUintegerAccessor (&CcnxPitImpl::GetMaxSize, &CcnxPitImpl::SetMaxSize),
+//   //                  MakeUintegerAccessor (&NdnPitImpl::GetMaxSize, &NdnPitImpl::SetMaxSize),
 //   //                  MakeUintegerChecker<uint32_t> ())
 //   //   ;
 
@@ -173,60 +173,60 @@
 // }
 
 template<class Policy>
-CcnxPitImpl<Policy>::CcnxPitImpl ()
+NdnPitImpl<Policy>::NdnPitImpl ()
 {
 }
 
 template<class Policy>
-CcnxPitImpl<Policy>::~CcnxPitImpl ()
+NdnPitImpl<Policy>::~NdnPitImpl ()
 {
 }
 
 template<class Policy>
 uint32_t
-CcnxPitImpl<Policy>::GetMaxSize () const
+NdnPitImpl<Policy>::GetMaxSize () const
 {
   return super::getPolicy ().get_max_size ();
 }
 
 template<class Policy>
 void
-CcnxPitImpl<Policy>::SetMaxSize (uint32_t maxSize)
+NdnPitImpl<Policy>::SetMaxSize (uint32_t maxSize)
 {
   super::getPolicy ().set_max_size (maxSize);
 }
 
 template<class Policy>
 void 
-CcnxPitImpl<Policy>::NotifyNewAggregate ()
+NdnPitImpl<Policy>::NotifyNewAggregate ()
 {
   if (m_fib == 0)
     {
-      m_fib = GetObject<CcnxFib> ();
+      m_fib = GetObject<NdnFib> ();
     }
   if (m_forwardingStrategy == 0)
     {
-      m_forwardingStrategy = GetObject<CcnxForwardingStrategy> ();
+      m_forwardingStrategy = GetObject<NdnForwardingStrategy> ();
     }
 
-  CcnxPit::NotifyNewAggregate ();
+  NdnPit::NotifyNewAggregate ();
 }
 
 template<class Policy>
 void 
-CcnxPitImpl<Policy>::DoDispose ()
+NdnPitImpl<Policy>::DoDispose ()
 {
   super::clear ();
 
   m_forwardingStrategy = 0;
   m_fib = 0;
 
-  CcnxPit::DoDispose ();
+  NdnPit::DoDispose ();
 }
 
 template<class Policy>
 void
-CcnxPitImpl<Policy>::RescheduleCleaning ()
+NdnPitImpl<Policy>::RescheduleCleaning ()
 {
   m_cleanEvent.Cancel ();
   if (i_time.empty ())
@@ -243,12 +243,12 @@
   //               i_time.begin ()->GetExpireTime () << "s abs time");
   
   m_cleanEvent = Simulator::Schedule (nextEvent,
-                                      &CcnxPitImpl<Policy>::CleanExpired, this);
+                                      &NdnPitImpl<Policy>::CleanExpired, this);
 }
 
 template<class Policy>
 void
-CcnxPitImpl<Policy>::CleanExpired ()
+NdnPitImpl<Policy>::CleanExpired ()
 {
   NS_LOG_LOGIC ("Cleaning PIT. Total: " << i_time.size ());
   Time now = Simulator::Now ();
@@ -276,8 +276,8 @@
 }
 
 template<class Policy>
-Ptr<CcnxPitEntry>
-CcnxPitImpl<Policy>::Lookup (const CcnxContentObjectHeader &header)
+Ptr<NdnPitEntry>
+NdnPitImpl<Policy>::Lookup (const NdnContentObjectHeader &header)
 {
   /// @todo use predicate to search with exclude filters  
   typename super::iterator item = super::longest_prefix_match (header.GetName ());
@@ -289,8 +289,8 @@
 }
 
 template<class Policy>
-Ptr<CcnxPitEntry>
-CcnxPitImpl<Policy>::Lookup (const CcnxInterestHeader &header)
+Ptr<NdnPitEntry>
+NdnPitImpl<Policy>::Lookup (const NdnInterestHeader &header)
 {
   // NS_LOG_FUNCTION (header.GetName ());
   NS_ASSERT_MSG (m_fib != 0, "FIB should be set");
@@ -307,10 +307,10 @@
 }
 
 template<class Policy>
-Ptr<CcnxPitEntry>
-CcnxPitImpl<Policy>::Create (Ptr<const CcnxInterestHeader> header)
+Ptr<NdnPitEntry>
+NdnPitImpl<Policy>::Create (Ptr<const NdnInterestHeader> header)
 {
-  Ptr<CcnxFibEntry> fibEntry = m_fib->LongestPrefixMatch (*header);
+  Ptr<NdnFibEntry> fibEntry = m_fib->LongestPrefixMatch (*header);
   if (fibEntry == 0)
     return 0;
   
@@ -341,7 +341,7 @@
 
 template<class Policy>
 void
-CcnxPitImpl<Policy>::MarkErased (Ptr<CcnxPitEntry> item)
+NdnPitImpl<Policy>::MarkErased (Ptr<NdnPitEntry> item)
 {
   // entry->SetExpireTime (Simulator::Now () + m_PitEntryPruningTimout);
   super::erase (StaticCast< entry > (item)->to_iterator ());
@@ -350,7 +350,7 @@
 
 template<class Policy>
 void
-CcnxPitImpl<Policy>::Print (std::ostream& os) const
+NdnPitImpl<Policy>::Print (std::ostream& os) const
 {
   // !!! unordered_set imposes "random" order of item in the same level !!!
   typename super::parent_trie::const_recursive_iterator item (super::getTrie ()), end (0);
@@ -364,14 +364,14 @@
 
 template<class Policy>
 uint32_t
-CcnxPitImpl<Policy>::GetSize () const
+NdnPitImpl<Policy>::GetSize () const
 {
   return super::getPolicy ().size ();
 }
 
 template<class Policy>
-Ptr<CcnxPitEntry>
-CcnxPitImpl<Policy>::Begin ()
+Ptr<NdnPitEntry>
+NdnPitImpl<Policy>::Begin ()
 {
   typename super::parent_trie::recursive_iterator item (super::getTrie ()), end (0);
   for (; item != end; item++)
@@ -387,15 +387,15 @@
 }
 
 template<class Policy>
-Ptr<CcnxPitEntry>
-CcnxPitImpl<Policy>::End ()
+Ptr<NdnPitEntry>
+NdnPitImpl<Policy>::End ()
 {
   return 0;
 }
 
 template<class Policy>
-Ptr<CcnxPitEntry>
-CcnxPitImpl<Policy>::Next (Ptr<CcnxPitEntry> from)
+Ptr<NdnPitEntry>
+NdnPitImpl<Policy>::Next (Ptr<NdnPitEntry> from)
 {
   if (from == 0) return 0;
   
@@ -417,13 +417,13 @@
 
 
 // explicit instantiation and registering
-template class CcnxPitImpl<persistent_policy_traits>;
-template class CcnxPitImpl<random_policy_traits>;
-template class CcnxPitImpl<lru_policy_traits>;
+template class NdnPitImpl<persistent_policy_traits>;
+template class NdnPitImpl<random_policy_traits>;
+template class NdnPitImpl<lru_policy_traits>;
 
-NS_OBJECT_ENSURE_REGISTERED_TEMPL(CcnxPitImpl, persistent_policy_traits);
-NS_OBJECT_ENSURE_REGISTERED_TEMPL(CcnxPitImpl, random_policy_traits);
-NS_OBJECT_ENSURE_REGISTERED_TEMPL(CcnxPitImpl, lru_policy_traits);
+NS_OBJECT_ENSURE_REGISTERED_TEMPL(NdnPitImpl, persistent_policy_traits);
+NS_OBJECT_ENSURE_REGISTERED_TEMPL(NdnPitImpl, random_policy_traits);
+NS_OBJECT_ENSURE_REGISTERED_TEMPL(NdnPitImpl, lru_policy_traits);
 
 
 } // namespace ns3
diff --git a/model/pit/ccnx-pit-impl.h b/model/pit/ndn-pit-impl.h
similarity index 71%
rename from model/pit/ccnx-pit-impl.h
rename to model/pit/ndn-pit-impl.h
index 6754dcd..4673bdb 100644
--- a/model/pit/ccnx-pit-impl.h
+++ b/model/pit/ndn-pit-impl.h
@@ -18,38 +18,38 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef _CCNX_PIT_IMPL_H_
-#define	_CCNX_PIT_IMPL_H_
+#ifndef _NDN_PIT_IMPL_H_
+#define	_NDN_PIT_IMPL_H_
 
-#include "ccnx-pit.h"
+#include "ndn-pit.h"
 
 #include "../../utils/trie-with-policy.h"
 
-#include "ccnx-pit-entry-impl.h"
+#include "ndn-pit-entry-impl.h"
 
-#include "ns3/ccnx-name-components.h"
+#include "ns3/ndn-name-components.h"
 
 namespace ns3 {
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief Class implementing Pending Interests Table
  */
 template<class Policy>
-class CcnxPitImpl : public CcnxPit
-                  , protected ndnSIM::trie_with_policy<CcnxNameComponents,
-                                                       ndnSIM::smart_pointer_payload_traits<CcnxPitEntryImpl< CcnxPitImpl< Policy > > >,
+class NdnPitImpl : public NdnPit
+                  , protected ndnSIM::trie_with_policy<NdnNameComponents,
+                                                       ndnSIM::smart_pointer_payload_traits<NdnPitEntryImpl< NdnPitImpl< Policy > > >,
                                                        // ndnSIM::persistent_policy_traits
                                                        Policy
                                                        >
 {
 public:
-  typedef ndnSIM::trie_with_policy<CcnxNameComponents,
-                                   ndnSIM::smart_pointer_payload_traits<CcnxPitEntryImpl< CcnxPitImpl< Policy > > >,
+  typedef ndnSIM::trie_with_policy<NdnNameComponents,
+                                   ndnSIM::smart_pointer_payload_traits<NdnPitEntryImpl< NdnPitImpl< Policy > > >,
                                    // ndnSIM::persistent_policy_traits
                                    Policy
                                    > super;
-  typedef CcnxPitEntryImpl< CcnxPitImpl< Policy > > entry;
+  typedef NdnPitEntryImpl< NdnPitImpl< Policy > > entry;
 
   /**
    * \brief Interface ID
@@ -61,25 +61,25 @@
   /**
    * \brief PIT constructor
    */
-  CcnxPitImpl ();
+  NdnPitImpl ();
 
   /**
    * \brief Destructor
    */
-  virtual ~CcnxPitImpl ();
+  virtual ~NdnPitImpl ();
 
-  // inherited from CcnxPit  
-  virtual Ptr<CcnxPitEntry>
-  Lookup (const CcnxContentObjectHeader &header);
+  // inherited from NdnPit  
+  virtual Ptr<NdnPitEntry>
+  Lookup (const NdnContentObjectHeader &header);
 
-  virtual Ptr<CcnxPitEntry>
-  Lookup (const CcnxInterestHeader &header);
+  virtual Ptr<NdnPitEntry>
+  Lookup (const NdnInterestHeader &header);
 
-  virtual Ptr<CcnxPitEntry>
-  Create (Ptr<const CcnxInterestHeader> header);
+  virtual Ptr<NdnPitEntry>
+  Create (Ptr<const NdnInterestHeader> header);
   
   virtual void
-  MarkErased (Ptr<CcnxPitEntry> entry);
+  MarkErased (Ptr<NdnPitEntry> entry);
 
   virtual void
   Print (std::ostream &os) const;
@@ -87,14 +87,14 @@
   virtual uint32_t
   GetSize () const;
 
-  virtual Ptr<CcnxPitEntry>
+  virtual Ptr<NdnPitEntry>
   Begin ();
 
-  virtual Ptr<CcnxPitEntry>
+  virtual Ptr<NdnPitEntry>
   End ();
 
-  virtual Ptr<CcnxPitEntry>
-  Next (Ptr<CcnxPitEntry>);
+  virtual Ptr<NdnPitEntry>
+  Next (Ptr<NdnPitEntry>);
   
 protected:
   void RescheduleCleaning ();
@@ -113,8 +113,8 @@
   
 private:
   EventId m_cleanEvent;
-  Ptr<CcnxFib> m_fib; ///< \brief Link to FIB table
-  Ptr<CcnxForwardingStrategy> m_forwardingStrategy;
+  Ptr<NdnFib> m_fib; ///< \brief Link to FIB table
+  Ptr<NdnForwardingStrategy> m_forwardingStrategy;
 
   // indexes
   typedef
@@ -126,9 +126,9 @@
                         > time_index;
   time_index i_time; 
                         
-  friend class CcnxPitEntryImpl< CcnxPitImpl >;
+  friend class NdnPitEntryImpl< NdnPitImpl >;
 };
 
 } // namespace ns3
 
-#endif	/* CCNX_PIT_IMPL_H */
+#endif	/* NDN_PIT_IMPL_H */
diff --git a/model/pit/ccnx-pit.cc b/model/pit/ndn-pit.cc
similarity index 76%
rename from model/pit/ccnx-pit.cc
rename to model/pit/ndn-pit.cc
index e07ccfd..1f1bcde 100644
--- a/model/pit/ccnx-pit.cc
+++ b/model/pit/ndn-pit.cc
@@ -18,10 +18,10 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#include "ccnx-pit.h"
+#include "ndn-pit.h"
 
-#include "ns3/ccnx-interest-header.h"
-#include "ns3/ccnx-content-object-header.h"
+#include "ns3/ndn-interest-header.h"
+#include "ns3/ndn-content-object-header.h"
 
 #include "ns3/log.h"
 #include "ns3/string.h"
@@ -31,36 +31,36 @@
 #include <boost/lambda/bind.hpp>
 #include <boost/lambda/lambda.hpp>
 
-NS_LOG_COMPONENT_DEFINE ("CcnxPit");
+NS_LOG_COMPONENT_DEFINE ("NdnPit");
 
 namespace ns3 {
 
-NS_OBJECT_ENSURE_REGISTERED (CcnxPit);
+NS_OBJECT_ENSURE_REGISTERED (NdnPit);
 
-using namespace __ccnx_private;
+using namespace __ndn_private;
 
 TypeId
-CcnxPit::GetTypeId ()
+NdnPit::GetTypeId ()
 {
-  static TypeId tid = TypeId ("ns3::private::CcnxPit")
-    .SetGroupName ("Ccnx")
+  static TypeId tid = TypeId ("ns3::private::NdnPit")
+    .SetGroupName ("Ndn")
     .SetParent<Object> ()
     
     .AddAttribute ("PitEntryPruningTimout",
                    "Timeout for PIT entry to live after being satisfied. To make sure recently satisfied interest will not be satisfied again",
                    StringValue ("100ms"),
-                   MakeTimeAccessor (&CcnxPit::m_PitEntryPruningTimout),
+                   MakeTimeAccessor (&NdnPit::m_PitEntryPruningTimout),
                    MakeTimeChecker ())
     ;
 
   return tid;
 }
 
-CcnxPit::CcnxPit ()
+NdnPit::NdnPit ()
 {
 }
 
-CcnxPit::~CcnxPit ()
+NdnPit::~NdnPit ()
 {
 }
 
diff --git a/model/pit/ccnx-pit.h b/model/pit/ndn-pit.h
similarity index 81%
rename from model/pit/ccnx-pit.h
rename to model/pit/ndn-pit.h
index 26cc626..6a0556b 100644
--- a/model/pit/ccnx-pit.h
+++ b/model/pit/ndn-pit.h
@@ -18,30 +18,30 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef _CCNX_PIT_H_
-#define	_CCNX_PIT_H_
+#ifndef _NDN_PIT_H_
+#define	_NDN_PIT_H_
 
 #include "ns3/object.h"
 #include "ns3/nstime.h"
 #include "ns3/event-id.h"
 
-#include "ccnx-pit-entry.h"
+#include "ndn-pit-entry.h"
 
 namespace ns3 {
 
-class Ccnx;
-class CcnxFace;
-class CcnxContentObjectHeader;
-class CcnxInterestHeader;
+class Ndn;
+class NdnFace;
+class NdnContentObjectHeader;
+class NdnInterestHeader;
 
 ////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief Class implementing Pending Interests Table
  */
-class CcnxPit : public Object
+class NdnPit : public Object
 {
 public:
   /**
@@ -54,12 +54,12 @@
   /**
    * \brief PIT constructor
    */
-  CcnxPit ();
+  NdnPit ();
 
   /**
    * \brief Destructor
    */
-  virtual ~CcnxPit ();
+  virtual ~NdnPit ();
 
   /**
    * \brief Find corresponding PIT entry for the given content name
@@ -72,8 +72,8 @@
    * \returns smart pointer to PIT entry. If record not found,
    *          returns 0
    */
-  virtual Ptr<CcnxPitEntry>
-  Lookup (const CcnxContentObjectHeader &header) = 0;
+  virtual Ptr<NdnPitEntry>
+  Lookup (const NdnContentObjectHeader &header) = 0;
 
   /**
    * \brief Find a PIT entry for the given content interest
@@ -81,8 +81,8 @@
    * \returns iterator to Pit entry. If record not found,
    *          return end() iterator
    */
-  virtual Ptr<CcnxPitEntry>
-  Lookup (const CcnxInterestHeader &header) = 0;
+  virtual Ptr<NdnPitEntry>
+  Lookup (const NdnInterestHeader &header) = 0;
 
   /**
    * @brief Creates a PIT entry for the given interest
@@ -92,8 +92,8 @@
    *
    * Note. This call assumes that the entry does not exist (i.e., there was a Lookup call before)
    */
-  virtual Ptr<CcnxPitEntry>
-  Create (Ptr<const CcnxInterestHeader> header) = 0;
+  virtual Ptr<NdnPitEntry>
+  Create (Ptr<const NdnInterestHeader> header) = 0;
   
   /**
    * @brief Mark PIT entry deleted
@@ -103,7 +103,7 @@
    * lifetime +m_PitEntryDefaultLifetime from Now ()
    */
   virtual void
-  MarkErased (Ptr<CcnxPitEntry> entry) = 0;
+  MarkErased (Ptr<NdnPitEntry> entry) = 0;
 
   /**
    * @brief Print out PIT contents for debugging purposes
@@ -122,20 +122,20 @@
   /**
    * @brief Return first element of FIB (no order guaranteed)
    */
-  virtual Ptr<CcnxPitEntry>
+  virtual Ptr<NdnPitEntry>
   Begin () = 0;
 
   /**
    * @brief Return item next after last (no order guaranteed)
    */
-  virtual Ptr<CcnxPitEntry>
+  virtual Ptr<NdnPitEntry>
   End () = 0;
 
   /**
    * @brief Advance the iterator
    */
-  virtual Ptr<CcnxPitEntry>
-  Next (Ptr<CcnxPitEntry>) = 0;
+  virtual Ptr<NdnPitEntry>
+  Next (Ptr<NdnPitEntry>) = 0;
 
   ////////////////////////////////////////////////////////////////////////////
   ////////////////////////////////////////////////////////////////////////////
@@ -144,8 +144,8 @@
   /**
    * @brief Static call to cheat python bindings
    */
-  static inline Ptr<CcnxPit>
-  GetCcnxPit (Ptr<Object> node);
+  static inline Ptr<NdnPit>
+  GetNdnPit (Ptr<Object> node);
 
 protected:
   // configuration variables. Check implementation of GetTypeId for more details
@@ -156,19 +156,19 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 inline std::ostream&
-operator<< (std::ostream& os, const CcnxPit &pit)
+operator<< (std::ostream& os, const NdnPit &pit)
 {
   pit.Print (os);
   return os;
 }
 
-inline Ptr<CcnxPit>
-CcnxPit::GetCcnxPit (Ptr<Object> node)
+inline Ptr<NdnPit>
+NdnPit::GetNdnPit (Ptr<Object> node)
 {
-  return node->GetObject<CcnxPit> ();
+  return node->GetObject<NdnPit> ();
 }
 
 
 } // namespace ns3
 
-#endif	/* CCNX_PIT_H */
+#endif	/* NDN_PIT_H */