diff --git a/helper/boost-graph-ccnx-global-routing-helper.h b/helper/boost-graph-ndn-global-routing-helper.h
similarity index 61%
rename from helper/boost-graph-ccnx-global-routing-helper.h
rename to helper/boost-graph-ndn-global-routing-helper.h
index ab6a239..ab619c6 100644
--- a/helper/boost-graph-ccnx-global-routing-helper.h
+++ b/helper/boost-graph-ndn-global-routing-helper.h
@@ -19,8 +19,8 @@
  */
 
 
-#ifndef BOOST_GRAPH_CCNX_GLOBAL_ROUTING_HELPER_H
-#define BOOST_GRAPH_CCNX_GLOBAL_ROUTING_HELPER_H
+#ifndef BOOST_GRAPH_NDN_GLOBAL_ROUTING_HELPER_H
+#define BOOST_GRAPH_NDN_GLOBAL_ROUTING_HELPER_H
 
 /// @cond include_hidden
 
@@ -28,35 +28,35 @@
 #include <boost/graph/properties.hpp>
 #include <boost/ref.hpp>
 
-#include "ns3/ccnx-face.h"
+#include "ns3/ndn-face.h"
 #include "ns3/node-list.h"
 #include "ns3/channel-list.h"
-#include "../model/ccnx-global-router.h"
+#include "../model/ndn-global-router.h"
 #include <list>
 #include <map>
 
 namespace boost
 {
 
-class CcnxGlobalRouterGraph
+class NdnGlobalRouterGraph
 {
 public:
-  typedef ns3::Ptr< ns3::CcnxGlobalRouter > Vertice;
+  typedef ns3::Ptr< ns3::NdnGlobalRouter > Vertice;
   typedef uint16_t edge_property_type;
   typedef uint32_t vertex_property_type;
   
-  CcnxGlobalRouterGraph ()
+  NdnGlobalRouterGraph ()
   {
     for (ns3::NodeList::Iterator node = ns3::NodeList::Begin (); node != ns3::NodeList::End (); node++)
       {
-        ns3::Ptr<ns3::CcnxGlobalRouter> gr = (*node)->GetObject<ns3::CcnxGlobalRouter> ();
+        ns3::Ptr<ns3::NdnGlobalRouter> gr = (*node)->GetObject<ns3::NdnGlobalRouter> ();
 	if (gr != 0)
 	  m_vertices.push_back (gr);
       }
 
     for (ns3::ChannelList::Iterator channel = ns3::ChannelList::Begin (); channel != ns3::ChannelList::End (); channel++)
       {
-        ns3::Ptr<ns3::CcnxGlobalRouter> gr = (*channel)->GetObject<ns3::CcnxGlobalRouter> ();
+        ns3::Ptr<ns3::NdnGlobalRouter> gr = (*channel)->GetObject<ns3::NdnGlobalRouter> ();
 	if (gr != 0)
 	  m_vertices.push_back (gr);
       }
@@ -73,7 +73,7 @@
 };
 
 
-class ccnx_global_router_graph_category :
+class ndn_global_router_graph_category :
     public virtual vertex_list_graph_tag,
     public virtual incidence_graph_tag
 {
@@ -81,21 +81,21 @@
 
 
 template<>
-struct graph_traits< CcnxGlobalRouterGraph >
+struct graph_traits< NdnGlobalRouterGraph >
 {
   // Graph concept
-  typedef CcnxGlobalRouterGraph::Vertice vertex_descriptor;
-  typedef ns3::CcnxGlobalRouter::Incidency edge_descriptor;
+  typedef NdnGlobalRouterGraph::Vertice vertex_descriptor;
+  typedef ns3::NdnGlobalRouter::Incidency edge_descriptor;
   typedef directed_tag directed_category;
   typedef disallow_parallel_edge_tag edge_parallel_category;
-  typedef ccnx_global_router_graph_category traversal_category;
+  typedef ndn_global_router_graph_category traversal_category;
 
   // VertexList concept
   typedef std::list< vertex_descriptor >::const_iterator vertex_iterator;
   typedef size_t vertices_size_type;
 
   // AdjacencyGraph concept
-  typedef ns3::CcnxGlobalRouter::IncidencyList::iterator out_edge_iterator;
+  typedef ns3::NdnGlobalRouter::IncidencyList::iterator out_edge_iterator;
   typedef size_t degree_size_type;
 
   // typedef size_t edges_size_type;
@@ -107,55 +107,55 @@
 {
 
 inline
-graph_traits< CcnxGlobalRouterGraph >::vertex_descriptor
+graph_traits< NdnGlobalRouterGraph >::vertex_descriptor
 source(
-       graph_traits< CcnxGlobalRouterGraph >::edge_descriptor e,
-       const CcnxGlobalRouterGraph& g)
+       graph_traits< NdnGlobalRouterGraph >::edge_descriptor e,
+       const NdnGlobalRouterGraph& g)
 {
   return e.get<0> ();
 }
 
 inline
-graph_traits< CcnxGlobalRouterGraph >::vertex_descriptor
+graph_traits< NdnGlobalRouterGraph >::vertex_descriptor
 target(
-       graph_traits< CcnxGlobalRouterGraph >::edge_descriptor e,
-       const CcnxGlobalRouterGraph& g)
+       graph_traits< NdnGlobalRouterGraph >::edge_descriptor e,
+       const NdnGlobalRouterGraph& g)
 {
   return e.get<2> ();
 }
 
 inline
-std::pair< graph_traits< CcnxGlobalRouterGraph >::vertex_iterator,
-	   graph_traits< CcnxGlobalRouterGraph >::vertex_iterator >
-vertices (const CcnxGlobalRouterGraph&g)
+std::pair< graph_traits< NdnGlobalRouterGraph >::vertex_iterator,
+	   graph_traits< NdnGlobalRouterGraph >::vertex_iterator >
+vertices (const NdnGlobalRouterGraph&g)
 {
   return make_pair (g.GetVertices ().begin (), g.GetVertices ().end ());
 }
 
 inline
-graph_traits< CcnxGlobalRouterGraph >::vertices_size_type
-num_vertices(const CcnxGlobalRouterGraph &g)
+graph_traits< NdnGlobalRouterGraph >::vertices_size_type
+num_vertices(const NdnGlobalRouterGraph &g)
 {
   return g.GetVertices ().size ();
 }
   
 
 inline
-std::pair< graph_traits< CcnxGlobalRouterGraph >::out_edge_iterator,
-	   graph_traits< CcnxGlobalRouterGraph >::out_edge_iterator >  
+std::pair< graph_traits< NdnGlobalRouterGraph >::out_edge_iterator,
+	   graph_traits< NdnGlobalRouterGraph >::out_edge_iterator >  
 out_edges(
-	  graph_traits< CcnxGlobalRouterGraph >::vertex_descriptor u, 
-	  const CcnxGlobalRouterGraph& g)
+	  graph_traits< NdnGlobalRouterGraph >::vertex_descriptor u, 
+	  const NdnGlobalRouterGraph& g)
 {
   return std::make_pair(u->GetIncidencies ().begin (),
 			u->GetIncidencies ().end ());
 }
 
 inline
-graph_traits< CcnxGlobalRouterGraph >::degree_size_type
+graph_traits< NdnGlobalRouterGraph >::degree_size_type
 out_degree(
-	  graph_traits< CcnxGlobalRouterGraph >::vertex_descriptor u, 
-	  const CcnxGlobalRouterGraph& g)
+	  graph_traits< NdnGlobalRouterGraph >::vertex_descriptor u, 
+	  const NdnGlobalRouterGraph& g)
 {
   return u->GetIncidencies ().size ();
 }
@@ -166,36 +166,36 @@
 
 struct EdgeWeights
 {
-  EdgeWeights (const CcnxGlobalRouterGraph &graph)
+  EdgeWeights (const NdnGlobalRouterGraph &graph)
   : m_graph (graph)
   { 
   }
 
 private:
-  const CcnxGlobalRouterGraph &m_graph;
+  const NdnGlobalRouterGraph &m_graph;
 };
 
 
 struct VertexIds
 {
-  VertexIds (const CcnxGlobalRouterGraph &graph)
+  VertexIds (const NdnGlobalRouterGraph &graph)
   : m_graph (graph)
   { 
   }
 
 private:
-  const CcnxGlobalRouterGraph &m_graph;
+  const NdnGlobalRouterGraph &m_graph;
 };
 
 template<>
-struct property_map< CcnxGlobalRouterGraph, edge_weight_t >
+struct property_map< NdnGlobalRouterGraph, edge_weight_t >
 {
   typedef const EdgeWeights const_type;
   typedef EdgeWeights type;
 };
 
 template<>
-struct property_map< CcnxGlobalRouterGraph, vertex_index_t >
+struct property_map< NdnGlobalRouterGraph, vertex_index_t >
 {
   typedef const VertexIds const_type;
   typedef VertexIds type;
@@ -206,9 +206,9 @@
 struct property_traits< EdgeWeights >
 {
   // Metric property map
-  typedef tuple< ns3::Ptr<ns3::CcnxFace>, uint16_t > value_type;
-  typedef tuple< ns3::Ptr<ns3::CcnxFace>, uint16_t > reference;
-  typedef ns3::CcnxGlobalRouter::Incidency key_type;
+  typedef tuple< ns3::Ptr<ns3::NdnFace>, uint16_t > value_type;
+  typedef tuple< ns3::Ptr<ns3::NdnFace>, uint16_t > reference;
+  typedef ns3::NdnGlobalRouter::Incidency key_type;
   typedef readable_property_map_tag category;
 };
 
@@ -254,8 +254,8 @@
     return a + b.get<1> ();
   }
 
-  tuple< ns3::Ptr<ns3::CcnxFace>, uint32_t >
-  operator () (tuple< ns3::Ptr<ns3::CcnxFace>, uint32_t > a,
+  tuple< ns3::Ptr<ns3::NdnFace>, uint32_t >
+  operator () (tuple< ns3::Ptr<ns3::NdnFace>, uint32_t > a,
                property_traits< EdgeWeights >::reference b) const
   {
     if (a.get<0> () == 0)
@@ -271,14 +271,14 @@
   // Metric property map
   typedef uint32_t value_type;
   typedef uint32_t reference;
-  typedef ns3::Ptr< ns3::CcnxGlobalRouter > key_type;
+  typedef ns3::Ptr< ns3::NdnGlobalRouter > key_type;
   typedef readable_property_map_tag category;
 };
 
 
 inline EdgeWeights
 get(edge_weight_t,
-    const CcnxGlobalRouterGraph &g)
+    const NdnGlobalRouterGraph &g)
 {
   return EdgeWeights (g);
 }
@@ -286,7 +286,7 @@
 
 inline VertexIds
 get(vertex_index_t,
-    const CcnxGlobalRouterGraph &g)
+    const NdnGlobalRouterGraph &g)
 {
   return VertexIds (g);
 }
@@ -300,16 +300,16 @@
 }
 
 // void
-// put (cref< std::map< ns3::Ptr<ns3::CcnxGlobalRouter>, ns3::Ptr<ns3::CcnxGlobalRouter> > > map,
+// put (cref< std::map< ns3::Ptr<ns3::NdnGlobalRouter>, ns3::Ptr<ns3::NdnGlobalRouter> > > map,
 
 uint32_t
-get (const boost::VertexIds&, ns3::Ptr<ns3::CcnxGlobalRouter> &gr)
+get (const boost::VertexIds&, ns3::Ptr<ns3::NdnGlobalRouter> &gr)
 {
   return gr->GetId ();
 }
 
 inline property_traits< EdgeWeights >::reference
-get(const boost::EdgeWeights&, ns3::CcnxGlobalRouter::Incidency &edge)
+get(const boost::EdgeWeights&, ns3::NdnGlobalRouter::Incidency &edge)
 {
   if (edge.get<1> () == 0)
     return property_traits< EdgeWeights >::reference (0, 0);
@@ -318,7 +318,7 @@
 }
 
 struct PredecessorsMap :
-  public std::map< ns3::Ptr< ns3::CcnxGlobalRouter >, ns3::Ptr< ns3::CcnxGlobalRouter > >
+  public std::map< ns3::Ptr< ns3::NdnGlobalRouter >, ns3::Ptr< ns3::NdnGlobalRouter > >
 {
 };
 
@@ -326,15 +326,15 @@
 struct property_traits< reference_wrapper<PredecessorsMap> >
 {
   // Metric property map
-  typedef ns3::Ptr< ns3::CcnxGlobalRouter > value_type;
-  typedef ns3::Ptr< ns3::CcnxGlobalRouter > reference;
-  typedef ns3::Ptr< ns3::CcnxGlobalRouter > key_type;
+  typedef ns3::Ptr< ns3::NdnGlobalRouter > value_type;
+  typedef ns3::Ptr< ns3::NdnGlobalRouter > reference;
+  typedef ns3::Ptr< ns3::NdnGlobalRouter > key_type;
   typedef read_write_property_map_tag category;
 };
 
 
 struct DistancesMap :
-  public std::map< ns3::Ptr< ns3::CcnxGlobalRouter >, tuple< ns3::Ptr<ns3::CcnxFace>, uint32_t > >
+  public std::map< ns3::Ptr< ns3::NdnGlobalRouter >, tuple< ns3::Ptr<ns3::NdnFace>, uint32_t > >
 {
 };
 
@@ -342,18 +342,18 @@
 struct property_traits< reference_wrapper<DistancesMap> >
 {
   // Metric property map
-  typedef tuple< ns3::Ptr<ns3::CcnxFace>, uint32_t > value_type;
-  typedef tuple< ns3::Ptr<ns3::CcnxFace>, uint32_t > reference;
-  typedef ns3::Ptr< ns3::CcnxGlobalRouter > key_type;
+  typedef tuple< ns3::Ptr<ns3::NdnFace>, uint32_t > value_type;
+  typedef tuple< ns3::Ptr<ns3::NdnFace>, uint32_t > reference;
+  typedef ns3::Ptr< ns3::NdnGlobalRouter > key_type;
   typedef read_write_property_map_tag category;
 };
 
-inline tuple< ns3::Ptr<ns3::CcnxFace>, uint32_t >
-get (DistancesMap &map, ns3::Ptr<ns3::CcnxGlobalRouter> key)
+inline tuple< ns3::Ptr<ns3::NdnFace>, uint32_t >
+get (DistancesMap &map, ns3::Ptr<ns3::NdnGlobalRouter> key)
 {
   boost::DistancesMap::iterator i = map.find (key);
   if (i == map.end ())
-    return tuple< ns3::Ptr<ns3::CcnxFace>, uint32_t > (0, std::numeric_limits<uint32_t>::max ());
+    return tuple< ns3::Ptr<ns3::NdnFace>, uint32_t > (0, std::numeric_limits<uint32_t>::max ());
   else
     return i->second;
 }
@@ -362,4 +362,4 @@
 
 /// @endcond
 
-#endif // BOOST_GRAPH_CCNX_GLOBAL_ROUTING_HELPER_H
+#endif // BOOST_GRAPH_NDN_GLOBAL_ROUTING_HELPER_H
diff --git a/helper/ccnb-parser/syntax-tree/ccnb-parser-dtag.cc.~HEAD~ b/helper/ccnb-parser/syntax-tree/ccnb-parser-dtag.cc.~HEAD~
deleted file mode 100644
index 8d9ecf7..0000000
--- a/helper/ccnb-parser/syntax-tree/ccnb-parser-dtag.cc.~HEAD~
+++ /dev/null
@@ -1,76 +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>
- */
-
-#include "ccnb-parser-dtag.h"
-
-#include "ccnb-parser-base-attr.h"
-#include "ccnb-parser-base-tag.h"
-
-namespace ns3 {
-namespace CcnbParser {
-
-Dtag::Dtag (Buffer::Iterator &start, uint32_t dtag)
-{
-  m_dtag = dtag;
-
-  /**
-   * Hack
-   *
-   * Stop processing after encountering <Content> dtag.  Actual
-   * content (including virtual payload) will be stored in Packet
-   * buffer
-   */
-  if (dtag == CCN_DTAG_Content)
-    return; // hack #1. Do not process nesting block for <Content>
-  
-  // parse attributes until first nested block reached
-  while (!start.IsEnd () && start.PeekU8 ()!=CCN_CLOSE)
-    {
-      Ptr<Block> block = Block::ParseBlock (start);
-      if (DynamicCast<BaseAttr> (block)!=0)
-		m_attrs.push_back (block);
-	  else
-		{
-		  m_nestedTags.push_back (block);
-		  break;
-		}
-	}
-
-  // parse the rest of nested blocks
-  while (!start.IsEnd () && start.PeekU8 ()!=CCN_CLOSE)
-    {
-      // hack #2. Stop processing nested blocks if last block was <Content>
-      if (m_dtag == CCN_DTAG_ContentObject && // we are in <ContentObject>
-          DynamicCast<Dtag> (m_nestedTags.back())!=0 && // last block is DTAG
-          DynamicCast<Dtag> (m_nestedTags.back())->m_dtag == CCN_DTAG_Content) 
-        {
-          return; 
-        }
-
-      m_nestedTags.push_back (Block::ParseBlock (start));
-    }
-  if (start.IsEnd ())
-      throw CcnbDecodingException ();
-
-  start.ReadU8 (); // read CCN_CLOSE
-}
-
-}
-}
diff --git a/helper/ccnb-parser/visitors/ccnb-parser-interest-visitor.cc b/helper/ccnb-parser/visitors/ccnb-parser-interest-visitor.cc
index ff219f0..5188f8d 100644
--- a/helper/ccnb-parser/visitors/ccnb-parser-interest-visitor.cc
+++ b/helper/ccnb-parser/visitors/ccnb-parser-interest-visitor.cc
@@ -23,12 +23,12 @@
 #include "../syntax-tree/ccnb-parser-block.h"
 #include "../syntax-tree/ccnb-parser-dtag.h"
 
-#include "ns3/ccnx-name-components.h"
+#include "ns3/ndn-name-components.h"
 
 #include "ns3/assert.h"
 #include "ns3/nstime.h"
 
-#include "ns3/ccnx-interest-header.h"
+#include "ns3/ndn-interest-header.h"
 #include "ccnb-parser-name-components-visitor.h"
 #include "ccnb-parser-non-negative-integer-visitor.h"
 #include "ccnb-parser-timestamp-visitor.h"
@@ -45,7 +45,7 @@
 
 // We don't care about any other fields
 void
-InterestVisitor::visit (Dtag &n, boost::any param/*should be CcnxInterestHeader* */)
+InterestVisitor::visit (Dtag &n, boost::any param/*should be NdnInterestHeader* */)
 {
   // uint32_t n.m_dtag;
   // std::list<Ptr<Block> > n.m_nestedBlocks;
@@ -55,7 +55,7 @@
   static TimestampVisitor          timestampVisitor;
   static Uint32tBlobVisitor        nonceVisitor;
   
-  CcnxInterestHeader &interest = *(boost::any_cast<CcnxInterestHeader*> (param));
+  NdnInterestHeader &interest = *(boost::any_cast<NdnInterestHeader*> (param));
 
   switch (n.m_dtag)
     {
@@ -73,7 +73,7 @@
         NS_LOG_DEBUG ("Name");
 
         // process name components
-        Ptr<CcnxNameComponents> name = Create<CcnxNameComponents> ();
+        Ptr<NdnNameComponents> name = Create<NdnNameComponents> ();
         
         BOOST_FOREACH (Ptr<Block> block, n.m_nestedTags)
           {
@@ -106,7 +106,7 @@
       {
         NS_LOG_DEBUG ("Exclude");
         // process exclude components
-        Ptr<CcnxNameComponents> exclude = Create<CcnxNameComponents> ();
+        Ptr<NdnNameComponents> exclude = Create<NdnNameComponents> ();
         
         BOOST_FOREACH (Ptr<Block> block, n.m_nestedTags)
           {
diff --git a/helper/ccnb-parser/visitors/ccnb-parser-name-components-visitor.cc b/helper/ccnb-parser/visitors/ccnb-parser-name-components-visitor.cc
index 80e49eb..387292b 100644
--- a/helper/ccnb-parser/visitors/ccnb-parser-name-components-visitor.cc
+++ b/helper/ccnb-parser/visitors/ccnb-parser-name-components-visitor.cc
@@ -22,19 +22,19 @@
 
 #include "ccnb-parser-string-visitor.h"
 #include "../syntax-tree/ccnb-parser-dtag.h"
-#include "ns3/ccnx-name-components.h"
+#include "ns3/ndn-name-components.h"
 
 namespace ns3 {
 namespace CcnbParser {
 
 void
-NameComponentsVisitor::visit (Dtag &n, boost::any param/*should be CcnxNameComponents* */)
+NameComponentsVisitor::visit (Dtag &n, boost::any param/*should be NdnNameComponents* */)
 {
   // uint32_t n.m_dtag;
   // std::list<Ptr<Block> > n.m_nestedBlocks;
   static StringVisitor stringVisitor; 
  
-  CcnxNameComponents &components = *(boost::any_cast<CcnxNameComponents*> (param));
+  NdnNameComponents &components = *(boost::any_cast<NdnNameComponents*> (param));
 
   switch (n.m_dtag)
     {
diff --git a/helper/ccnb-parser/visitors/ccnb-parser-void-no-argu-visitor.h b/helper/ccnb-parser/visitors/ccnb-parser-void-no-argu-visitor.h
index 90aee97..25f9e50 100644
--- a/helper/ccnb-parser/visitors/ccnb-parser-void-no-argu-visitor.h
+++ b/helper/ccnb-parser/visitors/ccnb-parser-void-no-argu-visitor.h
@@ -27,7 +27,7 @@
 namespace CcnbParser {
 
 /**
- * \ingroup ccnx-ccnb
+ * \ingroup ndn-ccnb
  * \brief Visitor interface that takes no arguments and returns nothing
  *
  * \see http://www.ccnx.org/releases/latest/doc/technical/BinaryEncoding.html
diff --git a/helper/ccnb-parser/visitors/ccnb-parser-void-visitor.h b/helper/ccnb-parser/visitors/ccnb-parser-void-visitor.h
index 5ac08bf..1f9d1fa 100644
--- a/helper/ccnb-parser/visitors/ccnb-parser-void-visitor.h
+++ b/helper/ccnb-parser/visitors/ccnb-parser-void-visitor.h
@@ -28,7 +28,7 @@
 namespace CcnbParser {
 
 /**
- * \ingroup ccnx-ccnb
+ * \ingroup ndn-ccnb
  * \brief Visitor interface that takes one boost::any argument and returns nothing
  *
  * \see http://www.ccnx.org/releases/latest/doc/technical/BinaryEncoding.html
diff --git a/helper/ccnx-decoding-helper.h b/helper/ccnx-decoding-helper.h
deleted file mode 100644
index 015b7ff..0000000
--- a/helper/ccnx-decoding-helper.h
+++ /dev/null
@@ -1,58 +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>
- */
-
-#ifndef _CCNX_DECODING_HELPER_H_
-#define _CCNX_DECODING_HELPER_H_
-
-#include <cstring>
-#include "ns3/buffer.h"
-
-namespace ns3 {
-
-class CcnxInterestHeader;
-class CcnxContentObjectHeader;
-
-/**
- * \brief Helper class to decode ccnb formatted CCNx message
- */
-class CcnxDecodingHelper
-{
-public:
-  /**
-   * \brief Deserialize Buffer::Iterator to CcnxInterestHeader
-   * @param start Buffer containing serialized CCNx message
-   * @param interest Pointer to the CcnxInterestHeader to hold deserialized value
-   * @return Number of bytes used for deserialization
-   */
-  static size_t
-  Deserialize (Buffer::Iterator start, CcnxInterestHeader &interest);
-
-  /**
-   * \brief Deserialize Buffer::Iterator to CcnxContentObjectHeader
-   * @param start Buffer containing serialized CCNx message
-   * @param contentObject Pointer to the CcnxContentObjectHeader to hold deserialized value
-   * @return Number of bytes used for deserialization
-   */
-  static size_t
-  Deserialize (Buffer::Iterator start, CcnxContentObjectHeader &contentObject);
-};
-} // namespace ns3
-
-#endif // _CCNX_DECODING_HELPER_H_
diff --git a/helper/ccnx-app-helper.cc b/helper/ndn-app-helper.cc
similarity index 79%
rename from helper/ccnx-app-helper.cc
rename to helper/ndn-app-helper.cc
index 0e77075..dcaee07 100644
--- a/helper/ccnx-app-helper.cc
+++ b/helper/ndn-app-helper.cc
@@ -18,40 +18,40 @@
  * Author: Ilya Moiseenko <iliamo@cs.ucla.edu>
  */
 
-#include "ccnx-app-helper.h"
+#include "ndn-app-helper.h"
 #include "ns3/log.h"
 #include "ns3/string.h"
 #include "ns3/names.h"
-#include "ns3/ccnx-app.h"
+#include "ns3/ndn-app.h"
 
 #ifdef NS3_MPI
 #include "ns3/mpi-interface.h"
 #endif
 
-NS_LOG_COMPONENT_DEFINE ("CcnxAppHelper");
+NS_LOG_COMPONENT_DEFINE ("NdnAppHelper");
 
 namespace ns3 
 {
 
-CcnxAppHelper::CcnxAppHelper (const std::string &app)
+NdnAppHelper::NdnAppHelper (const std::string &app)
 {
   m_factory.SetTypeId (app);
 }
 
 void
-CcnxAppHelper::SetPrefix (const std::string &prefix)
+NdnAppHelper::SetPrefix (const std::string &prefix)
 {
   m_factory.Set ("Prefix", StringValue(prefix));
 }
 
 void 
-CcnxAppHelper::SetAttribute (std::string name, const AttributeValue &value)
+NdnAppHelper::SetAttribute (std::string name, const AttributeValue &value)
 {
   m_factory.Set (name, value);
 }
     
 ApplicationContainer
-CcnxAppHelper::Install (Ptr<Node> node)
+NdnAppHelper::Install (Ptr<Node> node)
 {
   ApplicationContainer apps;
   Ptr<Application> app = InstallPriv (node);
@@ -62,14 +62,14 @@
 }
     
 ApplicationContainer
-CcnxAppHelper::Install (std::string nodeName)
+NdnAppHelper::Install (std::string nodeName)
 {
   Ptr<Node> node = Names::Find<Node> (nodeName);
   return Install (node);
 }
     
 ApplicationContainer
-CcnxAppHelper::Install (NodeContainer c)
+NdnAppHelper::Install (NodeContainer c)
 {
   ApplicationContainer apps;
   for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)
@@ -83,7 +83,7 @@
 }
     
 Ptr<Application>
-CcnxAppHelper::InstallPriv (Ptr<Node> node)
+NdnAppHelper::InstallPriv (Ptr<Node> node)
 {
 #ifdef NS3_MPI
   if (MpiInterface::IsEnabled () &&
@@ -94,7 +94,7 @@
     }
 #endif
   
-  Ptr<CcnxApp> app = m_factory.Create<CcnxApp> ();        
+  Ptr<NdnApp> app = m_factory.Create<NdnApp> ();        
   node->AddApplication (app);
         
   return app;
diff --git a/helper/ccnx-app-helper.h b/helper/ndn-app-helper.h
similarity index 72%
rename from helper/ccnx-app-helper.h
rename to helper/ndn-app-helper.h
index 3eb1296..1a76c84 100644
--- a/helper/ccnx-app-helper.h
+++ b/helper/ndn-app-helper.h
@@ -18,8 +18,8 @@
  * Author: Ilya Moiseenko <iliamo@cs.ucla.edu>
  */
 
-#ifndef CCNX_APP_HELPER_H
-#define CCNX_APP_HELPER_H
+#ifndef NDN_APP_HELPER_H
+#define NDN_APP_HELPER_H
 
 #include "ns3/object-factory.h"
 #include "ns3/attribute.h"
@@ -31,19 +31,19 @@
 {
 
 /**
- * \brief A helper to make it easier to instantiate an ns3::CcnxConsumer Application
+ * \brief A helper to make it easier to instantiate an ns3::NdnConsumer Application
  * on a set of nodes.
  */
-class CcnxAppHelper
+class NdnAppHelper
 {        
 public:
 
   /**
-   * \brief Create an CcnxAppHelper to make it easier to work with CCNx apps
+   * \brief Create an NdnAppHelper to make it easier to work with Ndn apps
    *
    * \param app Class of the application
    */
-  CcnxAppHelper (const std::string &prefix);
+  NdnAppHelper (const std::string &prefix);
 
   /**
    * @brief Set the prefix consumer will be requesting
@@ -60,29 +60,29 @@
   void SetAttribute (std::string name, const AttributeValue &value);
         
   /**
-   * Install an ns3::CcnxConsumer on each node of the input container
+   * Install an ns3::NdnConsumer on each node of the input container
    * configured with all the attributes set with SetAttribute.
    *
-   * \param c NodeContainer of the set of nodes on which an CcnxConsumer 
+   * \param c NodeContainer of the set of nodes on which an NdnConsumer 
    * will be installed.
    * \returns Container of Ptr to the applications installed.
    */
   ApplicationContainer Install (NodeContainer c);
         
   /**
-   * Install an ns3::CcnxConsumer on the node configured with all the 
+   * Install an ns3::NdnConsumer on the node configured with all the 
    * attributes set with SetAttribute.
    *
-   * \param node The node on which an CcnxConsumer will be installed.
+   * \param node The node on which an NdnConsumer will be installed.
    * \returns Container of Ptr to the applications installed.
    */
   ApplicationContainer Install (Ptr<Node> node);
         
   /**
-   * Install an ns3::CcnxConsumer on the node configured with all the 
+   * Install an ns3::NdnConsumer on the node configured with all the 
    * attributes set with SetAttribute.
    *
-   * \param nodeName The node on which an CcnxConsumer will be installed.
+   * \param nodeName The node on which an NdnConsumer will be installed.
    * \returns Container of Ptr to the applications installed.
    */
   ApplicationContainer Install (std::string nodeName);
@@ -90,10 +90,10 @@
 private:
   /**
    * \internal
-   * Install an ns3::CcnxConsumer on the node configured with all the 
+   * Install an ns3::NdnConsumer on the node configured with all the 
    * attributes set with SetAttribute.
    *
-   * \param node The node on which an CcnxConsumer will be installed.
+   * \param node The node on which an NdnConsumer will be installed.
    * \returns Ptr to the application installed.
    */
   Ptr<Application> InstallPriv (Ptr<Node> node);
@@ -102,5 +102,5 @@
 
 } // namespace ns3
 
-#endif // CCNX_APP_HELPER_H
+#endif // NDN_APP_HELPER_H
 
diff --git a/helper/ccnx-decoding-helper.cc b/helper/ndn-decoding-helper.cc
similarity index 84%
rename from helper/ccnx-decoding-helper.cc
rename to helper/ndn-decoding-helper.cc
index 6d1d7c8..4e5e6b8 100644
--- a/helper/ccnx-decoding-helper.cc
+++ b/helper/ndn-decoding-helper.cc
@@ -18,9 +18,9 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#include "ccnx-decoding-helper.h"
+#include "ndn-decoding-helper.h"
 
-#include "ns3/ccnx-interest-header.h"
+#include "ns3/ndn-interest-header.h"
 
 #include "ccnb-parser/visitors/ccnb-parser-interest-visitor.h"
 
@@ -29,12 +29,12 @@
 
 #include "ns3/log.h"
 
-NS_LOG_COMPONENT_DEFINE ("CcnxDecodingHelper");
+NS_LOG_COMPONENT_DEFINE ("NdnDecodingHelper");
 
 namespace ns3 {
 
 size_t
-CcnxDecodingHelper::Deserialize (Buffer::Iterator start, CcnxInterestHeader &interest)
+NdnDecodingHelper::Deserialize (Buffer::Iterator start, NdnInterestHeader &interest)
 {
   static CcnbParser::InterestVisitor interestVisitor;
 
@@ -46,7 +46,7 @@
 }
 
 // size_t
-// CcnxDecodingHelper::Deserialize (Buffer::Iterator start, CcnxContentObjectHeader &contentObject)
+// NdnDecodingHelper::Deserialize (Buffer::Iterator start, NdnContentObjectHeader &contentObject)
 // {
 //   static CcnbParser::ContentObjectVisitor contentObjectVisitor;
 
diff --git a/helper/ndn-decoding-helper.h b/helper/ndn-decoding-helper.h
new file mode 100644
index 0000000..f6ab9fa
--- /dev/null
+++ b/helper/ndn-decoding-helper.h
@@ -0,0 +1,58 @@
+/* -*- 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>
+ */
+
+#ifndef _NDN_DECODING_HELPER_H_
+#define _NDN_DECODING_HELPER_H_
+
+#include <cstring>
+#include "ns3/buffer.h"
+
+namespace ns3 {
+
+class NdnInterestHeader;
+class NdnContentObjectHeader;
+
+/**
+ * \brief Helper class to decode ccnb formatted Ndn message
+ */
+class NdnDecodingHelper
+{
+public:
+  /**
+   * \brief Deserialize Buffer::Iterator to NdnInterestHeader
+   * @param start Buffer containing serialized Ndn message
+   * @param interest Pointer to the NdnInterestHeader to hold deserialized value
+   * @return Number of bytes used for deserialization
+   */
+  static size_t
+  Deserialize (Buffer::Iterator start, NdnInterestHeader &interest);
+
+  /**
+   * \brief Deserialize Buffer::Iterator to NdnContentObjectHeader
+   * @param start Buffer containing serialized Ndn message
+   * @param contentObject Pointer to the NdnContentObjectHeader to hold deserialized value
+   * @return Number of bytes used for deserialization
+   */
+  static size_t
+  Deserialize (Buffer::Iterator start, NdnContentObjectHeader &contentObject);
+};
+} // namespace ns3
+
+#endif // _NDN_DECODING_HELPER_H_
diff --git a/helper/ccnx-encoding-helper.cc b/helper/ndn-encoding-helper.cc
similarity index 88%
rename from helper/ccnx-encoding-helper.cc
rename to helper/ndn-encoding-helper.cc
index acb3966..200072b 100644
--- a/helper/ccnx-encoding-helper.cc
+++ b/helper/ndn-encoding-helper.cc
@@ -18,11 +18,11 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu> 
  */
 
-#include "ccnx-encoding-helper.h"
+#include "ndn-encoding-helper.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"
 
 #include <sstream>
 #include <boost/foreach.hpp>
@@ -30,7 +30,7 @@
 namespace ns3 {
 
 size_t
-CcnxEncodingHelper::Serialize (Buffer::Iterator start, const CcnxInterestHeader &interest)
+NdnEncodingHelper::Serialize (Buffer::Iterator start, const NdnInterestHeader &interest)
 {
   size_t written = 0;
   written += AppendBlockHeader (start, CcnbParser::CCN_DTAG_Interest, CcnbParser::CCN_DTAG); // <Interest>
@@ -99,7 +99,7 @@
 }
 
 size_t
-CcnxEncodingHelper::GetSerializedSize (const CcnxInterestHeader &interest)
+NdnEncodingHelper::GetSerializedSize (const NdnInterestHeader &interest)
 {
   size_t written = 0;
   written += EstimateBlockHeader (CcnbParser::CCN_DTAG_Interest); // <Interest>
@@ -176,7 +176,7 @@
 #define CCN_TT_HBIT ((unsigned char)(1 << 7))
 
 size_t
-CcnxEncodingHelper::AppendBlockHeader (Buffer::Iterator &start, size_t val, CcnbParser::ccn_tt tt)
+NdnEncodingHelper::AppendBlockHeader (Buffer::Iterator &start, size_t val, CcnbParser::ccn_tt tt)
 {
   unsigned char buf[1+8*((sizeof(val)+6)/7)];
   unsigned char *p = &(buf[sizeof(buf)-1]);
@@ -195,7 +195,7 @@
 }
 
 size_t
-CcnxEncodingHelper::EstimateBlockHeader (size_t value)
+NdnEncodingHelper::EstimateBlockHeader (size_t value)
 {
   value >>= (7-CCN_TT_BITS);
   size_t n = 1;
@@ -208,7 +208,7 @@
 }
 
 size_t
-CcnxEncodingHelper::AppendNumber (Buffer::Iterator &start, uint32_t number)
+NdnEncodingHelper::AppendNumber (Buffer::Iterator &start, uint32_t number)
 {
   std::ostringstream os;
   os << number;
@@ -222,7 +222,7 @@
 }
 
 size_t
-CcnxEncodingHelper::EstimateNumber (uint32_t number)
+NdnEncodingHelper::EstimateNumber (uint32_t number)
 {
   std::ostringstream os;
   os << number;
@@ -230,14 +230,14 @@
 }
   
 size_t
-CcnxEncodingHelper::AppendCloser (Buffer::Iterator &start)
+NdnEncodingHelper::AppendCloser (Buffer::Iterator &start)
 {
   start.WriteU8 (CcnbParser::CCN_CLOSE);
   return 1;
 }
 
 size_t
-CcnxEncodingHelper::AppendNameComponents (Buffer::Iterator &start, const CcnxNameComponents &name)
+NdnEncodingHelper::AppendNameComponents (Buffer::Iterator &start, const NdnNameComponents &name)
 {
   size_t written = 0;
   BOOST_FOREACH (const std::string &component, name.GetComponents())
@@ -249,7 +249,7 @@
 }
 
 size_t
-CcnxEncodingHelper::EstimateNameComponents (const CcnxNameComponents &name)
+NdnEncodingHelper::EstimateNameComponents (const NdnNameComponents &name)
 {
   size_t written = 0;
   BOOST_FOREACH (const std::string &component, name.GetComponents())
@@ -260,7 +260,7 @@
 }
 
 size_t
-CcnxEncodingHelper::AppendTimestampBlob (Buffer::Iterator &start, const Time &time)
+NdnEncodingHelper::AppendTimestampBlob (Buffer::Iterator &start, const Time &time)
 {
   // the original function implements Markers... thought not sure what are these markers for...
 
@@ -287,7 +287,7 @@
 }
 
 size_t
-CcnxEncodingHelper::EstimateTimestampBlob (const Time &time)
+NdnEncodingHelper::EstimateTimestampBlob (const Time &time)
 {
   int required_bytes = 2; // 12 bits for fractions of a second, 4 bits left for seconds. Sometimes it is enough
   intmax_t ts = time.ToInteger (Time::S) >> 4;
@@ -298,7 +298,7 @@
 }
 
 size_t
-CcnxEncodingHelper::AppendTaggedBlob (Buffer::Iterator &start, CcnbParser::ccn_dtag dtag,
+NdnEncodingHelper::AppendTaggedBlob (Buffer::Iterator &start, CcnbParser::ccn_dtag dtag,
                   const uint8_t *data, size_t size)
 {
   size_t written = AppendBlockHeader (start, dtag, CcnbParser::CCN_DTAG);
@@ -317,7 +317,7 @@
 }
 
 size_t
-CcnxEncodingHelper::EstimateTaggedBlob (CcnbParser::ccn_dtag dtag, size_t size)
+NdnEncodingHelper::EstimateTaggedBlob (CcnbParser::ccn_dtag dtag, size_t size)
 {
   if (size>0)
     return EstimateBlockHeader (dtag) + EstimateBlockHeader (size) + size + 1;
@@ -326,7 +326,7 @@
 }
 
 size_t
-CcnxEncodingHelper::AppendString (Buffer::Iterator &start, CcnbParser::ccn_dtag dtag,
+NdnEncodingHelper::AppendString (Buffer::Iterator &start, CcnbParser::ccn_dtag dtag,
                                   const std::string &string)
 {
   size_t written = AppendBlockHeader (start, dtag, CcnbParser::CCN_DTAG);
@@ -341,7 +341,7 @@
 }
 
 size_t
-CcnxEncodingHelper::EstimateString (CcnbParser::ccn_dtag dtag, const std::string &string)
+NdnEncodingHelper::EstimateString (CcnbParser::ccn_dtag dtag, const std::string &string)
 {
   return EstimateBlockHeader (dtag) + EstimateBlockHeader (string.size ()) + string.size () + 1;
 }
diff --git a/helper/ccnx-encoding-helper.h b/helper/ndn-encoding-helper.h
similarity index 77%
rename from helper/ccnx-encoding-helper.h
rename to helper/ndn-encoding-helper.h
index 45fdc84..90b3f57 100644
--- a/helper/ccnx-encoding-helper.h
+++ b/helper/ndn-encoding-helper.h
@@ -18,8 +18,8 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef _CCNX_ENCODING_HELPER_H_
-#define _CCNX_ENCODING_HELPER_H_
+#ifndef _NDN_ENCODING_HELPER_H_
+#define _NDN_ENCODING_HELPER_H_
 
 #include <sys/types.h>
 
@@ -30,38 +30,38 @@
 
 namespace ns3 {
 
-class CcnxNameComponents;
+class NdnNameComponents;
 
-class CcnxInterestHeader;
-class CcnxContentObjectHeader;
+class NdnInterestHeader;
+class NdnContentObjectHeader;
   
 /**
- * \brief Helper to encode/decode ccnb formatted CCNx message
+ * \brief Helper to encode/decode ccnb formatted Ndn message
  */
-class CcnxEncodingHelper
+class NdnEncodingHelper
 {
 public:
   /**
-   * \brief Serialize CcnxInterestHeader to Buffer::Iterator
-   * @param start Buffer to store serialized CcnxInterestHeader
-   * @param interest Pointer to CcnxInterestHeader to be serialized 
-   * @return length of serialized CcnxInterestHeader
+   * \brief Serialize NdnInterestHeader to Buffer::Iterator
+   * @param start Buffer to store serialized NdnInterestHeader
+   * @param interest Pointer to NdnInterestHeader to be serialized 
+   * @return length of serialized NdnInterestHeader
    */
   static size_t
-  Serialize (Buffer::Iterator start, const CcnxInterestHeader &interest);
+  Serialize (Buffer::Iterator start, const NdnInterestHeader &interest);
 
   /**
-   * \brief Compute the size of serialized CcnxInterestHeader
-   * @param interest Pointer to CcnxInterestHeader
+   * \brief Compute the size of serialized NdnInterestHeader
+   * @param interest Pointer to NdnInterestHeader
    * @return length 
    */
   static size_t
-  GetSerializedSize (const CcnxInterestHeader &interest);
+  GetSerializedSize (const NdnInterestHeader &interest);
   
 public:
   /**
    * @brief Append CCNB block header
-   * @param start Buffer to store serialized CcnxInterestHeader
+   * @param start Buffer to store serialized NdnInterestHeader
    * @param value dictionary id of the block header
    * @param block_type Type of CCNB block
    *
@@ -80,7 +80,7 @@
 
   /**
    * @brief Add number in CCNB encoding
-   * @param start Buffer to store serialized CcnxInterestHeader
+   * @param start Buffer to store serialized NdnInterestHeader
    * @param number Number to be written
    *
    * @returns written length
@@ -98,7 +98,7 @@
 
   /**
    * @brief Append CCNB closer tag (estimated size is 1)
-   * @param start Buffer to store serialized CcnxInterestHeader
+   * @param start Buffer to store serialized NdnInterestHeader
    *
    * @returns written length
    */
@@ -106,22 +106,22 @@
   AppendCloser (Buffer::Iterator &start);
 
   /**
-   * @brief Append CcnxNameComponents in CCNB encoding
-   * @param start Buffer to store serialized CcnxInterestHeader
-   * @param name constant reference to CcnxNameComponents object
+   * @brief Append NdnNameComponents in CCNB encoding
+   * @param start Buffer to store serialized NdnInterestHeader
+   * @param name constant reference to NdnNameComponents object
    *
    * @returns written length
    */
   static size_t
-  AppendNameComponents (Buffer::Iterator &start, const CcnxNameComponents &name);
+  AppendNameComponents (Buffer::Iterator &start, const NdnNameComponents &name);
 
   /**
-   * @brief Estimate size of CcnxNameComponents in CCNB encoding
-   * @param name constant reference to CcnxNameComponents object
+   * @brief Estimate size of NdnNameComponents in CCNB encoding
+   * @param name constant reference to NdnNameComponents object
    * @returns estimated length
    */
   static size_t
-  EstimateNameComponents (const CcnxNameComponents &name);
+  EstimateNameComponents (const NdnNameComponents &name);
 
   /**
    * Append a binary timestamp as a BLOB using the ccn binary
@@ -213,12 +213,12 @@
 
 template<class T>
 size_t
-CcnxEncodingHelper::AppendTaggedBlob (Buffer::Iterator &start, CcnbParser::ccn_dtag dtag, const T &data)
+NdnEncodingHelper::AppendTaggedBlob (Buffer::Iterator &start, CcnbParser::ccn_dtag dtag, const T &data)
 {
   return AppendTaggedBlob (start, dtag, reinterpret_cast<const uint8_t*> (&data), sizeof (data));
 }
 
 } // namespace ns3
 
-#endif // _CCNX_ENCODING_HELPER_H_
+#endif // _NDN_ENCODING_HELPER_H_
 
diff --git a/helper/ccnx-face-container.cc b/helper/ndn-face-container.cc
similarity index 67%
rename from helper/ccnx-face-container.cc
rename to helper/ndn-face-container.cc
index 8a7a9e2..2e0ec33 100644
--- a/helper/ccnx-face-container.cc
+++ b/helper/ndn-face-container.cc
@@ -18,25 +18,25 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#include "ccnx-face-container.h"
+#include "ndn-face-container.h"
 
 #include <algorithm>
 
-#include "ns3/ccnx-face.h"
+#include "ns3/ndn-face.h"
 
 namespace ns3 {
 
-CcnxFaceContainer::CcnxFaceContainer ()
+NdnFaceContainer::NdnFaceContainer ()
 {
 }
 
-CcnxFaceContainer::CcnxFaceContainer (const CcnxFaceContainer &other)
+NdnFaceContainer::NdnFaceContainer (const NdnFaceContainer &other)
 {
   AddAll (other);
 }
 
-CcnxFaceContainer&
-CcnxFaceContainer::operator= (const CcnxFaceContainer &other)
+NdnFaceContainer&
+NdnFaceContainer::operator= (const NdnFaceContainer &other)
 {
   m_faces.clear ();
   AddAll (other);
@@ -46,38 +46,38 @@
 
   
 void
-CcnxFaceContainer::AddAll (Ptr<CcnxFaceContainer> other)
+NdnFaceContainer::AddAll (Ptr<NdnFaceContainer> other)
 {
   AddAll (*other);
 }
 
 void
-CcnxFaceContainer::AddAll (const CcnxFaceContainer &other)
+NdnFaceContainer::AddAll (const NdnFaceContainer &other)
 {
   m_faces.insert (m_faces.end (),
                   other.m_faces.begin (), other.m_faces.end ());
 }
 
-CcnxFaceContainer::Iterator
-CcnxFaceContainer::Begin (void) const
+NdnFaceContainer::Iterator
+NdnFaceContainer::Begin (void) const
 {
   return m_faces.begin ();
 }
 
-CcnxFaceContainer::Iterator
-CcnxFaceContainer::End (void) const
+NdnFaceContainer::Iterator
+NdnFaceContainer::End (void) const
 {
   return m_faces.end ();
 }
 
 uint32_t
-CcnxFaceContainer::GetN (void) const
+NdnFaceContainer::GetN (void) const
 {
   return m_faces.size ();
 }
 
 // void 
-// CcnxFaceContainer::SetMetricToAll (uint16_t metric)
+// NdnFaceContainer::SetMetricToAll (uint16_t metric)
 // {
 //   for (FaceContainer::iterator it=m_faces.begin ();
 //        it != m_faces.end ();
@@ -88,13 +88,13 @@
 // }
 
 void 
-CcnxFaceContainer::Add (const Ptr<CcnxFace> &face)
+NdnFaceContainer::Add (const Ptr<NdnFace> &face)
 {
   m_faces.push_back (face);
 }
 
-Ptr<CcnxFace>
-CcnxFaceContainer::Get (CcnxFaceContainer::Iterator i) const
+Ptr<NdnFace>
+NdnFaceContainer::Get (NdnFaceContainer::Iterator i) const
 {
   return *i;
 }
diff --git a/helper/ccnx-face-container.h b/helper/ndn-face-container.h
similarity index 69%
rename from helper/ccnx-face-container.h
rename to helper/ndn-face-container.h
index 39391f8..e1fd4b2 100644
--- a/helper/ccnx-face-container.h
+++ b/helper/ndn-face-container.h
@@ -18,68 +18,68 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef CCNX_FACE_CONTAINER_H
-#define CCNX_FACE_CONTAINER_H
+#ifndef NDN_FACE_CONTAINER_H
+#define NDN_FACE_CONTAINER_H
 
 #include <stdint.h>
 #include <vector>
 
 #include "ns3/ptr.h"
 #include "ns3/simple-ref-count.h"
-#include "ns3/ccnx-face.h"
+#include "ns3/ndn-face.h"
 
 namespace ns3 {
 
 /**
- * \ingroup ccnx-helpers
- * \brief A pool for CCNx faces
+ * \ingroup ndn-helpers
+ * \brief A pool for Ndn faces
  * 
  * Provides tools to perform basic manipulation on faces, such as
  * setting metrics and states on faces
  *
- * \see CcnxStackHelper
+ * \see NdnStackHelper
  */
-class CcnxFaceContainer : public SimpleRefCount<CcnxFaceContainer>
+class NdnFaceContainer : public SimpleRefCount<NdnFaceContainer>
 {
 private:
-  typedef std::vector<Ptr<CcnxFace> > FaceContainer;
+  typedef std::vector<Ptr<NdnFace> > FaceContainer;
 public:
-  typedef FaceContainer::const_iterator Iterator; ///< \brief Iterator over CcnxFaceContainer
+  typedef FaceContainer::const_iterator Iterator; ///< \brief Iterator over NdnFaceContainer
 
   /**
-   * \brief Create an empty CcnxFaceContainer.
+   * \brief Create an empty NdnFaceContainer.
    */
-  CcnxFaceContainer ();
+  NdnFaceContainer ();
 
   /**
-   * \brief Copy constructor for CcnxFaceContainer. Calls AddAll method
+   * \brief Copy constructor for NdnFaceContainer. Calls AddAll method
    *
-   * \see CcnxFaceContainer::AddAll
+   * \see NdnFaceContainer::AddAll
    */
-  CcnxFaceContainer (const CcnxFaceContainer &other);
+  NdnFaceContainer (const NdnFaceContainer &other);
 
   /**
-   * \brief Copy operator for CcnxFaceContainer. Empties vector and calls AddAll method
+   * \brief Copy operator for NdnFaceContainer. Empties vector and calls AddAll method
    *
    * All previously obtained iterators (Begin() and End()) will be invalidated
    *
-   * \see CcnxFaceContainer::AddAll
+   * \see NdnFaceContainer::AddAll
    */
-  CcnxFaceContainer& operator= (const CcnxFaceContainer &other);
+  NdnFaceContainer& operator= (const NdnFaceContainer &other);
   
   /**
    * \brief Add all entries from other container
    *
    * \param other smart pointer to a container
    */
-  void AddAll (Ptr<CcnxFaceContainer> other);
+  void AddAll (Ptr<NdnFaceContainer> other);
 
   /**
    * \brief Add all entries from other container
    *
    * \param other container
    */
-  void AddAll (const CcnxFaceContainer &other);
+  void AddAll (const NdnFaceContainer &other);
 
   /**
    * \brief Get an iterator which refers to the first pair in the
@@ -114,22 +114,22 @@
   /**
    * Add an entry to the container
    *
-   * \param face a smart pointer to a CcnxFace-derived object
+   * \param face a smart pointer to a NdnFace-derived object
    *
-   * @see CcnxFace
+   * @see NdnFace
    */
-  void Add (const Ptr<CcnxFace> &face);
+  void Add (const Ptr<NdnFace> &face);
 
   /**
-   * Get a smart pointer to CcnxFace-derived object stored in the container
+   * Get a smart pointer to NdnFace-derived object stored in the container
    *
    * \param i the iterator corresponding to the requested object
    *
    * This method is redundant and simple dereferencing of the iterator should be used instead
    *
-   * @see CcnxFace
+   * @see NdnFace
    */
-  Ptr<CcnxFace> Get (Iterator i) const;
+  Ptr<NdnFace> Get (Iterator i) const;
 
 private:
   FaceContainer m_faces;
@@ -137,4 +137,4 @@
 
 } // namespace ns3
 
-#endif /* CCNX_FACE_CONTAINER_H */
+#endif /* NDN_FACE_CONTAINER_H */
diff --git a/helper/ccnx-global-routing-helper.cc b/helper/ndn-global-routing-helper.cc
similarity index 67%
rename from helper/ccnx-global-routing-helper.cc
rename to helper/ndn-global-routing-helper.cc
index 908937e..c3c9968 100644
--- a/helper/ccnx-global-routing-helper.cc
+++ b/helper/ndn-global-routing-helper.cc
@@ -18,13 +18,13 @@
  * Author:  Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#include "ccnx-global-routing-helper.h"
+#include "ndn-global-routing-helper.h"
 
-#include "ns3/ccnx.h"
-#include "../model/ccnx-net-device-face.h"
-#include "../model/ccnx-global-router.h"
-#include "ns3/ccnx-name-components.h"
-#include "ns3/ccnx-fib.h"
+#include "ns3/ndn.h"
+#include "../model/ndn-net-device-face.h"
+#include "../model/ndn-global-router.h"
+#include "ns3/ndn-name-components.h"
+#include "ns3/ndn-fib.h"
 
 #include "ns3/node.h"
 #include "ns3/node-container.h"
@@ -43,9 +43,9 @@
 // #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/dijkstra_shortest_paths.hpp>
 
-#include "boost-graph-ccnx-global-routing-helper.h"
+#include "boost-graph-ndn-global-routing-helper.h"
 
-NS_LOG_COMPONENT_DEFINE ("CcnxGlobalRoutingHelper");
+NS_LOG_COMPONENT_DEFINE ("NdnGlobalRoutingHelper");
 
 using namespace std;
 using namespace boost;
@@ -53,26 +53,26 @@
 namespace ns3 {
 
 void
-CcnxGlobalRoutingHelper::Install (Ptr<Node> node)
+NdnGlobalRoutingHelper::Install (Ptr<Node> node)
 {
   NS_LOG_LOGIC ("Node: " << node->GetId ());
   
-  Ptr<Ccnx> ccnx = node->GetObject<Ccnx> ();
-  NS_ASSERT_MSG (ccnx != 0, "Cannot install CcnxGlobalRoutingHelper before Ccnx is installed on a node");
+  Ptr<Ndn> ndn = node->GetObject<Ndn> ();
+  NS_ASSERT_MSG (ndn != 0, "Cannot install NdnGlobalRoutingHelper before Ndn is installed on a node");
 
-  Ptr<CcnxGlobalRouter> gr = node->GetObject<CcnxGlobalRouter> ();
+  Ptr<NdnGlobalRouter> gr = node->GetObject<NdnGlobalRouter> ();
   if (gr != 0)
     {
-      NS_LOG_DEBUG ("CcnxGlobalRouter is already installed: " << gr);
+      NS_LOG_DEBUG ("NdnGlobalRouter is already installed: " << gr);
       return; // already installed
     }
   
-  gr = CreateObject<CcnxGlobalRouter> ();
+  gr = CreateObject<NdnGlobalRouter> ();
   node->AggregateObject (gr);
   
-  for (uint32_t faceId = 0; faceId < ccnx->GetNFaces (); faceId++)
+  for (uint32_t faceId = 0; faceId < ndn->GetNFaces (); faceId++)
     {
-      Ptr<CcnxNetDeviceFace> face = DynamicCast<CcnxNetDeviceFace> (ccnx->GetFace (faceId));
+      Ptr<NdnNetDeviceFace> face = DynamicCast<NdnNetDeviceFace> (ndn->GetFace (faceId));
       if (face == 0)
 	{
 	  NS_LOG_DEBUG ("Skipping non-netdevice face");
@@ -82,7 +82,7 @@
       Ptr<NetDevice> nd = face->GetNetDevice ();
       if (nd == 0)
 	{
-	  NS_LOG_DEBUG ("Not a NetDevice associated with CcnxNetDeviceFace");
+	  NS_LOG_DEBUG ("Not a NetDevice associated with NdnNetDeviceFace");
 	  continue;
 	}
       
@@ -104,24 +104,24 @@
 	      Ptr<Node> otherNode = otherSide->GetNode ();
 	      NS_ASSERT (otherNode != 0);
 	      
-	      Ptr<CcnxGlobalRouter> otherGr = otherNode->GetObject<CcnxGlobalRouter> ();
+	      Ptr<NdnGlobalRouter> otherGr = otherNode->GetObject<NdnGlobalRouter> ();
 	      if (otherGr == 0)
 		{
 		  Install (otherNode);
 		}
-	      otherGr = otherNode->GetObject<CcnxGlobalRouter> ();
+	      otherGr = otherNode->GetObject<NdnGlobalRouter> ();
 	      NS_ASSERT (otherGr != 0);
 	      gr->AddIncidency (face, otherGr);
 	    }
 	}
       else
 	{
-	  Ptr<CcnxGlobalRouter> grChannel = ch->GetObject<CcnxGlobalRouter> ();
+	  Ptr<NdnGlobalRouter> grChannel = ch->GetObject<NdnGlobalRouter> ();
 	  if (grChannel == 0)
 	    {
 	      Install (ch);
 	    }
-	  grChannel = ch->GetObject<CcnxGlobalRouter> ();
+	  grChannel = ch->GetObject<NdnGlobalRouter> ();
 	  
 	  gr->AddIncidency (0, grChannel);
 	}
@@ -129,15 +129,15 @@
 }
 
 void
-CcnxGlobalRoutingHelper::Install (Ptr<Channel> channel)
+NdnGlobalRoutingHelper::Install (Ptr<Channel> channel)
 {
   NS_LOG_LOGIC ("Channel: " << channel->GetId ());
 
-  Ptr<CcnxGlobalRouter> gr = channel->GetObject<CcnxGlobalRouter> ();
+  Ptr<NdnGlobalRouter> gr = channel->GetObject<NdnGlobalRouter> ();
   if (gr != 0)
     return;
 
-  gr = CreateObject<CcnxGlobalRouter> ();
+  gr = CreateObject<NdnGlobalRouter> ();
   channel->AggregateObject (gr);
   
   for (uint32_t deviceId = 0; deviceId < channel->GetNDevices (); deviceId ++)
@@ -147,12 +147,12 @@
       Ptr<Node> node = dev->GetNode ();
       NS_ASSERT (node != 0);
 
-      Ptr<CcnxGlobalRouter> grOther = node->GetObject<CcnxGlobalRouter> ();
+      Ptr<NdnGlobalRouter> grOther = node->GetObject<NdnGlobalRouter> ();
       if (grOther == 0)
 	{
 	  Install (node);
 	}
-      grOther = node->GetObject<CcnxGlobalRouter> ();
+      grOther = node->GetObject<NdnGlobalRouter> ();
       NS_ASSERT (grOther != 0);
 
       gr->AddIncidency (0, grOther);
@@ -160,7 +160,7 @@
 }
 
 void
-CcnxGlobalRoutingHelper::Install (const NodeContainer &nodes)
+NdnGlobalRoutingHelper::Install (const NodeContainer &nodes)
 {
   for (NodeContainer::Iterator node = nodes.Begin ();
        node != nodes.End ();
@@ -171,25 +171,25 @@
 }
 
 void
-CcnxGlobalRoutingHelper::InstallAll ()
+NdnGlobalRoutingHelper::InstallAll ()
 {
   Install (NodeContainer::GetGlobal ());
 }
 
 
 void
-CcnxGlobalRoutingHelper::AddOrigin (const std::string &prefix, Ptr<Node> node)
+NdnGlobalRoutingHelper::AddOrigin (const std::string &prefix, Ptr<Node> node)
 {
-  Ptr<CcnxGlobalRouter> gr = node->GetObject<CcnxGlobalRouter> ();
+  Ptr<NdnGlobalRouter> gr = node->GetObject<NdnGlobalRouter> ();
   NS_ASSERT_MSG (gr != 0,
-		 "CcnxGlobalRouter is not installed on the node");
+		 "NdnGlobalRouter is not installed on the node");
 
-  Ptr<CcnxNameComponents> name = Create<CcnxNameComponents> (boost::lexical_cast<CcnxNameComponents> (prefix));
+  Ptr<NdnNameComponents> name = Create<NdnNameComponents> (boost::lexical_cast<NdnNameComponents> (prefix));
   gr->AddLocalPrefix (name);  
 }
 
 void
-CcnxGlobalRoutingHelper::AddOrigins (const std::string &prefix, const NodeContainer &nodes)
+NdnGlobalRoutingHelper::AddOrigins (const std::string &prefix, const NodeContainer &nodes)
 {
   for (NodeContainer::Iterator node = nodes.Begin ();
        node != nodes.End ();
@@ -200,7 +200,7 @@
 }
 
 void
-CcnxGlobalRoutingHelper::AddOrigin (const std::string &prefix, const std::string &nodeName)
+NdnGlobalRoutingHelper::AddOrigin (const std::string &prefix, const std::string &nodeName)
 {
   Ptr<Node> node = Names::Find<Node> (nodeName);
   NS_ASSERT_MSG (node != 0, nodeName << "is not a Node");
@@ -209,28 +209,28 @@
 }
 
 void
-CcnxGlobalRoutingHelper::CalculateRoutes ()
+NdnGlobalRoutingHelper::CalculateRoutes ()
 {
   /**
    * Implementation of route calculation is heavily based on Boost Graph Library
    * See http://www.boost.org/doc/libs/1_49_0/libs/graph/doc/table_of_contents.html for more details
    */
   
-  BOOST_CONCEPT_ASSERT(( VertexListGraphConcept< CcnxGlobalRouterGraph > ));
-  BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept< CcnxGlobalRouterGraph > ));
+  BOOST_CONCEPT_ASSERT(( VertexListGraphConcept< NdnGlobalRouterGraph > ));
+  BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept< NdnGlobalRouterGraph > ));
   
-  CcnxGlobalRouterGraph graph;
-  typedef graph_traits < CcnxGlobalRouterGraph >::vertex_descriptor vertex_descriptor;
+  NdnGlobalRouterGraph graph;
+  typedef graph_traits < NdnGlobalRouterGraph >::vertex_descriptor vertex_descriptor;
 
   // For now we doing Dijkstra for every node.  Can be replaced with Bellman-Ford or Floyd-Warshall.
   // Other algorithms should be faster, but they need additional EdgeListGraph concept provided by the graph, which
   // is not obviously how implement in an efficient manner
   for (NodeList::Iterator node = NodeList::Begin (); node != NodeList::End (); node++)
     {
-      Ptr<CcnxGlobalRouter> source = (*node)->GetObject<CcnxGlobalRouter> ();
+      Ptr<NdnGlobalRouter> source = (*node)->GetObject<NdnGlobalRouter> ();
       if (source == 0)
 	{
-	  NS_LOG_DEBUG ("Node " << (*node)->GetId () << " does not export CcnxGlobalRouter interface");
+	  NS_LOG_DEBUG ("Node " << (*node)->GetId () << " does not export NdnGlobalRouter interface");
 	  continue;
 	}
   
@@ -252,7 +252,7 @@
 
       // NS_LOG_DEBUG (predecessors.size () << ", " << distances.size ());
 
-      Ptr<CcnxFib>  fib  = source->GetObject<CcnxFib> ();
+      Ptr<NdnFib>  fib  = source->GetObject<NdnFib> ();
       fib->InvalidateAll ();
       NS_ASSERT (fib != 0);
       
@@ -275,7 +275,7 @@
 		// cout << " reachable via face " << *i->second.get<0> ()
 		//      << " with distance " << i->second.get<1> () << endl;
 
-		BOOST_FOREACH (const Ptr<const CcnxNameComponents> &prefix, i->first->GetLocalPrefixes ())
+		BOOST_FOREACH (const Ptr<const NdnNameComponents> &prefix, i->first->GetLocalPrefixes ())
 		  {
 		    fib->Add (prefix, i->second.get<0> (), i->second.get<1> ());
 		  }
diff --git a/helper/ccnx-global-routing-helper.h b/helper/ndn-global-routing-helper.h
similarity index 75%
rename from helper/ccnx-global-routing-helper.h
rename to helper/ndn-global-routing-helper.h
index 1bf4b59..ac92641 100644
--- a/helper/ccnx-global-routing-helper.h
+++ b/helper/ndn-global-routing-helper.h
@@ -18,8 +18,8 @@
  * Author:  Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef CCNX_GLOBAL_ROUTING_HELPER_H
-#define CCNX_GLOBAL_ROUTING_HELPER_H
+#ifndef NDN_GLOBAL_ROUTING_HELPER_H
+#define NDN_GLOBAL_ROUTING_HELPER_H
 
 #include "ns3/ptr.h"
 
@@ -30,35 +30,35 @@
 class Channel;
 
 /**
- * @ingroup ccnx
- * @brief Helper for CcnxGlobalRouter interface
+ * @ingroup ndn
+ * @brief Helper for NdnGlobalRouter interface
  */
-class CcnxGlobalRoutingHelper
+class NdnGlobalRoutingHelper
 {
 public:
   /**
-   * @brief Install CcnxGlobalRouter interface on a node
+   * @brief Install NdnGlobalRouter interface on a node
    *
-   * Note that CcnxGlobalRouter will also be installed on all connected nodes and channels
+   * Note that NdnGlobalRouter will also be installed on all connected nodes and channels
    *
-   * @param node Node to install CcnxGlobalRouter interface
+   * @param node Node to install NdnGlobalRouter interface
    */
   void
   Install (Ptr<Node> node);
 
   
   /**
-   * @brief Install CcnxGlobalRouter interface on nodes
+   * @brief Install NdnGlobalRouter interface on nodes
    *
-   * Note that CcnxGlobalRouter will also be installed on all connected nodes and channels
+   * Note that NdnGlobalRouter will also be installed on all connected nodes and channels
    *
-   * @param nodes NodeContainer to install CcnxGlobalRouter interface
+   * @param nodes NodeContainer to install NdnGlobalRouter interface
    */
   void
   Install (const NodeContainer &nodes);
 
   /**
-   * @brief Install CcnxGlobalRouter interface on all nodes
+   * @brief Install NdnGlobalRouter interface on all nodes
    */
   void
   InstallAll ();
@@ -100,4 +100,4 @@
 
 }
 
-#endif // CCNX_GLOBAL_ROUTING_HELPER_H
+#endif // NDN_GLOBAL_ROUTING_HELPER_H
diff --git a/helper/ccnx-header-helper.cc b/helper/ndn-header-helper.cc
similarity index 75%
rename from helper/ccnx-header-helper.cc
rename to helper/ndn-header-helper.cc
index d3a3400..58f8dde 100644
--- a/helper/ccnx-header-helper.cc
+++ b/helper/ndn-header-helper.cc
@@ -18,43 +18,43 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#include "ccnx-header-helper.h"
+#include "ndn-header-helper.h"
 
 #include "ns3/log.h"
 #include "ns3/packet.h"
 #include "ns3/header.h"
 #include "ns3/object.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 <iomanip>
 
-NS_LOG_COMPONENT_DEFINE ("CcnxHeaderHelper");
+NS_LOG_COMPONENT_DEFINE ("NdnHeaderHelper");
 
 
 namespace ns3
 {
 
-CcnxHeaderHelper::Type
-CcnxHeaderHelper::GetCcnxHeaderType (Ptr<const Packet> packet)
+NdnHeaderHelper::Type
+NdnHeaderHelper::GetNdnHeaderType (Ptr<const Packet> packet)
 {
   uint8_t type[2];
   uint32_t read=packet->CopyData (type,2);
 
-  if (read!=2) throw CcnxUnknownHeaderException();
+  if (read!=2) throw NdnUnknownHeaderException();
 
   NS_LOG_DEBUG (*packet);
   if (type[0] == INTEREST_BYTE0 && type[1] == INTEREST_BYTE1)
     {
-      return CcnxHeaderHelper::INTEREST;
+      return NdnHeaderHelper::INTEREST;
     }
   else if (type[0] == CONTENT_OBJECT_BYTE0 && type[1] == CONTENT_OBJECT_BYTE1)
     {
-      return CcnxHeaderHelper::CONTENT_OBJECT;
+      return NdnHeaderHelper::CONTENT_OBJECT;
     }
 
   NS_LOG_DEBUG (*packet);
-  throw CcnxUnknownHeaderException();
+  throw NdnUnknownHeaderException();
 }
 
 } // namespace ns3
diff --git a/helper/ccnx-header-helper.h b/helper/ndn-header-helper.h
similarity index 68%
rename from helper/ccnx-header-helper.h
rename to helper/ndn-header-helper.h
index 7a23c6d..7f2e111 100644
--- a/helper/ccnx-header-helper.h
+++ b/helper/ndn-header-helper.h
@@ -18,8 +18,8 @@
  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
  */
 
-#ifndef _CCNX_HEADER_HELPER_H_
-#define _CCNX_HEADER_HELPER_H_
+#ifndef _NDN_HEADER_HELPER_H_
+#define _NDN_HEADER_HELPER_H_
 
 #include "ns3/ptr.h"
 
@@ -36,27 +36,27 @@
 class Packet;
 
 /**
- * \ingroup ccnx-helpers
+ * \ingroup ndn-helpers
  *
- * \brief Class implementing functionality to detect CCNx packet type and
+ * \brief Class implementing functionality to detect Ndn packet type and
  * create the corresponding object
  *
- * CCNx doesn't really have a header, so we need this class to
- * determine type of CCNx packet and return corresponent header class,
- * CcnxInterestHeader or CcnxContentObjectHeader
+ * Ndn doesn't really have a header, so we need this class to
+ * determine type of Ndn packet and return corresponent header class,
+ * NdnInterestHeader or NdnContentObjectHeader
  *
- * Throws CcnxUnknownHeaderException if header type couldn't be determined
+ * Throws NdnUnknownHeaderException if header type couldn't be determined
  */
-class CcnxHeaderHelper
+class NdnHeaderHelper
 {
 public:
   /**
-     @brief enum for Ccnx packet types
+     @brief enum for Ndn packet types
    */
   enum Type {INTEREST, CONTENT_OBJECT}; 
 
   /**
-   * Static function to create an appropriate CCNx header
+   * Static function to create an appropriate Ndn header
    *
    * It peeks first 2 bytes of a packet.
    *
@@ -73,24 +73,24 @@
    *                          |               |
    *                      terminator      DTAG (Dictionary TAG)
    *
-   * \see http://www.ccnx.org/releases/latest/doc/technical/BinaryEncoding.html
+   * \see http://www.ndn.org/releases/latest/doc/technical/BinaryEncoding.html
    */
   
   static Type
-  GetCcnxHeaderType (Ptr<const Packet> packet);
+  GetNdnHeaderType (Ptr<const Packet> packet);
 };
 
   /**
-   * \ingroup ccnx
-   * \defgroup ccnx-exceptions Exceptions
+   * \ingroup ndn
+   * \defgroup ndn-exceptions Exceptions
    */
   /**
-   * \ingroup ccnx-exceptions
-   * \brief Exception thrown if CCNx stack receives unrecognized
+   * \ingroup ndn-exceptions
+   * \brief Exception thrown if Ndn stack receives unrecognized
    * message type
    */
-class CcnxUnknownHeaderException {};
+class NdnUnknownHeaderException {};
 
 } // namespace ns3
 
-#endif // _CCNX_HEADER_HELPER_H_
+#endif // _NDN_HEADER_HELPER_H_
diff --git a/helper/ccnx-stack-helper.cc b/helper/ndn-stack-helper.cc
similarity index 71%
rename from helper/ccnx-stack-helper.cc
rename to helper/ndn-stack-helper.cc
index e178d18..6b0a022 100644
--- a/helper/ccnx-stack-helper.cc
+++ b/helper/ndn-stack-helper.cc
@@ -34,65 +34,65 @@
 #include "ns3/point-to-point-net-device.h"
 #include "ns3/point-to-point-helper.h"
 
-#include "../model/ccnx-net-device-face.h"
-#include "../model/ccnx-l3-protocol.h"
+#include "../model/ndn-net-device-face.h"
+#include "../model/ndn-l3-protocol.h"
 
-#include "ns3/ccnx-forwarding-strategy.h"
-#include "ns3/ccnx-fib.h"
-#include "ns3/ccnx-pit.h"
-#include "ns3/ccnx-name-components.h"
-#include "ns3/ccnx-content-store.h"
+#include "ns3/ndn-forwarding-strategy.h"
+#include "ns3/ndn-fib.h"
+#include "ns3/ndn-pit.h"
+#include "ns3/ndn-name-components.h"
+#include "ns3/ndn-content-store.h"
 
 #include "ns3/node-list.h"
 // #include "ns3/loopback-net-device.h"
 
 #include "ns3/data-rate.h"
 
-#include "ccnx-face-container.h"
-#include "ccnx-stack-helper.h"
+#include "ndn-face-container.h"
+#include "ndn-stack-helper.h"
 
 #include <limits>
 #include <map>
 #include <boost/foreach.hpp>
 #include <boost/lexical_cast.hpp>
 
-NS_LOG_COMPONENT_DEFINE ("CcnxStackHelper");
+NS_LOG_COMPONENT_DEFINE ("NdnStackHelper");
 
 namespace ns3 {
     
-CcnxStackHelper::CcnxStackHelper ()
+NdnStackHelper::NdnStackHelper ()
   : m_limitsEnabled (false)
   , m_needSetDefaultRoutes (false)
 {
-  m_ccnxFactory.        SetTypeId ("ns3::CcnxL3Protocol");
+  m_ndnFactory.        SetTypeId ("ns3::NdnL3Protocol");
   m_strategyFactory.    SetTypeId ("ns3::ndnSIM::Flooding");
-  m_contentStoreFactory.SetTypeId ("ns3::CcnxContentStoreLru");
-  m_fibFactory.         SetTypeId ("ns3::CcnxFib");
-  m_pitFactory.         SetTypeId ("ns3::CcnxPit");
+  m_contentStoreFactory.SetTypeId ("ns3::NdnContentStoreLru");
+  m_fibFactory.         SetTypeId ("ns3::NdnFib");
+  m_pitFactory.         SetTypeId ("ns3::NdnPit");
 }
     
-CcnxStackHelper::~CcnxStackHelper ()
+NdnStackHelper::~NdnStackHelper ()
 {
 }
 
 void
-CcnxStackHelper::SetCcnxAttributes (const std::string &attr1, const std::string &value1,
+NdnStackHelper::SetNdnAttributes (const std::string &attr1, const std::string &value1,
                                     const std::string &attr2, const std::string &value2,
                                     const std::string &attr3, const std::string &value3,
                                     const std::string &attr4, const std::string &value4)
 {
   if (attr1 != "")
-      m_ccnxFactory.Set (attr1, StringValue (value1));
+      m_ndnFactory.Set (attr1, StringValue (value1));
   if (attr2 != "")
-      m_ccnxFactory.Set (attr2, StringValue (value2));
+      m_ndnFactory.Set (attr2, StringValue (value2));
   if (attr3 != "")
-      m_ccnxFactory.Set (attr3, StringValue (value3));
+      m_ndnFactory.Set (attr3, StringValue (value3));
   if (attr4 != "")
-      m_ccnxFactory.Set (attr4, StringValue (value4));
+      m_ndnFactory.Set (attr4, StringValue (value4));
 }
 
 void 
-CcnxStackHelper::SetForwardingStrategy (const std::string &strategy,
+NdnStackHelper::SetForwardingStrategy (const std::string &strategy,
                                         const std::string &attr1, const std::string &value1,
                                         const std::string &attr2, const std::string &value2,
                                         const std::string &attr3, const std::string &value3,
@@ -110,7 +110,7 @@
 }
 
 void
-CcnxStackHelper::SetContentStore (const std::string &contentStore,
+NdnStackHelper::SetContentStore (const std::string &contentStore,
                                   const std::string &attr1, const std::string &value1,
                                   const std::string &attr2, const std::string &value2,
                                   const std::string &attr3, const std::string &value3,
@@ -128,7 +128,7 @@
 }
 
 void
-CcnxStackHelper::SetPit (const std::string &pitClass,
+NdnStackHelper::SetPit (const std::string &pitClass,
                          const std::string &attr1, const std::string &value1,
                          const std::string &attr2, const std::string &value2,
                          const std::string &attr3, const std::string &value3,
@@ -146,7 +146,7 @@
 }
 
 void
-CcnxStackHelper::SetFib (const std::string &fibClass,
+NdnStackHelper::SetFib (const std::string &fibClass,
                          const std::string &attr1, const std::string &value1,
                          const std::string &attr2, const std::string &value2,
                          const std::string &attr3, const std::string &value3,
@@ -164,14 +164,14 @@
 }
 
 void
-CcnxStackHelper::SetDefaultRoutes (bool needSet)
+NdnStackHelper::SetDefaultRoutes (bool needSet)
 {
   NS_LOG_FUNCTION (this << needSet);
   m_needSetDefaultRoutes = needSet;
 }
 
 void
-CcnxStackHelper::EnableLimits (bool enable/* = true*/,
+NdnStackHelper::EnableLimits (bool enable/* = true*/,
                                Time avgRtt/*=Seconds(0.1)*/,
                                uint32_t avgContentObject/*=1100*/,
                                uint32_t avgInterest/*=40*/)
@@ -183,10 +183,10 @@
   m_avgInterestSize = avgInterest;
 }
 
-Ptr<CcnxFaceContainer>
-CcnxStackHelper::Install (NodeContainer c) const
+Ptr<NdnFaceContainer>
+NdnStackHelper::Install (NodeContainer c) const
 {
-  Ptr<CcnxFaceContainer> faces = Create<CcnxFaceContainer> ();
+  Ptr<NdnFaceContainer> faces = Create<NdnFaceContainer> ();
   for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)
     {
       faces->AddAll (Install (*i));
@@ -194,43 +194,43 @@
   return faces;
 }
 
-Ptr<CcnxFaceContainer>
-CcnxStackHelper::InstallAll (void) const
+Ptr<NdnFaceContainer>
+NdnStackHelper::InstallAll (void) const
 {
   return Install (NodeContainer::GetGlobal ());
 }
 
-Ptr<CcnxFaceContainer>
-CcnxStackHelper::Install (Ptr<Node> node) const
+Ptr<NdnFaceContainer>
+NdnStackHelper::Install (Ptr<Node> node) const
 {
   // NS_ASSERT_MSG (m_forwarding, "SetForwardingHelper() should be set prior calling Install() method");
-  Ptr<CcnxFaceContainer> faces = Create<CcnxFaceContainer> ();
+  Ptr<NdnFaceContainer> faces = Create<NdnFaceContainer> ();
   
-  if (node->GetObject<Ccnx> () != 0)
+  if (node->GetObject<Ndn> () != 0)
     {
-      NS_FATAL_ERROR ("CcnxStackHelper::Install (): Installing " 
-                      "a CcnxStack to a node with an existing Ccnx object");
+      NS_FATAL_ERROR ("NdnStackHelper::Install (): Installing " 
+                      "a NdnStack to a node with an existing Ndn object");
       return 0;
     }
 
-  // Create CcnxL3Protocol
-  Ptr<Ccnx> ccnx = m_ccnxFactory.Create<Ccnx> ();
+  // Create NdnL3Protocol
+  Ptr<Ndn> ndn = m_ndnFactory.Create<Ndn> ();
 
   // Create and aggregate FIB
-  Ptr<CcnxFib> fib = m_fibFactory.Create<CcnxFib> ();
-  ccnx->AggregateObject (fib);
+  Ptr<NdnFib> fib = m_fibFactory.Create<NdnFib> ();
+  ndn->AggregateObject (fib);
 
   // Create and aggregate PIT
-  ccnx->AggregateObject (m_pitFactory.Create<CcnxPit> ());
+  ndn->AggregateObject (m_pitFactory.Create<NdnPit> ());
   
   // Create and aggregate forwarding strategy
-  ccnx->AggregateObject (m_strategyFactory.Create<CcnxForwardingStrategy> ());
+  ndn->AggregateObject (m_strategyFactory.Create<NdnForwardingStrategy> ());
 
   // Create and aggregate content store
-  ccnx->AggregateObject (m_contentStoreFactory.Create<CcnxContentStore> ());
+  ndn->AggregateObject (m_contentStoreFactory.Create<NdnContentStore> ());
 
-  // Aggregate CcnxL3Protocol on node
-  node->AggregateObject (ccnx);
+  // Aggregate NdnL3Protocol on node
+  node->AggregateObject (ndn);
   
   for (uint32_t index=0; index < node->GetNDevices (); index++)
     {
@@ -240,10 +240,10 @@
       // if (DynamicCast<LoopbackNetDevice> (device) != 0)
       //   continue; // don't create face for a LoopbackNetDevice
 
-      Ptr<CcnxNetDeviceFace> face = CreateObject<CcnxNetDeviceFace> (node, device);
+      Ptr<NdnNetDeviceFace> face = CreateObject<NdnNetDeviceFace> (node, device);
 
-      ccnx->AddFace (face);
-      NS_LOG_LOGIC ("Node " << node->GetId () << ": added CcnxNetDeviceFace as face #" << *face);
+      ndn->AddFace (face);
+      NS_LOG_LOGIC ("Node " << node->GetId () << ": added NdnNetDeviceFace as face #" << *face);
 
       if (m_needSetDefaultRoutes)
         {
@@ -282,8 +282,8 @@
   return faces;
 }
 
-Ptr<CcnxFaceContainer>
-CcnxStackHelper::Install (std::string nodeName) const
+Ptr<NdnFaceContainer>
+NdnStackHelper::Install (std::string nodeName) const
 {
   Ptr<Node> node = Names::Find<Node> (nodeName);
   return Install (node);
@@ -291,39 +291,39 @@
 
 
 void
-CcnxStackHelper::AddRoute (Ptr<Node> node, std::string prefix, Ptr<CcnxFace> face, int32_t metric)
+NdnStackHelper::AddRoute (Ptr<Node> node, std::string prefix, Ptr<NdnFace> face, int32_t metric)
 {
   NS_LOG_LOGIC ("[" << node->GetId () << "]$ route add " << prefix << " via " << *face << " metric " << metric);
 
-  Ptr<CcnxFib>  fib  = node->GetObject<CcnxFib> ();
+  Ptr<NdnFib>  fib  = node->GetObject<NdnFib> ();
 
-  CcnxNameComponentsValue prefixValue;
-  prefixValue.DeserializeFromString (prefix, MakeCcnxNameComponentsChecker ());
+  NdnNameComponentsValue prefixValue;
+  prefixValue.DeserializeFromString (prefix, MakeNdnNameComponentsChecker ());
   fib->Add (prefixValue.Get (), face, metric);
 }
 
 void
-CcnxStackHelper::AddRoute (Ptr<Node> node, std::string prefix, uint32_t faceId, int32_t metric)
+NdnStackHelper::AddRoute (Ptr<Node> node, std::string prefix, uint32_t faceId, int32_t metric)
 {
-  Ptr<Ccnx>     ccnx = node->GetObject<Ccnx> ();
-  NS_ASSERT_MSG (ccnx != 0, "Ccnx stack should be installed on the node");
+  Ptr<Ndn>     ndn = node->GetObject<Ndn> ();
+  NS_ASSERT_MSG (ndn != 0, "Ndn stack should be installed on the node");
 
-  Ptr<CcnxFace> face = ccnx->GetFace (faceId);
+  Ptr<NdnFace> face = ndn->GetFace (faceId);
   NS_ASSERT_MSG (face != 0, "Face with ID [" << faceId << "] does not exist on node [" << node->GetId () << "]");
 
   AddRoute (node, prefix, face, metric);
 }
 
 void
-CcnxStackHelper::AddRoute (std::string nodeName, std::string prefix, uint32_t faceId, int32_t metric)
+NdnStackHelper::AddRoute (std::string nodeName, std::string prefix, uint32_t faceId, int32_t metric)
 {
   Ptr<Node> node = Names::Find<Node> (nodeName);
   NS_ASSERT_MSG (node != 0, "Node [" << nodeName << "] does not exist");
   
-  Ptr<Ccnx>     ccnx = node->GetObject<Ccnx> ();
-  NS_ASSERT_MSG (ccnx != 0, "Ccnx stack should be installed on the node");
+  Ptr<Ndn>     ndn = node->GetObject<Ndn> ();
+  NS_ASSERT_MSG (ndn != 0, "Ndn stack should be installed on the node");
 
-  Ptr<CcnxFace> face = ccnx->GetFace (faceId);
+  Ptr<NdnFace> face = ndn->GetFace (faceId);
   NS_ASSERT_MSG (face != 0, "Face with ID [" << faceId << "] does not exist on node [" << nodeName << "]");
 
   AddRoute (node, prefix, face, metric);
diff --git a/helper/ccnx-stack-helper.h b/helper/ndn-stack-helper.h
similarity index 80%
rename from helper/ccnx-stack-helper.h
rename to helper/ndn-stack-helper.h
index ee0b547..0bd69ad 100644
--- a/helper/ccnx-stack-helper.h
+++ b/helper/ndn-stack-helper.h
@@ -19,8 +19,8 @@
  *          Ilya Moiseenko <iliamo@cs.ucla.edu> 
  */
 
-#ifndef CCNX_STACK_HELPER_H
-#define CCNX_STACK_HELPER_H
+#ifndef NDN_STACK_HELPER_H
+#define NDN_STACK_HELPER_H
 
 #include "ns3/packet.h"
 #include "ns3/ptr.h"
@@ -30,18 +30,18 @@
 namespace ns3 {
 
 class Node;
-class CcnxFaceContainer;
-class CcnxFace;
+class NdnFaceContainer;
+class NdnFace;
 
 /**
- * \ingroup ccnx
- * \defgroup ccnx-helpers Helpers
+ * \ingroup ndn
+ * \defgroup ndn-helpers Helpers
  */
 /**
- * \ingroup ccnx-helpers
- * \brief Adding CCNx functionality to existing Nodes.
+ * \ingroup ndn-helpers
+ * \brief Adding Ndn functionality to existing Nodes.
  *
- * This helper enables pcap and ascii tracing of events in the ccnx stack
+ * This helper enables pcap and ascii tracing of events in the ndn stack
  * associated with a node.  This is substantially similar to the tracing that
  * happens in device helpers, but the important difference is that, well, there
  * is no device.  This means that the creation of output file names will change,
@@ -49,29 +49,29 @@
  * the number of trace enable methods is reduced.
  *
  * Normally we eschew multiple inheritance, however, the classes
- * PcapUserHelperForCcnx and AsciiTraceUserHelperForCcnx are treated as
+ * PcapUserHelperForNdn and AsciiTraceUserHelperForNdn are treated as
  * "mixins".  A mixin is a self-contained class that encapsulates a general
  * attribute or a set of functionality that may be of interest to many other
  * classes.
  */
-class CcnxStackHelper 
+class NdnStackHelper 
 {
 public:
   /**
-   * \brief Create a new CcnxStackHelper with a default NDN_FLOODING forwarding stategy
+   * \brief Create a new NdnStackHelper with a default NDN_FLOODING forwarding stategy
    */
-  CcnxStackHelper();
+  NdnStackHelper();
   
   /**
-   * \brief Destroy the CcnxStackHelper
+   * \brief Destroy the NdnStackHelper
    */
-  virtual ~CcnxStackHelper ();
+  virtual ~NdnStackHelper ();
 
   /**
-   * @brief Set parameters of CcnxL3Protocol
+   * @brief Set parameters of NdnL3Protocol
    */
   void
-  SetCcnxAttributes (const std::string &attr1 = "", const std::string &value1 = "",
+  SetNdnAttributes (const std::string &attr1 = "", const std::string &value1 = "",
                      const std::string &attr2 = "", const std::string &value2 = "",
                      const std::string &attr3 = "", const std::string &value3 = "",
                      const std::string &attr4 = "", const std::string &value4 = "");
@@ -81,9 +81,9 @@
    * @brief Set forwarding strategy class and its attributes
    * @param forwardingStrategyClass string containing name of the forwarding strategy class
    *
-   * Valid options are "ns3::CcnxFloodingStrategy" (default) and "ns3::CcnxBestRouteStrategy"
+   * Valid options are "ns3::NdnFloodingStrategy" (default) and "ns3::NdnBestRouteStrategy"
    *
-   * Other strategies can be implemented, inheriting ns3::CcnxForwardingStrategy class
+   * Other strategies can be implemented, inheriting ns3::NdnForwardingStrategy class
    */
   void
   SetForwardingStrategy (const std::string &forwardingStrategyClass,
@@ -137,55 +137,55 @@
   EnableLimits (bool enable = true, Time avgRtt=Seconds(0.1), uint32_t avgContentObject=1100, uint32_t avgInterest=40);
   
   /**
-   * \brief Install CCNx stack on the node
+   * \brief Install Ndn stack on the node
    *
-   * This method will assert if called on a node that already has Ccnx object
+   * This method will assert if called on a node that already has Ndn object
    * installed on it
    * 
    * \param nodeName The name of the node on which to install the stack.
    *
    * \returns list of installed faces in the form of a smart pointer
-   * to CcnxFaceContainer object
+   * to NdnFaceContainer object
    */
-  Ptr<CcnxFaceContainer>
+  Ptr<NdnFaceContainer>
   Install (std::string nodeName) const;
 
   /**
-   * \brief Install CCNx stack on the node
+   * \brief Install Ndn stack on the node
    *
-   * This method will assert if called on a node that already has Ccnx object
+   * This method will assert if called on a node that already has Ndn object
    * installed on it
    * 
    * \param node The node on which to install the stack.
    *
    * \returns list of installed faces in the form of a smart pointer
-   * to CcnxFaceContainer object
+   * to NdnFaceContainer object
    */
-  Ptr<CcnxFaceContainer>
+  Ptr<NdnFaceContainer>
   Install (Ptr<Node> node) const;
 
   /**
-   * \brief Install CCNx stack on each node in the input container
+   * \brief Install Ndn stack on each node in the input container
    *
    * The program will assert if this method is called on a container with a node
-   * that already has an ccnx object aggregated to it.
+   * that already has an ndn object aggregated to it.
    * 
    * \param c NodeContainer that holds the set of nodes on which to install the
    * new stacks.
    *
    * \returns list of installed faces in the form of a smart pointer
-   * to CcnxFaceContainer object
+   * to NdnFaceContainer object
    */
-  Ptr<CcnxFaceContainer>
+  Ptr<NdnFaceContainer>
   Install (NodeContainer c) const;
 
   /**
-   * \brief Install CCNx stack on all nodes in the simulation
+   * \brief Install Ndn stack on all nodes in the simulation
    *
    * \returns list of installed faces in the form of a smart pointer
-   * to CcnxFaceContainer object
+   * to NdnFaceContainer object
    */
-  Ptr<CcnxFaceContainer>
+  Ptr<NdnFaceContainer>
   InstallAll () const;
 
   /**
@@ -219,7 +219,7 @@
    * \param metric Routing metric
    */
   static void
-  AddRoute (Ptr<Node> node, std::string prefix, Ptr<CcnxFace> face, int32_t metric);
+  AddRoute (Ptr<Node> node, std::string prefix, Ptr<NdnFace> face, int32_t metric);
 
   /**
    * \brief Set flag indicating necessity to install default routes in FIB
@@ -228,11 +228,11 @@
   SetDefaultRoutes (bool needSet);
 
 private:
-  CcnxStackHelper (const CcnxStackHelper &);
-  CcnxStackHelper &operator = (const CcnxStackHelper &o);
+  NdnStackHelper (const NdnStackHelper &);
+  NdnStackHelper &operator = (const NdnStackHelper &o);
   
 private:
-  ObjectFactory m_ccnxFactory;
+  ObjectFactory m_ndnFactory;
   ObjectFactory m_strategyFactory;
   ObjectFactory m_contentStoreFactory;
   ObjectFactory m_pitFactory;
@@ -247,4 +247,4 @@
 
 } // namespace ns3
 
-#endif /* CCNX_STACK_HELPER_H */
+#endif /* NDN_STACK_HELPER_H */