diff --git a/model/ccnx-app-face.cc b/model/ccnx-app-face.cc
deleted file mode 100644
index cec8a1c..0000000
--- a/model/ccnx-app-face.cc
+++ /dev/null
@@ -1,144 +0,0 @@
-/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
-/*
- * Copyright (c) 2011 University of California, Los Angeles
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation;
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- * Author:  Alexander Afanasyev <alexander.afanasyev@ucla.edu>
- *          Ilya Moiseenko <iliamo@cs.ucla.edu>
- *
- */
-
-#include "ccnx-app-face.h"
-
-#include "ns3/log.h"
-#include "ns3/packet.h"
-#include "ns3/node.h"
-#include "ns3/assert.h"
-#include "ns3/simulator.h"
-
-#include "ns3/ccnx-header-helper.h"
-#include "ns3/ccnx-app.h"
-
-#include "ccnx-interest-header.h"
-#include "ccnx-content-object-header.h"
-
-NS_LOG_COMPONENT_DEFINE ("CcnxAppFace");
-
-namespace ns3 
-{
-
-NS_OBJECT_ENSURE_REGISTERED (CcnxAppFace);
-
-TypeId
-CcnxAppFace::GetTypeId ()
-{
-  static TypeId tid = TypeId ("ns3::CcnxAppFace")
-    .SetParent<CcnxFace> ()
-    .SetGroupName ("Ccnx")
-    ;
-  return tid;
-}
-
-CcnxAppFace::CcnxAppFace (Ptr<CcnxApp> app)
-  : CcnxFace (app->GetNode ())
-  , m_app (app)
-{
-  NS_LOG_FUNCTION (this << app);
-  
-  NS_ASSERT (m_app != 0);
-}
-
-CcnxAppFace::~CcnxAppFace ()
-{
-  NS_LOG_FUNCTION_NOARGS ();
-}
-
-CcnxAppFace::CcnxAppFace ()
-  : CcnxFace (0)
-{
-}
-
-CcnxAppFace::CcnxAppFace (const CcnxAppFace &)
-  : CcnxFace (0)
-{
-}
-
-CcnxAppFace& CcnxAppFace::operator= (const CcnxAppFace &)
-{
-  return *((CcnxAppFace*)0);
-}
-
-
-void
-CcnxAppFace::RegisterProtocolHandler (ProtocolHandler handler)
-{
-  NS_LOG_FUNCTION (this);
-
-  CcnxFace::RegisterProtocolHandler (handler);
-
-  m_app->RegisterProtocolHandler (MakeCallback (&CcnxFace::Receive, this));
-}
-
-bool
-CcnxAppFace::SendImpl (Ptr<Packet> p)
-{
-  NS_LOG_FUNCTION (this << p);
-
-  try
-    {
-      CcnxHeaderHelper::Type type = CcnxHeaderHelper::GetCcnxHeaderType (p);
-      switch (type)
-        {
-        case CcnxHeaderHelper::INTEREST:
-          {
-            Ptr<CcnxInterestHeader> header = Create<CcnxInterestHeader> ();
-            p->RemoveHeader (*header);
-
-            if (header->GetNack () > 0)
-              m_app->OnNack (header, p);
-            else
-              m_app->OnInterest (header, p);
-          
-            break;
-          }
-        case CcnxHeaderHelper::CONTENT_OBJECT:
-          {
-            static CcnxContentObjectTail tail;
-            Ptr<CcnxContentObjectHeader> header = Create<CcnxContentObjectHeader> ();
-            p->RemoveHeader (*header);
-            p->RemoveTrailer (tail);
-            m_app->OnContentObject (header, p/*payload*/);
-          
-            break;
-          }
-        }
-      
-      return true;
-    }
-  catch (CcnxUnknownHeaderException)
-    {
-      NS_LOG_ERROR ("Unknown header type");
-      return false;
-    }
-}
-
-std::ostream& CcnxAppFace::Print (std::ostream& os) const
-{
-  os << "dev=local(" << GetId() << ")";
-  return os;
-}
-
-}; // namespace ns3
-
diff --git a/model/ccnx-global-router.cc b/model/ccnx-global-router.cc
deleted file mode 100644
index 8a4f767..0000000
--- a/model/ccnx-global-router.cc
+++ /dev/null
@@ -1,106 +0,0 @@
-/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
-/*
- * Copyright (c) 2011 UCLA
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation;
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- * Author:  Alexander Afanasyev <alexander.afanasyev@ucla.edu>
- */
-
-#include "ccnx-global-router.h"
-
-#include "ns3/ccnx.h"
-#include "ns3/ccnx-face.h"
-#include "ns3/ccnx-name-components.h"
-
-#include "ns3/channel.h"
-
-using namespace boost;
-
-namespace ns3 {
-
-uint32_t CcnxGlobalRouter::m_idCounter = 0;
-
-NS_OBJECT_ENSURE_REGISTERED (CcnxGlobalRouter);
-
-TypeId 
-CcnxGlobalRouter::GetTypeId ()
-{
-  static TypeId tid = TypeId ("ns3::CcnxGlobalRouter")
-    .SetGroupName ("Ccnx")
-    .SetParent<Object> ()
-  ;
-  return tid;
-}
-
-CcnxGlobalRouter::CcnxGlobalRouter ()
-{
-  m_id = m_idCounter;
-  m_idCounter ++;
-}
-
-void
-CcnxGlobalRouter::NotifyNewAggregate ()
-{
-  if (m_ccnx == 0)
-    {
-      m_ccnx = GetObject<Ccnx> ();
-    }
-  Object::NotifyNewAggregate ();
-}
-
-uint32_t
-CcnxGlobalRouter::GetId () const
-{
-  return m_id;
-}
-
-Ptr<Ccnx>
-CcnxGlobalRouter::GetCcnx () const
-{
-  return m_ccnx;
-}
-
-void
-CcnxGlobalRouter::AddLocalPrefix (Ptr< CcnxNameComponents > prefix)
-{
-  m_localPrefixes.push_back (prefix);
-}
-
-void
-CcnxGlobalRouter::AddIncidency (Ptr< CcnxFace > face, Ptr< CcnxGlobalRouter > gr)
-{
-  m_incidencies.push_back (make_tuple (this, face, gr));
-}
-
-CcnxGlobalRouter::IncidencyList &
-CcnxGlobalRouter::GetIncidencies ()
-{
-  return m_incidencies;
-}
-
-const CcnxGlobalRouter::LocalPrefixList &
-CcnxGlobalRouter::GetLocalPrefixes () const
-{
-  return m_localPrefixes;
-}
-
-// void
-// CcnxGlobalRouter::AddIncidencyChannel (Ptr< CcnxFace > face, Ptr< Channel > channel)
-// {
-//   m_incidenciesChannel.push_back (make_tuple (face, channel));
-// }
-
-}
-
diff --git a/model/content-store/ccnx-content-store-impl.h b/model/content-store/ndn-content-store-impl.h
similarity index 68%
rename from model/content-store/ccnx-content-store-impl.h
rename to model/content-store/ndn-content-store-impl.h
index b3275da..0140f58 100644
--- a/model/content-store/ccnx-content-store-impl.h
+++ b/model/content-store/ndn-content-store-impl.h
@@ -18,33 +18,33 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef CCNX_CONTENT_STORE_IMPL_H_
-#define CCNX_CONTENT_STORE_IMPL_H_
+#ifndef NDN_CONTENT_STORE_IMPL_H_
+#define NDN_CONTENT_STORE_IMPL_H_
 
-#include "ccnx-content-store.h"
+#include "ndn-content-store.h"
 #include "ns3/packet.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 <boost/foreach.hpp>
 
 namespace ns3
 {
 
 template<class Container>
-class CcnxContentStoreImpl : public CcnxContentStore,
+class NdnContentStoreImpl : public NdnContentStore,
                              protected Container
 {
 public:
-  // from CcnxContentStore
+  // from NdnContentStore
   
-  virtual inline boost::tuple<Ptr<Packet>, Ptr<const CcnxContentObjectHeader>, Ptr<const Packet> >
-  Lookup (Ptr<const CcnxInterestHeader> interest);
+  virtual inline boost::tuple<Ptr<Packet>, Ptr<const NdnContentObjectHeader>, Ptr<const Packet> >
+  Lookup (Ptr<const NdnInterestHeader> interest);
             
   virtual inline bool
-  Add (Ptr<const CcnxContentObjectHeader> header, Ptr<const Packet> packet);
+  Add (Ptr<const NdnContentObjectHeader> header, Ptr<const Packet> packet);
 
   // virtual bool
-  // Remove (Ptr<CcnxInterestHeader> header);
+  // Remove (Ptr<NdnInterestHeader> header);
   
   virtual inline void
   Print (std::ostream &os) const;  
@@ -52,8 +52,8 @@
 
 
 template<class Container>
-boost::tuple<Ptr<Packet>, Ptr<const CcnxContentObjectHeader>, Ptr<const Packet> >
-CcnxContentStoreImpl<Container>::Lookup (Ptr<const CcnxInterestHeader> interest)
+boost::tuple<Ptr<Packet>, Ptr<const NdnContentObjectHeader>, Ptr<const Packet> >
+NdnContentStoreImpl<Container>::Lookup (Ptr<const NdnInterestHeader> interest)
 {
   // NS_LOG_FUNCTION (this << interest->GetName ());
 
@@ -65,7 +65,7 @@
       this->m_cacheHitsTrace (interest, node->payload ()->GetHeader ());
 
       // NS_LOG_DEBUG ("cache hit with " << node->payload ()->GetHeader ()->GetName ());
-      return boost::make_tuple (node->payload ()->GetFullyFormedCcnxPacket (),
+      return boost::make_tuple (node->payload ()->GetFullyFormedNdnPacket (),
                                 node->payload ()->GetHeader (),
                                 node->payload ()->GetPacket ());
     }
@@ -73,24 +73,24 @@
     {
       // NS_LOG_DEBUG ("cache miss for " << interest->GetName ());
       this->m_cacheMissesTrace (interest);
-      return boost::tuple<Ptr<Packet>, Ptr<CcnxContentObjectHeader>, Ptr<Packet> > (0, 0, 0);
+      return boost::tuple<Ptr<Packet>, Ptr<NdnContentObjectHeader>, Ptr<Packet> > (0, 0, 0);
     }
 }   
     
 template<class Container>
 bool 
-CcnxContentStoreImpl<Container>::Add (Ptr<const CcnxContentObjectHeader> header, Ptr<const Packet> packet)
+NdnContentStoreImpl<Container>::Add (Ptr<const NdnContentObjectHeader> header, Ptr<const Packet> packet)
 {
   // NS_LOG_FUNCTION (this << header->GetName ());
 
   return
-    this->insert (header->GetName (), Create<CcnxContentStoreEntry> (header, packet))
+    this->insert (header->GetName (), Create<NdnContentStoreEntry> (header, packet))
     .second;
 }
     
 template<class Container>
 void 
-CcnxContentStoreImpl<Container>::Print (std::ostream &os) const
+NdnContentStoreImpl<Container>::Print (std::ostream &os) const
 {
   for (typename Container::policy_container::const_iterator item = this->getPolicy ().begin ();
        item != this->getPolicy ().end ();
@@ -104,4 +104,4 @@
 
 } // namespace ns3
 
-#endif // CCNX_CONTENT_STORE_IMPL_H_
+#endif // NDN_CONTENT_STORE_IMPL_H_
diff --git a/model/content-store/ccnx-content-store-policies.cc b/model/content-store/ndn-content-store-policies.cc
similarity index 62%
rename from model/content-store/ccnx-content-store-policies.cc
rename to model/content-store/ndn-content-store-policies.cc
index e9a23e1..a474461 100644
--- a/model/content-store/ccnx-content-store-policies.cc
+++ b/model/content-store/ndn-content-store-policies.cc
@@ -18,11 +18,11 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#include "ccnx-content-store-policies.h"
+#include "ndn-content-store-policies.h"
 #include "ns3/log.h"
 #include "ns3/uinteger.h"
 
-NS_LOG_COMPONENT_DEFINE ("CcnxContentStorePolicies");
+NS_LOG_COMPONENT_DEFINE ("NdnContentStorePolicies");
 
 namespace ns3
 {
@@ -33,20 +33,20 @@
 ////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////
 
-NS_OBJECT_ENSURE_REGISTERED (CcnxContentStoreLru);
+NS_OBJECT_ENSURE_REGISTERED (NdnContentStoreLru);
 
 TypeId 
-CcnxContentStoreLru::GetTypeId (void)
+NdnContentStoreLru::GetTypeId (void)
 {
-  static TypeId tid = TypeId ("ns3::CcnxContentStoreLru")
-    .SetGroupName ("Ccnx")
-    .SetParent< CcnxContentStore > ()
-    .AddConstructor<CcnxContentStoreLru> ()
+  static TypeId tid = TypeId ("ns3::NdnContentStoreLru")
+    .SetGroupName ("Ndn")
+    .SetParent< NdnContentStore > ()
+    .AddConstructor<NdnContentStoreLru> ()
     .AddAttribute ("Size",
                    "Maximum number of packets that content storage can hold",
                    UintegerValue (100),
-                   MakeUintegerAccessor (&CcnxContentStoreLru::SetMaxSize,
-                                         &CcnxContentStoreLru::GetMaxSize),
+                   MakeUintegerAccessor (&NdnContentStoreLru::SetMaxSize,
+                                         &NdnContentStoreLru::GetMaxSize),
                    MakeUintegerChecker<uint32_t> ())
     ;
 
@@ -54,22 +54,22 @@
 }
 
 void
-CcnxContentStoreLru::SetMaxSize (uint32_t maxSize)
+NdnContentStoreLru::SetMaxSize (uint32_t maxSize)
 {
   getPolicy ().set_max_size (maxSize);
 }
 
 uint32_t
-CcnxContentStoreLru::GetMaxSize () const
+NdnContentStoreLru::GetMaxSize () const
 {
   return getPolicy ().get_max_size ();
 }
 
-CcnxContentStoreLru::CcnxContentStoreLru ()
+NdnContentStoreLru::NdnContentStoreLru ()
 {
 }
         
-CcnxContentStoreLru::~CcnxContentStoreLru () 
+NdnContentStoreLru::~NdnContentStoreLru () 
 {
 }
 
@@ -79,21 +79,21 @@
 ////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////
 
-NS_OBJECT_ENSURE_REGISTERED (CcnxContentStoreRandom);
+NS_OBJECT_ENSURE_REGISTERED (NdnContentStoreRandom);
 
 TypeId 
-CcnxContentStoreRandom::GetTypeId (void)
+NdnContentStoreRandom::GetTypeId (void)
 {
-  static TypeId tid = TypeId ("ns3::CcnxContentStoreRandom")
-    .SetGroupName ("Ccnx")
-    .SetParent< CcnxContentStore > ()
-    .AddConstructor<CcnxContentStoreRandom> ()
+  static TypeId tid = TypeId ("ns3::NdnContentStoreRandom")
+    .SetGroupName ("Ndn")
+    .SetParent< NdnContentStore > ()
+    .AddConstructor<NdnContentStoreRandom> ()
     
     .AddAttribute ("Size",
                    "Maximum number of packets that content storage can hold",
                    UintegerValue (100),
-                   MakeUintegerAccessor (&CcnxContentStoreRandom::SetMaxSize,
-                                         &CcnxContentStoreRandom::GetMaxSize),
+                   MakeUintegerAccessor (&NdnContentStoreRandom::SetMaxSize,
+                                         &NdnContentStoreRandom::GetMaxSize),
                    MakeUintegerChecker<uint32_t> ())
     ;
 
@@ -101,22 +101,22 @@
 }
 
 void
-CcnxContentStoreRandom::SetMaxSize (uint32_t maxSize)
+NdnContentStoreRandom::SetMaxSize (uint32_t maxSize)
 {
   getPolicy ().set_max_size (maxSize);
 }
 
 uint32_t
-CcnxContentStoreRandom::GetMaxSize () const
+NdnContentStoreRandom::GetMaxSize () const
 {
   return getPolicy ().get_max_size ();
 }
 
-CcnxContentStoreRandom::CcnxContentStoreRandom ()
+NdnContentStoreRandom::NdnContentStoreRandom ()
 {
 }
         
-CcnxContentStoreRandom::~CcnxContentStoreRandom () 
+NdnContentStoreRandom::~NdnContentStoreRandom () 
 {
 }
 
@@ -127,21 +127,21 @@
 ////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////
 
-NS_OBJECT_ENSURE_REGISTERED (CcnxContentStoreFifo);
+NS_OBJECT_ENSURE_REGISTERED (NdnContentStoreFifo);
 
 TypeId 
-CcnxContentStoreFifo::GetTypeId (void)
+NdnContentStoreFifo::GetTypeId (void)
 {
-  static TypeId tid = TypeId ("ns3::CcnxContentStoreFifo")
-    .SetGroupName ("Ccnx")
-    .SetParent< CcnxContentStore > ()
-    .AddConstructor<CcnxContentStoreFifo> ()
+  static TypeId tid = TypeId ("ns3::NdnContentStoreFifo")
+    .SetGroupName ("Ndn")
+    .SetParent< NdnContentStore > ()
+    .AddConstructor<NdnContentStoreFifo> ()
     
     .AddAttribute ("Size",
                    "Maximum number of packets that content storage can hold",
                    UintegerValue (100),
-                   MakeUintegerAccessor (&CcnxContentStoreFifo::SetMaxSize,
-                                         &CcnxContentStoreFifo::GetMaxSize),
+                   MakeUintegerAccessor (&NdnContentStoreFifo::SetMaxSize,
+                                         &NdnContentStoreFifo::GetMaxSize),
                    MakeUintegerChecker<uint32_t> ())
     ;
 
@@ -149,22 +149,22 @@
 }
 
 void
-CcnxContentStoreFifo::SetMaxSize (uint32_t maxSize)
+NdnContentStoreFifo::SetMaxSize (uint32_t maxSize)
 {
   getPolicy ().set_max_size (maxSize);
 }
 
 uint32_t
-CcnxContentStoreFifo::GetMaxSize () const
+NdnContentStoreFifo::GetMaxSize () const
 {
   return getPolicy ().get_max_size ();
 }
 
-CcnxContentStoreFifo::CcnxContentStoreFifo ()
+NdnContentStoreFifo::NdnContentStoreFifo ()
 {
 }
         
-CcnxContentStoreFifo::~CcnxContentStoreFifo () 
+NdnContentStoreFifo::~NdnContentStoreFifo () 
 {
 }
 
diff --git a/model/content-store/ccnx-content-store-policies.h b/model/content-store/ndn-content-store-policies.h
similarity index 70%
rename from model/content-store/ccnx-content-store-policies.h
rename to model/content-store/ndn-content-store-policies.h
index cb8ee10..506dc72 100644
--- a/model/content-store/ccnx-content-store-policies.h
+++ b/model/content-store/ndn-content-store-policies.h
@@ -19,12 +19,12 @@
  *         Ilya Moiseenko <iliamo@cs.ucla.edu>
  */
 
-#ifndef CCNX_CONTENT_STORE_POLICIES_H
-#define	CCNX_CONTENT_STORE_POLICIES_H
+#ifndef NDN_CONTENT_STORE_POLICIES_H
+#define	NDN_CONTENT_STORE_POLICIES_H
 
-// #include "ns3/ccnx.h"
+// #include "ns3/ndn.h"
 
-#include "ccnx-content-store-impl.h"
+#include "ndn-content-store-impl.h"
 
 #include "../../utils/trie.h"
 #include "../../utils/trie-with-policy.h"
@@ -37,13 +37,13 @@
 {
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief Content Store with LRU replacement policy
  */
-class CcnxContentStoreLru :
-    public CcnxContentStoreImpl<
-       ndnSIM::trie_with_policy<CcnxNameComponents,
-                                ndnSIM::smart_pointer_payload_traits<CcnxContentStoreEntry>,
+class NdnContentStoreLru :
+    public NdnContentStoreImpl<
+       ndnSIM::trie_with_policy<NdnNameComponents,
+                                ndnSIM::smart_pointer_payload_traits<NdnContentStoreEntry>,
                                 ndnSIM::lru_policy_traits >
       >
 {
@@ -58,8 +58,8 @@
   /**
    * Default constructor
    */
-  CcnxContentStoreLru ();
-  virtual ~CcnxContentStoreLru ();
+  NdnContentStoreLru ();
+  virtual ~NdnContentStoreLru ();
 
 private:
   void
@@ -71,13 +71,13 @@
 
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief Content Store with RANDOM replacement policy
  */
-class CcnxContentStoreRandom :
-    public CcnxContentStoreImpl<
-      ndnSIM::trie_with_policy<CcnxNameComponents,
-                       ndnSIM::smart_pointer_payload_traits<CcnxContentStoreEntry>,
+class NdnContentStoreRandom :
+    public NdnContentStoreImpl<
+      ndnSIM::trie_with_policy<NdnNameComponents,
+                       ndnSIM::smart_pointer_payload_traits<NdnContentStoreEntry>,
                        ndnSIM::random_policy_traits >
       >
 {
@@ -92,8 +92,8 @@
   /**
    * Default constructor
    */
-  CcnxContentStoreRandom ();
-  virtual ~CcnxContentStoreRandom ();
+  NdnContentStoreRandom ();
+  virtual ~NdnContentStoreRandom ();
 
 private:
   void
@@ -104,13 +104,13 @@
 };
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief Content Store with FIFO replacement policy
  */
-class CcnxContentStoreFifo :
-    public CcnxContentStoreImpl<
-      ndnSIM::trie_with_policy<CcnxNameComponents,
-                       ndnSIM::smart_pointer_payload_traits<CcnxContentStoreEntry>,
+class NdnContentStoreFifo :
+    public NdnContentStoreImpl<
+      ndnSIM::trie_with_policy<NdnNameComponents,
+                       ndnSIM::smart_pointer_payload_traits<NdnContentStoreEntry>,
                        ndnSIM::fifo_policy_traits >
       >
 {
@@ -125,8 +125,8 @@
   /**
    * Default constructor
    */
-  CcnxContentStoreFifo ();
-  virtual ~CcnxContentStoreFifo ();
+  NdnContentStoreFifo ();
+  virtual ~NdnContentStoreFifo ();
 
 private:
   void
@@ -139,4 +139,4 @@
 
 } //namespace ns3
 
-#endif // CCNX_CONTENT_STORE_POLICIES_H
+#endif // NDN_CONTENT_STORE_POLICIES_H
diff --git a/model/content-store/ccnx-content-store.cc b/model/content-store/ndn-content-store.cc
similarity index 61%
rename from model/content-store/ccnx-content-store.cc
rename to model/content-store/ndn-content-store.cc
index abbf9c3..75e9373 100644
--- a/model/content-store/ccnx-content-store.cc
+++ b/model/content-store/ndn-content-store.cc
@@ -20,54 +20,54 @@
  *         
  */
 
-#include "ccnx-content-store.h"
+#include "ndn-content-store.h"
 #include "ns3/log.h"
 #include "ns3/packet.h"
-#include "ns3/ccnx-name-components.h"
-#include "ns3/ccnx-interest-header.h"
-#include "ns3/ccnx-content-object-header.h"
+#include "ns3/ndn-name-components.h"
+#include "ns3/ndn-interest-header.h"
+#include "ns3/ndn-content-object-header.h"
 
-NS_LOG_COMPONENT_DEFINE ("CcnxContentStore");
+NS_LOG_COMPONENT_DEFINE ("NdnContentStore");
 
 namespace ns3
 {
 
-NS_OBJECT_ENSURE_REGISTERED (CcnxContentStore);
+NS_OBJECT_ENSURE_REGISTERED (NdnContentStore);
 
 TypeId 
-CcnxContentStore::GetTypeId (void)
+NdnContentStore::GetTypeId (void)
 {
-  static TypeId tid = TypeId ("ns3::CcnxContentStore")
-    .SetGroupName ("Ccnx")
+  static TypeId tid = TypeId ("ns3::NdnContentStore")
+    .SetGroupName ("Ndn")
     .SetParent<Object> ()
 
     .AddTraceSource ("CacheHits", "Trace called every time there is a cache hit",
-                     MakeTraceSourceAccessor (&CcnxContentStore::m_cacheHitsTrace))
+                     MakeTraceSourceAccessor (&NdnContentStore::m_cacheHitsTrace))
 
     .AddTraceSource ("CacheMisses", "Trace called every time there is a cache miss",
-                     MakeTraceSourceAccessor (&CcnxContentStore::m_cacheMissesTrace))
+                     MakeTraceSourceAccessor (&NdnContentStore::m_cacheMissesTrace))
     ;
 
   return tid;
 }
 
 
-CcnxContentStore::~CcnxContentStore () 
+NdnContentStore::~NdnContentStore () 
 {
 }
 
 //////////////////////////////////////////////////////////////////////
 
-CcnxContentStoreEntry::CcnxContentStoreEntry (Ptr<const CcnxContentObjectHeader> header, Ptr<const Packet> packet)
+NdnContentStoreEntry::NdnContentStoreEntry (Ptr<const NdnContentObjectHeader> header, Ptr<const Packet> packet)
   : m_header (header)
   , m_packet (packet->Copy ())
 {
 }
 
 Ptr<Packet>
-CcnxContentStoreEntry::GetFullyFormedCcnxPacket () const
+NdnContentStoreEntry::GetFullyFormedNdnPacket () const
 {
-  static CcnxContentObjectTail tail; ///< \internal for optimization purposes
+  static NdnContentObjectTail tail; ///< \internal for optimization purposes
 
   Ptr<Packet> packet = m_packet->Copy ();
   packet->AddHeader (*m_header);
@@ -75,20 +75,20 @@
   return packet;
 }
 
-const CcnxNameComponents&
-CcnxContentStoreEntry::GetName () const
+const NdnNameComponents&
+NdnContentStoreEntry::GetName () const
 {
   return m_header->GetName ();
 }
 
-Ptr<const CcnxContentObjectHeader>
-CcnxContentStoreEntry::GetHeader () const
+Ptr<const NdnContentObjectHeader>
+NdnContentStoreEntry::GetHeader () const
 {
   return m_header;
 }
 
 Ptr<const Packet>
-CcnxContentStoreEntry::GetPacket () const
+NdnContentStoreEntry::GetPacket () const
 {
   return m_packet;
 }
diff --git a/model/content-store/ccnx-content-store.h b/model/content-store/ndn-content-store.h
similarity index 62%
rename from model/content-store/ccnx-content-store.h
rename to model/content-store/ndn-content-store.h
index f0abd61..2d4ada6 100644
--- a/model/content-store/ccnx-content-store.h
+++ b/model/content-store/ndn-content-store.h
@@ -19,8 +19,8 @@
  *         Ilya Moiseenko <iliamo@cs.ucla.edu>
  */
 
-#ifndef CCNX_CONTENT_STORE_H
-#define	CCNX_CONTENT_STORE_H
+#ifndef NDN_CONTENT_STORE_H
+#define	NDN_CONTENT_STORE_H
 
 #include "ns3/object.h"
 #include "ns3/ptr.h"
@@ -32,47 +32,47 @@
 {
 
 class Packet;
-class CcnxContentObjectHeader;
-class CcnxInterestHeader;
-class CcnxNameComponents;
+class NdnContentObjectHeader;
+class NdnInterestHeader;
+class NdnNameComponents;
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief NDN content store entry
  *
  * Content store entry stores separately pseudo header and content of
  * ContentObject packet.  It is responsibility of the caller to
- * construct a fully formed CcnxPacket by calling Copy(), AddHeader(),
+ * construct a fully formed NdnPacket by calling Copy(), AddHeader(),
  * AddTail() on the packet received by GetPacket() method.
  *
- * GetFullyFormedCcnxPacket method provided as a convenience
+ * GetFullyFormedNdnPacket method provided as a convenience
  */
-class CcnxContentStoreEntry : public SimpleRefCount<CcnxContentStoreEntry>
+class NdnContentStoreEntry : public SimpleRefCount<NdnContentStoreEntry>
 {
 public:
   /**
    * \brief Construct content store entry
    *
-   * \param header Parsed CcnxContentObject header
-   * \param packet Original CCNx packet
+   * \param header Parsed NdnContentObject header
+   * \param packet Original Ndn packet
    *
    * The constructor will make a copy of the supplied packet and calls
    * RemoveHeader and RemoveTail on the copy.
    */
-  CcnxContentStoreEntry (Ptr<const CcnxContentObjectHeader> header, Ptr<const Packet> packet);
+  NdnContentStoreEntry (Ptr<const NdnContentObjectHeader> header, Ptr<const Packet> packet);
 
   /**
    * \brief Get prefix of the stored entry
    * \returns prefix of the stored entry
    */
-  const CcnxNameComponents&
+  const NdnNameComponents&
   GetName () const;
 
   /**
-   * \brief Get CcnxContentObjectHeader of the stored entry
-   * \returns CcnxContentObjectHeader of the stored entry
+   * \brief Get NdnContentObjectHeader of the stored entry
+   * \returns NdnContentObjectHeader of the stored entry
    */
-  Ptr<const CcnxContentObjectHeader>
+  Ptr<const NdnContentObjectHeader>
   GetHeader () const;
 
   /**
@@ -83,25 +83,25 @@
   GetPacket () const;
 
   /**
-   * \brief Convenience method to create a fully formed CCNx packet from stored header and content
-   * \returns A read-write copy of the packet with CcnxContentObjectHeader and CcxnContentObjectTail
+   * \brief Convenience method to create a fully formed Ndn packet from stored header and content
+   * \returns A read-write copy of the packet with NdnContentObjectHeader and CcxnContentObjectTail
    */
   Ptr<Packet>
-  GetFullyFormedCcnxPacket () const;
+  GetFullyFormedNdnPacket () const;
 
 private:
-  Ptr<const CcnxContentObjectHeader> m_header; ///< \brief non-modifiable CcnxContentObjectHeader
+  Ptr<const NdnContentObjectHeader> m_header; ///< \brief non-modifiable NdnContentObjectHeader
   Ptr<Packet> m_packet; ///< \brief non-modifiable content of the ContentObject packet
 };
 
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief Base class for NDN content store
  *
  * Particular implementations should implement Lookup, Add, and Print methods
  */
-class CcnxContentStore : public Object
+class NdnContentStore : public Object
 {
 public:
   /**
@@ -115,7 +115,7 @@
   /**
    * @brief Virtual destructor
    */
-  virtual ~CcnxContentStore ();
+  virtual ~NdnContentStore ();
             
   /**
    * \brief Find corresponding CS entry for the given interest
@@ -126,19 +126,19 @@
    * If an entry is found, it is promoted to the top of most recent
    * used entries index, \see m_contentStore
    */
-  virtual boost::tuple<Ptr<Packet>, Ptr<const CcnxContentObjectHeader>, Ptr<const Packet> >
-  Lookup (Ptr<const CcnxInterestHeader> interest) = 0;
+  virtual boost::tuple<Ptr<Packet>, Ptr<const NdnContentObjectHeader>, Ptr<const Packet> >
+  Lookup (Ptr<const NdnInterestHeader> interest) = 0;
             
   /**
    * \brief Add a new content to the content store.
    *
-   * \param header Fully parsed CcnxContentObjectHeader
-   * \param packet Fully formed CCNx packet to add to content store
+   * \param header Fully parsed NdnContentObjectHeader
+   * \param packet Fully formed Ndn packet to add to content store
    * (will be copied and stripped down of headers)
    * @returns true if an existing entry was updated, false otherwise
    */
   virtual bool
-  Add (Ptr<const CcnxContentObjectHeader> header, Ptr<const Packet> packet) = 0;
+  Add (Ptr<const NdnContentObjectHeader> header, Ptr<const Packet> packet) = 0;
 
   // /**
   //  * \brief Add a new content to the content store.
@@ -147,7 +147,7 @@
   //  * @returns true if an existing entry was removed, false otherwise
   //  */
   // virtual bool
-  // Remove (Ptr<CcnxInterestHeader> header) = 0;
+  // Remove (Ptr<NdnInterestHeader> header) = 0;
   
   /**
    * \brief Print out content store entries
@@ -156,14 +156,14 @@
   Print (std::ostream &os) const = 0;
 
 protected:
-  TracedCallback<Ptr<const CcnxInterestHeader>,
-                 Ptr<const CcnxContentObjectHeader> > m_cacheHitsTrace; ///< @brief trace of cache hits
+  TracedCallback<Ptr<const NdnInterestHeader>,
+                 Ptr<const NdnContentObjectHeader> > m_cacheHitsTrace; ///< @brief trace of cache hits
     
-  TracedCallback<Ptr<const CcnxInterestHeader> > m_cacheMissesTrace; ///< @brief trace of cache misses
+  TracedCallback<Ptr<const NdnInterestHeader> > m_cacheMissesTrace; ///< @brief trace of cache misses
 };
 
 inline std::ostream&
-operator<< (std::ostream &os, const CcnxContentStore &cs)
+operator<< (std::ostream &os, const NdnContentStore &cs)
 {
   cs.Print (os);
   return os;
@@ -171,4 +171,4 @@
 
 } // namespace ns3
 
-#endif // CCNX_CONTENT_STORE_H
+#endif // NDN_CONTENT_STORE_H
diff --git a/model/fib/ccnx-fib-entry.cc b/model/fib/ndn-fib-entry.cc
similarity index 66%
rename from model/fib/ccnx-fib-entry.cc
rename to model/fib/ndn-fib-entry.cc
index c0c575a..965886f 100644
--- a/model/fib/ccnx-fib-entry.cc
+++ b/model/fib/ndn-fib-entry.cc
@@ -18,9 +18,9 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#include "ccnx-fib-entry.h"
+#include "ndn-fib-entry.h"
 
-#include "ns3/ccnx-name-components.h"
+#include "ns3/ndn-name-components.h"
 #include "ns3/log.h"
 
 #define NDN_RTO_ALPHA 0.125
@@ -32,7 +32,7 @@
 #include <boost/lambda/bind.hpp>
 namespace ll = boost::lambda;
 
-NS_LOG_COMPONENT_DEFINE ("CcnxFibEntry");
+NS_LOG_COMPONENT_DEFINE ("NdnFibEntry");
 
 namespace ns3
 {
@@ -40,11 +40,11 @@
 //////////////////////////////////////////////////////////////////////
 // Helpers
 //////////////////////////////////////////////////////////////////////
-namespace __ccnx_private {
+namespace __ndn_private {
 
-struct CcnxFibFaceMetricByFace
+struct NdnFibFaceMetricByFace
 {
-  typedef CcnxFibFaceMetricContainer::type::index<i_face>::type
+  typedef NdnFibFaceMetricContainer::type::index<i_face>::type
   type;
 };
 
@@ -52,10 +52,10 @@
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 
-using namespace __ccnx_private;
+using namespace __ndn_private;
 
 void
-CcnxFibFaceMetric::UpdateRtt (const Time &rttSample)
+NdnFibFaceMetric::UpdateRtt (const Time &rttSample)
 {
   // const Time & this->m_rttSample
   
@@ -78,56 +78,56 @@
 /////////////////////////////////////////////////////////////////////
 
 void
-CcnxFibEntry::UpdateFaceRtt (Ptr<CcnxFace> face, const Time &sample)
+NdnFibEntry::UpdateFaceRtt (Ptr<NdnFace> face, const Time &sample)
 {
-  CcnxFibFaceMetricByFace::type::iterator record = m_faces.get<i_face> ().find (face);
+  NdnFibFaceMetricByFace::type::iterator record = m_faces.get<i_face> ().find (face);
   NS_ASSERT_MSG (record != m_faces.get<i_face> ().end (),
                  "Update status can be performed only on existing faces of CcxnFibEntry");
 
   m_faces.modify (record,
-                  ll::bind (&CcnxFibFaceMetric::UpdateRtt, ll::_1, sample));
+                  ll::bind (&NdnFibFaceMetric::UpdateRtt, ll::_1, sample));
 
   // reordering random access index same way as by metric index
   m_faces.get<i_nth> ().rearrange (m_faces.get<i_metric> ().begin ());
 }
 
 void
-CcnxFibEntry::UpdateStatus (Ptr<CcnxFace> face, CcnxFibFaceMetric::Status status)
+NdnFibEntry::UpdateStatus (Ptr<NdnFace> face, NdnFibFaceMetric::Status status)
 {
   NS_LOG_FUNCTION (this << boost::cref(*face) << status);
 
-  CcnxFibFaceMetricByFace::type::iterator record = m_faces.get<i_face> ().find (face);
+  NdnFibFaceMetricByFace::type::iterator record = m_faces.get<i_face> ().find (face);
   NS_ASSERT_MSG (record != m_faces.get<i_face> ().end (),
                  "Update status can be performed only on existing faces of CcxnFibEntry");
 
   m_faces.modify (record,
-                  (&ll::_1)->*&CcnxFibFaceMetric::m_status = status);
+                  (&ll::_1)->*&NdnFibFaceMetric::m_status = status);
 
   // reordering random access index same way as by metric index
   m_faces.get<i_nth> ().rearrange (m_faces.get<i_metric> ().begin ());
 }
 
 void
-CcnxFibEntry::AddOrUpdateRoutingMetric (Ptr<CcnxFace> face, int32_t metric)
+NdnFibEntry::AddOrUpdateRoutingMetric (Ptr<NdnFace> face, int32_t metric)
 {
   NS_LOG_FUNCTION (this);
   NS_ASSERT_MSG (face != NULL, "Trying to Add or Update NULL face");
 
-  CcnxFibFaceMetricByFace::type::iterator record = m_faces.get<i_face> ().find (face);
+  NdnFibFaceMetricByFace::type::iterator record = m_faces.get<i_face> ().find (face);
   if (record == m_faces.get<i_face> ().end ())
     {
-      m_faces.insert (CcnxFibFaceMetric (face, metric));
+      m_faces.insert (NdnFibFaceMetric (face, metric));
     }
   else
   {
     // don't update metric to higher value
-    if (record->m_routingCost > metric || record->m_status == CcnxFibFaceMetric::NDN_FIB_RED)
+    if (record->m_routingCost > metric || record->m_status == NdnFibFaceMetric::NDN_FIB_RED)
       {
         m_faces.modify (record,
-                        (&ll::_1)->*&CcnxFibFaceMetric::m_routingCost = metric);
+                        (&ll::_1)->*&NdnFibFaceMetric::m_routingCost = metric);
 
         m_faces.modify (record,
-                        (&ll::_1)->*&CcnxFibFaceMetric::m_status = CcnxFibFaceMetric::NDN_FIB_YELLOW);
+                        (&ll::_1)->*&NdnFibFaceMetric::m_status = NdnFibFaceMetric::NDN_FIB_YELLOW);
       }
   }
   
@@ -136,31 +136,31 @@
 }
 
 void
-CcnxFibEntry::Invalidate ()
+NdnFibEntry::Invalidate ()
 {
-  for (CcnxFibFaceMetricByFace::type::iterator face = m_faces.begin ();
+  for (NdnFibFaceMetricByFace::type::iterator face = m_faces.begin ();
        face != m_faces.end ();
        face++)
     {
       m_faces.modify (face,
-                      (&ll::_1)->*&CcnxFibFaceMetric::m_routingCost = std::numeric_limits<uint16_t>::max ());
+                      (&ll::_1)->*&NdnFibFaceMetric::m_routingCost = std::numeric_limits<uint16_t>::max ());
 
       m_faces.modify (face,
-                      (&ll::_1)->*&CcnxFibFaceMetric::m_status = CcnxFibFaceMetric::NDN_FIB_RED);
+                      (&ll::_1)->*&NdnFibFaceMetric::m_status = NdnFibFaceMetric::NDN_FIB_RED);
     }
 }
 
-const CcnxFibFaceMetric &
-CcnxFibEntry::FindBestCandidate (uint32_t skip/* = 0*/) const
+const NdnFibFaceMetric &
+NdnFibEntry::FindBestCandidate (uint32_t skip/* = 0*/) const
 {
-  if (m_faces.size () == 0) throw CcnxFibEntry::NoFaces ();
+  if (m_faces.size () == 0) throw NdnFibEntry::NoFaces ();
   skip = skip % m_faces.size();
   return m_faces.get<i_nth> () [skip];
 }
 
-std::ostream& operator<< (std::ostream& os, const CcnxFibEntry &entry)
+std::ostream& operator<< (std::ostream& os, const NdnFibEntry &entry)
 {
-  for (CcnxFibFaceMetricContainer::type::index<i_nth>::type::iterator metric =
+  for (NdnFibFaceMetricContainer::type::index<i_nth>::type::iterator metric =
          entry.m_faces.get<i_nth> ().begin ();
        metric != entry.m_faces.get<i_nth> ().end ();
        metric++)
@@ -173,7 +173,7 @@
   return os;
 }
 
-std::ostream& operator<< (std::ostream& os, const CcnxFibFaceMetric &metric)
+std::ostream& operator<< (std::ostream& os, const NdnFibFaceMetric &metric)
 {
   static const std::string statusString[] = {"","g","y","r"};
 
diff --git a/model/fib/ccnx-fib-entry.h b/model/fib/ndn-fib-entry.h
similarity index 67%
rename from model/fib/ccnx-fib-entry.h
rename to model/fib/ndn-fib-entry.h
index 9aa75cb..cf8cbe6 100644
--- a/model/fib/ccnx-fib-entry.h
+++ b/model/fib/ndn-fib-entry.h
@@ -18,13 +18,13 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef _CCNX_FIB_ENTRY_H_
-#define	_CCNX_FIB_ENTRY_H_
+#ifndef _NDN_FIB_ENTRY_H_
+#define	_NDN_FIB_ENTRY_H_
 
 #include "ns3/ptr.h"
 #include "ns3/nstime.h"
-#include "ns3/ccnx.h"
-#include "ns3/ccnx-face.h"
+#include "ns3/ndn.h"
+#include "ns3/ndn-face.h"
 
 #include <boost/multi_index_container.hpp>
 #include <boost/multi_index/tag.hpp>
@@ -38,13 +38,13 @@
 namespace ns3
 {
 
-class CcnxNameComponents;
+class NdnNameComponents;
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief Structure holding various parameters associated with a (FibEntry, Face) tuple
  */
-class CcnxFibFaceMetric
+class NdnFibFaceMetric
 {
 public:
   /**
@@ -60,7 +60,7 @@
    * \param face Face for which metric
    * \param cost Initial value for routing cost
    */
-  CcnxFibFaceMetric (Ptr<CcnxFace> face, int32_t cost)
+  NdnFibFaceMetric (Ptr<NdnFace> face, int32_t cost)
     : m_face (face)
     , m_status (NDN_FIB_YELLOW)
     , m_routingCost (cost)
@@ -72,18 +72,18 @@
    * \brief Comparison operator used by boost::multi_index::identity<>
    */
   bool
-  operator< (const CcnxFibFaceMetric &fm) const { return *m_face < *fm.m_face; } // return identity of the face
+  operator< (const NdnFibFaceMetric &fm) const { return *m_face < *fm.m_face; } // return identity of the face
 
   /**
-   * @brief Comparison between CcnxFibFaceMetric and CcnxFace
+   * @brief Comparison between NdnFibFaceMetric and NdnFace
    */
   bool
-  operator< (const Ptr<CcnxFace> &face) const { return *m_face < *face; } 
+  operator< (const Ptr<NdnFace> &face) const { return *m_face < *face; } 
 
   /**
-   * @brief Return CcnxFace associated with CcnxFibFaceMetric
+   * @brief Return NdnFace associated with NdnFibFaceMetric
    */
-  Ptr<CcnxFace>
+  Ptr<NdnFace>
   GetFace () const { return m_face; }
 
   /**
@@ -94,9 +94,9 @@
   UpdateRtt (const Time &rttSample);
   
 private:
-  friend std::ostream& operator<< (std::ostream& os, const CcnxFibFaceMetric &metric);
+  friend std::ostream& operator<< (std::ostream& os, const NdnFibFaceMetric &metric);
 public:
-  Ptr<CcnxFace> m_face; ///< Face
+  Ptr<NdnFace> m_face; ///< Face
   
   Status m_status;		///< \brief Status of the next hop: 
 				///<		- NDN_FIB_GREEN
@@ -110,8 +110,8 @@
 };
 
 /**
- * \ingroup ccnx
- * \brief Typedef for indexed face container of CcnxFibEntry
+ * \ingroup ndn
+ * \brief Typedef for indexed face container of NdnFibEntry
  *
  * Currently, there are 2 indexes:
  * - by face (used to find record and update metric)
@@ -119,31 +119,31 @@
  * - random access index (for fast lookup on nth face). Order is
  *   maintained manually to be equal to the 'by metric' order
  */
-struct CcnxFibFaceMetricContainer
+struct NdnFibFaceMetricContainer
 {
   /// @cond include_hidden
   typedef boost::multi_index::multi_index_container<
-    CcnxFibFaceMetric,
+    NdnFibFaceMetric,
     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<CcnxFibFaceMetric,Ptr<CcnxFace>,&CcnxFibFaceMetric::m_face>
+        boost::multi_index::tag<__ndn_private::i_face>,
+        boost::multi_index::member<NdnFibFaceMetric,Ptr<NdnFace>,&NdnFibFaceMetric::m_face>
       >,
 
       // List of available faces ordered by (status, m_routingCost)
       boost::multi_index::ordered_non_unique<
-        boost::multi_index::tag<__ccnx_private::i_metric>,
+        boost::multi_index::tag<__ndn_private::i_metric>,
         boost::multi_index::composite_key<
-          CcnxFibFaceMetric,
-          boost::multi_index::member<CcnxFibFaceMetric,CcnxFibFaceMetric::Status,&CcnxFibFaceMetric::m_status>,
-          boost::multi_index::member<CcnxFibFaceMetric,int32_t,&CcnxFibFaceMetric::m_routingCost>
+          NdnFibFaceMetric,
+          boost::multi_index::member<NdnFibFaceMetric,NdnFibFaceMetric::Status,&NdnFibFaceMetric::m_status>,
+          boost::multi_index::member<NdnFibFaceMetric,int32_t,&NdnFibFaceMetric::m_routingCost>
         >
       >,
 
       // To optimize nth candidate selection (sacrifice a little bit space to gain speed)
       boost::multi_index::random_access<
-        boost::multi_index::tag<__ccnx_private::i_nth>
+        boost::multi_index::tag<__ndn_private::i_nth>
       >
     >
    > type;
@@ -151,11 +151,11 @@
 };
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief Structure for FIB table entry, holding indexed list of
  *        available faces and their respective metrics
  */
-class CcnxFibEntry : public SimpleRefCount<CcnxFibEntry>
+class NdnFibEntry : public SimpleRefCount<NdnFibEntry>
 {
 public:
   class NoFaces {}; ///< @brief Exception class for the case when FIB entry is not found
@@ -164,7 +164,7 @@
    * \brief Constructor
    * \param prefix smart pointer to the prefix for the FIB entry
    */
-  CcnxFibEntry (const Ptr<const CcnxNameComponents> &prefix)
+  NdnFibEntry (const Ptr<const NdnNameComponents> &prefix)
   : m_prefix (prefix)
   , m_needsProbing (false)
   { }
@@ -173,14 +173,14 @@
    * \brief Update status of FIB next hop
    * \param status Status to set on the FIB entry
    */
-  void UpdateStatus (Ptr<CcnxFace> face, CcnxFibFaceMetric::Status status);
+  void UpdateStatus (Ptr<NdnFace> face, NdnFibFaceMetric::Status status);
 
   /**
    * \brief Add or update routing metric of FIB next hop
    *
    * Initial status of the next hop is set to YELLOW
    */
-  void AddOrUpdateRoutingMetric (Ptr<CcnxFace> face, int32_t metric);
+  void AddOrUpdateRoutingMetric (Ptr<NdnFace> face, int32_t metric);
 
   /**
    * @brief Invalidate face
@@ -194,44 +194,44 @@
    * @brief Update RTT averages for the face
    */
   void
-  UpdateFaceRtt (Ptr<CcnxFace> face, const Time &sample);
+  UpdateFaceRtt (Ptr<NdnFace> face, const Time &sample);
   
   /**
    * \brief Get prefix for the FIB entry
    */
-  const CcnxNameComponents&
+  const NdnNameComponents&
   GetPrefix () const { return *m_prefix; }
 
   /**
    * \brief Find "best route" candidate, skipping `skip' first candidates (modulo # of faces)
    *
-   * throws CcnxFibEntry::NoFaces if m_faces.size()==0
+   * throws NdnFibEntry::NoFaces if m_faces.size()==0
    */
-  const CcnxFibFaceMetric &
+  const NdnFibFaceMetric &
   FindBestCandidate (uint32_t skip = 0) const;
 
   /**
    * @brief Remove record associated with `face`
    */
   void
-  RemoveFace (const Ptr<CcnxFace> &face)
+  RemoveFace (const Ptr<NdnFace> &face)
   {
     m_faces.erase (face);
   }
 	
 private:
-  friend std::ostream& operator<< (std::ostream& os, const CcnxFibEntry &entry);
+  friend std::ostream& operator<< (std::ostream& os, const NdnFibEntry &entry);
 
 public:
-  Ptr<const CcnxNameComponents> m_prefix; ///< \brief Prefix of the FIB entry
-  CcnxFibFaceMetricContainer::type m_faces; ///< \brief Indexed list of faces
+  Ptr<const NdnNameComponents> m_prefix; ///< \brief Prefix of the FIB entry
+  NdnFibFaceMetricContainer::type m_faces; ///< \brief Indexed list of faces
 
   bool m_needsProbing;      ///< \brief flag indicating that probing should be performed 
 };
 
-std::ostream& operator<< (std::ostream& os, const CcnxFibEntry &entry);
-std::ostream& operator<< (std::ostream& os, const CcnxFibFaceMetric &metric);
+std::ostream& operator<< (std::ostream& os, const NdnFibEntry &entry);
+std::ostream& operator<< (std::ostream& os, const NdnFibFaceMetric &metric);
 
 } // ns3
 
-#endif // _CCNX_FIB_ENTRY_H_
+#endif // _NDN_FIB_ENTRY_H_
diff --git a/model/fib/ccnx-fib-impl.cc b/model/fib/ndn-fib-impl.cc
similarity index 71%
rename from model/fib/ccnx-fib-impl.cc
rename to model/fib/ndn-fib-impl.cc
index 90f0cd8..747c689 100644
--- a/model/fib/ccnx-fib-impl.cc
+++ b/model/fib/ndn-fib-impl.cc
@@ -18,11 +18,11 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#include "ccnx-fib-impl.h"
+#include "ndn-fib-impl.h"
 
-#include "ns3/ccnx.h"
-#include "ns3/ccnx-face.h"
-#include "ns3/ccnx-interest-header.h"
+#include "ns3/ndn.h"
+#include "ns3/ndn-face.h"
+#include "ns3/ndn-interest-header.h"
 
 #include "ns3/node.h"
 #include "ns3/assert.h"
@@ -34,43 +34,43 @@
 #include <boost/lambda/bind.hpp>
 namespace ll = boost::lambda;
 
-NS_LOG_COMPONENT_DEFINE ("CcnxFibImpl");
+NS_LOG_COMPONENT_DEFINE ("NdnFibImpl");
 
 namespace ns3 {
 
-NS_OBJECT_ENSURE_REGISTERED (CcnxFibImpl);
+NS_OBJECT_ENSURE_REGISTERED (NdnFibImpl);
 
 TypeId 
-CcnxFibImpl::GetTypeId (void)
+NdnFibImpl::GetTypeId (void)
 {
-  static TypeId tid = TypeId ("ns3::CcnxFib") // cheating ns3 object system
-    .SetParent<CcnxFib> ()
-    .SetGroupName ("Ccnx")
-    .AddConstructor<CcnxFibImpl> ()
+  static TypeId tid = TypeId ("ns3::NdnFib") // cheating ns3 object system
+    .SetParent<NdnFib> ()
+    .SetGroupName ("Ndn")
+    .AddConstructor<NdnFibImpl> ()
   ;
   return tid;
 }
 
-CcnxFibImpl::CcnxFibImpl ()
+NdnFibImpl::NdnFibImpl ()
 {
 }
 
 void
-CcnxFibImpl::NotifyNewAggregate ()
+NdnFibImpl::NotifyNewAggregate ()
 {
   Object::NotifyNewAggregate ();
 }
 
 void 
-CcnxFibImpl::DoDispose (void)
+NdnFibImpl::DoDispose (void)
 {
   clear ();
   Object::DoDispose ();
 }
 
 
-Ptr<CcnxFibEntry>
-CcnxFibImpl::LongestPrefixMatch (const CcnxInterestHeader &interest)
+Ptr<NdnFibEntry>
+NdnFibImpl::LongestPrefixMatch (const NdnInterestHeader &interest)
 {
   super::iterator item = super::longest_prefix_match (interest.GetName ());
   // @todo use predicate to search with exclude filters
@@ -82,14 +82,14 @@
 }
 
 
-Ptr<CcnxFibEntry>
-CcnxFibImpl::Add (const CcnxNameComponents &prefix, Ptr<CcnxFace> face, int32_t metric)
+Ptr<NdnFibEntry>
+NdnFibImpl::Add (const NdnNameComponents &prefix, Ptr<NdnFace> face, int32_t metric)
 {
-  return Add (Create<CcnxNameComponents> (prefix), face, metric);
+  return Add (Create<NdnNameComponents> (prefix), face, metric);
 }
   
-Ptr<CcnxFibEntry>
-CcnxFibImpl::Add (const Ptr<const CcnxNameComponents> &prefix, Ptr<CcnxFace> face, int32_t metric)
+Ptr<NdnFibEntry>
+NdnFibImpl::Add (const Ptr<const NdnNameComponents> &prefix, Ptr<NdnFace> face, int32_t metric)
 {
   NS_LOG_FUNCTION (this->GetObject<Node> ()->GetId () << boost::cref(*prefix) << boost::cref(*face) << metric);
 
@@ -99,13 +99,13 @@
     {
       if (result.second)
         {
-            Ptr<CcnxFibEntryImpl> newEntry = Create<CcnxFibEntryImpl> (prefix);
+            Ptr<NdnFibEntryImpl> newEntry = Create<NdnFibEntryImpl> (prefix);
             newEntry->SetTrie (result.first);
             result.first->set_payload (newEntry);
         }
   
       super::modify (result.first,
-                     ll::bind (&CcnxFibEntry::AddOrUpdateRoutingMetric, ll::_1, face, metric));
+                     ll::bind (&NdnFibEntry::AddOrUpdateRoutingMetric, ll::_1, face, metric));
     
       return result.first->payload ();
     }
@@ -114,7 +114,7 @@
 }
 
 void
-CcnxFibImpl::Remove (const Ptr<const CcnxNameComponents> &prefix)
+NdnFibImpl::Remove (const Ptr<const NdnNameComponents> &prefix)
 {
   NS_LOG_FUNCTION (this->GetObject<Node> ()->GetId () << boost::cref(*prefix));
 
@@ -122,7 +122,7 @@
 }
 
 // void
-// CcnxFibImpl::Invalidate (const Ptr<const CcnxNameComponents> &prefix)
+// NdnFibImpl::Invalidate (const Ptr<const NdnNameComponents> &prefix)
 // {
 //   NS_LOG_FUNCTION (this->GetObject<Node> ()->GetId () << boost::cref(*prefix));
 
@@ -134,11 +134,11 @@
 //     return; // nothing to invalidate
 
 //   super::modify (lastItem,
-//                  ll::bind (&CcnxFibEntry::Invalidate, ll::_1));
+//                  ll::bind (&NdnFibEntry::Invalidate, ll::_1));
 // }
 
 void
-CcnxFibImpl::InvalidateAll ()
+NdnFibImpl::InvalidateAll ()
 {
   NS_LOG_FUNCTION (this->GetObject<Node> ()->GetId ());
 
@@ -149,28 +149,28 @@
       if (item->payload () == 0) continue;
 
       super::modify (&(*item),
-                     ll::bind (&CcnxFibEntry::Invalidate, ll::_1));
+                     ll::bind (&NdnFibEntry::Invalidate, ll::_1));
     }
 }
 
 void
-CcnxFibImpl::RemoveFace (super::parent_trie &item, Ptr<CcnxFace> face)
+NdnFibImpl::RemoveFace (super::parent_trie &item, Ptr<NdnFace> face)
 {
   if (item.payload () == 0) return;
   NS_LOG_FUNCTION (this);
 
   super::modify (&item,
-                 ll::bind (&CcnxFibEntry::RemoveFace, ll::_1, face));
+                 ll::bind (&NdnFibEntry::RemoveFace, ll::_1, face));
 }
 
 void
-CcnxFibImpl::RemoveFromAll (Ptr<CcnxFace> face)
+NdnFibImpl::RemoveFromAll (Ptr<NdnFace> face)
 {
   NS_LOG_FUNCTION (this);
 
   std::for_each (super::parent_trie::recursive_iterator (super::getTrie ()),
                  super::parent_trie::recursive_iterator (0), 
-                 ll::bind (&CcnxFibImpl::RemoveFace,
+                 ll::bind (&NdnFibImpl::RemoveFace,
                            this, ll::_1, face));
 
   super::parent_trie::recursive_iterator trieNode (super::getTrie ());
@@ -187,7 +187,7 @@
 }
 
 void
-CcnxFibImpl::Print (std::ostream &os) const
+NdnFibImpl::Print (std::ostream &os) const
 {
   // !!! unordered_set imposes "random" order of item in the same level !!!
   super::parent_trie::const_recursive_iterator item (super::getTrie ());
@@ -201,13 +201,13 @@
 }
 
 uint32_t
-CcnxFibImpl::GetSize () const
+NdnFibImpl::GetSize () const
 {
   return super::getPolicy ().size ();
 }
 
-Ptr<const CcnxFibEntry>
-CcnxFibImpl::Begin ()
+Ptr<const NdnFibEntry>
+NdnFibImpl::Begin ()
 {
   super::parent_trie::const_recursive_iterator item (super::getTrie ());
   super::parent_trie::const_recursive_iterator end (0);
@@ -223,18 +223,18 @@
     return item->payload ();
 }
 
-Ptr<const CcnxFibEntry>
-CcnxFibImpl::End ()
+Ptr<const NdnFibEntry>
+NdnFibImpl::End ()
 {
   return 0;
 }
 
-Ptr<const CcnxFibEntry>
-CcnxFibImpl::Next (Ptr<const CcnxFibEntry> from)
+Ptr<const NdnFibEntry>
+NdnFibImpl::Next (Ptr<const NdnFibEntry> from)
 {
   if (from == 0) return 0;
   
-  super::parent_trie::const_recursive_iterator item (*StaticCast<const CcnxFibEntryImpl> (from)->to_iterator ());
+  super::parent_trie::const_recursive_iterator item (*StaticCast<const NdnFibEntryImpl> (from)->to_iterator ());
   super::parent_trie::const_recursive_iterator end (0);
   for (item++; item != end; item++)
     {
diff --git a/model/fib/ccnx-fib-impl.h b/model/fib/ndn-fib-impl.h
similarity index 62%
rename from model/fib/ccnx-fib-impl.h
rename to model/fib/ndn-fib-impl.h
index e6da99b..562f06e 100644
--- a/model/fib/ccnx-fib-impl.h
+++ b/model/fib/ndn-fib-impl.h
@@ -18,28 +18,28 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef _CCNX_FIB_IMPL_H_
-#define	_CCNX_FIB_IMPL_H_
+#ifndef _NDN_FIB_IMPL_H_
+#define	_NDN_FIB_IMPL_H_
 
-#include "ns3/ccnx-fib.h"
-#include "ns3/ccnx-name-components.h"
+#include "ns3/ndn-fib.h"
+#include "ns3/ndn-name-components.h"
 
 #include "../../utils/trie-with-policy.h"
 #include "../../utils/counting-policy.h"
 
 namespace ns3 {
 
-class CcnxFibEntryImpl : public CcnxFibEntry
+class NdnFibEntryImpl : public NdnFibEntry
 {
 public:
   typedef ndnSIM::trie_with_policy<
-    CcnxNameComponents,
-    ndnSIM::smart_pointer_payload_traits<CcnxFibEntryImpl>,
+    NdnNameComponents,
+    ndnSIM::smart_pointer_payload_traits<NdnFibEntryImpl>,
     ndnSIM::counting_policy_traits
     > trie;
 
-  CcnxFibEntryImpl (const Ptr<const CcnxNameComponents> &prefix)
-    : CcnxFibEntry (prefix)
+  NdnFibEntryImpl (const Ptr<const NdnNameComponents> &prefix)
+    : NdnFibEntry (prefix)
     , item_ (0)
   {
   }
@@ -57,24 +57,24 @@
   trie::iterator item_;
 };
 
-struct CcnxFibEntryContainer
+struct NdnFibEntryContainer
 {
   typedef ndnSIM::trie_with_policy<
-    CcnxNameComponents,
-    ndnSIM::smart_pointer_payload_traits<CcnxFibEntryImpl>,
+    NdnNameComponents,
+    ndnSIM::smart_pointer_payload_traits<NdnFibEntryImpl>,
     ndnSIM::counting_policy_traits
     > type;
 };
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief Class implementing FIB functionality
  */
-class CcnxFibImpl : public CcnxFib,
-                    private CcnxFibEntryContainer::type
+class NdnFibImpl : public NdnFib,
+                    private NdnFibEntryContainer::type
 {
 public:
-  typedef CcnxFibEntryContainer::type super;
+  typedef NdnFibEntryContainer::type super;
   
   /**
    * \brief Interface ID
@@ -86,25 +86,25 @@
   /**
    * \brief Constructor
    */
-  CcnxFibImpl ();
+  NdnFibImpl ();
 
-  virtual Ptr<CcnxFibEntry>
-  LongestPrefixMatch (const CcnxInterestHeader &interest);
+  virtual Ptr<NdnFibEntry>
+  LongestPrefixMatch (const NdnInterestHeader &interest);
   
-  virtual Ptr<CcnxFibEntry>
-  Add (const CcnxNameComponents &prefix, Ptr<CcnxFace> face, int32_t metric);
+  virtual Ptr<NdnFibEntry>
+  Add (const NdnNameComponents &prefix, Ptr<NdnFace> face, int32_t metric);
 
-  virtual Ptr<CcnxFibEntry>
-  Add (const Ptr<const CcnxNameComponents> &prefix, Ptr<CcnxFace> face, int32_t metric);
+  virtual Ptr<NdnFibEntry>
+  Add (const Ptr<const NdnNameComponents> &prefix, Ptr<NdnFace> face, int32_t metric);
 
   virtual void
-  Remove (const Ptr<const CcnxNameComponents> &prefix);
+  Remove (const Ptr<const NdnNameComponents> &prefix);
 
   virtual void
   InvalidateAll ();
   
   virtual void
-  RemoveFromAll (Ptr<CcnxFace> face);
+  RemoveFromAll (Ptr<NdnFace> face);
 
   virtual void
   Print (std::ostream &os) const;
@@ -112,23 +112,23 @@
   virtual uint32_t
   GetSize () const;
 
-  virtual Ptr<const CcnxFibEntry>
+  virtual Ptr<const NdnFibEntry>
   Begin ();
 
-  virtual Ptr<const CcnxFibEntry>
+  virtual Ptr<const NdnFibEntry>
   End ();
 
-  virtual Ptr<const CcnxFibEntry>
-  Next (Ptr<const CcnxFibEntry> item);
+  virtual Ptr<const NdnFibEntry>
+  Next (Ptr<const NdnFibEntry> item);
   
   // /**
   //  * @brief Modify element in container
   //  */
   // template<typename Modifier>
   // bool
-  // modify (Ptr<CcnxFibEntry> item, Modifier mod)
+  // modify (Ptr<NdnFibEntry> item, Modifier mod)
   // {
-  //   return super::modify (StaticCast<CcnxFibEntryImpl> (item)->to_iterator (), mod);
+  //   return super::modify (StaticCast<NdnFibEntryImpl> (item)->to_iterator (), mod);
   // }
   
 protected:
@@ -142,7 +142,7 @@
    * entry will be removed
    */
   void
-  RemoveFace (super::parent_trie &item, Ptr<CcnxFace> face);
+  RemoveFace (super::parent_trie &item, Ptr<NdnFace> face);
   
 private:
   Ptr<Node> m_node;
@@ -150,4 +150,4 @@
  
 } // namespace ns3
 
-#endif	/* _CCNX_FIB_IMPL_H_ */
+#endif	/* _NDN_FIB_IMPL_H_ */
diff --git a/model/fib/ccnx-fib.cc b/model/fib/ndn-fib.cc
similarity index 76%
rename from model/fib/ccnx-fib.cc
rename to model/fib/ndn-fib.cc
index fdd1aea..7046634 100644
--- a/model/fib/ccnx-fib.cc
+++ b/model/fib/ndn-fib.cc
@@ -18,14 +18,14 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#include "ccnx-fib.h"
+#include "ndn-fib.h"
 
-#include "ccnx-fib-impl.h"
+#include "ndn-fib-impl.h"
 
-#include "ns3/ccnx.h"
-#include "ns3/ccnx-face.h"
-#include "ns3/ccnx-interest-header.h"
-#include "ns3/ccnx-name-components.h"
+#include "ns3/ndn.h"
+#include "ns3/ndn-face.h"
+#include "ns3/ndn-interest-header.h"
+#include "ns3/ndn-name-components.h"
 
 #include "ns3/node.h"
 #include "ns3/names.h"
@@ -37,19 +37,19 @@
 
 namespace ns3 {
 
-using namespace __ccnx_private;
+using namespace __ndn_private;
 
 TypeId 
-CcnxFib::GetTypeId (void)
+NdnFib::GetTypeId (void)
 {
-  static TypeId tid = TypeId ("ns3::private::CcnxFib") // cheating ns3 object system
+  static TypeId tid = TypeId ("ns3::private::NdnFib") // cheating ns3 object system
     .SetParent<Object> ()
-    .SetGroupName ("Ccnx")
+    .SetGroupName ("Ndn")
   ;
   return tid;
 }
 
-std::ostream& operator<< (std::ostream& os, const CcnxFib &fib)
+std::ostream& operator<< (std::ostream& os, const NdnFib &fib)
 {
   os << "Node " << Names::FindName (fib.GetObject<Node>()) << "\n";
   os << "  Dest prefix      Interfaces(Costs)                  \n";
diff --git a/model/fib/ccnx-fib.h b/model/fib/ndn-fib.h
similarity index 78%
rename from model/fib/ccnx-fib.h
rename to model/fib/ndn-fib.h
index eae0c65..12a6148 100644
--- a/model/fib/ccnx-fib.h
+++ b/model/fib/ndn-fib.h
@@ -18,23 +18,23 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef _CCNX_FIB_H_
-#define	_CCNX_FIB_H_
+#ifndef _NDN_FIB_H_
+#define	_NDN_FIB_H_
 
 #include "ns3/simple-ref-count.h"
 #include "ns3/node.h"
 
-#include "ns3/ccnx-fib-entry.h"
+#include "ns3/ndn-fib-entry.h"
 
 namespace ns3 {
 
-class CcnxInterestHeader;
+class NdnInterestHeader;
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief Class implementing FIB functionality
  */
-class CcnxFib : public Object
+class NdnFib : public Object
 {
 public:
   /**
@@ -46,12 +46,12 @@
   /**
    * @brief Default constructor
    */
-  CcnxFib () {}
+  NdnFib () {}
   
   /**
    * @brief Virtual destructor
    */
-  virtual ~CcnxFib () { };
+  virtual ~NdnFib () { };
   
   /**
    * \brief Perform longest prefix match
@@ -61,8 +61,8 @@
    * \param interest Interest packet header
    * \returns If entry found a valid iterator will be returned, otherwise end ()
    */
-  virtual Ptr<CcnxFibEntry>
-  LongestPrefixMatch (const CcnxInterestHeader &interest) = 0;
+  virtual Ptr<NdnFibEntry>
+  LongestPrefixMatch (const NdnInterestHeader &interest) = 0;
   
   /**
    * \brief Add or update FIB entry
@@ -75,8 +75,8 @@
    * @param face	Forwarding face
    * @param metric	Routing metric
    */
-  virtual Ptr<CcnxFibEntry>
-  Add (const CcnxNameComponents &prefix, Ptr<CcnxFace> face, int32_t metric) = 0;
+  virtual Ptr<NdnFibEntry>
+  Add (const NdnNameComponents &prefix, Ptr<NdnFace> face, int32_t metric) = 0;
 
   /**
    * \brief Add or update FIB entry using smart pointer to prefix
@@ -89,8 +89,8 @@
    * @param face	Forwarding face
    * @param metric	Routing metric
    */
-  virtual Ptr<CcnxFibEntry>
-  Add (const Ptr<const CcnxNameComponents> &prefix, Ptr<CcnxFace> face, int32_t metric) = 0;
+  virtual Ptr<NdnFibEntry>
+  Add (const Ptr<const NdnNameComponents> &prefix, Ptr<NdnFace> face, int32_t metric) = 0;
 
   /**
    * @brief Remove FIB entry
@@ -101,7 +101,7 @@
    * @param name	Smart pointer to prefix
    */
   virtual void
-  Remove (const Ptr<const CcnxNameComponents> &prefix) = 0;
+  Remove (const Ptr<const NdnNameComponents> &prefix) = 0;
 
   // /**
   //  * @brief Invalidate FIB entry ("Safe" version of Remove)
@@ -110,7 +110,7 @@
   //  * @param name	Smart pointer to prefix
   //  */
   // virtual void
-  // Invalidate (const Ptr<const CcnxNameComponents> &prefix) = 0;
+  // Invalidate (const Ptr<const NdnNameComponents> &prefix) = 0;
 
   /**
    * @brief Invalidate all FIB entries
@@ -123,7 +123,7 @@
    * this FIB entry will be removed.
    */
   virtual void
-  RemoveFromAll (Ptr<CcnxFace> face) = 0;
+  RemoveFromAll (Ptr<NdnFace> face) = 0;
 
   /**
    * @brief Print out entries in FIB
@@ -140,20 +140,20 @@
   /**
    * @brief Return first element of FIB (no order guaranteed)
    */
-  virtual Ptr<const CcnxFibEntry>
+  virtual Ptr<const NdnFibEntry>
   Begin () = 0;
 
   /**
    * @brief Return item next after last (no order guaranteed)
    */
-  virtual Ptr<const CcnxFibEntry>
+  virtual Ptr<const NdnFibEntry>
   End () = 0;
 
   /**
    * @brief Advance the iterator
    */
-  virtual Ptr<const CcnxFibEntry>
-  Next (Ptr<const CcnxFibEntry>) = 0;
+  virtual Ptr<const NdnFibEntry>
+  Next (Ptr<const NdnFibEntry>) = 0;
 
   ////////////////////////////////////////////////////////////////////////////
   ////////////////////////////////////////////////////////////////////////////
@@ -162,28 +162,28 @@
   /**
    * @brief Static call to cheat python bindings
    */
-  static inline Ptr<CcnxFib>
-  GetCcnxFib (Ptr<Object> node);
+  static inline Ptr<NdnFib>
+  GetNdnFib (Ptr<Object> node);
 
   ////////////////////////////////////////////////////////////////////////////
   ////////////////////////////////////////////////////////////////////////////
   ////////////////////////////////////////////////////////////////////////////
   
 private:
-  CcnxFib(const CcnxFib&) {} ; ///< \brief copy constructor is disabled
+  NdnFib(const NdnFib&) {} ; ///< \brief copy constructor is disabled
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-std::ostream& operator<< (std::ostream& os, const CcnxFib &fib);
+std::ostream& operator<< (std::ostream& os, const NdnFib &fib);
 
-Ptr<CcnxFib>
-CcnxFib::GetCcnxFib (Ptr<Object> node)
+Ptr<NdnFib>
+NdnFib::GetNdnFib (Ptr<Object> node)
 {
-  return node->GetObject<CcnxFib> ();
+  return node->GetObject<NdnFib> ();
 }
 
 } // namespace ns3
 
-#endif // _CCNX_FIB_H_
+#endif // _NDN_FIB_H_
diff --git a/model/forwarding-strategy/best-route.cc b/model/forwarding-strategy/best-route.cc
index 867527f..ba56979 100644
--- a/model/forwarding-strategy/best-route.cc
+++ b/model/forwarding-strategy/best-route.cc
@@ -21,9 +21,9 @@
 
 #include "best-route.h"
 
-#include "ns3/ccnx-interest-header.h"
-#include "ns3/ccnx-pit.h"
-#include "ns3/ccnx-pit-entry.h"
+#include "ns3/ndn-interest-header.h"
+#include "ns3/ndn-pit.h"
+#include "ns3/ndn-pit-entry.h"
 
 #include "ns3/assert.h"
 #include "ns3/log.h"
@@ -38,7 +38,7 @@
 namespace ns3 {
 namespace ndnSIM {
 
-using namespace __ccnx_private;
+using namespace __ndn_private;
 
 NS_OBJECT_ENSURE_REGISTERED (BestRoute);
   
@@ -46,7 +46,7 @@
 BestRoute::GetTypeId (void)
 {
   static TypeId tid = TypeId ("ns3::ndnSIM::BestRoute")
-    .SetGroupName ("Ccnx")
+    .SetGroupName ("Ndn")
     .SetParent <GreenYellowRed> ()
     .AddConstructor <BestRoute> ()
     ;
@@ -58,10 +58,10 @@
 }
     
 bool
-BestRoute::DoPropagateInterest (const Ptr<CcnxFace> &incomingFace,
-                                Ptr<CcnxInterestHeader> header,
+BestRoute::DoPropagateInterest (const Ptr<NdnFace> &incomingFace,
+                                Ptr<NdnInterestHeader> header,
                                 const Ptr<const Packet> &packet,
-                                Ptr<CcnxPitEntry> pitEntry)
+                                Ptr<NdnPitEntry> pitEntry)
 {
   NS_LOG_FUNCTION (this);
 
@@ -73,9 +73,9 @@
 
   int propagatedCount = 0;
 
-  BOOST_FOREACH (const CcnxFibFaceMetric &metricFace, pitEntry->GetFibEntry ()->m_faces.get<i_metric> ())
+  BOOST_FOREACH (const NdnFibFaceMetric &metricFace, pitEntry->GetFibEntry ()->m_faces.get<i_metric> ())
     {
-      if (metricFace.m_status == CcnxFibFaceMetric::NDN_FIB_RED) // all non-read faces are in front
+      if (metricFace.m_status == NdnFibFaceMetric::NDN_FIB_RED) // all non-read faces are in front
         break;
       
       if (metricFace.m_face == incomingFace) 
diff --git a/model/forwarding-strategy/best-route.h b/model/forwarding-strategy/best-route.h
index 01c9493..ec86914 100644
--- a/model/forwarding-strategy/best-route.h
+++ b/model/forwarding-strategy/best-route.h
@@ -29,7 +29,7 @@
 namespace ndnSIM {
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief Best route strategy
  */
 class BestRoute :
@@ -44,12 +44,12 @@
    */
   BestRoute ();
         
-  // inherited from  CcnxForwardingStrategy
+  // inherited from  NdnForwardingStrategy
   virtual bool
-  DoPropagateInterest (const Ptr<CcnxFace> &incomingFace,
-                       Ptr<CcnxInterestHeader> header,
+  DoPropagateInterest (const Ptr<NdnFace> &incomingFace,
+                       Ptr<NdnInterestHeader> header,
                        const Ptr<const Packet> &packet,
-                       Ptr<CcnxPitEntry> pitEntry);
+                       Ptr<NdnPitEntry> pitEntry);
 
 private:
   typedef GreenYellowRed super;
diff --git a/model/forwarding-strategy/ccnx-forwarding-strategy.h b/model/forwarding-strategy/ccnx-forwarding-strategy.h
deleted file mode 100644
index ff0dcef..0000000
--- a/model/forwarding-strategy/ccnx-forwarding-strategy.h
+++ /dev/null
@@ -1,235 +0,0 @@
-/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
-/*
- * Copyright (c) 2011 University of California, Los Angeles
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation;
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- * Author:  Alexander Afanasyev <alexander.afanasyev@ucla.edu>
- *          Ilya Moiseenko <iliamo@cs.ucla.edu>
- */
-#ifndef CCNX_FORWARDING_STRATEGY_H
-#define CCNX_FORWARDING_STRATEGY_H
-
-#include "ns3/packet.h"
-#include "ns3/callback.h"
-#include "ns3/object.h"
-#include "ns3/traced-callback.h"
-
-namespace ns3 {
-
-class CcnxFace;
-class CcnxInterestHeader;
-class CcnxContentObjectHeader;
-class CcnxPit;
-class CcnxPitEntry;
-class CcnxFibFaceMetric;
-class CcnxFib;
-class CcnxContentStore;
-
-/**
- * \ingroup ccnx
- * \brief Abstract base class for CCNx forwarding strategies
- */
-class CcnxForwardingStrategy :
-    public Object
-{
-public:
-  static TypeId GetTypeId (void);
-
-  /**
-   * @brief Default constructor
-   */
-  CcnxForwardingStrategy ();
-  virtual ~CcnxForwardingStrategy ();
-
-  /**
-   * \brief Actual processing of incoming CCNx interests. Note, interests do not have payload
-   * 
-   * Processing Interest packets
-   * @param face    incoming face
-   * @param header  deserialized Interest header
-   * @param packet  original packet
-   */
-  virtual void
-  OnInterest (const Ptr<CcnxFace> &face,
-              Ptr<CcnxInterestHeader> &header,
-              const Ptr<const Packet> &p);
-
-  /**
-   * \brief Actual processing of incoming CCNx content objects
-   * 
-   * Processing ContentObject packets
-   * @param face    incoming face
-   * @param header  deserialized ContentObject header
-   * @param payload data packet payload
-   * @param packet  original packet
-   */
-  virtual void
-  OnData (const Ptr<CcnxFace> &face,
-          Ptr<CcnxContentObjectHeader> &header,
-          Ptr<Packet> &payload,
-          const Ptr<const Packet> &packet);
-
-  virtual void
-  WillErasePendingInterest (Ptr<CcnxPitEntry> pitEntry);
-
-  virtual void
-  RemoveFace (Ptr<CcnxFace> face);
-  
-protected:
-  // events
-  virtual void
-  DidReceiveDuplicateInterest (const Ptr<CcnxFace> &face,
-                               Ptr<CcnxInterestHeader> &header,
-                               const Ptr<const Packet> &packet,
-                               Ptr<CcnxPitEntry> pitEntry);
-
-  virtual void
-  DidExhaustForwardingOptions (const Ptr<CcnxFace> &incomingFace,
-                               Ptr<CcnxInterestHeader> header,
-                               const Ptr<const Packet> &packet,
-                               Ptr<CcnxPitEntry> pitEntry);
-
-  virtual void
-  FailedToCreatePitEntry (const Ptr<CcnxFace> &incomingFace,
-                          Ptr<CcnxInterestHeader> header,
-                          const Ptr<const Packet> &packet);
-  
-  virtual void
-  DidCreatePitEntry (const Ptr<CcnxFace> &incomingFace,
-                     Ptr<CcnxInterestHeader> header,
-                     const Ptr<const Packet> &packet,
-                     Ptr<CcnxPitEntry> pitEntry);
-
-  virtual bool
-  DetectRetransmittedInterest (const Ptr<CcnxFace> &incomingFace,
-                               Ptr<CcnxPitEntry> pitEntry);
-
-  // makes sense only for data received from network
-  // When Interest is satisfied from the cache, incoming face is 0
-  virtual void
-  WillSatisfyPendingInterest (const Ptr<CcnxFace> &incomingFace,
-                              Ptr<CcnxPitEntry> pitEntry);
-
-  // for data received both from network and cache
-  virtual void
-  SatisfyPendingInterest (const Ptr<CcnxFace> &incomingFace, // 0 allowed (from cache)
-                          Ptr<const CcnxContentObjectHeader> header,
-                          Ptr<const Packet> payload,
-                          const Ptr<const Packet> &packet,
-                          Ptr<CcnxPitEntry> pitEntry);
-
-  virtual void
-  DidSendOutData (const Ptr<CcnxFace> &face,
-                  Ptr<const CcnxContentObjectHeader> header,
-                  Ptr<const Packet> payload,
-                  const Ptr<const Packet> &packet);
-  
-  virtual void
-  DidReceiveUnsolicitedData (const Ptr<CcnxFace> &incomingFace,
-                             Ptr<const CcnxContentObjectHeader> header,
-                             Ptr<const Packet> payload);
-  
-  virtual bool
-  ShouldSuppressIncomingInterest (const Ptr<CcnxFace> &incomingFace,
-                                  Ptr<CcnxPitEntry> pitEntry);
-
-  /**
-   * @brief Event fired before actually sending out an interest
-   *
-   * If event returns false, then there is some kind of a problem (e.g., per-face limit reached)
-   */
-  virtual bool
-  WillSendOutInterest (const Ptr<CcnxFace> &outgoingFace,
-                       Ptr<CcnxInterestHeader> header,
-                       Ptr<CcnxPitEntry> pitEntry);
-
-  /**
-   * @brief Event fired just after sending out an interest
-   */
-  virtual void
-  DidSendOutInterest (const Ptr<CcnxFace> &outgoingFace,
-                      Ptr<CcnxInterestHeader> header,
-                      const Ptr<const Packet> &packet,
-                      Ptr<CcnxPitEntry> pitEntry);
-
-  virtual void
-  PropagateInterest (const Ptr<CcnxFace> &incomingFace,
-                     Ptr<CcnxInterestHeader> header,
-                     const Ptr<const Packet> &packet,
-                     Ptr<CcnxPitEntry> pitEntry);
-  
-  /**
-   * @brief Base method to propagate the interest according to the forwarding strategy
-   *
-   * @param pitEntry      Reference to PIT entry (reference to corresponding FIB entry inside)
-   * @param incomingFace  Incoming face
-   * @param header        CcnxInterestHeader
-   * @param packet        Original Interest packet
-   * @param sendCallback  Send callback
-   *
-   * @return true if interest was successfully propagated, false if all options have failed
-   */
-  virtual bool
-  DoPropagateInterest (const Ptr<CcnxFace> &incomingFace,
-                       Ptr<CcnxInterestHeader> header,
-                       const Ptr<const Packet> &packet,
-                       Ptr<CcnxPitEntry> pitEntry) = 0;
-
-
-  // virtual void
-  // OnDataDelayed (Ptr<const CcnxContentObjectHeader> header,
-  //                Ptr<const Packet> payload,
-  //                const Ptr<const Packet> &packet);
-  
-protected:
-  // inherited from Object class                                                                                                                                                        
-  virtual void NotifyNewAggregate (); ///< @brief Even when object is aggregated to another Object
-  virtual void DoDispose (); ///< @brief Do cleanup
-  
-protected:  
-  Ptr<CcnxPit> m_pit; ///< \brief Reference to PIT to which this forwarding strategy is associated
-  Ptr<CcnxFib> m_fib; ///< \brief FIB  
-  Ptr<CcnxContentStore> m_contentStore; ///< \brief Content store (for caching purposes only)
-
-  bool m_cacheUnsolicitedData;
-  bool m_detectRetransmissions;
-  
-  TracedCallback<Ptr<const CcnxInterestHeader>,
-                 Ptr<const CcnxFace> > m_outInterests; ///< @brief Transmitted interests trace
-
-  TracedCallback<Ptr<const CcnxInterestHeader>,
-                 Ptr<const CcnxFace> > m_inInterests; ///< @brief trace of incoming Interests
-
-  TracedCallback<Ptr<const CcnxInterestHeader>,
-                 Ptr<const CcnxFace> > m_dropInterests; ///< @brief trace of dropped Interests
-  
-  ////////////////////////////////////////////////////////////////////
-  ////////////////////////////////////////////////////////////////////
-  ////////////////////////////////////////////////////////////////////
-
-  TracedCallback<Ptr<const CcnxContentObjectHeader>, Ptr<const Packet>,
-                 bool /*from cache*/,
-                 Ptr<const CcnxFace> > m_outData; ///< @brief trace of outgoing Data
-
-  TracedCallback<Ptr<const CcnxContentObjectHeader>, Ptr<const Packet>,
-                 Ptr<const CcnxFace> > m_inData; ///< @brief trace of incoming Data
-
-  TracedCallback<Ptr<const CcnxContentObjectHeader>, Ptr<const Packet>,
-                  Ptr<const CcnxFace> > m_dropData;  ///< @brief trace of dropped Data
-};
-
-} //namespace ns3
-
-#endif /* CCNX_FORWARDING_STRATEGY_H */
diff --git a/model/forwarding-strategy/flooding.cc b/model/forwarding-strategy/flooding.cc
index 176122d..b20854f 100644
--- a/model/forwarding-strategy/flooding.cc
+++ b/model/forwarding-strategy/flooding.cc
@@ -21,9 +21,9 @@
 
 #include "flooding.h"
 
-#include "ns3/ccnx-interest-header.h"
-#include "ns3/ccnx-pit.h"
-#include "ns3/ccnx-pit-entry.h"
+#include "ns3/ndn-interest-header.h"
+#include "ns3/ndn-pit.h"
+#include "ns3/ndn-pit-entry.h"
 
 #include "ns3/assert.h"
 #include "ns3/log.h"
@@ -41,14 +41,14 @@
 namespace ns3 {
 namespace ndnSIM {
 
-using namespace __ccnx_private;
+using namespace __ndn_private;
 
 NS_OBJECT_ENSURE_REGISTERED (Flooding);
     
 TypeId Flooding::GetTypeId (void)
 {
   static TypeId tid = TypeId ("ns3::ndnSIM::Flooding")
-    .SetGroupName ("Ccnx")
+    .SetGroupName ("Ndn")
     .SetParent <Nacks> ()
     .AddConstructor <Flooding> ()
     ;
@@ -60,19 +60,19 @@
 }
 
 bool
-Flooding::DoPropagateInterest (const Ptr<CcnxFace> &incomingFace,
-                               Ptr<CcnxInterestHeader> header,
+Flooding::DoPropagateInterest (const Ptr<NdnFace> &incomingFace,
+                               Ptr<NdnInterestHeader> header,
                                const Ptr<const Packet> &packet,
-                               Ptr<CcnxPitEntry> pitEntry)
+                               Ptr<NdnPitEntry> pitEntry)
 {
   NS_LOG_FUNCTION (this);
 
   int propagatedCount = 0;
 
-  BOOST_FOREACH (const CcnxFibFaceMetric &metricFace, pitEntry->GetFibEntry ()->m_faces.get<i_metric> ())
+  BOOST_FOREACH (const NdnFibFaceMetric &metricFace, pitEntry->GetFibEntry ()->m_faces.get<i_metric> ())
     {
       NS_LOG_DEBUG ("Trying " << boost::cref(metricFace));
-      if (metricFace.m_status == CcnxFibFaceMetric::NDN_FIB_RED) // all non-read faces are in the front of the list
+      if (metricFace.m_status == NdnFibFaceMetric::NDN_FIB_RED) // all non-read faces are in the front of the list
         break;
       
       if (metricFace.m_face == incomingFace) 
diff --git a/model/forwarding-strategy/flooding.h b/model/forwarding-strategy/flooding.h
index 71665c7..32fa7ae 100644
--- a/model/forwarding-strategy/flooding.h
+++ b/model/forwarding-strategy/flooding.h
@@ -28,7 +28,7 @@
 namespace ndnSIM {
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief Flooding strategy
  *
  * \todo Describe
@@ -45,12 +45,12 @@
   Flooding ();
 
 protected:
-  // inherited from  Nacks/CcnxForwardingStrategy
+  // inherited from  Nacks/NdnForwardingStrategy
   virtual bool
-  DoPropagateInterest (const Ptr<CcnxFace> &incomingFace,
-                       Ptr<CcnxInterestHeader> header,
+  DoPropagateInterest (const Ptr<NdnFace> &incomingFace,
+                       Ptr<NdnInterestHeader> header,
                        const Ptr<const Packet> &packet,
-                       Ptr<CcnxPitEntry> pitEntry);
+                       Ptr<NdnPitEntry> pitEntry);
 
 private:
   typedef Nacks super;
diff --git a/model/forwarding-strategy/fw-stats.cc b/model/forwarding-strategy/fw-stats.cc
index 38f03c8..af344e4 100644
--- a/model/forwarding-strategy/fw-stats.cc
+++ b/model/forwarding-strategy/fw-stats.cc
@@ -21,10 +21,10 @@
 
 #include "fw-stats.h"
 
-#include "ns3/ccnx-interest-header.h"
-#include "ns3/ccnx-content-object-header.h"
-#include "ns3/ccnx-pit.h"
-#include "ns3/ccnx-pit-entry.h"
+#include "ns3/ndn-interest-header.h"
+#include "ns3/ndn-content-object-header.h"
+#include "ns3/ndn-pit.h"
+#include "ns3/ndn-pit-entry.h"
 
 #include "ns3/assert.h"
 #include "ns3/log.h"
@@ -47,7 +47,7 @@
 FwStats::GetTypeId (void)
 {
   static TypeId tid = TypeId ("ns3::ndnSIM::FwStats")
-    .SetGroupName ("Ccnx")
+    .SetGroupName ("Ndn")
     .SetParent <BestRoute> ()
     .AddConstructor <FwStats> ()
 
@@ -69,8 +69,8 @@
 }
 
 void
-FwStats::OnInterest (const Ptr<CcnxFace> &face,
-                     Ptr<CcnxInterestHeader> &header,
+FwStats::OnInterest (const Ptr<NdnFace> &face,
+                     Ptr<NdnInterestHeader> &header,
                      const Ptr<const Packet> &packet)
 {
   super::OnInterest (face, header, packet);
@@ -81,8 +81,8 @@
 }
 
 void
-FwStats::OnData (const Ptr<CcnxFace> &face,
-                 Ptr<CcnxContentObjectHeader> &header,
+FwStats::OnData (const Ptr<NdnFace> &face,
+                 Ptr<NdnContentObjectHeader> &header,
                  Ptr<Packet> &payload,
                  const Ptr<const Packet> &packet)
 {
@@ -95,8 +95,8 @@
 
 
 void
-FwStats::FailedToCreatePitEntry (const Ptr<CcnxFace> &incomingFace,
-                                 Ptr<CcnxInterestHeader> header,
+FwStats::FailedToCreatePitEntry (const Ptr<NdnFace> &incomingFace,
+                                 Ptr<NdnInterestHeader> header,
                                  const Ptr<const Packet> &packet)
 {
   super::FailedToCreatePitEntry (incomingFace, header, packet);
@@ -110,10 +110,10 @@
 }
 
 void
-FwStats::DidCreatePitEntry (const Ptr<CcnxFace> &incomingFace,
-                            Ptr<CcnxInterestHeader> header,
+FwStats::DidCreatePitEntry (const Ptr<NdnFace> &incomingFace,
+                            Ptr<NdnInterestHeader> header,
                             const Ptr<const Packet> &packet,
-                            Ptr<CcnxPitEntry> pitEntry)
+                            Ptr<NdnPitEntry> pitEntry)
 {
   super::DidCreatePitEntry (incomingFace, header, packet, pitEntry);
   
@@ -124,8 +124,8 @@
 }
 
 void
-FwStats::WillSatisfyPendingInterest (const Ptr<CcnxFace> &incomingFace,
-                                     Ptr<CcnxPitEntry> pitEntry)
+FwStats::WillSatisfyPendingInterest (const Ptr<NdnFace> &incomingFace,
+                                     Ptr<NdnPitEntry> pitEntry)
 {
   super::WillSatisfyPendingInterest (incomingFace, pitEntry);
   
@@ -135,10 +135,10 @@
 }
 
 void
-FwStats::DidSendOutInterest (const Ptr<CcnxFace> &outgoingFace,
-                             Ptr<CcnxInterestHeader> header,
+FwStats::DidSendOutInterest (const Ptr<NdnFace> &outgoingFace,
+                             Ptr<NdnInterestHeader> header,
                              const Ptr<const Packet> &packet,
-                             Ptr<CcnxPitEntry> pitEntry)
+                             Ptr<NdnPitEntry> pitEntry)
 {
   super::DidSendOutInterest (outgoingFace, header, packet, pitEntry);
 
@@ -149,8 +149,8 @@
 }
 
 void
-FwStats::DidSendOutData (const Ptr<CcnxFace> &face,
-                         Ptr<const CcnxContentObjectHeader> header,
+FwStats::DidSendOutData (const Ptr<NdnFace> &face,
+                         Ptr<const NdnContentObjectHeader> header,
                          Ptr<const Packet> payload,
                          const Ptr<const Packet> &packet)
 {
@@ -163,7 +163,7 @@
 
 
 void
-FwStats::WillErasePendingInterest (Ptr<CcnxPitEntry> pitEntry)
+FwStats::WillErasePendingInterest (Ptr<NdnPitEntry> pitEntry)
 {
   super::WillErasePendingInterest (pitEntry);
 
@@ -194,7 +194,7 @@
 }
 
 void
-FwStats::RemoveFace (Ptr<CcnxFace> face)
+FwStats::RemoveFace (Ptr<NdnFace> face)
 {
   m_stats.RemoveFace (face);
 
diff --git a/model/forwarding-strategy/fw-stats.h b/model/forwarding-strategy/fw-stats.h
index 69149f3..1d7140f 100644
--- a/model/forwarding-strategy/fw-stats.h
+++ b/model/forwarding-strategy/fw-stats.h
@@ -31,7 +31,7 @@
 namespace ndnSIM {
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  * \brief Strategy based on best route and adding statistics gathering capabilities
  */
 class FwStats :
@@ -51,49 +51,49 @@
   GetStatsTree () const;  
 
   virtual void
-  OnInterest (const Ptr<CcnxFace> &face,
-              Ptr<CcnxInterestHeader> &header,
+  OnInterest (const Ptr<NdnFace> &face,
+              Ptr<NdnInterestHeader> &header,
               const Ptr<const Packet> &p);
 
   virtual void
-  OnData (const Ptr<CcnxFace> &face,
-          Ptr<CcnxContentObjectHeader> &header,
+  OnData (const Ptr<NdnFace> &face,
+          Ptr<NdnContentObjectHeader> &header,
           Ptr<Packet> &payload,
           const Ptr<const Packet> &packet);
 
   virtual void
-  RemoveFace (Ptr<CcnxFace> face);
+  RemoveFace (Ptr<NdnFace> face);
 
 protected:
   virtual void
-  DidCreatePitEntry (const Ptr<CcnxFace> &incomingFace,
-                     Ptr<CcnxInterestHeader> header,
+  DidCreatePitEntry (const Ptr<NdnFace> &incomingFace,
+                     Ptr<NdnInterestHeader> header,
                      const Ptr<const Packet> &packet,
-                     Ptr<CcnxPitEntry> pitEntry);
+                     Ptr<NdnPitEntry> pitEntry);
 
   virtual void
-  FailedToCreatePitEntry (const Ptr<CcnxFace> &incomingFace,
-                          Ptr<CcnxInterestHeader> header,
+  FailedToCreatePitEntry (const Ptr<NdnFace> &incomingFace,
+                          Ptr<NdnInterestHeader> header,
                           const Ptr<const Packet> &packet);
 
   virtual void
-  WillSatisfyPendingInterest (const Ptr<CcnxFace> &incomingFace,
-                              Ptr<CcnxPitEntry> pitEntry);
+  WillSatisfyPendingInterest (const Ptr<NdnFace> &incomingFace,
+                              Ptr<NdnPitEntry> pitEntry);
 
   virtual void
-  DidSendOutInterest (const Ptr<CcnxFace> &outgoingFace,
-                      Ptr<CcnxInterestHeader> header,
+  DidSendOutInterest (const Ptr<NdnFace> &outgoingFace,
+                      Ptr<NdnInterestHeader> header,
                       const Ptr<const Packet> &packet,
-                      Ptr<CcnxPitEntry> pitEntry);
+                      Ptr<NdnPitEntry> pitEntry);
 
   virtual void
-  DidSendOutData (const Ptr<CcnxFace> &face,
-                  Ptr<const CcnxContentObjectHeader> header,
+  DidSendOutData (const Ptr<NdnFace> &face,
+                  Ptr<const NdnContentObjectHeader> header,
                   Ptr<const Packet> payload,
                   const Ptr<const Packet> &packet);
 
   virtual void
-  WillErasePendingInterest (Ptr<CcnxPitEntry> pitEntry);
+  WillErasePendingInterest (Ptr<NdnPitEntry> pitEntry);
 
   // from Object
   void
@@ -110,7 +110,7 @@
   ::ndnSIM::StatsTree m_stats;
   EventId m_statsRefreshEvent;
 
-  TracedCallback< Ptr<CcnxForwardingStrategy>,
+  TracedCallback< Ptr<NdnForwardingStrategy>,
                   const ::ndnSIM::StatsTree & > m_statsTrace;
   
   typedef BestRoute super;
diff --git a/model/forwarding-strategy/green-yellow-red.cc b/model/forwarding-strategy/green-yellow-red.cc
index c00e6d8..5d497a6 100644
--- a/model/forwarding-strategy/green-yellow-red.cc
+++ b/model/forwarding-strategy/green-yellow-red.cc
@@ -21,13 +21,13 @@
 
 #include "green-yellow-red.h"
 
-#include "ns3/ccnx-pit.h"
-#include "ns3/ccnx-pit-entry.h"
-#include "ns3/ccnx-interest-header.h"
-#include "ns3/ccnx-content-object-header.h"
-#include "ns3/ccnx-pit.h"
-#include "ns3/ccnx-fib.h"
-#include "ns3/ccnx-content-store.h"
+#include "ns3/ndn-pit.h"
+#include "ns3/ndn-pit-entry.h"
+#include "ns3/ndn-interest-header.h"
+#include "ns3/ndn-content-object-header.h"
+#include "ns3/ndn-pit.h"
+#include "ns3/ndn-fib.h"
+#include "ns3/ndn-content-store.h"
 
 #include "ns3/assert.h"
 #include "ns3/ptr.h"
@@ -47,7 +47,7 @@
 
 namespace ns3 {
 
-using namespace __ccnx_private;
+using namespace __ndn_private;
 
 namespace ndnSIM {
 
@@ -57,7 +57,7 @@
 GreenYellowRed::GetTypeId (void)
 {
   static TypeId tid = TypeId ("ns3::ndnSIM::GreenYellowRed")
-    .SetGroupName ("Ccnx")
+    .SetGroupName ("Ndn")
     .SetParent<Nacks> ()
 
     ;
@@ -65,20 +65,20 @@
 }
 
 bool
-GreenYellowRed::DoPropagateInterest (const Ptr<CcnxFace> &incomingFace,
-                                     Ptr<CcnxInterestHeader> header,
+GreenYellowRed::DoPropagateInterest (const Ptr<NdnFace> &incomingFace,
+                                     Ptr<NdnInterestHeader> header,
                                      const Ptr<const Packet> &packet,
-                                     Ptr<CcnxPitEntry> pitEntry)
+                                     Ptr<NdnPitEntry> pitEntry)
 {
   NS_LOG_FUNCTION (this);
   NS_ASSERT_MSG (m_pit != 0, "PIT should be aggregated with forwarding strategy");
 
   int propagatedCount = 0;
   
-  BOOST_FOREACH (const CcnxFibFaceMetric &metricFace, pitEntry->GetFibEntry ()->m_faces.get<i_metric> ())
+  BOOST_FOREACH (const NdnFibFaceMetric &metricFace, pitEntry->GetFibEntry ()->m_faces.get<i_metric> ())
     {
-      if (metricFace.m_status == CcnxFibFaceMetric::NDN_FIB_RED ||
-          metricFace.m_status == CcnxFibFaceMetric::NDN_FIB_YELLOW)
+      if (metricFace.m_status == NdnFibFaceMetric::NDN_FIB_RED ||
+          metricFace.m_status == NdnFibFaceMetric::NDN_FIB_YELLOW)
         break; //propagate only to green faces
 
       if (pitEntry->GetIncoming ().find (metricFace.m_face) != pitEntry->GetIncoming ().end ()) 
@@ -103,29 +103,29 @@
 }
 
 void
-GreenYellowRed::WillSatisfyPendingInterest (const Ptr<CcnxFace> &incomingFace,
-                                            Ptr<CcnxPitEntry> pitEntry)
+GreenYellowRed::WillSatisfyPendingInterest (const Ptr<NdnFace> &incomingFace,
+                                            Ptr<NdnPitEntry> pitEntry)
 {
   if (incomingFace != 0)
     {
       // Update metric status for the incoming interface in the corresponding FIB entry
-      pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_GREEN);
+      pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, NdnFibFaceMetric::NDN_FIB_GREEN);
     }
 
   super::WillSatisfyPendingInterest (incomingFace, pitEntry);
 }
 
 void
-GreenYellowRed::DidReceiveValidNack (const Ptr<CcnxFace> &incomingFace,
+GreenYellowRed::DidReceiveValidNack (const Ptr<NdnFace> &incomingFace,
                                      uint32_t nackCode,
-                                     Ptr<CcnxPitEntry> pitEntry)
+                                     Ptr<NdnPitEntry> pitEntry)
 {
   super::DidReceiveValidNack (incomingFace, nackCode, pitEntry);
 
   if (incomingFace != 0 &&
-      nackCode != CcnxInterestHeader::NACK_LOOP)
+      nackCode != NdnInterestHeader::NACK_LOOP)
     {
-      pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW);
+      pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, NdnFibFaceMetric::NDN_FIB_YELLOW);
     }
 }
 
diff --git a/model/forwarding-strategy/green-yellow-red.h b/model/forwarding-strategy/green-yellow-red.h
index 71002b9..67263ee 100644
--- a/model/forwarding-strategy/green-yellow-red.h
+++ b/model/forwarding-strategy/green-yellow-red.h
@@ -27,7 +27,7 @@
 namespace ndnSIM {
 
 /**
- * \ingroup ccnx
+ * \ingroup ndn
  */
 class GreenYellowRed :
     public Nacks
@@ -37,18 +37,18 @@
 
 protected:
   virtual void
-  WillSatisfyPendingInterest (const Ptr<CcnxFace> &incomingFace,
-                              Ptr<CcnxPitEntry> pitEntry);
+  WillSatisfyPendingInterest (const Ptr<NdnFace> &incomingFace,
+                              Ptr<NdnPitEntry> pitEntry);
 
   virtual bool
-  DoPropagateInterest (const Ptr<CcnxFace> &incomingFace,
-                       Ptr<CcnxInterestHeader> header,
+  DoPropagateInterest (const Ptr<NdnFace> &incomingFace,
+                       Ptr<NdnInterestHeader> header,
                        const Ptr<const Packet> &packet,
-                       Ptr<CcnxPitEntry> pitEntry);
+                       Ptr<NdnPitEntry> pitEntry);
   virtual void
-  DidReceiveValidNack (const Ptr<CcnxFace> &incomingFace,
+  DidReceiveValidNack (const Ptr<NdnFace> &incomingFace,
                        uint32_t nackCode,
-                       Ptr<CcnxPitEntry> pitEntry);
+                       Ptr<NdnPitEntry> pitEntry);
 
 private:
   typedef Nacks super;
diff --git a/model/forwarding-strategy/nacks.cc b/model/forwarding-strategy/nacks.cc
index b0a193e..4cc8287 100644
--- a/model/forwarding-strategy/nacks.cc
+++ b/model/forwarding-strategy/nacks.cc
@@ -20,13 +20,13 @@
 
 #include "nacks.h"
 
-#include "ns3/ccnx-pit.h"
-#include "ns3/ccnx-pit-entry.h"
-#include "ns3/ccnx-interest-header.h"
-#include "ns3/ccnx-content-object-header.h"
-#include "ns3/ccnx-pit.h"
-#include "ns3/ccnx-fib.h"
-#include "ns3/ccnx-content-store.h"
+#include "ns3/ndn-pit.h"
+#include "ns3/ndn-pit-entry.h"
+#include "ns3/ndn-interest-header.h"
+#include "ns3/ndn-content-object-header.h"
+#include "ns3/ndn-pit.h"
+#include "ns3/ndn-fib.h"
+#include "ns3/ndn-content-store.h"
 
 #include "ns3/assert.h"
 #include "ns3/ptr.h"
@@ -53,8 +53,8 @@
 Nacks::GetTypeId (void)
 {
   static TypeId tid = TypeId ("ns3::ndnSIM::Nacks")
-    .SetGroupName ("Ccnx")
-    .SetParent<CcnxForwardingStrategy> ()
+    .SetGroupName ("Ndn")
+    .SetParent<NdnForwardingStrategy> ()
     
     ////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////////////////////////////
@@ -72,8 +72,8 @@
 }
 
 void
-Nacks::OnInterest (const Ptr<CcnxFace> &incomingFace,
-                   Ptr<CcnxInterestHeader> &header,
+Nacks::OnInterest (const Ptr<NdnFace> &incomingFace,
+                   Ptr<NdnInterestHeader> &header,
                    const Ptr<const Packet> &packet)
 {
   if (header->GetNack () > 0)
@@ -83,8 +83,8 @@
 }
 
 void
-Nacks::OnNack (const Ptr<CcnxFace> &incomingFace,
-               Ptr<CcnxInterestHeader> &header,
+Nacks::OnNack (const Ptr<NdnFace> &incomingFace,
+               Ptr<NdnInterestHeader> &header,
                const Ptr<const Packet> &packet)
 {
   NS_ASSERT (m_nacksEnabled);
@@ -92,7 +92,7 @@
   // NS_LOG_FUNCTION (incomingFace << header << packet);
   m_inNacks (header, incomingFace);
 
-  Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
+  Ptr<NdnPitEntry> pitEntry = m_pit->Lookup (*header);
   if (pitEntry == 0)
     {
       // somebody is doing something bad
@@ -119,7 +119,7 @@
     }
   
   Ptr<Packet> nonNackInterest = Create<Packet> ();
-  header->SetNack (CcnxInterestHeader::NORMAL_INTEREST);
+  header->SetNack (NdnInterestHeader::NORMAL_INTEREST);
   nonNackInterest->AddHeader (*header);
   
   bool propagated = DoPropagateInterest (incomingFace, header, nonNackInterest, pitEntry);
@@ -130,17 +130,17 @@
 }
 
 void
-Nacks::DidReceiveDuplicateInterest (const Ptr<CcnxFace> &incomingFace,
-                                    Ptr<CcnxInterestHeader> &header,
+Nacks::DidReceiveDuplicateInterest (const Ptr<NdnFace> &incomingFace,
+                                    Ptr<NdnInterestHeader> &header,
                                     const Ptr<const Packet> &packet,
-                                    Ptr<CcnxPitEntry> pitEntry)
+                                    Ptr<NdnPitEntry> pitEntry)
 {
   super::DidReceiveDuplicateInterest (incomingFace, header, packet, pitEntry);
 
   if (m_nacksEnabled)
     {
       NS_LOG_DEBUG ("Sending NACK_LOOP");
-      header->SetNack (CcnxInterestHeader::NACK_LOOP);
+      header->SetNack (NdnInterestHeader::NACK_LOOP);
       Ptr<Packet> nack = Create<Packet> ();
       nack->AddHeader (*header);
 
@@ -150,20 +150,20 @@
 }
 
 void
-Nacks::DidExhaustForwardingOptions (const Ptr<CcnxFace> &incomingFace,
-                                    Ptr<CcnxInterestHeader> header,
+Nacks::DidExhaustForwardingOptions (const Ptr<NdnFace> &incomingFace,
+                                    Ptr<NdnInterestHeader> header,
                                     const Ptr<const Packet> &packet,
-                                    Ptr<CcnxPitEntry> pitEntry)
+                                    Ptr<NdnPitEntry> pitEntry)
 {
   super::DidExhaustForwardingOptions (incomingFace, header, packet, pitEntry);
 
   if (m_nacksEnabled)
     {
       Ptr<Packet> packet = Create<Packet> ();
-      header->SetNack (CcnxInterestHeader::NACK_GIVEUP_PIT);
+      header->SetNack (NdnInterestHeader::NACK_GIVEUP_PIT);
       packet->AddHeader (*header);
 
-      BOOST_FOREACH (const CcnxPitEntryIncomingFace &incoming, pitEntry->GetIncoming ())
+      BOOST_FOREACH (const NdnPitEntryIncomingFace &incoming, pitEntry->GetIncoming ())
         {
           NS_LOG_DEBUG ("Send NACK for " << boost::cref (header->GetName ()) << " to " << boost::cref (*incoming.m_face));
           incoming.m_face->Send (packet->Copy ());
@@ -183,18 +183,18 @@
 }
 
 void
-Nacks::DidReceiveValidNack (const Ptr<CcnxFace> &incomingFace,
+Nacks::DidReceiveValidNack (const Ptr<NdnFace> &incomingFace,
                             uint32_t nackCode,
-                            Ptr<CcnxPitEntry> pitEntry)
+                            Ptr<NdnPitEntry> pitEntry)
 {
   // If NACK is NACK_GIVEUP_PIT, then neighbor gave up trying to and removed it's PIT entry.
   // So, if we had an incoming entry to this neighbor, then we can remove it now
-  if (nackCode == CcnxInterestHeader::NACK_GIVEUP_PIT)
+  if (nackCode == NdnInterestHeader::NACK_GIVEUP_PIT)
     {
       pitEntry->RemoveIncoming (incomingFace);
     }
 
-  pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW);
+  pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, NdnFibFaceMetric::NDN_FIB_YELLOW);
 }
 
 } // namespace ndnSIM
diff --git a/model/forwarding-strategy/nacks.h b/model/forwarding-strategy/nacks.h
index 81e478c..074f5ab 100644
--- a/model/forwarding-strategy/nacks.h
+++ b/model/forwarding-strategy/nacks.h
@@ -20,25 +20,25 @@
 #ifndef NDNSIM_NACKS_H
 #define NDNSIM_NACKS_H
 
-#include "ns3/ccnx-forwarding-strategy.h"
+#include "ns3/ndn-forwarding-strategy.h"
 
 namespace ns3 {
 
 namespace ndnSIM {
 
 /**
- * \ingroup ccnx
- * \brief Abstract base class for CCNx forwarding strategies
+ * \ingroup ndn
+ * \brief Abstract base class for Ndn forwarding strategies
  */
 class Nacks :
-    public CcnxForwardingStrategy
+    public NdnForwardingStrategy
 {
 public:
   static TypeId
   GetTypeId (void);
 
   /**
-   * \brief Actual processing of incoming CCNx interests. Note, interests do not have payload
+   * \brief Actual processing of incoming Ndn interests. Note, interests do not have payload
    * 
    * Processing Interest packets
    * @param face    incoming face
@@ -46,49 +46,49 @@
    * @param packet  original packet
    */
   virtual void
-  OnInterest (const Ptr<CcnxFace> &face,
-              Ptr<CcnxInterestHeader> &header,
+  OnInterest (const Ptr<NdnFace> &face,
+              Ptr<NdnInterestHeader> &header,
               const Ptr<const Packet> &p);
 
 protected:
-  // using CcnxForwardingStrategy::PropagateInterest; // some strange c++ cheating
+  // using NdnForwardingStrategy::PropagateInterest; // some strange c++ cheating
 
   virtual void
-  DidReceiveDuplicateInterest (const Ptr<CcnxFace> &face,
-                               Ptr<CcnxInterestHeader> &header,
+  DidReceiveDuplicateInterest (const Ptr<NdnFace> &face,
+                               Ptr<NdnInterestHeader> &header,
                                const Ptr<const Packet> &packet,
-                               Ptr<CcnxPitEntry> pitEntry);
+                               Ptr<NdnPitEntry> pitEntry);
   
   virtual void
-  DidExhaustForwardingOptions (const Ptr<CcnxFace> &incomingFace,
-                               Ptr<CcnxInterestHeader> header,
+  DidExhaustForwardingOptions (const Ptr<NdnFace> &incomingFace,
+                               Ptr<NdnInterestHeader> header,
                                const Ptr<const Packet> &packet,
-                               Ptr<CcnxPitEntry> pitEntry);
+                               Ptr<NdnPitEntry> pitEntry);
 
   virtual void
-  OnNack (const Ptr<CcnxFace> &face,
-          Ptr<CcnxInterestHeader> &header,
+  OnNack (const Ptr<NdnFace> &face,
+          Ptr<NdnInterestHeader> &header,
           const Ptr<const Packet> &p);
 
   virtual void
-  DidReceiveValidNack (const Ptr<CcnxFace> &incomingFace,
+  DidReceiveValidNack (const Ptr<NdnFace> &incomingFace,
                        uint32_t nackCode,
-                       Ptr<CcnxPitEntry> pitEntry);
+                       Ptr<NdnPitEntry> pitEntry);
   
 protected:  
   bool m_nacksEnabled;
 
-  TracedCallback<Ptr<const CcnxInterestHeader>,
-                 Ptr<const CcnxFace> > m_outNacks; ///< @brief trace of outgoing NACKs
+  TracedCallback<Ptr<const NdnInterestHeader>,
+                 Ptr<const NdnFace> > m_outNacks; ///< @brief trace of outgoing NACKs
 
-  TracedCallback<Ptr<const CcnxInterestHeader>,
-                 Ptr<const CcnxFace> > m_inNacks; ///< @brief trace of incoming NACKs
+  TracedCallback<Ptr<const NdnInterestHeader>,
+                 Ptr<const NdnFace> > m_inNacks; ///< @brief trace of incoming NACKs
 
-  TracedCallback<Ptr<const CcnxInterestHeader>,
-                 Ptr<const CcnxFace> > m_dropNacks; ///< @brief trace of dropped NACKs
+  TracedCallback<Ptr<const NdnInterestHeader>,
+                 Ptr<const NdnFace> > m_dropNacks; ///< @brief trace of dropped NACKs
 
 private:
-  typedef CcnxForwardingStrategy super;
+  typedef NdnForwardingStrategy super;
 };
 
 } // namespace ndnSIM
diff --git a/model/forwarding-strategy/ccnx-forwarding-strategy.cc b/model/forwarding-strategy/ndn-forwarding-strategy.cc
similarity index 70%
rename from model/forwarding-strategy/ccnx-forwarding-strategy.cc
rename to model/forwarding-strategy/ndn-forwarding-strategy.cc
index ddc4e51..dedd60f 100644
--- a/model/forwarding-strategy/ccnx-forwarding-strategy.cc
+++ b/model/forwarding-strategy/ndn-forwarding-strategy.cc
@@ -19,16 +19,16 @@
  *          Ilya Moiseenko <iliamo@cs.ucla.edu>
  */
 
-#include "ccnx-forwarding-strategy.h"
+#include "ndn-forwarding-strategy.h"
 
-#include "ns3/ccnx-pit.h"
-#include "ns3/ccnx-pit-entry.h"
-#include "ns3/ccnx-interest-header.h"
-#include "ns3/ccnx-content-object-header.h"
-#include "ns3/ccnx-pit.h"
-#include "ns3/ccnx-fib.h"
-#include "ns3/ccnx-content-store.h"
-#include "ns3/ccnx-face.h"
+#include "ns3/ndn-pit.h"
+#include "ns3/ndn-pit-entry.h"
+#include "ns3/ndn-interest-header.h"
+#include "ns3/ndn-content-object-header.h"
+#include "ns3/ndn-pit.h"
+#include "ns3/ndn-fib.h"
+#include "ns3/ndn-content-store.h"
+#include "ns3/ndn-face.h"
 
 #include "ns3/assert.h"
 #include "ns3/ptr.h"
@@ -44,77 +44,77 @@
 #include <boost/tuple/tuple.hpp>
 namespace ll = boost::lambda;
 
-NS_LOG_COMPONENT_DEFINE ("CcnxForwardingStrategy");
+NS_LOG_COMPONENT_DEFINE ("NdnForwardingStrategy");
 
 namespace ns3 {
 
-using namespace __ccnx_private;
+using namespace __ndn_private;
 
-NS_OBJECT_ENSURE_REGISTERED (CcnxForwardingStrategy);
+NS_OBJECT_ENSURE_REGISTERED (NdnForwardingStrategy);
 
-TypeId CcnxForwardingStrategy::GetTypeId (void)
+TypeId NdnForwardingStrategy::GetTypeId (void)
 {
-  static TypeId tid = TypeId ("ns3::CcnxForwardingStrategy")
-    .SetGroupName ("Ccnx")
+  static TypeId tid = TypeId ("ns3::NdnForwardingStrategy")
+    .SetGroupName ("Ndn")
     .SetParent<Object> ()
 
     ////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////////////////////////////
 
-    .AddTraceSource ("OutInterests", "OutInterests",   MakeTraceSourceAccessor (&CcnxForwardingStrategy::m_outInterests))
-    .AddTraceSource ("InInterests",   "InInterests",   MakeTraceSourceAccessor (&CcnxForwardingStrategy::m_inInterests))
-    .AddTraceSource ("DropInterests", "DropInterests", MakeTraceSourceAccessor (&CcnxForwardingStrategy::m_dropInterests))
+    .AddTraceSource ("OutInterests", "OutInterests",   MakeTraceSourceAccessor (&NdnForwardingStrategy::m_outInterests))
+    .AddTraceSource ("InInterests",   "InInterests",   MakeTraceSourceAccessor (&NdnForwardingStrategy::m_inInterests))
+    .AddTraceSource ("DropInterests", "DropInterests", MakeTraceSourceAccessor (&NdnForwardingStrategy::m_dropInterests))
     
     ////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////////////////////////////
 
-    .AddTraceSource ("OutData",  "OutData",  MakeTraceSourceAccessor (&CcnxForwardingStrategy::m_outData))
-    .AddTraceSource ("InData",   "InData",   MakeTraceSourceAccessor (&CcnxForwardingStrategy::m_inData))
-    .AddTraceSource ("DropData", "DropData", MakeTraceSourceAccessor (&CcnxForwardingStrategy::m_dropData))
+    .AddTraceSource ("OutData",  "OutData",  MakeTraceSourceAccessor (&NdnForwardingStrategy::m_outData))
+    .AddTraceSource ("InData",   "InData",   MakeTraceSourceAccessor (&NdnForwardingStrategy::m_inData))
+    .AddTraceSource ("DropData", "DropData", MakeTraceSourceAccessor (&NdnForwardingStrategy::m_dropData))
 
     .AddAttribute ("CacheUnsolicitedData", "Cache overheard data that have not been requested",
                    BooleanValue (false),
-                   MakeBooleanAccessor (&CcnxForwardingStrategy::m_cacheUnsolicitedData),
+                   MakeBooleanAccessor (&NdnForwardingStrategy::m_cacheUnsolicitedData),
                    MakeBooleanChecker ())
 
     .AddAttribute ("DetectRetransmissions", "If non-duplicate interest is received on the same face more than once, "
                                             "it is considered a retransmission",
                    BooleanValue (true),
-                   MakeBooleanAccessor (&CcnxForwardingStrategy::m_detectRetransmissions),
+                   MakeBooleanAccessor (&NdnForwardingStrategy::m_detectRetransmissions),
                    MakeBooleanChecker ())
     ;
   return tid;
 }
 
-CcnxForwardingStrategy::CcnxForwardingStrategy ()
+NdnForwardingStrategy::NdnForwardingStrategy ()
 {
 }
 
-CcnxForwardingStrategy::~CcnxForwardingStrategy ()
+NdnForwardingStrategy::~NdnForwardingStrategy ()
 {
 }
 
 void
-CcnxForwardingStrategy::NotifyNewAggregate ()
+NdnForwardingStrategy::NotifyNewAggregate ()
 {
   if (m_pit == 0)
     {
-      m_pit = GetObject<CcnxPit> ();
+      m_pit = GetObject<NdnPit> ();
     }
   if (m_fib == 0)
     {
-      m_fib = GetObject<CcnxFib> ();
+      m_fib = GetObject<NdnFib> ();
     }
   if (m_contentStore == 0)
     {
-      m_contentStore = GetObject<CcnxContentStore> ();
+      m_contentStore = GetObject<NdnContentStore> ();
     }
 
   Object::NotifyNewAggregate ();
 }
 
 void
-CcnxForwardingStrategy::DoDispose ()
+NdnForwardingStrategy::DoDispose ()
 {
   m_pit = 0;
   m_contentStore = 0;
@@ -124,13 +124,13 @@
 }
 
 void
-CcnxForwardingStrategy::OnInterest (const Ptr<CcnxFace> &incomingFace,
-                                    Ptr<CcnxInterestHeader> &header,
+NdnForwardingStrategy::OnInterest (const Ptr<NdnFace> &incomingFace,
+                                    Ptr<NdnInterestHeader> &header,
                                     const Ptr<const Packet> &packet)
 {
   m_inInterests (header, incomingFace);
 
-  Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
+  Ptr<NdnPitEntry> pitEntry = m_pit->Lookup (*header);
   if (pitEntry == 0)
     {
       pitEntry = m_pit->Create (header);
@@ -159,7 +159,7 @@
     }
 
   Ptr<Packet> contentObject;
-  Ptr<const CcnxContentObjectHeader> contentObjectHeader; // used for tracing
+  Ptr<const NdnContentObjectHeader> contentObjectHeader; // used for tracing
   Ptr<const Packet> payload; // used for tracing
   boost::tie (contentObject, contentObjectHeader, payload) = m_contentStore->Lookup (header);
   if (contentObject != 0)
@@ -192,8 +192,8 @@
 }
 
 void
-CcnxForwardingStrategy::OnData (const Ptr<CcnxFace> &incomingFace,
-                                Ptr<CcnxContentObjectHeader> &header,
+NdnForwardingStrategy::OnData (const Ptr<NdnFace> &incomingFace,
+                                Ptr<NdnContentObjectHeader> &header,
                                 Ptr<Packet> &payload,
                                 const Ptr<const Packet> &packet)
 {
@@ -201,7 +201,7 @@
   m_inData (header, payload, incomingFace);
   
   // Lookup PIT entry
-  Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
+  Ptr<NdnPitEntry> pitEntry = m_pit->Lookup (*header);
   if (pitEntry == 0)
     {
       DidReceiveUnsolicitedData (incomingFace, header, payload);
@@ -228,10 +228,10 @@
 
 
 void
-CcnxForwardingStrategy::DidReceiveDuplicateInterest (const Ptr<CcnxFace> &incomingFace,
-                                                     Ptr<CcnxInterestHeader> &header,
+NdnForwardingStrategy::DidReceiveDuplicateInterest (const Ptr<NdnFace> &incomingFace,
+                                                     Ptr<NdnInterestHeader> &header,
                                                      const Ptr<const Packet> &packet,
-                                                     Ptr<CcnxPitEntry> pitEntry)
+                                                     Ptr<NdnPitEntry> pitEntry)
 {
   NS_LOG_FUNCTION (this << boost::cref (*incomingFace));
   /////////////////////////////////////////////////////////////////////////////////////////
@@ -244,18 +244,18 @@
 }
 
 void
-CcnxForwardingStrategy::DidExhaustForwardingOptions (const Ptr<CcnxFace> &incomingFace,
-                                                     Ptr<CcnxInterestHeader> header,
+NdnForwardingStrategy::DidExhaustForwardingOptions (const Ptr<NdnFace> &incomingFace,
+                                                     Ptr<NdnInterestHeader> header,
                                                      const Ptr<const Packet> &packet,
-                                                     Ptr<CcnxPitEntry> pitEntry)
+                                                     Ptr<NdnPitEntry> pitEntry)
 {
   NS_LOG_FUNCTION (this << boost::cref (*incomingFace));
   m_dropInterests (header, incomingFace);
 }
 
 void
-CcnxForwardingStrategy::FailedToCreatePitEntry (const Ptr<CcnxFace> &incomingFace,
-                                                Ptr<CcnxInterestHeader> header,
+NdnForwardingStrategy::FailedToCreatePitEntry (const Ptr<NdnFace> &incomingFace,
+                                                Ptr<NdnInterestHeader> header,
                                                 const Ptr<const Packet> &packet)
 {
   NS_LOG_FUNCTION (this);
@@ -263,18 +263,18 @@
 }
   
 void
-CcnxForwardingStrategy::DidCreatePitEntry (const Ptr<CcnxFace> &incomingFace,
-                                           Ptr<CcnxInterestHeader> header,
+NdnForwardingStrategy::DidCreatePitEntry (const Ptr<NdnFace> &incomingFace,
+                                           Ptr<NdnInterestHeader> header,
                                            const Ptr<const Packet> &packet,
-                                           Ptr<CcnxPitEntry> pitEntrypitEntry)
+                                           Ptr<NdnPitEntry> pitEntrypitEntry)
 {
 }
 
 bool
-CcnxForwardingStrategy::DetectRetransmittedInterest (const Ptr<CcnxFace> &incomingFace,
-                                                     Ptr<CcnxPitEntry> pitEntry)
+NdnForwardingStrategy::DetectRetransmittedInterest (const Ptr<NdnFace> &incomingFace,
+                                                     Ptr<NdnPitEntry> pitEntry)
 {
-  CcnxPitEntry::in_iterator inFace = pitEntry->GetIncoming ().find (incomingFace);
+  NdnPitEntry::in_iterator inFace = pitEntry->GetIncoming ().find (incomingFace);
 
   bool isRetransmitted = false;
   
@@ -288,17 +288,17 @@
 }
 
 void
-CcnxForwardingStrategy::SatisfyPendingInterest (const Ptr<CcnxFace> &incomingFace,
-                                                Ptr<const CcnxContentObjectHeader> header,
+NdnForwardingStrategy::SatisfyPendingInterest (const Ptr<NdnFace> &incomingFace,
+                                                Ptr<const NdnContentObjectHeader> header,
                                                 Ptr<const Packet> payload,
                                                 const Ptr<const Packet> &packet,
-                                                Ptr<CcnxPitEntry> pitEntry)
+                                                Ptr<NdnPitEntry> pitEntry)
 {
   if (incomingFace != 0)
     pitEntry->RemoveIncoming (incomingFace);
 
   //satisfy all pending incoming Interests
-  BOOST_FOREACH (const CcnxPitEntryIncomingFace &incoming, pitEntry->GetIncoming ())
+  BOOST_FOREACH (const NdnPitEntryIncomingFace &incoming, pitEntry->GetIncoming ())
     {
       bool ok = incoming.m_face->Send (packet->Copy ());
       if (ok)
@@ -328,8 +328,8 @@
 }
 
 void
-CcnxForwardingStrategy::DidReceiveUnsolicitedData (const Ptr<CcnxFace> &incomingFace,
-                                                   Ptr<const CcnxContentObjectHeader> header,
+NdnForwardingStrategy::DidReceiveUnsolicitedData (const Ptr<NdnFace> &incomingFace,
+                                                   Ptr<const NdnContentObjectHeader> header,
                                                    Ptr<const Packet> payload)
 {
   if (m_cacheUnsolicitedData)
@@ -348,10 +348,10 @@
 }
 
 void
-CcnxForwardingStrategy::WillSatisfyPendingInterest (const Ptr<CcnxFace> &incomingFace,
-                                                    Ptr<CcnxPitEntry> pitEntry)
+NdnForwardingStrategy::WillSatisfyPendingInterest (const Ptr<NdnFace> &incomingFace,
+                                                    Ptr<NdnPitEntry> pitEntry)
 {
-  CcnxPitEntry::out_iterator out = pitEntry->GetOutgoing ().find (incomingFace);
+  NdnPitEntry::out_iterator out = pitEntry->GetOutgoing ().find (incomingFace);
   
   // If we have sent interest for this data via this face, then update stats.
   if (out != pitEntry->GetOutgoing ().end ())
@@ -361,8 +361,8 @@
 }
 
 bool
-CcnxForwardingStrategy::ShouldSuppressIncomingInterest (const Ptr<CcnxFace> &incomingFace,
-                                                        Ptr<CcnxPitEntry> pitEntry)
+NdnForwardingStrategy::ShouldSuppressIncomingInterest (const Ptr<NdnFace> &incomingFace,
+                                                        Ptr<NdnPitEntry> pitEntry)
 {
   bool isNew = pitEntry->GetIncoming ().size () == 0 && pitEntry->GetOutgoing ().size () == 0;
 
@@ -382,7 +382,7 @@
 
       // ?? not sure if we need to do that ?? ...
       
-      // pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW);
+      // pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, NdnFibFaceMetric::NDN_FIB_YELLOW);
     }
   else
     if (!isNew && !isRetransmitted)
@@ -394,10 +394,10 @@
 }
 
 void
-CcnxForwardingStrategy::PropagateInterest (const Ptr<CcnxFace> &incomingFace,
-                                           Ptr<CcnxInterestHeader> header,
+NdnForwardingStrategy::PropagateInterest (const Ptr<NdnFace> &incomingFace,
+                                           Ptr<NdnInterestHeader> header,
                                            const Ptr<const Packet> &packet,
-                                           Ptr<CcnxPitEntry> pitEntry)
+                                           Ptr<NdnPitEntry> pitEntry)
 {
   bool isRetransmitted = m_detectRetransmissions && // a small guard
                          DetectRetransmittedInterest (incomingFace, pitEntry);  
@@ -427,11 +427,11 @@
 }
 
 bool
-CcnxForwardingStrategy::WillSendOutInterest (const Ptr<CcnxFace> &outgoingFace,
-                                             Ptr<CcnxInterestHeader> header,
-                                             Ptr<CcnxPitEntry> pitEntry)
+NdnForwardingStrategy::WillSendOutInterest (const Ptr<NdnFace> &outgoingFace,
+                                             Ptr<NdnInterestHeader> header,
+                                             Ptr<NdnPitEntry> pitEntry)
 {
-  CcnxPitEntryOutgoingFaceContainer::type::iterator outgoing =
+  NdnPitEntryOutgoingFaceContainer::type::iterator outgoing =
     pitEntry->GetOutgoing ().find (outgoingFace);
       
   if (outgoing != pitEntry->GetOutgoing ().end () &&
@@ -451,31 +451,31 @@
 }
 
 void
-CcnxForwardingStrategy::DidSendOutInterest (const Ptr<CcnxFace> &outgoingFace,
-                                            Ptr<CcnxInterestHeader> header,
+NdnForwardingStrategy::DidSendOutInterest (const Ptr<NdnFace> &outgoingFace,
+                                            Ptr<NdnInterestHeader> header,
                                             const Ptr<const Packet> &packet,
-                                            Ptr<CcnxPitEntry> pitEntry)
+                                            Ptr<NdnPitEntry> pitEntry)
 {
   m_outInterests (header, outgoingFace);
 }
 
 void
-CcnxForwardingStrategy::DidSendOutData (const Ptr<CcnxFace> &face,
-                                        Ptr<const CcnxContentObjectHeader> header,
+NdnForwardingStrategy::DidSendOutData (const Ptr<NdnFace> &face,
+                                        Ptr<const NdnContentObjectHeader> header,
                                         Ptr<const Packet> payload,
                                         const Ptr<const Packet> &packet)
 {
 }
 
 void
-CcnxForwardingStrategy::WillErasePendingInterest (Ptr<CcnxPitEntry> pitEntry)
+NdnForwardingStrategy::WillErasePendingInterest (Ptr<NdnPitEntry> pitEntry)
 {
   // do nothing for now. may be need to do some logging
 }
 
 
 void
-CcnxForwardingStrategy::RemoveFace (Ptr<CcnxFace> face)
+NdnForwardingStrategy::RemoveFace (Ptr<NdnFace> face)
 {
   // do nothing here
 }
diff --git a/model/forwarding-strategy/ndn-forwarding-strategy.h b/model/forwarding-strategy/ndn-forwarding-strategy.h
new file mode 100644
index 0000000..c2fa296
--- /dev/null
+++ b/model/forwarding-strategy/ndn-forwarding-strategy.h
@@ -0,0 +1,235 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2011 University of California, Los Angeles
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation;
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * Author:  Alexander Afanasyev <alexander.afanasyev@ucla.edu>
+ *          Ilya Moiseenko <iliamo@cs.ucla.edu>
+ */
+#ifndef NDN_FORWARDING_STRATEGY_H
+#define NDN_FORWARDING_STRATEGY_H
+
+#include "ns3/packet.h"
+#include "ns3/callback.h"
+#include "ns3/object.h"
+#include "ns3/traced-callback.h"
+
+namespace ns3 {
+
+class NdnFace;
+class NdnInterestHeader;
+class NdnContentObjectHeader;
+class NdnPit;
+class NdnPitEntry;
+class NdnFibFaceMetric;
+class NdnFib;
+class NdnContentStore;
+
+/**
+ * \ingroup ndn
+ * \brief Abstract base class for Ndn forwarding strategies
+ */
+class NdnForwardingStrategy :
+    public Object
+{
+public:
+  static TypeId GetTypeId (void);
+
+  /**
+   * @brief Default constructor
+   */
+  NdnForwardingStrategy ();
+  virtual ~NdnForwardingStrategy ();
+
+  /**
+   * \brief Actual processing of incoming Ndn interests. Note, interests do not have payload
+   * 
+   * Processing Interest packets
+   * @param face    incoming face
+   * @param header  deserialized Interest header
+   * @param packet  original packet
+   */
+  virtual void
+  OnInterest (const Ptr<NdnFace> &face,
+              Ptr<NdnInterestHeader> &header,
+              const Ptr<const Packet> &p);
+
+  /**
+   * \brief Actual processing of incoming Ndn content objects
+   * 
+   * Processing ContentObject packets
+   * @param face    incoming face
+   * @param header  deserialized ContentObject header
+   * @param payload data packet payload
+   * @param packet  original packet
+   */
+  virtual void
+  OnData (const Ptr<NdnFace> &face,
+          Ptr<NdnContentObjectHeader> &header,
+          Ptr<Packet> &payload,
+          const Ptr<const Packet> &packet);
+
+  virtual void
+  WillErasePendingInterest (Ptr<NdnPitEntry> pitEntry);
+
+  virtual void
+  RemoveFace (Ptr<NdnFace> face);
+  
+protected:
+  // events
+  virtual void
+  DidReceiveDuplicateInterest (const Ptr<NdnFace> &face,
+                               Ptr<NdnInterestHeader> &header,
+                               const Ptr<const Packet> &packet,
+                               Ptr<NdnPitEntry> pitEntry);
+
+  virtual void
+  DidExhaustForwardingOptions (const Ptr<NdnFace> &incomingFace,
+                               Ptr<NdnInterestHeader> header,
+                               const Ptr<const Packet> &packet,
+                               Ptr<NdnPitEntry> pitEntry);
+
+  virtual void
+  FailedToCreatePitEntry (const Ptr<NdnFace> &incomingFace,
+                          Ptr<NdnInterestHeader> header,
+                          const Ptr<const Packet> &packet);
+  
+  virtual void
+  DidCreatePitEntry (const Ptr<NdnFace> &incomingFace,
+                     Ptr<NdnInterestHeader> header,
+                     const Ptr<const Packet> &packet,
+                     Ptr<NdnPitEntry> pitEntry);
+
+  virtual bool
+  DetectRetransmittedInterest (const Ptr<NdnFace> &incomingFace,
+                               Ptr<NdnPitEntry> pitEntry);
+
+  // makes sense only for data received from network
+  // When Interest is satisfied from the cache, incoming face is 0
+  virtual void
+  WillSatisfyPendingInterest (const Ptr<NdnFace> &incomingFace,
+                              Ptr<NdnPitEntry> pitEntry);
+
+  // for data received both from network and cache
+  virtual void
+  SatisfyPendingInterest (const Ptr<NdnFace> &incomingFace, // 0 allowed (from cache)
+                          Ptr<const NdnContentObjectHeader> header,
+                          Ptr<const Packet> payload,
+                          const Ptr<const Packet> &packet,
+                          Ptr<NdnPitEntry> pitEntry);
+
+  virtual void
+  DidSendOutData (const Ptr<NdnFace> &face,
+                  Ptr<const NdnContentObjectHeader> header,
+                  Ptr<const Packet> payload,
+                  const Ptr<const Packet> &packet);
+  
+  virtual void
+  DidReceiveUnsolicitedData (const Ptr<NdnFace> &incomingFace,
+                             Ptr<const NdnContentObjectHeader> header,
+                             Ptr<const Packet> payload);
+  
+  virtual bool
+  ShouldSuppressIncomingInterest (const Ptr<NdnFace> &incomingFace,
+                                  Ptr<NdnPitEntry> pitEntry);
+
+  /**
+   * @brief Event fired before actually sending out an interest
+   *
+   * If event returns false, then there is some kind of a problem (e.g., per-face limit reached)
+   */
+  virtual bool
+  WillSendOutInterest (const Ptr<NdnFace> &outgoingFace,
+                       Ptr<NdnInterestHeader> header,
+                       Ptr<NdnPitEntry> pitEntry);
+
+  /**
+   * @brief Event fired just after sending out an interest
+   */
+  virtual void
+  DidSendOutInterest (const Ptr<NdnFace> &outgoingFace,
+                      Ptr<NdnInterestHeader> header,
+                      const Ptr<const Packet> &packet,
+                      Ptr<NdnPitEntry> pitEntry);
+
+  virtual void
+  PropagateInterest (const Ptr<NdnFace> &incomingFace,
+                     Ptr<NdnInterestHeader> header,
+                     const Ptr<const Packet> &packet,
+                     Ptr<NdnPitEntry> pitEntry);
+  
+  /**
+   * @brief Base method to propagate the interest according to the forwarding strategy
+   *
+   * @param pitEntry      Reference to PIT entry (reference to corresponding FIB entry inside)
+   * @param incomingFace  Incoming face
+   * @param header        NdnInterestHeader
+   * @param packet        Original Interest packet
+   * @param sendCallback  Send callback
+   *
+   * @return true if interest was successfully propagated, false if all options have failed
+   */
+  virtual bool
+  DoPropagateInterest (const Ptr<NdnFace> &incomingFace,
+                       Ptr<NdnInterestHeader> header,
+                       const Ptr<const Packet> &packet,
+                       Ptr<NdnPitEntry> pitEntry) = 0;
+
+
+  // virtual void
+  // OnDataDelayed (Ptr<const NdnContentObjectHeader> header,
+  //                Ptr<const Packet> payload,
+  //                const Ptr<const Packet> &packet);
+  
+protected:
+  // inherited from Object class                                                                                                                                                        
+  virtual void NotifyNewAggregate (); ///< @brief Even when object is aggregated to another Object
+  virtual void DoDispose (); ///< @brief Do cleanup
+  
+protected:  
+  Ptr<NdnPit> m_pit; ///< \brief Reference to PIT to which this forwarding strategy is associated
+  Ptr<NdnFib> m_fib; ///< \brief FIB  
+  Ptr<NdnContentStore> m_contentStore; ///< \brief Content store (for caching purposes only)
+
+  bool m_cacheUnsolicitedData;
+  bool m_detectRetransmissions;
+  
+  TracedCallback<Ptr<const NdnInterestHeader>,
+                 Ptr<const NdnFace> > m_outInterests; ///< @brief Transmitted interests trace
+
+  TracedCallback<Ptr<const NdnInterestHeader>,
+                 Ptr<const NdnFace> > m_inInterests; ///< @brief trace of incoming Interests
+
+  TracedCallback<Ptr<const NdnInterestHeader>,
+                 Ptr<const NdnFace> > m_dropInterests; ///< @brief trace of dropped Interests
+  
+  ////////////////////////////////////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////
+
+  TracedCallback<Ptr<const NdnContentObjectHeader>, Ptr<const Packet>,
+                 bool /*from cache*/,
+                 Ptr<const NdnFace> > m_outData; ///< @brief trace of outgoing Data
+
+  TracedCallback<Ptr<const NdnContentObjectHeader>, Ptr<const Packet>,
+                 Ptr<const NdnFace> > m_inData; ///< @brief trace of incoming Data
+
+  TracedCallback<Ptr<const NdnContentObjectHeader>, Ptr<const Packet>,
+                  Ptr<const NdnFace> > m_dropData;  ///< @brief trace of dropped Data
+};
+
+} //namespace ns3
+
+#endif /* NDN_FORWARDING_STRATEGY_H */
diff --git a/model/forwarding-strategy/smart-flooding.cc b/model/forwarding-strategy/smart-flooding.cc
index a7d0167..58a56a2 100644
--- a/model/forwarding-strategy/smart-flooding.cc
+++ b/model/forwarding-strategy/smart-flooding.cc
@@ -20,9 +20,9 @@
 
 #include "smart-flooding.h"
 
-#include "ns3/ccnx-interest-header.h"
-#include "ns3/ccnx-pit.h"
-#include "ns3/ccnx-pit-entry.h"
+#include "ns3/ndn-interest-header.h"
+#include "ns3/ndn-pit.h"
+#include "ns3/ndn-pit-entry.h"
 
 #include "ns3/assert.h"
 #include "ns3/log.h"
@@ -39,7 +39,7 @@
 
 namespace ns3 {
 
-using namespace __ccnx_private;
+using namespace __ndn_private;
 
 namespace ndnSIM {
 
@@ -49,7 +49,7 @@
 SmartFlooding::GetTypeId (void)
 {
   static TypeId tid = TypeId ("ns3::ndnSIM::SmartFloodingy")
-    .SetGroupName ("Ccnx")
+    .SetGroupName ("Ndn")
     .SetParent <GreenYellowRed> ()
     .AddConstructor <SmartFlooding> ()
     ;
@@ -61,10 +61,10 @@
 }
 
 bool
-SmartFlooding::DoPropagateInterest (const Ptr<CcnxFace> &incomingFace,
-                                    Ptr<CcnxInterestHeader> header,
+SmartFlooding::DoPropagateInterest (const Ptr<NdnFace> &incomingFace,
+                                    Ptr<NdnInterestHeader> header,
                                     const Ptr<const Packet> &packet,
-                                    Ptr<CcnxPitEntry> pitEntry)
+                                    Ptr<NdnPitEntry> pitEntry)
 {
   NS_LOG_FUNCTION (this);
 
@@ -75,10 +75,10 @@
 
   int propagatedCount = 0;
 
-  BOOST_FOREACH (const CcnxFibFaceMetric &metricFace, pitEntry->GetFibEntry ()->m_faces.get<i_metric> ())
+  BOOST_FOREACH (const NdnFibFaceMetric &metricFace, pitEntry->GetFibEntry ()->m_faces.get<i_metric> ())
     {
       NS_LOG_DEBUG ("Trying " << boost::cref(metricFace));
-      if (metricFace.m_status == CcnxFibFaceMetric::NDN_FIB_RED) // all non-read faces are in the front of the list
+      if (metricFace.m_status == NdnFibFaceMetric::NDN_FIB_RED) // all non-read faces are in the front of the list
         break;
       
       if (metricFace.m_face == incomingFace) 
diff --git a/model/forwarding-strategy/smart-flooding.h b/model/forwarding-strategy/smart-flooding.h
index 840ce6a..c939015 100644
--- a/model/forwarding-strategy/smart-flooding.h
+++ b/model/forwarding-strategy/smart-flooding.h
@@ -42,10 +42,10 @@
 
   // inherited
   virtual bool
-  DoPropagateInterest (const Ptr<CcnxFace> &incomingFace,
-                       Ptr<CcnxInterestHeader> header,
+  DoPropagateInterest (const Ptr<NdnFace> &incomingFace,
+                       Ptr<NdnInterestHeader> header,
                        const Ptr<const Packet> &packet,
-                       Ptr<CcnxPitEntry> pitEntry);
+                       Ptr<NdnPitEntry> pitEntry);
 
 private:
   typedef GreenYellowRed super;
diff --git a/model/ndn-app-face.cc b/model/ndn-app-face.cc
new file mode 100644
index 0000000..55cee9b
--- /dev/null
+++ b/model/ndn-app-face.cc
@@ -0,0 +1,145 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2011 University of California, Los Angeles
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation;
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * Author:  Alexander Afanasyev <alexander.afanasyev@ucla.edu>
+ *          Ilya Moiseenko <iliamo@cs.ucla.edu>
+ *
+ */
+
+#include "ndn-app-face.h"
+
+#include "ns3/log.h"
+#include "ns3/packet.h"
+#include "ns3/node.h"
+#include "ns3/assert.h"
+#include "ns3/simulator.h"
+
+#include "ns3/ndn-header-helper.h"
+#include "ns3/ndn-app.h"
+
+#include "ndn-interest-header.h"
+#include "ndn-content-object-header.h"
+
+NS_LOG_COMPONENT_DEFINE ("NdnAppFace");
+
+namespace ns3 
+{
+
+NS_OBJECT_ENSURE_REGISTERED (NdnAppFace);
+
+TypeId
+NdnAppFace::GetTypeId ()
+{
+  static TypeId tid = TypeId ("ns3::NdnAppFace")
+    .SetParent<NdnFace> ()
+    .SetGroupName ("Ndn")
+    ;
+  return tid;
+}
+
+NdnAppFace::NdnAppFace (Ptr<NdnApp> app)
+  : NdnFace (app->GetNode ())
+  , m_app (app)
+{
+  NS_LOG_FUNCTION (this << app);
+  
+  NS_ASSERT (m_app != 0);
+}
+
+NdnAppFace::~NdnAppFace ()
+{
+  NS_LOG_FUNCTION_NOARGS ();
+}
+
+NdnAppFace::NdnAppFace ()
+  : NdnFace (0)
+{
+}
+
+NdnAppFace::NdnAppFace (const NdnAppFace &)
+  : NdnFace (0)
+{
+}
+
+NdnAppFace& NdnAppFace::operator= (const NdnAppFace &)
+{
+  return *((NdnAppFace*)0);
+}
+
+
+void
+NdnAppFace::RegisterProtocolHandler (ProtocolHandler handler)
+{
+  NS_LOG_FUNCTION (this);
+
+  NdnFace::RegisterProtocolHandler (handler);
+
+  m_app->RegisterProtocolHandler (MakeCallback (&NdnFace::Receive, this));
+}
+
+bool
+NdnAppFace::SendImpl (Ptr<Packet> p)
+{
+  NS_LOG_FUNCTION (this << p);
+
+  try
+    {
+      NdnHeaderHelper::Type type = NdnHeaderHelper::GetNdnHeaderType (p);
+      switch (type)
+        {
+        case NdnHeaderHelper::INTEREST:
+          {
+            Ptr<NdnInterestHeader> header = Create<NdnInterestHeader> ();
+            p->RemoveHeader (*header);
+
+            if (header->GetNack () > 0)
+              m_app->OnNack (header, p);
+            else
+              m_app->OnInterest (header, p);
+          
+            break;
+          }
+        case NdnHeaderHelper::CONTENT_OBJECT:
+          {
+            static NdnContentObjectTail tail;
+            Ptr<NdnContentObjectHeader> header = Create<NdnContentObjectHeader> ();
+            p->RemoveHeader (*header);
+            p->RemoveTrailer (tail);
+            m_app->OnContentObject (header, p/*payload*/);
+          
+            break;
+          }
+        }
+      
+      return true;
+    }
+  catch (NdnUnknownHeaderException)
+    {
+      NS_LOG_ERROR ("Unknown header type");
+      return false;
+    }
+}
+
+std::ostream&
+NdnAppFace::Print (std::ostream& os) const
+{
+  os << "dev=local(" << GetId() << ")";
+  return os;
+}
+
+}; // namespace ns3
+
diff --git a/model/ccnx-app-face.h b/model/ndn-app-face.h
similarity index 67%
rename from model/ccnx-app-face.h
rename to model/ndn-app-face.h
index 967ee13..9a9d2c5 100644
--- a/model/ccnx-app-face.h
+++ b/model/ndn-app-face.h
@@ -19,31 +19,31 @@
                 Ilya Moiseenko <iliamo@cs.ucla.edu>
  */
 
-#ifndef CCNX_APP_FACE_H
-#define CCNX_APP_FACE_H
+#ifndef NDN_APP_FACE_H
+#define NDN_APP_FACE_H
 
-#include "ccnx-face.h"
+#include "ndn-face.h"
 #include "ns3/traced-callback.h"
 
 namespace ns3 
 {
 
-class CcnxInterestHeader;
-class CcnxContentObjectHeader;
+class NdnInterestHeader;
+class NdnContentObjectHeader;
 class Packet;
-class CcnxApp;
+class NdnApp;
 
 /**
- * \ingroup ccnx-face
- * \brief Implementation of application CCNx face
+ * \ingroup ndn-face
+ * \brief Implementation of application Ndn face
  *
- * This class defines basic functionality of CCNx face. Face is core
+ * This class defines basic functionality of Ndn face. Face is core
  * component responsible for actual delivery of data packet to and
- * from CCNx stack
+ * from Ndn stack
  *
- * \see CcnxAppFace, CcnxNetDeviceFace, CcnxIpv4Face, CcnxUdpFace
+ * \see NdnAppFace, NdnNetDeviceFace, NdnIpv4Face, NdnUdpFace
  */
-class CcnxAppFace  : public CcnxFace
+class NdnAppFace  : public NdnFace
 {
 public:
   static TypeId
@@ -52,11 +52,11 @@
   /**
    * \brief Default constructor
    */
-  CcnxAppFace (Ptr<CcnxApp> app);
-  virtual ~CcnxAppFace();
+  NdnAppFace (Ptr<NdnApp> app);
+  virtual ~NdnAppFace();
   
   ////////////////////////////////////////////////////////////////////
-  // methods overloaded from CcnxFace
+  // methods overloaded from NdnFace
   virtual void
   RegisterProtocolHandler (ProtocolHandler handler);
 
@@ -70,14 +70,14 @@
   ////////////////////////////////////////////////////////////////////
  
 private:
-  CcnxAppFace ();
-  CcnxAppFace (const CcnxAppFace &); ///< \brief Disabled copy constructor
-  CcnxAppFace& operator= (const CcnxAppFace &); ///< \brief Disabled copy operator
+  NdnAppFace ();
+  NdnAppFace (const NdnAppFace &); ///< \brief Disabled copy constructor
+  NdnAppFace& operator= (const NdnAppFace &); ///< \brief Disabled copy operator
 
 private:
-  Ptr<CcnxApp> m_app;
+  Ptr<NdnApp> m_app;
 };
 
 } // namespace ns3
 
-#endif // CCNX_APP_FACE_H
+#endif // NDN_APP_FACE_H
diff --git a/model/ccnx-content-object-header.cc b/model/ndn-content-object-header.cc
similarity index 83%
rename from model/ccnx-content-object-header.cc
rename to model/ndn-content-object-header.cc
index f11296c..2a480d8 100644
--- a/model/ccnx-content-object-header.cc
+++ b/model/ndn-content-object-header.cc
@@ -1,4 +1,4 @@
-/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
+/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil -*- */
 /*
  * Copyright (c) 2011 University of California, Los Angeles
  *
@@ -19,11 +19,11 @@
  *         Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#include "ccnx-content-object-header.h"
+#include "ndn-content-object-header.h"
 
 #include "ns3/log.h"
-#include "../helper/ccnx-encoding-helper.h"
-#include "../helper/ccnx-decoding-helper.h"
+#include "../helper/ndn-encoding-helper.h"
+#include "../helper/ndn-decoding-helper.h"
 
 #include "../helper/ccnb-parser/ccnb-parser-common.h"
 #include "../helper/ccnb-parser/visitors/ccnb-parser-void-depth-first-visitor.h"
@@ -39,56 +39,56 @@
 
 #include <boost/foreach.hpp>
 
-NS_LOG_COMPONENT_DEFINE ("CcnxContentObjectHeader");
+NS_LOG_COMPONENT_DEFINE ("NdnContentObjectHeader");
 
 using namespace ns3::CcnbParser;
 
 namespace ns3
 {
 
-const std::string CcnxContentObjectHeader::Signature::DefaultDigestAlgorithm = "2.16.840.1.101.3.4.2.1";
+const std::string NdnContentObjectHeader::Signature::DefaultDigestAlgorithm = "2.16.840.1.101.3.4.2.1";
 
-NS_OBJECT_ENSURE_REGISTERED (CcnxContentObjectHeader);
-NS_OBJECT_ENSURE_REGISTERED (CcnxContentObjectTail);
+NS_OBJECT_ENSURE_REGISTERED (NdnContentObjectHeader);
+NS_OBJECT_ENSURE_REGISTERED (NdnContentObjectTail);
 
 TypeId
-CcnxContentObjectHeader::GetTypeId (void)
+NdnContentObjectHeader::GetTypeId (void)
 {
-  static TypeId tid = TypeId ("ns3::CcnxContentObjectHeader")
-    .SetGroupName ("Ccnx")
+  static TypeId tid = TypeId ("ns3::NdnContentObjectHeader")
+    .SetGroupName ("ndn")
     .SetParent<Header> ()
-    .AddConstructor<CcnxContentObjectHeader> ()
+    .AddConstructor<NdnContentObjectHeader> ()
     ;
   return tid;
 }
 
-CcnxContentObjectHeader::CcnxContentObjectHeader ()
+NdnContentObjectHeader::NdnContentObjectHeader ()
 {
 }
 
 void
-CcnxContentObjectHeader::SetName (const Ptr<CcnxNameComponents> &name)
+NdnContentObjectHeader::SetName (const Ptr<NdnNameComponents> &name)
 {
   m_name = name;
 }
 
-const CcnxNameComponents&
-CcnxContentObjectHeader::GetName () const
+const NdnNameComponents&
+NdnContentObjectHeader::GetName () const
 {
-  if (m_name==0) throw CcnxContentObjectHeaderException();
+  if (m_name==0) throw NdnContentObjectHeaderException();
   return *m_name;
 }
 
-Ptr<const CcnxNameComponents>
-CcnxContentObjectHeader::GetNamePtr () const
+Ptr<const NdnNameComponents>
+NdnContentObjectHeader::GetNamePtr () const
 {
   return m_name;
 }
 
-#define CCNB CcnxEncodingHelper // just to simplify writing
+#define CCNB NdnEncodingHelper // just to simplify writing
 
 void
-CcnxContentObjectHeader::Serialize (Buffer::Iterator start) const
+NdnContentObjectHeader::Serialize (Buffer::Iterator start) const
 {
   size_t written = 0;
   written += CCNB::AppendBlockHeader (start, CCN_DTAG_ContentObject, CcnbParser::CCN_DTAG); // <ContentObject>
@@ -159,11 +159,11 @@
   written += CCNB::AppendBlockHeader (start, CCN_DTAG_Content, CCN_DTAG); // <Content>
 
   // there are no closing tags !!!
-  // The closing tag is handled by CcnxContentObjectTail
+  // The closing tag is handled by NdnContentObjectTail
 }
 
 uint32_t
-CcnxContentObjectHeader::GetSerializedSize () const
+NdnContentObjectHeader::GetSerializedSize () const
 {
   size_t written = 0;
   written += CCNB::EstimateBlockHeader (CCN_DTAG_ContentObject); // <ContentObject>
@@ -232,7 +232,7 @@
   written += CCNB::EstimateBlockHeader (CCN_DTAG_Content); // <Content>
 
   // there are no closing tags !!!
-  // The closing tag is handled by CcnxContentObjectTail
+  // The closing tag is handled by NdnContentObjectTail
   return written;
 }
 #undef CCNB
@@ -240,7 +240,7 @@
 class ContentObjectVisitor : public VoidDepthFirstVisitor
 {
 public:
-  virtual void visit (Dtag &n, boost::any param/*should be CcnxContentObjectHeader* */)
+  virtual void visit (Dtag &n, boost::any param/*should be NdnContentObjectHeader* */)
   {
     // uint32_t n.m_dtag;
     // std::list<Ptr<Block> > n.m_nestedBlocks;
@@ -251,7 +251,7 @@
     static Uint32tBlobVisitor uint32tBlobVisitor;
     static ContentTypeVisitor contentTypeVisitor;
   
-    CcnxContentObjectHeader &contentObject = *(boost::any_cast<CcnxContentObjectHeader*> (param));
+    NdnContentObjectHeader &contentObject = *(boost::any_cast<NdnContentObjectHeader*> (param));
   
     switch (n.m_dtag)
       {
@@ -265,7 +265,7 @@
       case CCN_DTAG_Name:
         {
           // process name components
-          Ptr<CcnxNameComponents> name = Create<CcnxNameComponents> ();
+          Ptr<NdnNameComponents> name = Create<NdnNameComponents> ();
         
           BOOST_FOREACH (Ptr<Block> block, n.m_nestedTags)
             {
@@ -337,7 +337,7 @@
           throw CcnbDecodingException ();
 
         contentObject.GetSignedInfo ().SetContentType
-          (static_cast<CcnxContentObjectHeader::ContentType>
+          (static_cast<NdnContentObjectHeader::ContentType>
            (boost::any_cast<uint32_t> ((*n.m_nestedTags.begin())->accept
                                        (contentTypeVisitor))));
         break;
@@ -372,7 +372,7 @@
             throw CcnbDecodingException ();
 
           // process name components
-          Ptr<CcnxNameComponents> name = Create<CcnxNameComponents> ();
+          Ptr<NdnNameComponents> name = Create<NdnNameComponents> ();
         
           BOOST_FOREACH (Ptr<Block> block, nameTag->m_nestedTags)
             {
@@ -394,7 +394,7 @@
 };
 
 uint32_t
-CcnxContentObjectHeader::Deserialize (Buffer::Iterator start)
+NdnContentObjectHeader::Deserialize (Buffer::Iterator start)
 {
   static ContentObjectVisitor contentObjectVisitor;
 
@@ -406,13 +406,13 @@
 }
   
 TypeId
-CcnxContentObjectHeader::GetInstanceTypeId (void) const
+NdnContentObjectHeader::GetInstanceTypeId (void) const
 {
   return GetTypeId ();
 }
   
 void
-CcnxContentObjectHeader::Print (std::ostream &os) const
+NdnContentObjectHeader::Print (std::ostream &os) const
 {
   os << "D: " << GetName ();
   // os << "<ContentObject><Name>" << GetName () << "</Name><Content>";
@@ -420,40 +420,40 @@
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-CcnxContentObjectTail::CcnxContentObjectTail ()
+NdnContentObjectTail::NdnContentObjectTail ()
 {
 }
 
 TypeId
-CcnxContentObjectTail::GetTypeId (void)
+NdnContentObjectTail::GetTypeId (void)
 {
-  static TypeId tid = TypeId ("ns3::CcnxContentObjectTail")
+  static TypeId tid = TypeId ("ns3::NdnContentObjectTail")
     .SetParent<Trailer> ()
-    .AddConstructor<CcnxContentObjectTail> ()
+    .AddConstructor<NdnContentObjectTail> ()
     ;
   return tid;
 }
 
 TypeId
-CcnxContentObjectTail::GetInstanceTypeId (void) const
+NdnContentObjectTail::GetInstanceTypeId (void) const
 {
   return GetTypeId ();
 }
 
 void
-CcnxContentObjectTail::Print (std::ostream &os) const
+NdnContentObjectTail::Print (std::ostream &os) const
 {
   os << "</Content></ContentObject>";
 }
 
 uint32_t
-CcnxContentObjectTail::GetSerializedSize (void) const
+NdnContentObjectTail::GetSerializedSize (void) const
 {
   return 2;
 }
 
 void
-CcnxContentObjectTail::Serialize (Buffer::Iterator start) const
+NdnContentObjectTail::Serialize (Buffer::Iterator start) const
 {
   Buffer::Iterator i = start;
   i.Prev (2); // Trailer interface requires us to go backwards
@@ -463,7 +463,7 @@
 }
 
 uint32_t
-CcnxContentObjectTail::Deserialize (Buffer::Iterator start)
+NdnContentObjectTail::Deserialize (Buffer::Iterator start)
 {
   Buffer::Iterator i = start;
   i.Prev (2); // Trailer interface requires us to go backwards
@@ -481,7 +481,7 @@
 ///////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////
 
-CcnxContentObjectHeader::SignedInfo::SignedInfo ()
+NdnContentObjectHeader::SignedInfo::SignedInfo ()
   : m_publisherPublicKeyDigest (0)
   // ,  m_timestamp
   , m_type (DATA)
@@ -492,61 +492,61 @@
 }
 
 void
-CcnxContentObjectHeader::SignedInfo::SetPublisherPublicKeyDigest (uint32_t digest)
+NdnContentObjectHeader::SignedInfo::SetPublisherPublicKeyDigest (uint32_t digest)
 {
   m_publisherPublicKeyDigest = digest;
 }
 
 uint32_t
-CcnxContentObjectHeader::SignedInfo::GetPublisherPublicKeyDigest () const
+NdnContentObjectHeader::SignedInfo::GetPublisherPublicKeyDigest () const
 {
   return m_publisherPublicKeyDigest;
 }
 
 void
-CcnxContentObjectHeader::SignedInfo::SetTimestamp (const Time &timestamp)
+NdnContentObjectHeader::SignedInfo::SetTimestamp (const Time &timestamp)
 {
   m_timestamp = timestamp;
 }
 
 Time
-CcnxContentObjectHeader::SignedInfo::GetTimestamp () const
+NdnContentObjectHeader::SignedInfo::GetTimestamp () const
 {
   return m_timestamp;
 }
 
 void
-CcnxContentObjectHeader::SignedInfo::SetContentType (CcnxContentObjectHeader::ContentType type)
+NdnContentObjectHeader::SignedInfo::SetContentType (NdnContentObjectHeader::ContentType type)
 {
   m_type = type;
 }
 
-CcnxContentObjectHeader::ContentType
-CcnxContentObjectHeader::SignedInfo::GetContentType () const
+NdnContentObjectHeader::ContentType
+NdnContentObjectHeader::SignedInfo::GetContentType () const
 {
   return m_type;
 }
 
 void
-CcnxContentObjectHeader::SignedInfo::SetFreshness (const Time &freshness)
+NdnContentObjectHeader::SignedInfo::SetFreshness (const Time &freshness)
 {
   m_freshness = freshness;
 }
 
 Time
-CcnxContentObjectHeader::SignedInfo::GetFreshness () const
+NdnContentObjectHeader::SignedInfo::GetFreshness () const
 {
   return m_freshness;
 }
 
 void
-CcnxContentObjectHeader::SignedInfo::SetKeyLocator (Ptr<const CcnxNameComponents> keyLocator)
+NdnContentObjectHeader::SignedInfo::SetKeyLocator (Ptr<const NdnNameComponents> keyLocator)
 {
   m_keyLocator = keyLocator;
 }
 
-Ptr<const CcnxNameComponents>
-CcnxContentObjectHeader::SignedInfo::GetKeyLocator () const
+Ptr<const NdnNameComponents>
+NdnContentObjectHeader::SignedInfo::GetKeyLocator () const
 {
   return m_keyLocator;
 }
diff --git a/model/ccnx-content-object-header.h b/model/ndn-content-object-header.h
similarity index 85%
rename from model/ccnx-content-object-header.h
rename to model/ndn-content-object-header.h
index c563f70..0266cc9 100644
--- a/model/ccnx-content-object-header.h
+++ b/model/ndn-content-object-header.h
@@ -19,8 +19,8 @@
  *         Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef _CCNX_CONTENT_OBJECT_HEADER_H_
-#define _CCNX_CONTENT_OBJECT_HEADER_H_
+#ifndef _NDN_CONTENT_OBJECT_HEADER_H_
+#define _NDN_CONTENT_OBJECT_HEADER_H_
 
 #include "ns3/integer.h"
 #include "ns3/header.h"
@@ -32,13 +32,13 @@
 #include <vector>
 #include <list>
 
-#include "ccnx-name-components.h"
+#include "ndn-name-components.h"
 
 namespace ns3
 {
 
 /**
- * CCNx XML definition of ContentObject
+ * Ndn XML definition of ContentObject
  * 
  * Only few important fields are actually implemented in the simulation
  *
@@ -51,7 +51,7 @@
  * "<ContentObject><Signature>..</Signature><Name>...</Name><SignedInfo>...</SignedInfo><Content>"
  * 
  */
-class CcnxContentObjectHeader : public SimpleRefCount<CcnxContentObjectHeader,Header>
+class NdnContentObjectHeader : public SimpleRefCount<NdnContentObjectHeader,Header>
 {
 public:
   ////////////////////////////////////////////////////////////////////////////  
@@ -195,14 +195,14 @@
      * Note that only <KeyName> option for the key locator is supported
      */
     void
-    SetKeyLocator (Ptr<const CcnxNameComponents> keyLocator);
+    SetKeyLocator (Ptr<const NdnNameComponents> keyLocator);
 
     /**
      * @brief Get key locator
      *
      * Note that only <KeyName> option for the key locator is supported
      */
-    Ptr<const CcnxNameComponents>
+    Ptr<const NdnNameComponents>
     GetKeyLocator () const;
     
   private:
@@ -211,7 +211,7 @@
     ContentType m_type;
     Time m_freshness;
     // FinalBlockID
-    Ptr<const CcnxNameComponents> m_keyLocator; // support only <KeyName> option for KeyLocator
+    Ptr<const NdnNameComponents> m_keyLocator; // support only <KeyName> option for KeyLocator
   };
 
   ////////////////////////////////////////////////////////////////////////////  
@@ -226,26 +226,26 @@
    *
    * Creates a null header
    **/
-  CcnxContentObjectHeader ();
+  NdnContentObjectHeader ();
 
   /**
    * \brief Set content object name
    *
-   * Sets name of the content object. For example, SetName( CcnxNameComponents("prefix")("postfix") );
+   * Sets name of the content object. For example, SetName( NdnNameComponents("prefix")("postfix") );
    **/
   void
-  SetName (const Ptr<CcnxNameComponents> &name);
+  SetName (const Ptr<NdnNameComponents> &name);
 
   /**
    * @brief Get name of the content object
    */
-  const CcnxNameComponents&
+  const NdnNameComponents&
   GetName () const;
 
   /**
    * @brief Get smart pointer to the interest name (to avoid extra memory usage)
    */
-  Ptr<const CcnxNameComponents>
+  Ptr<const NdnNameComponents>
   GetNamePtr () const;
 
   /**
@@ -283,7 +283,7 @@
   
 private:
   Signature  m_signature;
-  Ptr<CcnxNameComponents> m_name;
+  Ptr<NdnNameComponents> m_name;
   SignedInfo m_signedInfo;
 };
 
@@ -291,10 +291,10 @@
  * ContentObjectTail should always be 2 bytes, representing two closing tags:
  * "</Content><ContentObject>"
  */
-class CcnxContentObjectTail : public Trailer
+class NdnContentObjectTail : public Trailer
 {
 public:
-  CcnxContentObjectTail ();
+  NdnContentObjectTail ();
   //////////////////////////////////////////////////////////////////
   
   static TypeId GetTypeId (void); ///< @brief Get TypeId
@@ -306,57 +306,57 @@
 };
 
 
-CcnxContentObjectHeader::Signature::Signature ()
+NdnContentObjectHeader::Signature::Signature ()
   : m_digestAlgorithm ("99.0")
   , m_signatureBits (0)
 {
 }
 
 const std::string &
-CcnxContentObjectHeader::Signature::GetDigestAlgorithm () const
+NdnContentObjectHeader::Signature::GetDigestAlgorithm () const
 {
   return m_digestAlgorithm;
 }
 
 void
-CcnxContentObjectHeader::Signature::SetDigestAlgorithm (const std::string &digestAlgorithm)
+NdnContentObjectHeader::Signature::SetDigestAlgorithm (const std::string &digestAlgorithm)
 {
   m_digestAlgorithm = digestAlgorithm;
 }
 
 uint32_t
-CcnxContentObjectHeader::Signature::GetSignatureBits () const
+NdnContentObjectHeader::Signature::GetSignatureBits () const
 {
   return m_signatureBits;
 }
 
 inline void
-CcnxContentObjectHeader::Signature::SetSignatureBits (uint32_t signature)
+NdnContentObjectHeader::Signature::SetSignatureBits (uint32_t signature)
 {
   m_signatureBits = signature;
 }
 
 
-CcnxContentObjectHeader::Signature &
-CcnxContentObjectHeader::GetSignature ()
+NdnContentObjectHeader::Signature &
+NdnContentObjectHeader::GetSignature ()
 {
   return m_signature;
 }
 
-const CcnxContentObjectHeader::Signature &
-CcnxContentObjectHeader::GetSignature () const
+const NdnContentObjectHeader::Signature &
+NdnContentObjectHeader::GetSignature () const
 {
   return m_signature;
 }
 
-CcnxContentObjectHeader::SignedInfo &
-CcnxContentObjectHeader::GetSignedInfo ()
+NdnContentObjectHeader::SignedInfo &
+NdnContentObjectHeader::GetSignedInfo ()
 {
   return m_signedInfo;
 }
 
-const CcnxContentObjectHeader::SignedInfo &
-CcnxContentObjectHeader::GetSignedInfo () const
+const NdnContentObjectHeader::SignedInfo &
+NdnContentObjectHeader::GetSignedInfo () const
 {
   return m_signedInfo;
 }
@@ -364,8 +364,8 @@
 /**
  * @brief Class for ContentObject parsing exception 
  */
-class CcnxContentObjectHeaderException {};
+class NdnContentObjectHeaderException {};
 
 } // namespace ns3
 
-#endif // _CCNX_CONTENT_OBJECT_HEADER_H_
+#endif // _NDN_CONTENT_OBJECT_HEADER_H_
diff --git a/model/ccnx-face.cc b/model/ndn-face.cc
similarity index 74%
rename from model/ccnx-face.cc
rename to model/ndn-face.cc
index ba9e4ec..316b1df 100644
--- a/model/ccnx-face.cc
+++ b/model/ndn-face.cc
@@ -19,7 +19,7 @@
  *
  */
 
-#include "ccnx-face.h"
+#include "ndn-face.h"
 
 #include "ns3/packet.h"
 #include "ns3/log.h"
@@ -35,64 +35,64 @@
 
 #include <boost/ref.hpp>
 
-NS_LOG_COMPONENT_DEFINE ("CcnxFace");
+NS_LOG_COMPONENT_DEFINE ("NdnFace");
 
 namespace ns3 {
 
-NS_OBJECT_ENSURE_REGISTERED (CcnxFace);
+NS_OBJECT_ENSURE_REGISTERED (NdnFace);
 
 TypeId
-CcnxFace::GetTypeId ()
+NdnFace::GetTypeId ()
 {
-  static TypeId tid = TypeId ("ns3::CcnxFace")
+  static TypeId tid = TypeId ("ns3::NdnFace")
     .SetParent<Object> ()
-    .SetGroupName ("Ccnx")
-    .AddAttribute ("Id", "Face id (unique integer for the CCNx stack on this node)",
+    .SetGroupName ("Ndn")
+    .AddAttribute ("Id", "Face id (unique integer for the Ndn stack on this node)",
                    TypeId::ATTR_GET, // allow only getting it.
                    UintegerValue (0),
-                   MakeUintegerAccessor (&CcnxFace::m_id),
+                   MakeUintegerAccessor (&NdnFace::m_id),
                    MakeUintegerChecker<uint32_t> ())
 
     .AddAttribute ("BucketMax", "Maximum size of leaky bucket",
                    DoubleValue (-1.0),
-                   MakeDoubleAccessor (&CcnxFace::m_bucketMax),
+                   MakeDoubleAccessor (&NdnFace::m_bucketMax),
                    MakeDoubleChecker<double> ())
     .AddAttribute ("BucketLeak", "Normalized bucket leak size",
                    DoubleValue (0.0),
-                   MakeDoubleAccessor (&CcnxFace::m_bucketLeak),
+                   MakeDoubleAccessor (&NdnFace::m_bucketLeak),
                    MakeDoubleChecker<double> ())
 
     .AddAttribute ("RandomizeLimitChecking", "Whether or not to randomize the limit checking procedure. false (persistent) by default",
                    BooleanValue (false),
-                   MakeBooleanAccessor (&CcnxFace::m_randomizeLimitChecking),
+                   MakeBooleanAccessor (&NdnFace::m_randomizeLimitChecking),
                    MakeBooleanChecker ())
                    
     // .AddAttribute ("MetricTagging", "Enable metric tagging (path-stretch calculation)",
     //                BooleanValue (false),
-    //                MakeBooleanAccessor (&CcnxFace::m_enableMetricTagging),
+    //                MakeBooleanAccessor (&NdnFace::m_enableMetricTagging),
     //                MakeBooleanChecker ())
 
-    .AddTraceSource ("CcnxTx", "Transmitted packet trace",
-                     MakeTraceSourceAccessor (&CcnxFace::m_ccnxTxTrace))
-    .AddTraceSource ("CcnxRx", "Received packet trace",
-                     MakeTraceSourceAccessor (&CcnxFace::m_ccnxRxTrace))
-    .AddTraceSource ("CcnxDrop", "Dropped packet trace",
-                     MakeTraceSourceAccessor (&CcnxFace::m_ccnxDropTrace))
+    .AddTraceSource ("NdnTx", "Transmitted packet trace",
+                     MakeTraceSourceAccessor (&NdnFace::m_ndnTxTrace))
+    .AddTraceSource ("NdnRx", "Received packet trace",
+                     MakeTraceSourceAccessor (&NdnFace::m_ndnRxTrace))
+    .AddTraceSource ("NdnDrop", "Dropped packet trace",
+                     MakeTraceSourceAccessor (&NdnFace::m_ndnDropTrace))
     ;
   return tid;
 }
 
 /** 
- * By default, Ccnx face are created in the "down" state
+ * By default, Ndn face are created in the "down" state
  *  with no IP addresses.  Before becoming useable, the user must 
- * invoke SetUp on them once an Ccnx address and mask have been set.
+ * invoke SetUp on them once an Ndn address and mask have been set.
  */
-CcnxFace::CcnxFace (Ptr<Node> node) 
+NdnFace::NdnFace (Ptr<Node> node) 
   : m_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_protocolHandler (MakeNullCallback<void,const Ptr<NdnFace>&,const Ptr<const Packet>&> ())
   , m_ifup (false)
   , m_id ((uint32_t)-1)
   , m_lastLeakTime (0)
@@ -104,28 +104,28 @@
   NS_ASSERT_MSG (node != 0, "node cannot be NULL. Check the code");
 }
 
-CcnxFace::~CcnxFace ()
+NdnFace::~NdnFace ()
 {
   NS_LOG_FUNCTION_NOARGS ();
 }
 
-CcnxFace::CcnxFace (const CcnxFace &)
+NdnFace::NdnFace (const NdnFace &)
 {
 }
 
-CcnxFace& CcnxFace::operator= (const CcnxFace &)
+NdnFace& NdnFace::operator= (const NdnFace &)
 {
   return *this;
 }
 
 Ptr<Node>
-CcnxFace::GetNode () const
+NdnFace::GetNode () const
 {
   return m_node;
 }
 
 void
-CcnxFace::RegisterProtocolHandler (ProtocolHandler handler)
+NdnFace::RegisterProtocolHandler (ProtocolHandler handler)
 {
   NS_LOG_FUNCTION_NOARGS ();
 
@@ -133,14 +133,14 @@
 }
 
 bool
-CcnxFace::IsBelowLimit ()
+NdnFace::IsBelowLimit ()
 {
   NS_LOG_FUNCTION_NOARGS ();
 
   /// \todo Implement tracing, if requested
   
   if (!IsUp ()){
-    NS_LOG_INFO("CcnxFace is not up.");
+    NS_LOG_INFO("NdnFace is not up.");
     return false;
   }
 
@@ -182,14 +182,14 @@
 }
 
 bool
-CcnxFace::Send (Ptr<Packet> packet)
+NdnFace::Send (Ptr<Packet> packet)
 {
   NS_LOG_FUNCTION (boost::cref (*this) << packet << packet->GetSize ());
   NS_LOG_DEBUG (*packet);
 
   if (!IsUp ())
     {
-      m_ccnxDropTrace (packet);
+      m_ndnDropTrace (packet);
       return false;
     }
 
@@ -214,18 +214,18 @@
   bool ok = SendImpl (packet);
   if (ok)
     {
-      m_ccnxTxTrace (packet);
+      m_ndnTxTrace (packet);
       return true;
     }
   else
     {
-      m_ccnxDropTrace (packet);
+      m_ndnDropTrace (packet);
       return false;
     }
 }
 
 bool
-CcnxFace::Receive (const Ptr<const Packet> &packet)
+NdnFace::Receive (const Ptr<const Packet> &packet)
 {
   NS_LOG_FUNCTION (boost::cref (*this) << packet << packet->GetSize ());
 
@@ -235,14 +235,14 @@
       return false;
     }
 
-  m_ccnxRxTrace (packet);
+  m_ndnRxTrace (packet);
   m_protocolHandler (this, packet);
   
   return true;
 }
 
 void
-CcnxFace::LeakBucket ()
+NdnFace::LeakBucket ()
 {
   if (m_lastLeakTime.IsZero ())
     {
@@ -262,28 +262,28 @@
 }
 
 void
-CcnxFace::SetBucketMax (double bucket)
+NdnFace::SetBucketMax (double bucket)
 {
   NS_LOG_FUNCTION (this << bucket);
   m_bucketMax = bucket;
 }
 
 void
-CcnxFace::SetBucketLeak (double leak)
+NdnFace::SetBucketLeak (double leak)
 {
   NS_LOG_FUNCTION (this << leak);
   m_bucketLeak = leak;
 }
 
 void
-CcnxFace::SetMetric (uint16_t metric)
+NdnFace::SetMetric (uint16_t metric)
 {
   NS_LOG_FUNCTION (metric);
   m_metric = metric;
 }
 
 uint16_t
-CcnxFace::GetMetric (void) const
+NdnFace::GetMetric (void) const
 {
   NS_LOG_FUNCTION_NOARGS ();
   return m_metric;
@@ -296,21 +296,21 @@
  */
 
 bool 
-CcnxFace::IsUp (void) const
+NdnFace::IsUp (void) const
 {
   NS_LOG_FUNCTION_NOARGS ();
   return m_ifup;
 }
 
 void 
-CcnxFace::SetUp (bool up/* = true*/)
+NdnFace::SetUp (bool up/* = true*/)
 {
   NS_LOG_FUNCTION_NOARGS ();
   m_ifup = up;
 }
 
 bool
-CcnxFace::operator== (const CcnxFace &face) const
+NdnFace::operator== (const NdnFace &face) const
 {
   NS_ASSERT_MSG (m_node->GetId () == face.m_node->GetId (),
                  "Faces of different nodes should not be compared to each other");
@@ -319,7 +319,7 @@
 }
 
 bool
-CcnxFace::operator< (const CcnxFace &face) const
+NdnFace::operator< (const NdnFace &face) const
 {
   NS_ASSERT_MSG (m_node->GetId () == face.m_node->GetId (),
                  "Faces of different nodes should not be compared to each other");
@@ -328,13 +328,14 @@
 }
 
 std::ostream&
-CcnxFace::Print (std::ostream &os) const
+NdnFace::Print (std::ostream &os) const
 {
   os << "id=" << GetId ();
   return os;
 }
 
-std::ostream& operator<< (std::ostream& os, const CcnxFace &face)
+std::ostream&
+operator<< (std::ostream& os, const NdnFace &face)
 {
   face.Print (os);
   return os;
diff --git a/model/ccnx-face.h b/model/ndn-face.h
similarity index 80%
rename from model/ccnx-face.h
rename to model/ndn-face.h
index 25b0082..e785ac9 100644
--- a/model/ccnx-face.h
+++ b/model/ndn-face.h
@@ -18,14 +18,14 @@
  * Authors: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef CCNX_FACE_H
-#define CCNX_FACE_H
+#ifndef NDN_FACE_H
+#define NDN_FACE_H
 
 #include <ostream>
 #include <algorithm>
 
 #include "ns3/ptr.h"
-#include "ns3/ccnx.h"
+#include "ns3/ndn.h"
 #include "ns3/nstime.h"
 #include "ns3/type-id.h"
 
@@ -35,38 +35,38 @@
 class Node;
   
 /**
- * \ingroup ccnx
- * \defgroup ccnx-face Faces
+ * \ingroup ndn
+ * \defgroup ndn-face Faces
  */
 /**
- * \ingroup ccnx-face
- * \brief Virtual class defining CCNx face
+ * \ingroup ndn-face
+ * \brief Virtual class defining Ndn face
  *
- * This class defines basic functionality of CCNx face. Face is core
+ * This class defines basic functionality of Ndn face. Face is core
  * component responsible for actual delivery of data packet to and
- * from CCNx stack
+ * from Ndn stack
  *
- * \see CcnxLocalFace, CcnxNetDeviceFace, CcnxIpv4Face, CcnxUdpFace
+ * \see NdnLocalFace, NdnNetDeviceFace, NdnIpv4Face, NdnUdpFace
  */
-class CcnxFace  : public Object
+class NdnFace  : public Object
 {
 public:
   static TypeId
   GetTypeId ();
   
   /**
-   * \brief Ccnx protocol handler
+   * \brief Ndn protocol handler
    *
    * \param face Face from which packet has been received
    * \param packet Original packet
    */
-  typedef Callback<void,const Ptr<CcnxFace>&,const Ptr<const Packet>& > ProtocolHandler;
+  typedef Callback<void,const Ptr<NdnFace>&,const Ptr<const Packet>& > ProtocolHandler;
 
   /**
    * \brief Default constructor
    */
-  CcnxFace (Ptr<Node> node);
-  virtual ~CcnxFace();
+  NdnFace (Ptr<Node> node);
+  virtual ~NdnFace();
 
   /**
    * @brief Get node to which this face is associated
@@ -107,7 +107,7 @@
   Send (Ptr<Packet> p);
 
   /**
-   * \brief Receive packet from application or another node and forward it to the CCNx stack
+   * \brief Receive packet from application or another node and forward it to the Ndn stack
    *
    * \todo The only reason for this call is to handle tracing, if requested
    */
@@ -132,7 +132,7 @@
   /**
    * These are face states and may be distinct from actual lower-layer
    * device states, such as found in real implementations (where the
-   * device may be down but ccnx face state is still up).
+   * device may be down but ndn face state is still up).
    */
   
   /**
@@ -201,7 +201,7 @@
    * Internal index is used for comparison.
    */
   bool
-  operator== (const CcnxFace &face) const;
+  operator== (const NdnFace &face) const;
 
   /**
    * \brief Compare two faces. Only two faces on the same node could be compared.
@@ -209,7 +209,7 @@
    * Internal index is used for comparison.
    */
   inline bool
-  operator!= (const CcnxFace &face) const;
+  operator!= (const NdnFace &face) const;
   
   /**
    * \brief Compare two faces. Only two faces on the same node could be compared.
@@ -217,7 +217,7 @@
    * Internal index is used for comparison.
    */
   bool
-  operator< (const CcnxFace &face) const;
+  operator< (const NdnFace &face) const;
 
 protected:
   /**
@@ -229,8 +229,8 @@
   SendImpl (Ptr<Packet> p) = 0;  
 
 private:
-  CcnxFace (const CcnxFace &); ///< \brief Disabled copy constructor
-  CcnxFace& operator= (const CcnxFace &); ///< \brief Disabled copy operator
+  NdnFace (const NdnFace &); ///< \brief Disabled copy constructor
+  NdnFace& operator= (const NdnFace &); ///< \brief Disabled copy operator
   
 protected:
   // uint16_t m_metric; ///< \brief Routing/forwarding metric
@@ -241,42 +241,42 @@
   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
+  ProtocolHandler m_protocolHandler; ///< Callback via which packets are getting send to Ndn 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)
+  uint32_t m_id; ///< \brief id of the interface in Ndn stack (per-node uniqueness)
   Time m_lastLeakTime;
   uint32_t m_metric; ///< \brief metric of the face
   bool m_randomizeLimitChecking;
 
   // bool m_enableMetricTagging;
 
-  TracedCallback<Ptr<const Packet> > m_ccnxTxTrace;
-  TracedCallback<Ptr<const Packet> > m_ccnxRxTrace;
-  TracedCallback<Ptr<const Packet> > m_ccnxDropTrace;
+  TracedCallback<Ptr<const Packet> > m_ndnTxTrace;
+  TracedCallback<Ptr<const Packet> > m_ndnRxTrace;
+  TracedCallback<Ptr<const Packet> > m_ndnDropTrace;
 };
 
-std::ostream& operator<< (std::ostream& os, const CcnxFace &face);
+std::ostream& operator<< (std::ostream& os, const NdnFace &face);
 
 inline bool
-operator < (const Ptr<CcnxFace> &lhs, const Ptr<CcnxFace> &rhs)
+operator < (const Ptr<NdnFace> &lhs, const Ptr<NdnFace> &rhs)
 {
   return *lhs < *rhs;
 }
 
 void
-CcnxFace::SetId (uint32_t id)
+NdnFace::SetId (uint32_t id)
 {
   m_id = id;
 }
 
 uint32_t
-CcnxFace::GetId () const
+NdnFace::GetId () const
 {
   return m_id;
 }
 
 inline bool
-CcnxFace::operator!= (const CcnxFace &face) const
+NdnFace::operator!= (const NdnFace &face) const
 {
   return !(*this == face);
 }
@@ -284,4 +284,4 @@
 
 } // namespace ns3
 
-#endif //CCNX_FACE_H
+#endif //NDN_FACE_H
diff --git a/model/ndn-global-router.cc b/model/ndn-global-router.cc
new file mode 100644
index 0000000..816dc88
--- /dev/null
+++ b/model/ndn-global-router.cc
@@ -0,0 +1,106 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2011 UCLA
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation;
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * Author:  Alexander Afanasyev <alexander.afanasyev@ucla.edu>
+ */
+
+#include "ndn-global-router.h"
+
+#include "ns3/ndn.h"
+#include "ns3/ndn-face.h"
+#include "ns3/ndn-name-components.h"
+
+#include "ns3/channel.h"
+
+using namespace boost;
+
+namespace ns3 {
+
+uint32_t NdnGlobalRouter::m_idCounter = 0;
+
+NS_OBJECT_ENSURE_REGISTERED (NdnGlobalRouter);
+
+TypeId 
+NdnGlobalRouter::GetTypeId ()
+{
+  static TypeId tid = TypeId ("ns3::NdnGlobalRouter")
+    .SetGroupName ("Ndn")
+    .SetParent<Object> ()
+  ;
+  return tid;
+}
+
+NdnGlobalRouter::NdnGlobalRouter ()
+{
+  m_id = m_idCounter;
+  m_idCounter ++;
+}
+
+void
+NdnGlobalRouter::NotifyNewAggregate ()
+{
+  if (m_ndn == 0)
+    {
+      m_ndn = GetObject<Ndn> ();
+    }
+  Object::NotifyNewAggregate ();
+}
+
+uint32_t
+NdnGlobalRouter::GetId () const
+{
+  return m_id;
+}
+
+Ptr<Ndn>
+NdnGlobalRouter::GetNdn () const
+{
+  return m_ndn;
+}
+
+void
+NdnGlobalRouter::AddLocalPrefix (Ptr< NdnNameComponents > prefix)
+{
+  m_localPrefixes.push_back (prefix);
+}
+
+void
+NdnGlobalRouter::AddIncidency (Ptr< NdnFace > face, Ptr< NdnGlobalRouter > gr)
+{
+  m_incidencies.push_back (make_tuple (this, face, gr));
+}
+
+NdnGlobalRouter::IncidencyList &
+NdnGlobalRouter::GetIncidencies ()
+{
+  return m_incidencies;
+}
+
+const NdnGlobalRouter::LocalPrefixList &
+NdnGlobalRouter::GetLocalPrefixes () const
+{
+  return m_localPrefixes;
+}
+
+// void
+// NdnGlobalRouter::AddIncidencyChannel (Ptr< NdnFace > face, Ptr< Channel > channel)
+// {
+//   m_incidenciesChannel.push_back (make_tuple (face, channel));
+// }
+
+}
+
diff --git a/model/ccnx-global-router.h b/model/ndn-global-router.h
similarity index 72%
rename from model/ccnx-global-router.h
rename to model/ndn-global-router.h
index a35c08b..f1475a3 100644
--- a/model/ccnx-global-router.h
+++ b/model/ndn-global-router.h
@@ -18,8 +18,8 @@
  * Author:  Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef CCNX_GLOBAL_ROUTER_H
-#define CCNX_GLOBAL_ROUTER_H
+#ifndef NDN_GLOBAL_ROUTER_H
+#define NDN_GLOBAL_ROUTER_H
 
 #include "ns3/object.h"
 #include "ns3/ptr.h"
@@ -30,20 +30,20 @@
 namespace ns3 {
 
 class Channel;
-class Ccnx;
-class CcnxFace;
-class CcnxNameComponents;
+class Ndn;
+class NdnFace;
+class NdnNameComponents;
 
 /**
  * @brief Class representing global router interface for ndnSIM
  */
-class CcnxGlobalRouter : public Object
+class NdnGlobalRouter : public Object
 {
 public:
   /**
    * @brief Graph edge
    */
-  typedef boost::tuple< Ptr< CcnxGlobalRouter >, Ptr< CcnxFace >, Ptr< CcnxGlobalRouter > > Incidency;
+  typedef boost::tuple< Ptr< NdnGlobalRouter >, Ptr< NdnFace >, Ptr< NdnGlobalRouter > > Incidency;
   /**
    * @brief List of graph edges
    */
@@ -51,7 +51,7 @@
   /**
    * @brief List of locally exported prefixes
    */
-  typedef std::list< Ptr<CcnxNameComponents> > LocalPrefixList;
+  typedef std::list< Ptr<NdnNameComponents> > LocalPrefixList;
   
   /**
    * \brief Interface ID
@@ -64,7 +64,7 @@
   /**
    * @brief Default constructor
    */
-  CcnxGlobalRouter ();
+  NdnGlobalRouter ();
 
   /**
    * @brief Get numeric ID of the node (internally assigned)
@@ -73,25 +73,25 @@
   GetId () const;
 
   /**
-   * @brief Helper function to get smart pointer to Ccnx object (basically, self)
+   * @brief Helper function to get smart pointer to Ndn object (basically, self)
    */
-  Ptr<Ccnx>
-  GetCcnx () const;
+  Ptr<Ndn>
+  GetNdn () const;
 
   /**
    * @brief Add new locally exported prefix
    * @param prefix Prefix
    */
   void
-  AddLocalPrefix (Ptr< CcnxNameComponents > prefix);
+  AddLocalPrefix (Ptr< NdnNameComponents > prefix);
 
   /**
    * @brief Add edge to the node
    * @param face Face of the edge
-   * @param ccnx CcnxGlobalRouter of another node
+   * @param ndn NdnGlobalRouter of another node
    */
   void
-  AddIncidency (Ptr< CcnxFace > face, Ptr< CcnxGlobalRouter > ccnx);
+  AddIncidency (Ptr< NdnFace > face, Ptr< NdnGlobalRouter > ndn);
 
   /**
    * @brief Get list of edges that are connected to this node
@@ -113,7 +113,7 @@
 private:
   uint32_t m_id;
   
-  Ptr<Ccnx> m_ccnx;
+  Ptr<Ndn> m_ndn;
   LocalPrefixList m_localPrefixes;
   IncidencyList m_incidencies;
 
@@ -121,8 +121,8 @@
 };
 
 inline bool
-operator == (const CcnxGlobalRouter::Incidency &a,
-             const CcnxGlobalRouter::Incidency &b)
+operator == (const NdnGlobalRouter::Incidency &a,
+             const NdnGlobalRouter::Incidency &b)
 {
   return a.get<0> () == b.get<0> () &&
     a.get<1> () == b.get<1> () &&
@@ -130,12 +130,12 @@
 }
 
 inline bool
-operator != (const CcnxGlobalRouter::Incidency &a,
-             const CcnxGlobalRouter::Incidency &b)
+operator != (const NdnGlobalRouter::Incidency &a,
+             const NdnGlobalRouter::Incidency &b)
 {
   return ! (a == b);
 }
 
 }
 
-#endif // CCNX_GLOBAL_ROUTER_H
+#endif // NDN_GLOBAL_ROUTER_H
diff --git a/model/ccnx-interest-header.cc b/model/ndn-interest-header.cc
similarity index 62%
rename from model/ccnx-interest-header.cc
rename to model/ndn-interest-header.cc
index 2c7e798..192cae5 100644
--- a/model/ccnx-interest-header.cc
+++ b/model/ndn-interest-header.cc
@@ -23,33 +23,33 @@
 ///< #CCN_PR_SCOPE1 (0x40) this host,
 ///< #CCN_PR_SCOPE2 (0x80) immediate neighborhood
 
-#include "ccnx-interest-header.h"
+#include "ndn-interest-header.h"
 
 #include "ns3/log.h"
 #include "ns3/unused.h"
-#include "../helper/ccnx-encoding-helper.h"
-#include "../helper/ccnx-decoding-helper.h"
+#include "../helper/ndn-encoding-helper.h"
+#include "../helper/ndn-decoding-helper.h"
 
-NS_LOG_COMPONENT_DEFINE ("CcnxInterestHeader");
+NS_LOG_COMPONENT_DEFINE ("NdnInterestHeader");
 
 namespace ns3
 {
 
-NS_OBJECT_ENSURE_REGISTERED (CcnxInterestHeader);
+NS_OBJECT_ENSURE_REGISTERED (NdnInterestHeader);
 
 TypeId
-CcnxInterestHeader::GetTypeId (void)
+NdnInterestHeader::GetTypeId (void)
 {
-  static TypeId tid = TypeId ("ns3::CcnxInterestHeader")
-    .SetGroupName ("Ccnx")
+  static TypeId tid = TypeId ("ns3::NdnInterestHeader")
+    .SetGroupName ("Ndn")
     .SetParent<Header> ()
-    .AddConstructor<CcnxInterestHeader> ()
+    .AddConstructor<NdnInterestHeader> ()
     ;
   return tid;
 }
   
 
-CcnxInterestHeader::CcnxInterestHeader ()
+NdnInterestHeader::NdnInterestHeader ()
   : m_minSuffixComponents (-1)
   , m_maxSuffixComponents (-1)
   , m_childSelector (false)
@@ -62,168 +62,168 @@
 }
 
 void
-CcnxInterestHeader::SetName (const Ptr<CcnxNameComponents> &name)
+NdnInterestHeader::SetName (const Ptr<NdnNameComponents> &name)
 {
   m_name = name;
 }
 
-const CcnxNameComponents&
-CcnxInterestHeader::GetName () const
+const NdnNameComponents&
+NdnInterestHeader::GetName () const
 {
-  if (m_name==0) throw CcnxInterestHeaderException();
+  if (m_name==0) throw NdnInterestHeaderException();
   return *m_name;
 }
 
-Ptr<const CcnxNameComponents>
-CcnxInterestHeader::GetNamePtr () const
+Ptr<const NdnNameComponents>
+NdnInterestHeader::GetNamePtr () const
 {
   return m_name;
 }
 
 void
-CcnxInterestHeader::SetMinSuffixComponents (int32_t value)
+NdnInterestHeader::SetMinSuffixComponents (int32_t value)
 {
   m_minSuffixComponents = value;
 }
 
 int32_t
-CcnxInterestHeader::GetMinSuffixComponents () const
+NdnInterestHeader::GetMinSuffixComponents () const
 {
   return m_minSuffixComponents;
 }
 
 void
-CcnxInterestHeader::SetMaxSuffixComponents (int32_t value)
+NdnInterestHeader::SetMaxSuffixComponents (int32_t value)
 {
   m_maxSuffixComponents = value;
 }
 
 int32_t
-CcnxInterestHeader::GetMaxSuffixComponents () const
+NdnInterestHeader::GetMaxSuffixComponents () const
 {
   return m_maxSuffixComponents;
 }
 
 void
-CcnxInterestHeader::SetExclude (const Ptr<CcnxNameComponents> &exclude)
+NdnInterestHeader::SetExclude (const Ptr<NdnNameComponents> &exclude)
 {
   m_exclude = exclude;
 }
 
 bool
-CcnxInterestHeader::IsEnabledExclude () const
+NdnInterestHeader::IsEnabledExclude () const
 {
   return m_exclude!=0;
 }
 
-const CcnxNameComponents&
-CcnxInterestHeader::GetExclude () const
+const NdnNameComponents&
+NdnInterestHeader::GetExclude () const
 {
-  if (m_exclude==0) throw CcnxInterestHeaderException();
+  if (m_exclude==0) throw NdnInterestHeaderException();
   return *m_exclude;
 }
 
 void
-CcnxInterestHeader::SetChildSelector (bool value)
+NdnInterestHeader::SetChildSelector (bool value)
 {
   m_childSelector = value;
 }
 
 bool
-CcnxInterestHeader::IsEnabledChildSelector () const
+NdnInterestHeader::IsEnabledChildSelector () const
 {
   return m_childSelector;
 }
 
 void
-CcnxInterestHeader::SetAnswerOriginKind (bool value)
+NdnInterestHeader::SetAnswerOriginKind (bool value)
 {
   m_answerOriginKind = value;
 }
 
 bool
-CcnxInterestHeader::IsEnabledAnswerOriginKind () const
+NdnInterestHeader::IsEnabledAnswerOriginKind () const
 {
   return m_answerOriginKind;
 }
 
 void
-CcnxInterestHeader::SetScope (int8_t scope)
+NdnInterestHeader::SetScope (int8_t scope)
 {
   m_scope = scope;
 }
 
 int8_t
-CcnxInterestHeader::GetScope () const
+NdnInterestHeader::GetScope () const
 {
   return m_scope;
 }
 
 void
-CcnxInterestHeader::SetInterestLifetime (Time lifetime)
+NdnInterestHeader::SetInterestLifetime (Time lifetime)
 {
   m_interestLifetime = lifetime;
 }
 
 Time
-CcnxInterestHeader::GetInterestLifetime () const
+NdnInterestHeader::GetInterestLifetime () const
 {
   return m_interestLifetime;
 }
 
 void
-CcnxInterestHeader::SetNonce (uint32_t nonce)
+NdnInterestHeader::SetNonce (uint32_t nonce)
 {
   m_nonce = nonce;
 }
 
 uint32_t
-CcnxInterestHeader::GetNonce () const
+NdnInterestHeader::GetNonce () const
 {
   return m_nonce;
 }
 
 void
-CcnxInterestHeader::SetNack (uint32_t nackType)
+NdnInterestHeader::SetNack (uint32_t nackType)
 {
   m_nackType = nackType;
 }
 
 uint32_t
-CcnxInterestHeader::GetNack () const
+NdnInterestHeader::GetNack () const
 {
   return m_nackType;
 }
 
 uint32_t
-CcnxInterestHeader::GetSerializedSize (void) const
+NdnInterestHeader::GetSerializedSize (void) const
 {
   // unfortunately, we don't know exact header size in advance
-  return CcnxEncodingHelper::GetSerializedSize (*this);
+  return NdnEncodingHelper::GetSerializedSize (*this);
 }
     
 void
-CcnxInterestHeader::Serialize (Buffer::Iterator start) const
+NdnInterestHeader::Serialize (Buffer::Iterator start) const
 {
-  size_t size = CcnxEncodingHelper::Serialize (start, *this);
+  size_t size = NdnEncodingHelper::Serialize (start, *this);
   NS_UNUSED (size);
   NS_LOG_INFO ("Serialize size = " << size);
 }
 
 uint32_t
-CcnxInterestHeader::Deserialize (Buffer::Iterator start)
+NdnInterestHeader::Deserialize (Buffer::Iterator start)
 {
-  return CcnxDecodingHelper::Deserialize (start, *this); // \todo Debugging is necessary
+  return NdnDecodingHelper::Deserialize (start, *this); // \todo Debugging is necessary
 }
 
 TypeId
-CcnxInterestHeader::GetInstanceTypeId (void) const
+NdnInterestHeader::GetInstanceTypeId (void) const
 {
   return GetTypeId ();
 }
   
 void
-CcnxInterestHeader::Print (std::ostream &os) const
+NdnInterestHeader::Print (std::ostream &os) const
 {
   os << "I: " << GetName ();
   
diff --git a/model/ccnx-interest-header.h b/model/ndn-interest-header.h
similarity index 87%
rename from model/ccnx-interest-header.h
rename to model/ndn-interest-header.h
index 77b8426..9b52ca2 100644
--- a/model/ccnx-interest-header.h
+++ b/model/ndn-interest-header.h
@@ -19,8 +19,8 @@
  *         Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef _CCNX_INTEREST_HEADER_H_
-#define _CCNX_INTEREST_HEADER_H_
+#ifndef _NDN_INTEREST_HEADER_H_
+#define _NDN_INTEREST_HEADER_H_
 
 #include "ns3/integer.h"
 #include "ns3/header.h"
@@ -31,13 +31,13 @@
 #include <vector>
 #include <list>
 
-#include "ccnx-name-components.h"
+#include "ndn-name-components.h"
 
 namespace ns3
 {
   
 /**
- * CCNx XML definition of Interest
+ * Ndn XML definition of Interest
  * 
  * Only few important fields are actually implemented in the simulation
  *
@@ -122,11 +122,11 @@
   * - MinSuffixComponents and MasSuffixComponents: if value is negative (default), will not be serialized
   * - ChildSelector, AnswerOriginKind: 0 - false, 1 - true, -1 not set
   * - Publisher* elements are not supported
-  * - Exclude: only simple name matching is supported (Bloom support has been deprecated in CCNx)
+  * - Exclude: only simple name matching is supported (Bloom support has been deprecated in Ndn)
   * - InterestLifetime: ?
   * - Nonce: 32 bit random integer.  If value is 0, will not be serialized
   **/
-class CcnxInterestHeader : public SimpleRefCount<CcnxInterestHeader,Header>
+class NdnInterestHeader : public SimpleRefCount<NdnInterestHeader,Header>
 {
 public:
   /**
@@ -134,16 +134,16 @@
    *
    * Creates a null header
    **/
-  CcnxInterestHeader ();
+  NdnInterestHeader ();
 
   /**
    * \brief Set interest name
    *
-   * Sets name of the interest. For example, SetName( CcnxNameComponents("prefix")("postfix") );
-   * @param[in] name const pointer to CcnxNameComponents object that contains an interest name
+   * Sets name of the interest. For example, SetName( ndnNameComponents("prefix")("postfix") );
+   * @param[in] name const pointer to ndnNameComponents object that contains an interest name
    **/
   void
-  SetName (const Ptr<CcnxNameComponents> &name);
+  SetName (const Ptr<NdnNameComponents> &name);
 
 
   /**
@@ -151,13 +151,13 @@
    *
    * Gets name of the interest.
    **/
-  const CcnxNameComponents&
+  const NdnNameComponents&
   GetName () const;
 
   /**
    * @brief Get smart pointer to the interest name (to avoid extra memory usage)
    */
-  Ptr<const CcnxNameComponents>
+  Ptr<const NdnNameComponents>
   GetNamePtr () const;
 
   /**
@@ -165,7 +165,7 @@
    *
    * MinSuffixComponents refer to the number of name components beyond those in the prefix, 
    * and counting the implicit digest, that may occur in the matching ContentObject.
-   * \see http://www.ccnx.org/releases/latest/doc/technical/InterestMessage.html for more information.
+   * \see http://www.ndn.org/releases/latest/doc/technical/InterestMessage.html for more information.
    * @param[in] value minimum length of suffix components
    **/
   void
@@ -176,7 +176,7 @@
    *
    * MinSuffixComponents refer to the number of name components beyond those in the prefix, 
    * and counting the implicit digest, that may occur in the matching ContentObject.
-   * For more information, see http://www.ccnx.org/releases/latest/doc/technical/InterestMessage.html
+   * For more information, see http://www.ndn.org/releases/latest/doc/technical/InterestMessage.html
    **/
   int32_t
   GetMinSuffixComponents () const;
@@ -187,7 +187,7 @@
    *
    * MaxSuffixComponents refer to the number of name components beyond those in the prefix, 
    * and counting the implicit digest, that may occur in the matching ContentObject.
-   * \see http://www.ccnx.org/releases/latest/doc/technical/InterestMessage.html for more information.
+   * \see http://www.ndn.org/releases/latest/doc/technical/InterestMessage.html for more information.
    * @param[in] value maximum length of suffix components
    **/
   void
@@ -198,7 +198,7 @@
    *
    * MaxSuffixComponents refer to the number of name components beyond those in the prefix, 
    * and counting the implicit digest, that may occur in the matching ContentObject.
-   * For more information, see http://www.ccnx.org/releases/latest/doc/technical/InterestMessage.html
+   * For more information, see http://www.ndn.org/releases/latest/doc/technical/InterestMessage.html
    **/
   int32_t
   GetMaxSuffixComponents () const;
@@ -206,11 +206,11 @@
   /**
    * \brief Set exclude filer
    *
-   * For example, SetExclude (CcnxNameComponents("exclude1")("exclude2")("exclude3"))
-   * @param[in] exclude const pointer to CcnxNameComponents to be excluded 
+   * For example, SetExclude (ndnNameComponents("exclude1")("exclude2")("exclude3"))
+   * @param[in] exclude const pointer to ndnNameComponents to be excluded 
    **/
   void
-  SetExclude (const Ptr<CcnxNameComponents> &exclude);
+  SetExclude (const Ptr<NdnNameComponents> &exclude);
 
   /**
    * \brief Check if interest conatins exclude filter
@@ -222,7 +222,7 @@
   /**
    * \brief Get exclude filter 
    */
-  const CcnxNameComponents&
+  const NdnNameComponents&
   GetExclude () const;
 
   /**
@@ -230,7 +230,7 @@
    * Often a given interest will match more than one ContentObject within a given content store. 
    * The ChildSelector provides a way of expressing a preference for which of these should be returned. 
    * If the value is false, the leftmost child is preferred. If true, the rightmost child is preferred.
-   * \see http://www.ccnx.org/releases/latest/doc/technical/InterestMessage.html for more information. 
+   * \see http://www.ndn.org/releases/latest/doc/technical/InterestMessage.html for more information. 
    * @param[in] value boolean ChildSelector value
    */
   void
@@ -238,7 +238,7 @@
 
   /**
    * \brief Return ChildSelector value
-   * \see http://www.ccnx.org/releases/latest/doc/technical/InterestMessage.html for more information.
+   * \see http://www.ndn.org/releases/latest/doc/technical/InterestMessage.html for more information.
    *
    */
   bool
@@ -288,7 +288,7 @@
    * \brief Set InterestLifetime
    * InterestLifetime indicates the (approximate) time remaining before the interest times out.
    * The timeout is relative to the arrival time of the interest at the current node.
-   * \see http://www.ccnx.org/releases/latest/doc/technical/InterestMessage.html for more information.
+   * \see http://www.ndn.org/releases/latest/doc/technical/InterestMessage.html for more information.
    * @param[in] time interest lifetime  
    */ 
   void
@@ -298,7 +298,7 @@
    * \brief Get InterestLifetime value
    * InterestLifetime indicates the (approximate) time remaining before the interest times out.
    * The timeout is relative to the arrival time of the interest at the current node.
-   * \see http://www.ccnx.org/releases/latest/doc/technical/InterestMessage.html for more information.
+   * \see http://www.ndn.org/releases/latest/doc/technical/InterestMessage.html for more information.
    */ 
   Time
   GetInterestLifetime () const;
@@ -381,10 +381,10 @@
   virtual uint32_t Deserialize (Buffer::Iterator start);
 
 private:
-  Ptr<CcnxNameComponents> m_name;     ///< Interest name
+  Ptr<NdnNameComponents> m_name;     ///< Interest name
   int32_t m_minSuffixComponents;      ///< Minimum suffix components. not used if negative
   int32_t m_maxSuffixComponents;      ///< Maximum suffix components. not used if negative
-  Ptr<CcnxNameComponents> m_exclude;  ///< Exclude filter
+  Ptr<NdnNameComponents> m_exclude;  ///< Exclude filter
   bool m_childSelector;               ///< Default value for ChildSelector is false
   bool m_answerOriginKind;            ///< Default value for AnswerOriginKind is false
   int8_t m_scope;                     ///< -1 not set, 0 local scope, 1 this host, 2 immediate neighborhood
@@ -396,8 +396,8 @@
 /**
  * @brief Class for Interest parsing exception 
  */
-class CcnxInterestHeaderException {};
+class NdnInterestHeaderException {};
 
 } // namespace ns3
 
-#endif // _CCNX_INTEREST_HEADER_H_
+#endif // _NDN_INTEREST_HEADER_H_
diff --git a/model/ccnx-l3-protocol.cc b/model/ndn-l3-protocol.cc
similarity index 75%
rename from model/ccnx-l3-protocol.cc
rename to model/ndn-l3-protocol.cc
index 12087c1..62c6241 100644
--- a/model/ccnx-l3-protocol.cc
+++ b/model/ndn-l3-protocol.cc
@@ -19,7 +19,7 @@
  *         Ilya Moiseenko <iliamo@cs.ucla.edu>
  */
 
-#include "ccnx-l3-protocol.h"
+#include "ndn-l3-protocol.h"
 
 #include "ns3/packet.h"
 #include "ns3/node.h"
@@ -32,61 +32,61 @@
 #include "ns3/simulator.h"
 #include "ns3/random-variable.h"
 
-#include "ns3/ccnx-header-helper.h"
-#include "ns3/ccnx-pit.h"
-#include "ns3/ccnx-interest-header.h"
-#include "ns3/ccnx-content-object-header.h"
+#include "ns3/ndn-header-helper.h"
+#include "ns3/ndn-pit.h"
+#include "ns3/ndn-interest-header.h"
+#include "ns3/ndn-content-object-header.h"
 
-#include "ns3/ccnx-face.h"
-#include "ns3/ccnx-forwarding-strategy.h"
+#include "ns3/ndn-face.h"
+#include "ns3/ndn-forwarding-strategy.h"
 
-// #include "fib/ccnx-fib-impl.h"
+// #include "fib/ndn-fib-impl.h"
 
-#include "ccnx-net-device-face.h"
+#include "ndn-net-device-face.h"
 
 #include <boost/foreach.hpp>
 
-NS_LOG_COMPONENT_DEFINE ("CcnxL3Protocol");
+NS_LOG_COMPONENT_DEFINE ("NdnL3Protocol");
 
 namespace ns3 {
 
-const uint16_t CcnxL3Protocol::ETHERNET_FRAME_TYPE = 0x7777;
+const uint16_t NdnL3Protocol::ETHERNET_FRAME_TYPE = 0x7777;
 
 
-NS_OBJECT_ENSURE_REGISTERED (CcnxL3Protocol);
+NS_OBJECT_ENSURE_REGISTERED (NdnL3Protocol);
 
 TypeId 
-CcnxL3Protocol::GetTypeId (void)
+NdnL3Protocol::GetTypeId (void)
 {
-  static TypeId tid = TypeId ("ns3::CcnxL3Protocol")
-    .SetParent<Ccnx> ()
-    .SetGroupName ("Ccnx")
-    .AddConstructor<CcnxL3Protocol> ()
-    .AddAttribute ("FaceList", "List of faces associated with CCNx stack",
+  static TypeId tid = TypeId ("ns3::NdnL3Protocol")
+    .SetParent<Ndn> ()
+    .SetGroupName ("ndn")
+    .AddConstructor<NdnL3Protocol> ()
+    .AddAttribute ("FaceList", "List of faces associated with ndn stack",
                    ObjectVectorValue (),
-                   MakeObjectVectorAccessor (&CcnxL3Protocol::m_faces),
-                   MakeObjectVectorChecker<CcnxFace> ())
+                   MakeObjectVectorAccessor (&NdnL3Protocol::m_faces),
+                   MakeObjectVectorChecker<NdnFace> ())
   ;
   return tid;
 }
 
-CcnxL3Protocol::CcnxL3Protocol()
+NdnL3Protocol::NdnL3Protocol()
 : m_faceCounter (0)
 {
   NS_LOG_FUNCTION (this);
 }
 
-CcnxL3Protocol::~CcnxL3Protocol ()
+NdnL3Protocol::~NdnL3Protocol ()
 {
   NS_LOG_FUNCTION (this);
 }
 
 /*
  * This method is called by AddAgregate and completes the aggregation
- * by setting the node in the ccnx stack
+ * by setting the node in the ndn stack
  */
 void
-CcnxL3Protocol::NotifyNewAggregate ()
+NdnL3Protocol::NotifyNewAggregate ()
 {
   // not really efficient, but this will work only once
   if (m_node == 0)
@@ -95,37 +95,37 @@
       if (m_node != 0)
         {
           // NS_ASSERT_MSG (m_pit != 0 && m_fib != 0 && m_contentStore != 0 && m_forwardingStrategy != 0,
-          //                "PIT, FIB, and ContentStore should be aggregated before CcnxL3Protocol");
+          //                "PIT, FIB, and ContentStore should be aggregated before NdnL3Protocol");
           NS_ASSERT_MSG (m_forwardingStrategy != 0,
-                         "Forwarding strategy should be aggregated before CcnxL3Protocol");
+                         "Forwarding strategy should be aggregated before NdnL3Protocol");
         }
     }
   // if (m_pit == 0)
   //   {
-  //     m_pit = GetObject<CcnxPit> ();
+  //     m_pit = GetObject<NdnPit> ();
   //   }
   // if (m_fib == 0)
   //   {
-  //     m_fib = GetObject<CcnxFib> ();
+  //     m_fib = GetObject<NdnFib> ();
   //   }
   if (m_forwardingStrategy == 0)
     {
-      m_forwardingStrategy = GetObject<CcnxForwardingStrategy> ();
+      m_forwardingStrategy = GetObject<NdnForwardingStrategy> ();
     }
   // if (m_contentStore == 0)
   //   {
-  //     m_contentStore = GetObject<CcnxContentStore> ();
+  //     m_contentStore = GetObject<NdnContentStore> ();
   //   }
 
-  Ccnx::NotifyNewAggregate ();
+  Ndn::NotifyNewAggregate ();
 }
 
 void 
-CcnxL3Protocol::DoDispose (void)
+NdnL3Protocol::DoDispose (void)
 {
   NS_LOG_FUNCTION (this);
 
-  for (CcnxFaceList::iterator i = m_faces.begin (); i != m_faces.end (); ++i)
+  for (NdnFaceList::iterator i = m_faces.begin (); i != m_faces.end (); ++i)
     {
       *i = 0;
     }
@@ -135,18 +135,18 @@
   // Force delete on objects
   m_forwardingStrategy = 0; // there is a reference to PIT stored in here
 
-  Ccnx::DoDispose ();
+  Ndn::DoDispose ();
 }
 
 uint32_t 
-CcnxL3Protocol::AddFace (const Ptr<CcnxFace> &face)
+NdnL3Protocol::AddFace (const Ptr<NdnFace> &face)
 {
   NS_LOG_FUNCTION (this << &face);
 
   face->SetId (m_faceCounter); // sets a unique ID of the face. This ID serves only informational purposes
 
   // ask face to register in lower-layer stack
-  face->RegisterProtocolHandler (MakeCallback (&CcnxL3Protocol::Receive, this));
+  face->RegisterProtocolHandler (MakeCallback (&NdnL3Protocol::Receive, this));
 
   m_faces.push_back (face);
   m_faceCounter++;
@@ -154,15 +154,15 @@
 }
 
 void
-CcnxL3Protocol::RemoveFace (Ptr<CcnxFace> face)
+NdnL3Protocol::RemoveFace (Ptr<NdnFace> face)
 {
   // ask face to register in lower-layer stack
-  face->RegisterProtocolHandler (MakeNullCallback<void,const Ptr<CcnxFace>&,const Ptr<const Packet>&> ());
-  Ptr<CcnxPit> pit = GetObject<CcnxPit> ();
+  face->RegisterProtocolHandler (MakeNullCallback<void,const Ptr<NdnFace>&,const Ptr<const Packet>&> ());
+  Ptr<NdnPit> pit = GetObject<NdnPit> ();
 
   // just to be on a safe side. Do the process in two steps
-  std::list< Ptr<CcnxPitEntry> > entriesToRemoves;
-  for (Ptr<CcnxPitEntry> pitEntry = pit->Begin (); pitEntry != 0; pitEntry = pit->Next (pitEntry))
+  std::list< Ptr<NdnPitEntry> > entriesToRemoves;
+  for (Ptr<NdnPitEntry> pitEntry = pit->Begin (); pitEntry != 0; pitEntry = pit->Next (pitEntry))
     {
       pitEntry->RemoveAllReferencesToFace (face);
       
@@ -174,20 +174,20 @@
           entriesToRemoves.push_back (pitEntry);
         }
     }
-  BOOST_FOREACH (Ptr<CcnxPitEntry> removedEntry, entriesToRemoves)
+  BOOST_FOREACH (Ptr<NdnPitEntry> removedEntry, entriesToRemoves)
     {
       pit->MarkErased (removedEntry);
     }
 
-  CcnxFaceList::iterator face_it = find (m_faces.begin(), m_faces.end(), face);
+  NdnFaceList::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);
 }
 
-Ptr<CcnxFace>
-CcnxL3Protocol::GetFace (uint32_t index) const
+Ptr<NdnFace>
+NdnL3Protocol::GetFace (uint32_t index) const
 {
-  BOOST_FOREACH (const Ptr<CcnxFace> &face, m_faces) // this function is not supposed to be called often, so linear search is fine
+  BOOST_FOREACH (const Ptr<NdnFace> &face, m_faces) // this function is not supposed to be called often, so linear search is fine
     {
       if (face->GetId () == index)
         return face;
@@ -195,12 +195,12 @@
   return 0;
 }
 
-Ptr<CcnxFace>
-CcnxL3Protocol::GetFaceByNetDevice (Ptr<NetDevice> netDevice) const
+Ptr<NdnFace>
+NdnL3Protocol::GetFaceByNetDevice (Ptr<NetDevice> netDevice) const
 {
-  BOOST_FOREACH (const Ptr<CcnxFace> &face, m_faces) // this function is not supposed to be called often, so linear search is fine
+  BOOST_FOREACH (const Ptr<NdnFace> &face, m_faces) // this function is not supposed to be called often, so linear search is fine
     {
-      Ptr<CcnxNetDeviceFace> netDeviceFace = DynamicCast<CcnxNetDeviceFace> (face);
+      Ptr<NdnNetDeviceFace> netDeviceFace = DynamicCast<NdnNetDeviceFace> (face);
       if (netDeviceFace == 0) continue;
 
       if (netDeviceFace->GetNetDevice () == netDevice)
@@ -210,14 +210,14 @@
 }
 
 uint32_t 
-CcnxL3Protocol::GetNFaces (void) const
+NdnL3Protocol::GetNFaces (void) const
 {
   return m_faces.size ();
 }
 
 // Callback from lower layer
 void 
-CcnxL3Protocol::Receive (const Ptr<CcnxFace> &face, const Ptr<const Packet> &p)
+NdnL3Protocol::Receive (const Ptr<NdnFace> &face, const Ptr<const Packet> &p)
 {
   if (!face->IsUp ())
     return;
@@ -229,12 +229,12 @@
   Ptr<Packet> packet = p->Copy (); // give upper layers a rw copy of the packet
   try
     {
-      CcnxHeaderHelper::Type type = CcnxHeaderHelper::GetCcnxHeaderType (p);
+      NdnHeaderHelper::Type type = NdnHeaderHelper::GetNdnHeaderType (p);
       switch (type)
         {
-        case CcnxHeaderHelper::INTEREST:
+        case NdnHeaderHelper::INTEREST:
           {
-            Ptr<CcnxInterestHeader> header = Create<CcnxInterestHeader> ();
+            Ptr<NdnInterestHeader> header = Create<NdnInterestHeader> ();
 
             // Deserialization. Exception may be thrown
             packet->RemoveHeader (*header);
@@ -247,11 +247,11 @@
             //   OnInterest (face, header, p/*original packet*/);  
             break;
           }
-        case CcnxHeaderHelper::CONTENT_OBJECT:
+        case NdnHeaderHelper::CONTENT_OBJECT:
           {
-            Ptr<CcnxContentObjectHeader> header = Create<CcnxContentObjectHeader> ();
+            Ptr<NdnContentObjectHeader> header = Create<NdnContentObjectHeader> ();
             
-            static CcnxContentObjectTail contentObjectTrailer; //there is no data in this object
+            static NdnContentObjectTail contentObjectTrailer; //there is no data in this object
 
             // Deserialization. Exception may be thrown
             packet->RemoveHeader (*header);
@@ -264,23 +264,23 @@
       
       // exception will be thrown if packet is not recognized
     }
-  catch (CcnxUnknownHeaderException)
+  catch (NdnUnknownHeaderException)
     {
-      NS_ASSERT_MSG (false, "Unknown CCNx header. Should not happen");
-      NS_LOG_ERROR ("Unknown CCNx header. Should not happen");
+      NS_ASSERT_MSG (false, "Unknown Ndn header. Should not happen");
+      NS_LOG_ERROR ("Unknown Ndn header. Should not happen");
       return;
     }
 }
 
 // void
-// CcnxL3Protocol::OnNack (const Ptr<CcnxFace> &incomingFace,
-//                         Ptr<CcnxInterestHeader> &header,
+// NdnL3Protocol::OnNack (const Ptr<NdnFace> &incomingFace,
+//                         Ptr<NdnInterestHeader> &header,
 //                         const Ptr<const Packet> &packet)
 // {
 //   NS_LOG_FUNCTION (incomingFace << header << packet);
 //   m_inNacks (header, incomingFace);
 
-//   Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
+//   Ptr<NdnPitEntry> pitEntry = m_pit->Lookup (*header);
 //   if (pitEntry == 0)
 //     {
 //       // somebody is doing something bad
@@ -288,8 +288,8 @@
 //       return;
 //     }
   
-//   // CcnxPitEntryIncomingFaceContainer::type::iterator inFace = pitEntry->GetIncoming ().find (incomingFace);
-//   CcnxPitEntryOutgoingFaceContainer::type::iterator outFace = pitEntry->GetOutgoing ().find (incomingFace);
+//   // NdnPitEntryIncomingFaceContainer::type::iterator inFace = pitEntry->GetIncoming ().find (incomingFace);
+//   NdnPitEntryOutgoingFaceContainer::type::iterator outFace = pitEntry->GetOutgoing ().find (incomingFace);
 
 //   if (outFace == pitEntry->GetOutgoing ().end ())
 //     {
@@ -313,15 +313,15 @@
 //   // If NACK is NACK_GIVEUP_PIT, then neighbor gave up trying to and removed it's PIT entry.
 //   // So, if we had an incoming entry to this neighbor, then we can remove it now
 
-//   if (header->GetNack () == CcnxInterestHeader::NACK_GIVEUP_PIT)
+//   if (header->GetNack () == NdnInterestHeader::NACK_GIVEUP_PIT)
 //     {
 //       pitEntry->RemoveIncoming (incomingFace);
 //     }
 
-//   pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW);
-//   // StaticCast<CcnxFibImpl> (m_fib)->modify (pitEntry->GetFibEntry (),
-//   //                                           ll::bind (&CcnxFibEntry::UpdateStatus,
-//   //                                                     ll::_1, incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW));
+//   pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, NdnFibFaceMetric::NDN_FIB_YELLOW);
+//   // StaticCast<NdnFibImpl> (m_fib)->modify (pitEntry->GetFibEntry (),
+//   //                                           ll::bind (&NdnFibEntry::UpdateStatus,
+//   //                                                     ll::_1, incomingFace, NdnFibFaceMetric::NDN_FIB_YELLOW));
 
 //   if (pitEntry->GetIncoming ().size () == 0) // interest was actually satisfied
 //     {
@@ -340,7 +340,7 @@
 //     }
   
 //   Ptr<Packet> nonNackInterest = Create<Packet> ();
-//   header->SetNack (CcnxInterestHeader::NORMAL_INTEREST);
+//   header->SetNack (NdnInterestHeader::NORMAL_INTEREST);
 //   nonNackInterest->AddHeader (*header);
   
 //   bool propagated = m_forwardingStrategy->
@@ -360,13 +360,13 @@
 //
 // // !!! Key point.
 // // !!! All interests should be answerred!!! Either later with data, immediately with data, or immediately with NACK
-// void CcnxL3Protocol::OnInterest (const Ptr<CcnxFace> &incomingFace,
-//                                  Ptr<CcnxInterestHeader> &header,
+// void NdnL3Protocol::OnInterest (const Ptr<NdnFace> &incomingFace,
+//                                  Ptr<NdnInterestHeader> &header,
 //                                  const Ptr<const Packet> &packet)
 // {
 //   m_inInterests (header, incomingFace);
 
-//   Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
+//   Ptr<NdnPitEntry> pitEntry = m_pit->Lookup (*header);
 //   if (pitEntry == 0)
 //     {
 //       pitEntry = m_pit->Create (header);
@@ -400,14 +400,14 @@
 //   /////////////////////////////////////////////////////////////////////////////////////////
   
 //   // Data is not in cache
-//   CcnxPitEntry::in_iterator inFace   = pitEntry->GetIncoming ().find (incomingFace);
-//   CcnxPitEntry::out_iterator outFace = pitEntry->GetOutgoing ().find (incomingFace);
+//   NdnPitEntry::in_iterator inFace   = pitEntry->GetIncoming ().find (incomingFace);
+//   NdnPitEntry::out_iterator outFace = pitEntry->GetOutgoing ().find (incomingFace);
 
 //   bool isRetransmitted = false;
   
 //   if (inFace != pitEntry->GetIncoming ().end ())
 //     {
-//       // CcnxPitEntryIncomingFace.m_arrivalTime keeps track arrival time of the first packet... why?
+//       // NdnPitEntryIncomingFace.m_arrivalTime keeps track arrival time of the first packet... why?
 
 //       isRetransmitted = true;
 //       // this is almost definitely a retransmission. But should we trust the user on that?
@@ -434,7 +434,7 @@
 //       if (m_nacksEnabled)
 //         {
 //           NS_LOG_DEBUG ("Sending NACK_LOOP");
-//           header->SetNack (CcnxInterestHeader::NACK_LOOP);
+//           header->SetNack (NdnInterestHeader::NACK_LOOP);
 //           Ptr<Packet> nack = Create<Packet> ();
 //           nack->AddHeader (*header);
 
@@ -446,7 +446,7 @@
 //     }
 
 //   Ptr<Packet> contentObject;
-//   Ptr<const CcnxContentObjectHeader> contentObjectHeader; // used for tracing
+//   Ptr<const NdnContentObjectHeader> contentObjectHeader; // used for tracing
 //   Ptr<const Packet> payload; // used for tracing
 //   tie (contentObject, contentObjectHeader, payload) = m_contentStore->Lookup (header);
 //   if (contentObject != 0)
@@ -472,10 +472,10 @@
 
 //       // ?? not sure if we need to do that ?? ...
       
-//       pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW);
-//       // StaticCast<CcnxFibImpl> (m_fib)->modify(pitEntry->GetFibEntry (),
-//       //                                          ll::bind (&CcnxFibEntry::UpdateStatus,
-//       //                                                    ll::_1, incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW));
+//       pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, NdnFibFaceMetric::NDN_FIB_YELLOW);
+//       // StaticCast<NdnFibImpl> (m_fib)->modify(pitEntry->GetFibEntry (),
+//       //                                          ll::bind (&NdnFibEntry::UpdateStatus,
+//       //                                                    ll::_1, incomingFace, NdnFibFaceMetric::NDN_FIB_YELLOW));
 //     }
 //   else
 //     if (!isNew && !isRetransmitted)
@@ -515,16 +515,16 @@
 // }
 
 // void
-// CcnxL3Protocol::OnDataDelayed (Ptr<const CcnxContentObjectHeader> header,
+// NdnL3Protocol::OnDataDelayed (Ptr<const NdnContentObjectHeader> header,
 //                                Ptr<const Packet> payload,
 //                                const Ptr<const Packet> &packet)
 // {
 //   // 1. Lookup PIT entry
-//   Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
+//   Ptr<NdnPitEntry> pitEntry = m_pit->Lookup (*header);
 //   if (pitEntry != 0)
 //     {
 //       //satisfy all pending incoming Interests
-//       BOOST_FOREACH (const CcnxPitEntryIncomingFace &incoming, pitEntry->GetIncoming ())
+//       BOOST_FOREACH (const NdnPitEntryIncomingFace &incoming, pitEntry->GetIncoming ())
 //         {
 //           incoming.m_face->Send (packet->Copy ());
 //           m_outData (header, payload, false, incoming.m_face);
@@ -554,8 +554,8 @@
 
 // // Processing ContentObjects
 // void
-// CcnxL3Protocol::OnData (const Ptr<CcnxFace> &incomingFace,
-//                         Ptr<CcnxContentObjectHeader> &header,
+// NdnL3Protocol::OnData (const Ptr<NdnFace> &incomingFace,
+//                         Ptr<NdnContentObjectHeader> &header,
 //                         Ptr<Packet> &payload,
 //                         const Ptr<const Packet> &packet)
 // {
@@ -564,19 +564,19 @@
 //   m_inData (header, payload, incomingFace);
   
 //   // 1. Lookup PIT entry
-//   Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
+//   Ptr<NdnPitEntry> pitEntry = m_pit->Lookup (*header);
 //   if (pitEntry != 0)
 //     {
 //       // Note that with MultiIndex we need to modify entries indirectly
 
-//       CcnxPitEntry::out_iterator out = pitEntry->GetOutgoing ().find (incomingFace);
+//       NdnPitEntry::out_iterator out = pitEntry->GetOutgoing ().find (incomingFace);
   
 //       // If we have sent interest for this data via this face, then update stats.
 //       if (out != pitEntry->GetOutgoing ().end ())
 //         {
 //           pitEntry->GetFibEntry ()->UpdateFaceRtt (incomingFace, Simulator::Now () - out->m_sendTime);
-//           // StaticCast<CcnxFibImpl> (m_fib)->modify (pitEntry->GetFibEntry (),
-//           //                                          ll::bind (&CcnxFibEntry::UpdateFaceRtt,
+//           // StaticCast<NdnFibImpl> (m_fib)->modify (pitEntry->GetFibEntry (),
+//           //                                          ll::bind (&NdnFibEntry::UpdateFaceRtt,
 //           //                                                    ll::_1,
 //           //                                                    incomingFace,
 //           //                                                    Simulator::Now () - out->m_sendTime));
@@ -602,10 +602,10 @@
 //         }
 
 //       // Update metric status for the incoming interface in the corresponding FIB entry
-//       pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_GREEN);
-//       // StaticCast<CcnxFibImpl>(m_fib)->modify (pitEntry->GetFibEntry (),
-//       //                                          ll::bind (&CcnxFibEntry::UpdateStatus, ll::_1,
-//       //                                                    incomingFace, CcnxFibFaceMetric::NDN_FIB_GREEN));
+//       pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, NdnFibFaceMetric::NDN_FIB_GREEN);
+//       // StaticCast<NdnFibImpl>(m_fib)->modify (pitEntry->GetFibEntry (),
+//       //                                          ll::bind (&NdnFibEntry::UpdateStatus, ll::_1,
+//       //                                                    incomingFace, NdnFibFaceMetric::NDN_FIB_GREEN));
   
 //       // Add or update entry in the content store
 //       m_contentStore->Add (header, payload);
@@ -643,18 +643,18 @@
 // }
 
 // void
-// CcnxL3Protocol::GiveUpInterest (Ptr<CcnxPitEntry> pitEntry,
-//                                 Ptr<CcnxInterestHeader> header)
+// NdnL3Protocol::GiveUpInterest (Ptr<NdnPitEntry> pitEntry,
+//                                 Ptr<NdnInterestHeader> header)
 // {
 //   NS_LOG_FUNCTION (this);
 
 //   if (m_nacksEnabled)
 //     {
 //       Ptr<Packet> packet = Create<Packet> ();
-//       header->SetNack (CcnxInterestHeader::NACK_GIVEUP_PIT);
+//       header->SetNack (NdnInterestHeader::NACK_GIVEUP_PIT);
 //       packet->AddHeader (*header);
 
-//       BOOST_FOREACH (const CcnxPitEntryIncomingFace &incoming, pitEntry->GetIncoming ())
+//       BOOST_FOREACH (const NdnPitEntryIncomingFace &incoming, pitEntry->GetIncoming ())
 //         {
 //           NS_LOG_DEBUG ("Send NACK for " << boost::cref (header->GetName ()) << " to " << boost::cref (*incoming.m_face));
 //           incoming.m_face->Send (packet->Copy ());
diff --git a/model/ccnx-l3-protocol.h b/model/ndn-l3-protocol.h
similarity index 64%
rename from model/ccnx-l3-protocol.h
rename to model/ndn-l3-protocol.h
index 3525db5..3b1897d 100644
--- a/model/ccnx-l3-protocol.h
+++ b/model/ndn-l3-protocol.h
@@ -18,8 +18,8 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef CCNX_L3_PROTOCOL_H
-#define CCNX_L3_PROTOCOL_H
+#ifndef NDN_L3_PROTOCOL_H
+#define NDN_L3_PROTOCOL_H
 
 #include <list>
 #include <vector>
@@ -28,28 +28,28 @@
 #include "ns3/net-device.h"
 #include "ns3/nstime.h"
 
-// #include "ccnx-content-store.h"
-// #include "ccnx-pit.h"
-// #include "ccnx-fib.h"
+// #include "ndn-content-store.h"
+// #include "ndn-pit.h"
+// #include "ndn-fib.h"
 
-#include "ccnx.h"
+#include "ndn.h"
 
 namespace ns3 {
 
 class Packet;
 class NetDevice;
 class Node;
-class CcnxFace;
-class CcnxRoute;
-class CcnxForwardingStrategy;
+class NdnFace;
+class NdnRoute;
+class NdnForwardingStrategy;
 class Header;
-class CcnxInterestHeader;
-class CcnxContentObjectHeader;
+class NdnInterestHeader;
+class NdnContentObjectHeader;
 
     
 /**
- * \ingroup ccnx
- * \brief Actual implementation of the Ccnx network layer
+ * \ingroup ndn
+ * \brief Actual implementation of the Ndn network layer
  * 
  * \todo This description is incorrect. Should be changed accordingly
  *
@@ -57,13 +57,13 @@
  * trace sources 'Rx' and 'Tx' are called, respectively, immediately
  * after receiving from the NetDevice and immediately before sending
  * to a NetDevice for transmitting a packet.  These are low level
- * trace sources that include the CcnxHeader already serialized into
+ * trace sources that include the NdnHeader already serialized into
  * the packet.  In contrast, the Drop, SendOutgoing, UnicastForward,
  * and LocalDeliver trace sources are slightly higher-level and pass
- * around the CcnxHeader as an explicit parameter and not as part of
+ * around the NdnHeader as an explicit parameter and not as part of
  * the packet.
  */
-class CcnxL3Protocol : public Ccnx
+class NdnL3Protocol : public Ndn
 {
 public:
   /**
@@ -73,41 +73,41 @@
    */
   static TypeId GetTypeId ();
 
-  static const uint16_t ETHERNET_FRAME_TYPE; ///< \brief Ethernet Frame Type of CCNx
-  // static const uint16_t IP_PROTOCOL_TYPE;    ///< \brief IP protocol type of CCNx
-  // static const uint16_t UDP_PORT;            ///< \brief UDP port of CCNx
+  static const uint16_t ETHERNET_FRAME_TYPE; ///< \brief Ethernet Frame Type of Ndn
+  // static const uint16_t IP_PROTOCOL_TYPE;    ///< \brief IP protocol type of Ndn
+  // static const uint16_t UDP_PORT;            ///< \brief UDP port of Ndn
 
   /**
    * \brief Default constructor. Creates an empty stack without forwarding strategy set
    */
-  CcnxL3Protocol();
-  virtual ~CcnxL3Protocol ();
+  NdnL3Protocol();
+  virtual ~NdnL3Protocol ();
 
   ////////////////////////////////////////////////////////////////////
-  // functions defined in base class Ccnx
+  // functions defined in base class Ndn
 
   virtual uint32_t
-  AddFace (const Ptr<CcnxFace> &face);
+  AddFace (const Ptr<NdnFace> &face);
   
   virtual uint32_t
   GetNFaces () const;
   
-  virtual Ptr<CcnxFace>
+  virtual Ptr<NdnFace>
   GetFace (uint32_t face) const;
 
   virtual void
-  RemoveFace (Ptr<CcnxFace> face);
+  RemoveFace (Ptr<NdnFace> face);
 
-  virtual Ptr<CcnxFace>
+  virtual Ptr<NdnFace>
   GetFaceByNetDevice (Ptr<NetDevice> netDevice) const;
   
   // void ScheduleLeakage();
 private:
   void
-  Receive (const Ptr<CcnxFace> &face, const Ptr<const Packet> &p);
+  Receive (const Ptr<NdnFace> &face, const Ptr<const Packet> &p);
 
   // /**
-  //  * \brief Actual processing of incoming CCNx interests. Note, interests do not have payload
+  //  * \brief Actual processing of incoming Ndn interests. Note, interests do not have payload
   //  * 
   //  * Processing Interest packets
   //  * @param face    incoming face
@@ -115,12 +115,12 @@
   //  * @param packet  original packet
   //  */
   // void
-  // OnInterest (const Ptr<CcnxFace> &face,
-  //             Ptr<CcnxInterestHeader> &header,
+  // OnInterest (const Ptr<NdnFace> &face,
+  //             Ptr<NdnInterestHeader> &header,
   //             const Ptr<const Packet> &p);
 
   // /**
-  //  * \brief Processing of incoming CCNx NACKs. Note, these packets, like interests, do not have payload
+  //  * \brief Processing of incoming Ndn NACKs. Note, these packets, like interests, do not have payload
   //  * 
   //  * Processing NACK packets
   //  * @param face    incoming face
@@ -128,12 +128,12 @@
   //  * @param packet  original packet
   //  */
   // void
-  // OnNack (const Ptr<CcnxFace> &face,
-  //         Ptr<CcnxInterestHeader> &header,
+  // OnNack (const Ptr<NdnFace> &face,
+  //         Ptr<NdnInterestHeader> &header,
   //         const Ptr<const Packet> &p);
   
   // /**
-  //  * \brief Actual processing of incoming CCNx content objects
+  //  * \brief Actual processing of incoming Ndn content objects
   //  * 
   //  * Processing ContentObject packets
   //  * @param face    incoming face
@@ -142,8 +142,8 @@
   //  * @param packet  original packet
   //  */
   // void
-  // OnData (const Ptr<CcnxFace> &face,
-  //         Ptr<CcnxContentObjectHeader> &header,
+  // OnData (const Ptr<NdnFace> &face,
+  //         Ptr<NdnContentObjectHeader> &header,
   //         Ptr<Packet> &payload,
   //         const Ptr<const Packet> &packet);
 
@@ -157,26 +157,26 @@
   virtual void NotifyNewAggregate ();
 
 private:
-  CcnxL3Protocol(const CcnxL3Protocol &); ///< copy constructor is disabled
-  CcnxL3Protocol &operator = (const CcnxL3Protocol &); ///< copy operator is disabled
+  NdnL3Protocol(const NdnL3Protocol &); ///< copy constructor is disabled
+  NdnL3Protocol &operator = (const NdnL3Protocol &); ///< copy operator is disabled
 
   // void
-  // GiveUpInterest (Ptr<CcnxPitEntry> pitEntry,
-  //                 Ptr<CcnxInterestHeader> header);
+  // GiveUpInterest (Ptr<NdnPitEntry> pitEntry,
+  //                 Ptr<NdnInterestHeader> header);
 
   // void
-  // OnDataDelayed (Ptr<const CcnxContentObjectHeader> header,
+  // OnDataDelayed (Ptr<const NdnContentObjectHeader> header,
   //                Ptr<const Packet> payload,
   //                const Ptr<const Packet> &packet);
   
 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;
-  CcnxFaceList m_faces; ///< \brief list of faces that belongs to ccnx stack on this node
+  typedef std::vector<Ptr<NdnFace> > NdnFaceList;
+  NdnFaceList m_faces; ///< \brief list of faces that belongs to ndn stack on this node
 
   // These objects are aggregated, but for optimization, get them here
-  Ptr<Node> m_node; ///< \brief node on which ccnx stack is installed
-  Ptr<CcnxForwardingStrategy> m_forwardingStrategy; ///< \brief smart pointer to the selected forwarding strategy
+  Ptr<Node> m_node; ///< \brief node on which ndn stack is installed
+  Ptr<NdnForwardingStrategy> m_forwardingStrategy; ///< \brief smart pointer to the selected forwarding strategy
 
   // bool m_nacksEnabled;
   // bool m_cacheUnsolicitedData;
@@ -184,4 +184,4 @@
   
 } // Namespace ns3
 
-#endif /* CCNX_L3_PROTOCOL_H */
+#endif /* NDN_L3_PROTOCOL_H */
diff --git a/model/ccnx-name-components-hash-helper.h b/model/ndn-name-components-hash-helper.h
similarity index 84%
rename from model/ccnx-name-components-hash-helper.h
rename to model/ndn-name-components-hash-helper.h
index 45e9f0e..c773580 100644
--- a/model/ccnx-name-components-hash-helper.h
+++ b/model/ndn-name-components-hash-helper.h
@@ -18,18 +18,18 @@
  * Author: Ilya Moiseenko <iliamo@cs.ucla.edu>
  */
 
-#ifndef CCNX_HASH_HELPER_H
-#define CCNX_HASH_HELPER_H
+#ifndef NDN_HASH_HELPER_H
+#define NDN_HASH_HELPER_H
 
 #include <string>
 #include <boost/foreach.hpp>
-#include "ccnx-name-components.h"
+#include "ndn-name-components.h"
 
 namespace ns3
 {
 
 /**
- * \ingroup ccnx-helpers
+ * \ingroup ndn-helpers
  * \brief Helper providing hash value for the name prefix
  *
  * The whole prefix is considered as a long string with '/' delimiters
@@ -37,13 +37,13 @@
  * \todo Testing is required to determine if this hash function
  * actually provides good hash results
  */
-struct CcnxPrefixHash : public std::unary_function<CcnxNameComponents, std::size_t>
+struct NdnPrefixHash : public std::unary_function<NdnNameComponents, std::size_t>
 {
   /**
    * @brief Compute hash of the name prefix
    */
   std::size_t
-  operator() (const CcnxNameComponents &prefix) const
+  operator() (const NdnNameComponents &prefix) const
   {
     std::size_t hash = 23;
     BOOST_FOREACH (const std::string &str, prefix.GetComponents ())
@@ -60,4 +60,4 @@
 };
 } // namespace ns3
 
-#endif // CCNX_HASH_HELPER_H
+#endif // NDN_HASH_HELPER_H
diff --git a/model/ccnx-name-components.cc b/model/ndn-name-components.cc
similarity index 74%
rename from model/ccnx-name-components.cc
rename to model/ndn-name-components.cc
index c852d33..96d40ec 100644
--- a/model/ccnx-name-components.cc
+++ b/model/ndn-name-components.cc
@@ -15,10 +15,11 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
- * Author: Ilya Moiseenko <iliamo@cs.ucla.edu>
+ * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
+ *         Ilya Moiseenko <iliamo@cs.ucla.edu>
  */
 
-#include "ccnx-name-components.h"
+#include "ndn-name-components.h"
 #include <boost/foreach.hpp>
 #include "ns3/log.h"
 
@@ -26,17 +27,17 @@
 
 using namespace std;
 
-NS_LOG_COMPONENT_DEFINE ("CcnxNameComponents");
+NS_LOG_COMPONENT_DEFINE ("NdnNameComponents");
 
 namespace ns3 {
 
-ATTRIBUTE_HELPER_CPP (CcnxNameComponents);
+ATTRIBUTE_HELPER_CPP (NdnNameComponents);
 
-CcnxNameComponents::CcnxNameComponents (/* root */)
+NdnNameComponents::NdnNameComponents (/* root */)
 {
 }
 
-CcnxNameComponents::CcnxNameComponents (const std::list<boost::reference_wrapper<const std::string> > &components)
+NdnNameComponents::NdnNameComponents (const std::list<boost::reference_wrapper<const std::string> > &components)
 {
   BOOST_FOREACH (const boost::reference_wrapper<const std::string> &component, components)
     {
@@ -44,13 +45,13 @@
     }
 }
 
-CcnxNameComponents::CcnxNameComponents (const std::string &prefix)
+NdnNameComponents::NdnNameComponents (const std::string &prefix)
 {
   istringstream is (prefix);
   is >> *this;
 }
 
-CcnxNameComponents::CcnxNameComponents (const char *prefix)
+NdnNameComponents::NdnNameComponents (const char *prefix)
 {
   NS_ASSERT (prefix != 0);
   
@@ -59,13 +60,13 @@
 }
 
 const std::list<std::string> &
-CcnxNameComponents::GetComponents () const
+NdnNameComponents::GetComponents () const
 {
   return m_prefix;
 }
 
 std::string
-CcnxNameComponents::GetLastComponent () const
+NdnNameComponents::GetLastComponent () const
 {
   if (m_prefix.size () == 0)
     {
@@ -76,7 +77,7 @@
 }
 
 std::list<boost::reference_wrapper<const std::string> >
-CcnxNameComponents::GetSubComponents (size_t num) const
+NdnNameComponents::GetSubComponents (size_t num) const
 {
   NS_ASSERT_MSG (0<=num && num<=m_prefix.size (), "Invalid number of subcomponents requested");
   
@@ -90,10 +91,10 @@
   return subComponents;
 }
 
-CcnxNameComponents
-CcnxNameComponents::cut (size_t minusComponents) const
+NdnNameComponents
+NdnNameComponents::cut (size_t minusComponents) const
 {
-  CcnxNameComponents retval;
+  NdnNameComponents retval;
   std::list<std::string>::const_iterator component = m_prefix.begin (); 
   for (uint32_t i = 0; i < m_prefix.size () - minusComponents; i++, component++)
     {
@@ -104,7 +105,7 @@
 }
 
 void
-CcnxNameComponents::Print (std::ostream &os) const
+NdnNameComponents::Print (std::ostream &os) const
 {
   for (const_iterator i=m_prefix.begin(); i!=m_prefix.end(); i++)
     {
@@ -114,14 +115,14 @@
 }
   
 std::ostream &
-operator << (std::ostream &os, const CcnxNameComponents &components)
+operator << (std::ostream &os, const NdnNameComponents &components)
 {
   components.Print (os);
   return os;
 }
 
 std::istream &
-operator >> (std::istream &is, CcnxNameComponents &components)
+operator >> (std::istream &is, NdnNameComponents &components)
 {
   istream_iterator<char> eos; // end of stream
   
diff --git a/model/ccnx-name-components.h b/model/ndn-name-components.h
similarity index 76%
rename from model/ccnx-name-components.h
rename to model/ndn-name-components.h
index 54f9998..553c140 100644
--- a/model/ccnx-name-components.h
+++ b/model/ndn-name-components.h
@@ -15,7 +15,8 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
- * Author: Ilya Moiseenko <iliamo@cs.ucla.edu>
+ * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
+ *         Ilya Moiseenko <iliamo@cs.ucla.edu>
  */
 
 #ifndef _NDN_NAME_COMPONENTS_H_
@@ -35,15 +36,15 @@
 namespace ns3 {
 
 /**
- * \ingroup ccnx
- * \brief Hierarchical CCNX name
- * A Name element represents a hierarchical name for CCNx content. 
+ * \ingroup ndn
+ * \brief Hierarchical NDN name
+ * A Name element represents a hierarchical name for Ndn content. 
  * It simply contains a sequence of Component elements. 
  * Each Component element contains a sequence of zero or more bytes. 
  * There are no restrictions on what byte sequences may be used.
  * The Name element in an Interest is often referred to with the term name prefix or simply prefix.
  */ 
-class CcnxNameComponents : public SimpleRefCount<CcnxNameComponents>
+class NdnNameComponents : public SimpleRefCount<NdnNameComponents>
 {
 public:
   typedef std::list<std::string>::iterator       iterator;            
@@ -53,28 +54,28 @@
    * \brief Constructor 
    * Creates a prefix with zero components (can be looked as root "/")
    */
-  CcnxNameComponents ();
+  NdnNameComponents ();
   
   /**
    * \brief Constructor
    * Creates a prefix from a list of strings where every string represents a prefix component
    * @param[in] components A list of strings
    */
-  CcnxNameComponents (const std::list<boost::reference_wrapper<const std::string> > &components);
+  NdnNameComponents (const std::list<boost::reference_wrapper<const std::string> > &components);
 
   /**
    * @brief Constructor
    * Creates a prefix from the string (string is parsed using operator>>)
    * @param[in] prefix A string representation of a prefix
    */
-  CcnxNameComponents (const std::string &prefix);
+  NdnNameComponents (const std::string &prefix);
 
   /**
    * @brief Constructor
    * Creates a prefix from the string (string is parsed using operator>>)
    * @param[in] prefix A string representation of a prefix
    */
-  CcnxNameComponents (const char *prefix);
+  NdnNameComponents (const char *prefix);
   
   /**
    * \brief Generic Add method
@@ -90,7 +91,7 @@
    * The object of type T will be appended to the list of components
    */
   template<class T>
-  inline CcnxNameComponents&
+  inline NdnNameComponents&
   operator () (const T &value);
 
   /**
@@ -116,7 +117,7 @@
   /**
    * @brief Get prefix of the name, containing less  minusComponents right components
    */
-  CcnxNameComponents
+  NdnNameComponents
   cut (size_t minusComponents) const;
   
   /**
@@ -126,7 +127,7 @@
   void Print (std::ostream &os) const;
 
   /**
-   * \brief Returns the size of CcnxNameComponents
+   * \brief Returns the size of NdnNameComponents
    */
   inline size_t
   size () const;
@@ -156,16 +157,16 @@
   end () const;
 
   /**
-   * \brief Equality operator for CcnxNameComponents
+   * \brief Equality operator for NdnNameComponents
    */
   inline bool
-  operator== (const CcnxNameComponents &prefix) const;
+  operator== (const NdnNameComponents &prefix) const;
 
   /**
-   * \brief Less than operator for CcnxNameComponents
+   * \brief Less than operator for NdnNameComponents
    */
   inline bool
-  operator< (const CcnxNameComponents &prefix) const;
+  operator< (const NdnNameComponents &prefix) const;
 
   typedef std::string partial_type;
   
@@ -177,26 +178,26 @@
  * \brief Print out name components separated by slashes, e.g., /first/second/third
  */
 std::ostream &
-operator << (std::ostream &os, const CcnxNameComponents &components);
+operator << (std::ostream &os, const NdnNameComponents &components);
 
 /**
  * \brief Read components from input and add them to components. Will read input stream till eof
  * Substrings separated by slashes will become separate components
  */
 std::istream &
-operator >> (std::istream &is, CcnxNameComponents &components);
+operator >> (std::istream &is, NdnNameComponents &components);
 
 /**
- * \brief Returns the size of CcnxNameComponents object
+ * \brief Returns the size of NdnNameComponents object
  */  
 size_t
-CcnxNameComponents::size () const
+NdnNameComponents::size () const
 {
   return m_prefix.size ();
 }
 
-CcnxNameComponents::iterator
-CcnxNameComponents::begin ()
+NdnNameComponents::iterator
+NdnNameComponents::begin ()
 {
   return m_prefix.begin ();
 }
@@ -204,8 +205,8 @@
 /**
  * @brief Get read-only begin() iterator
  */
-CcnxNameComponents::const_iterator
-CcnxNameComponents::begin () const
+NdnNameComponents::const_iterator
+NdnNameComponents::begin () const
 {
   return m_prefix.begin ();
 }  
@@ -213,8 +214,8 @@
 /**
  * @brief Get read-write end() iterator
  */
-CcnxNameComponents::iterator
-CcnxNameComponents::end ()
+NdnNameComponents::iterator
+NdnNameComponents::end ()
 {
   return m_prefix.end ();
 }
@@ -222,8 +223,8 @@
 /**
  * @brief Get read-only end() iterator
  */
-CcnxNameComponents::const_iterator
-CcnxNameComponents::end () const
+NdnNameComponents::const_iterator
+NdnNameComponents::end () const
 {
   return m_prefix.end ();
 }
@@ -234,8 +235,8 @@
  * The object of type T will be appended to the list of components
  */
 template<class T>
-CcnxNameComponents&
-CcnxNameComponents::operator () (const T &value)
+NdnNameComponents&
+NdnNameComponents::operator () (const T &value)
 {
   Add (value);
   return *this;
@@ -248,7 +249,7 @@
  */
 template<class T>
 void
-CcnxNameComponents::Add (const T &value)
+NdnNameComponents::Add (const T &value)
 {
   std::ostringstream os;
   os << value;
@@ -256,10 +257,10 @@
 }
 
 /**
- * \brief Equality operator for CcnxNameComponents
+ * \brief Equality operator for NdnNameComponents
  */
 bool
-CcnxNameComponents::operator== (const CcnxNameComponents &prefix) const
+NdnNameComponents::operator== (const NdnNameComponents &prefix) const
 {
   if (m_prefix.size () != prefix.m_prefix.size ())
     return false;
@@ -268,17 +269,17 @@
 }
 
 /**
- * \brief Less than operator for CcnxNameComponents
+ * \brief Less than operator for NdnNameComponents
  */
 bool
-CcnxNameComponents::operator< (const CcnxNameComponents &prefix) const
+NdnNameComponents::operator< (const NdnNameComponents &prefix) const
 {
   return std::lexicographical_compare (m_prefix.begin (), m_prefix.end (),
                                        prefix.m_prefix.begin (), prefix.m_prefix.end ());
 }
 
     
-ATTRIBUTE_HELPER_HEADER (CcnxNameComponents);
+ATTRIBUTE_HELPER_HEADER (NdnNameComponents);
 } // namespace ns3
 
 #endif // _NDN_NAME_COMPONENTS_H_
diff --git a/model/ccnx-net-device-face.cc b/model/ndn-net-device-face.cc
similarity index 65%
rename from model/ccnx-net-device-face.cc
rename to model/ndn-net-device-face.cc
index 95e45c2..7baa363 100644
--- a/model/ccnx-net-device-face.cc
+++ b/model/ndn-net-device-face.cc
@@ -19,8 +19,8 @@
  *
  */
 
-#include "ccnx-net-device-face.h"
-#include "ccnx-l3-protocol.h"
+#include "ndn-net-device-face.h"
+#include "ndn-l3-protocol.h"
 
 #include "ns3/net-device.h"
 #include "ns3/log.h"
@@ -30,82 +30,82 @@
 
 #include "ns3/point-to-point-net-device.h"
 #include "ns3/channel.h"
-#include "ns3/ccnx-name-components.h"
+#include "ns3/ndn-name-components.h"
 
-NS_LOG_COMPONENT_DEFINE ("CcnxNetDeviceFace");
+NS_LOG_COMPONENT_DEFINE ("NdnNetDeviceFace");
 
 namespace ns3 {
 
 TypeId
-CcnxNetDeviceFace::GetTypeId ()
+NdnNetDeviceFace::GetTypeId ()
 {
-  static TypeId tid = TypeId ("ns3::CcnxNetDeviceFace")
-    .SetParent<CcnxFace> ()
-    .SetGroupName ("Ccnx")
+  static TypeId tid = TypeId ("ns3::NdnNetDeviceFace")
+    .SetParent<NdnFace> ()
+    .SetGroupName ("Ndn")
     ;
   return tid;
 }
 
 /** 
- * By default, Ccnx face are created in the "down" state.  Before
+ * By default, Ndn face are created in the "down" state.  Before
  * becoming useable, the user must invoke SetUp on the face
  */
-CcnxNetDeviceFace::CcnxNetDeviceFace (Ptr<Node> node, const Ptr<NetDevice> &netDevice)
-  : CcnxFace (node)
+NdnNetDeviceFace::NdnNetDeviceFace (Ptr<Node> node, const Ptr<NetDevice> &netDevice)
+  : NdnFace (node)
   , m_netDevice (netDevice)
 {
   NS_LOG_FUNCTION (this << netDevice);
 
   SetMetric (1); // default metric
 
-  NS_ASSERT_MSG (m_netDevice != 0, "CcnxNetDeviceFace needs to be assigned a valid NetDevice");
+  NS_ASSERT_MSG (m_netDevice != 0, "NdnNetDeviceFace needs to be assigned a valid NetDevice");
 }
 
-CcnxNetDeviceFace::~CcnxNetDeviceFace ()
+NdnNetDeviceFace::~NdnNetDeviceFace ()
 {
   NS_LOG_FUNCTION_NOARGS ();
 }
 
-CcnxNetDeviceFace& CcnxNetDeviceFace::operator= (const CcnxNetDeviceFace &)
+NdnNetDeviceFace& NdnNetDeviceFace::operator= (const NdnNetDeviceFace &)
 {
   return *this;
 }
 
 Ptr<NetDevice>
-CcnxNetDeviceFace::GetNetDevice () const
+NdnNetDeviceFace::GetNetDevice () const
 {
   return m_netDevice;
 }
 
 void
-CcnxNetDeviceFace::RegisterProtocolHandler (ProtocolHandler handler)
+NdnNetDeviceFace::RegisterProtocolHandler (ProtocolHandler handler)
 {
   NS_LOG_FUNCTION (this);
 
-  CcnxFace::RegisterProtocolHandler (handler);
+  NdnFace::RegisterProtocolHandler (handler);
   
-  m_node->RegisterProtocolHandler (MakeCallback (&CcnxNetDeviceFace::ReceiveFromNetDevice, this),
-                                   CcnxL3Protocol::ETHERNET_FRAME_TYPE, m_netDevice, true/*promiscuous mode*/);
+  m_node->RegisterProtocolHandler (MakeCallback (&NdnNetDeviceFace::ReceiveFromNetDevice, this),
+                                   NdnL3Protocol::ETHERNET_FRAME_TYPE, m_netDevice, true/*promiscuous mode*/);
 }
 
 bool
-CcnxNetDeviceFace::SendImpl (Ptr<Packet> packet)
+NdnNetDeviceFace::SendImpl (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");
+                 << " for Ndn; fragmentation not supported");
 
   bool ok = m_netDevice->Send (packet, m_netDevice->GetBroadcast (), 
-                               CcnxL3Protocol::ETHERNET_FRAME_TYPE);
+                               NdnL3Protocol::ETHERNET_FRAME_TYPE);
   return ok;
 }
 
 // callback
 void
-CcnxNetDeviceFace::ReceiveFromNetDevice (Ptr<NetDevice> device,
+NdnNetDeviceFace::ReceiveFromNetDevice (Ptr<NetDevice> device,
                                          Ptr<const Packet> p,
                                          uint16_t protocol,
                                          const Address &from,
@@ -118,7 +118,7 @@
 
 
 std::ostream&
-CcnxNetDeviceFace::Print (std::ostream& os) const
+NdnNetDeviceFace::Print (std::ostream& os) const
 {
   os << "dev[" << GetNode ()->GetId () << "]=net(" << GetId () << ",";
   os << DynamicCast<PointToPointNetDevice> (m_netDevice)->GetChannel ()->GetDevice (0)->GetNode ()->GetId ();
diff --git a/model/ccnx-net-device-face.h b/model/ndn-net-device-face.h
similarity index 72%
rename from model/ccnx-net-device-face.h
rename to model/ndn-net-device-face.h
index 2a018bf..bc132f7 100644
--- a/model/ccnx-net-device-face.h
+++ b/model/ndn-net-device-face.h
@@ -18,10 +18,10 @@
  * Authors: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef CCNX_NET_DEVICE_FACE_H
-#define CCNX_NET_DEVICE_FACE_H
+#ifndef NDN_NET_DEVICE_FACE_H
+#define NDN_NET_DEVICE_FACE_H
 
-#include "ccnx-face.h"
+#include "ndn-face.h"
 #include "ns3/net-device.h"
 
 namespace ns3 {
@@ -29,20 +29,20 @@
 class Address;
   
 /**
- * \ingroup ccnx-face
- * \brief Implementation of layer-2 (Ethernet) CCNx face
+ * \ingroup ndn-face
+ * \brief Implementation of layer-2 (Ethernet) Ndn face
  *
- * This class defines basic functionality of CCNx face. Face is core
+ * This class defines basic functionality of Ndn face. Face is core
  * component responsible for actual delivery of data packet to and
- * from CCNx stack
+ * from Ndn stack
  *
- * CcnxNetDevice face is permanently associated with one NetDevice
+ * NdnNetDevice face is permanently associated with one NetDevice
  * object and this object cannot be changed for the lifetime of the
  * face
  *
- * \see CcnxAppFace, CcnxNetDeviceFace, CcnxIpv4Face, CcnxUdpFace
+ * \see NdnAppFace, NdnNetDeviceFace, NdnIpv4Face, NdnUdpFace
  */
-class CcnxNetDeviceFace  : public CcnxFace
+class NdnNetDeviceFace  : public NdnFace
 {
 public:
   static TypeId
@@ -55,22 +55,22 @@
    * @param netDevice a smart pointer to NetDevice object to which
    * this face will be associate
    */
-  CcnxNetDeviceFace (Ptr<Node> node, const Ptr<NetDevice> &netDevice);
-  virtual ~CcnxNetDeviceFace();
+  NdnNetDeviceFace (Ptr<Node> node, const Ptr<NetDevice> &netDevice);
+  virtual ~NdnNetDeviceFace();
 
   ////////////////////////////////////////////////////////////////////
-  // methods overloaded from CcnxFace
+  // methods overloaded from NdnFace
   virtual void
   RegisterProtocolHandler (ProtocolHandler handler);
   
 protected:
-  // also from CcnxFace
+  // also from NdnFace
   virtual bool
   SendImpl (Ptr<Packet> p);
 
 public:
   /**
-   * @brief Print out name of the CcnxFace to the stream
+   * @brief Print out name of the NdnFace to the stream
    */
   virtual std::ostream&
   Print (std::ostream &os) const;
@@ -84,8 +84,8 @@
   Ptr<NetDevice> GetNetDevice () const;
 
 private:
-  CcnxNetDeviceFace (const CcnxNetDeviceFace &); ///< \brief Disabled copy constructor
-  CcnxNetDeviceFace& operator= (const CcnxNetDeviceFace &); ///< \brief Disabled copy operator
+  NdnNetDeviceFace (const NdnNetDeviceFace &); ///< \brief Disabled copy constructor
+  NdnNetDeviceFace& operator= (const NdnNetDeviceFace &); ///< \brief Disabled copy operator
 
   /// \brief callback from lower layers
   void ReceiveFromNetDevice (Ptr<NetDevice> device,
@@ -101,4 +101,4 @@
 
 } // namespace ns3
 
-#endif //CCNX_NET_DEVICE_FACE_H
+#endif //NDN_NET_DEVICE_FACE_H
diff --git a/model/ccnx.cc b/model/ndn.cc
similarity index 76%
rename from model/ccnx.cc
rename to model/ndn.cc
index 79452bf..1083992 100644
--- a/model/ccnx.cc
+++ b/model/ndn.cc
@@ -22,27 +22,27 @@
 #include "ns3/node.h" 
 #include "ns3/boolean.h"
 
-#include "ccnx.h"
-#include "ccnx-face.h"
-#include "forwarding-strategy/ccnx-forwarding-strategy.h"
-#include "ccnx-interest-header.h"
-#include "ccnx-content-object-header.h"
+#include "ndn.h"
+#include "ndn-face.h"
+#include "forwarding-strategy/ndn-forwarding-strategy.h"
+#include "ndn-interest-header.h"
+#include "ndn-content-object-header.h"
 
 namespace ns3 {
 
-NS_OBJECT_ENSURE_REGISTERED (Ccnx);
+NS_OBJECT_ENSURE_REGISTERED (Ndn);
 
 TypeId 
-Ccnx::GetTypeId (void)
+Ndn::GetTypeId (void)
 {
-  static TypeId tid = TypeId ("ns3::Ccnx")
-    .SetGroupName ("Ccnx")
+  static TypeId tid = TypeId ("ns3::Ndn")
+    .SetGroupName ("Ndn")
     .SetParent<Object> ()
   ;
   return tid;
 }
 
-Ccnx::~Ccnx ()
+Ndn::~Ndn ()
 {
 }
 
diff --git a/model/ccnx.h b/model/ndn.h
similarity index 63%
rename from model/ccnx.h
rename to model/ndn.h
index ca36c1f..55c5722 100644
--- a/model/ccnx.h
+++ b/model/ndn.h
@@ -18,8 +18,8 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef _CCNX_H_
-#define _CCNX_H_
+#ifndef _NDN_H_
+#define _NDN_H_
 
 #include "ns3/object.h"
 #include "ns3/callback.h"
@@ -30,18 +30,18 @@
 class Node;
 class NetDevice;
 class Packet;
-class CcnxForwardingStrategy;
-class CcnxFace;
-class CcnxContentObjectHeader;
-class CcnxInterestHeader;
-class CcnxPit;
+class NdnForwardingStrategy;
+class NdnFace;
+class NdnContentObjectHeader;
+class NdnInterestHeader;
+class NdnPit;
 
 /// @cond include_hidden
 /**
  * \internal
- * \brief Private namespace for CCNx content store implementation
+ * \brief Private namespace for Ndn content store implementation
  */
-namespace __ccnx_private
+namespace __ndn_private
 {
 class i_face {};
 class i_metric {};
@@ -57,30 +57,30 @@
 // #define NDN_INTEREST_RESET_PERIOD	(10*MILLI_SECOND)
 
 /**
- * \defgroup ccnx NDN abstraction
+ * \defgroup ndn NDN abstraction
  *
  * This is an abstract implementation of NDN protocol
  */
 /**
- * \ingroup ccnx
- * \brief Interface to manage Ccnx stack
+ * \ingroup ndn
+ * \brief Interface to manage Ndn stack
  *
  * This class defines the API to manipulate the following aspects of
- * the Ccnx stack implementation:
- * -# register a face (CcnxFace-derived object) for use by the Ccnx
+ * the Ndn stack implementation:
+ * -# register a face (NdnFace-derived object) for use by the Ndn
  *    layer
- * -# register forwarding strategy (CcnxForwardingStrategy-derived
- *    object) to use by Ccnx stack
- * -# export Ccnx configuration attributes
+ * -# register forwarding strategy (NdnForwardingStrategy-derived
+ *    object) to use by Ndn stack
+ * -# export Ndn configuration attributes
  * 
- * Each CcnxFace-derived object has conceptually a single Ccnx
+ * Each NdnFace-derived object has conceptually a single Ndn
  * interface associated with it.
  *
- * In addition, this class defines CCNx packet coding constants
+ * In addition, this class defines Ndn packet coding constants
  *
- * \see CcnxFace, CcnxForwardingStrategy
+ * \see NdnFace, NdnForwardingStrategy
  */
-class Ccnx : public Object
+class Ndn : public Object
 {
 public:
   /**
@@ -89,22 +89,22 @@
    * \return interface ID
    */
   static TypeId GetTypeId ();
-  virtual ~Ccnx ();
+  virtual ~Ndn ();
   
   /**
-   * \brief Add face to CCNx stack
+   * \brief Add face to Ndn stack
    *
-   * \param face smart pointer to CcnxFace-derived object
-   * (CcnxLocalFace, CcnxNetDeviceFace, CcnxUdpFace) \returns the
-   * index of the Ccnx interface added.
+   * \param face smart pointer to NdnFace-derived object
+   * (NdnLocalFace, NdnNetDeviceFace, NdnUdpFace) \returns the
+   * index of the Ndn interface added.
    * 
-   * \see CcnxLocalFace, CcnxNetDeviceFace, CcnxUdpFace
+   * \see NdnLocalFace, NdnNetDeviceFace, NdnUdpFace
    */
   virtual uint32_t
-  AddFace (const Ptr<CcnxFace> &face) = 0;
+  AddFace (const Ptr<NdnFace> &face) = 0;
 
   /**
-   * \brief Get current number of faces added to CCNx stack
+   * \brief Get current number of faces added to Ndn stack
    *
    * \returns the number of faces
    */
@@ -113,22 +113,22 @@
 
   /**
    * \brief Get face by face index
-   * \param face The face number of an Ccnx interface.
-   * \returns The CcnxFace associated with the Ccnx face number.
+   * \param face The face number of an Ndn interface.
+   * \returns The NdnFace associated with the Ndn face number.
    */
-  virtual Ptr<CcnxFace>
+  virtual Ptr<NdnFace>
   GetFace (uint32_t face) const = 0;
 
   /**
-   * \brief Remove face from ccnx stack (remove callbacks)
+   * \brief Remove face from ndn stack (remove callbacks)
    */
   virtual void
-  RemoveFace (Ptr<CcnxFace> face) = 0;
+  RemoveFace (Ptr<NdnFace> face) = 0;
 
   /**
    * \brief Get face for NetDevice
    */
-  virtual Ptr<CcnxFace>
+  virtual Ptr<NdnFace>
   GetFaceByNetDevice (Ptr<NetDevice> netDevice) const = 0;
 
   // /**
@@ -149,4 +149,4 @@
 
 } // namespace ns3 
 
-#endif /* _CCNX_H_ */
+#endif /* _NDN_H_ */
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 */