diff --git a/examples/ndn-simple-tcp.cc b/examples/ndn-simple-tcp.cc
new file mode 100644
index 0000000..f959dc7
--- /dev/null
+++ b/examples/ndn-simple-tcp.cc
@@ -0,0 +1,126 @@
+/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2012 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>
+ */
+// ndn-simple-tcp.cc
+#include "ns3/core-module.h"
+#include "ns3/network-module.h"
+#include "ns3/point-to-point-module.h"
+#include "ns3/internet-module.h"
+#include "ns3/ndnSIM-module.h"
+
+using namespace ns3;
+
+/**
+ * This scenario simulates a very simple network topology:
+ *
+ *
+ *      +----------+     1Mbps      +--------+     1Mbps      +----------+
+ *      | consumer | <------------> | router | <------------> | producer |
+ *      +----------+         10ms   +--------+          10ms  +----------+
+ *           \                                                   /
+ *            -------------------- tcp face --------------------
+ *
+ * Consumer requests data from producer with frequency 10 interests per second
+ * (interests contain constantly increasing sequence number).
+ *
+ * For every received interest, producer replies with a data packet, containing
+ * 1024 bytes of virtual payload.
+ *
+ * To run scenario and see what is happening, use the following command:
+ *
+ *     NS_LOG=ndn.Consumer:ndn.Producer ./waf --run=ndn-simple-tcp
+ */
+
+int 
+main (int argc, char *argv[])
+{
+  Packet::EnablePrinting ();
+  
+  // setting default parameters for PointToPoint links and channels
+  Config::SetDefault ("ns3::PointToPointNetDevice::DataRate", StringValue ("1Mbps"));
+  Config::SetDefault ("ns3::PointToPointChannel::Delay", StringValue ("10ms"));
+  Config::SetDefault ("ns3::DropTailQueue::MaxPackets", StringValue ("20"));
+
+  // Read optional command-line parameters (e.g., enable visualizer with ./waf --run=<> --visualize
+  CommandLine cmd;
+  cmd.Parse (argc, argv);
+
+  // Creating nodes
+  NodeContainer nodes;
+  nodes.Create (3);
+
+  // Connecting nodes using two links
+  PointToPointHelper p2p;
+  NetDeviceContainer link1 = p2p.Install (nodes.Get (0), nodes.Get (1));
+  NetDeviceContainer link2 = p2p.Install (nodes.Get (1), nodes.Get (2));
+
+  // Install NDN stack on all nodes
+  ndn::StackHelper ndnHelper;
+  ndnHelper.SetDefaultRoutes (false);
+  ndnHelper.InstallAll ();
+
+  InternetStackHelper ipStack;
+  ipStack.SetIpv6StackInstall (false);
+  ipStack.InstallAll ();
+
+  Ipv4AddressHelper ipAddressHelper;
+  ipAddressHelper.SetBase (Ipv4Address ("10.1.1.0"), Ipv4Mask ("255.255.255.0"));
+  ipAddressHelper.Assign (link1);
+  
+  ipAddressHelper.SetBase (Ipv4Address ("10.1.2.0"), Ipv4Mask ("255.255.255.0"));
+  ipAddressHelper.Assign (link2);
+
+  Ipv4StaticRoutingHelper ipStaticRouting;
+  ipStaticRouting.GetStaticRouting (nodes.Get (0)->GetObject<Ipv4> ())->
+    AddNetworkRouteTo (Ipv4Address ("10.1.2.0"), Ipv4Mask ("255.255.255.0"),
+                       Ipv4Address ("10.1.1.2"),
+                       1, 1);
+
+  ipStaticRouting.GetStaticRouting (nodes.Get (2)->GetObject<Ipv4> ())->
+    AddNetworkRouteTo (Ipv4Address ("10.1.1.0"), Ipv4Mask ("255.255.255.0"),
+                       Ipv4Address ("10.1.2.1"),
+                       1, 1);
+  
+  ndn::IpFacesHelper::InstallAll ();
+  ndn::IpFacesHelper::CreateTcpFace (Seconds (1.0), nodes.Get (0), Ipv4Address ("10.1.2.2"), "/tcp-route");
+  
+  // Installing applications
+
+  // Consumer
+  ndn::AppHelper consumerHelper ("ns3::ndn::ConsumerCbr");
+  // Consumer will request /tcp-route/0, /tcp-route/1, ...
+  consumerHelper.SetPrefix ("/tcp-route");
+  consumerHelper.SetAttribute ("Frequency", StringValue ("10")); // 10 interests a second
+  consumerHelper.Install (nodes.Get (0)).
+    Start (Seconds (3)); // first node
+
+  // Producer
+  ndn::AppHelper producerHelper ("ns3::ndn::Producer");
+  // Producer will reply to all requests starting with /prefix
+  producerHelper.SetPrefix ("/tcp-route");
+  producerHelper.SetAttribute ("PayloadSize", StringValue("1024"));
+  producerHelper.Install (nodes.Get (2)); // last node
+
+  Simulator::Stop (Seconds (20.0));
+
+  Simulator::Run ();
+  Simulator::Destroy ();
+
+  return 0;
+}
diff --git a/examples/ndn-simple-udp.cc b/examples/ndn-simple-udp.cc
new file mode 100644
index 0000000..2fa093d
--- /dev/null
+++ b/examples/ndn-simple-udp.cc
@@ -0,0 +1,139 @@
+/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2012 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>
+ */
+// ndn-simple-tcp.cc
+#include "ns3/core-module.h"
+#include "ns3/network-module.h"
+#include "ns3/point-to-point-module.h"
+#include "ns3/internet-module.h"
+#include "ns3/ndnSIM-module.h"
+
+using namespace ns3;
+
+/**
+ * This scenario simulates a very simple network topology:
+ *
+ *
+ *      +----------+     1Mbps      +--------+     1Mbps      +----------+
+ *      | consumer | <------------> | router | <------------> | producer |
+ *      +----------+         10ms   +--------+          10ms  +----------+
+ *           \                                                   /
+ *            -------------------- udp face --------------------
+ *
+ * Consumer requests data from producer with frequency 10 interests per second
+ * (interests contain constantly increasing sequence number).
+ *
+ * For every received interest, producer replies with a data packet, containing
+ * 1024 bytes of virtual payload.
+ *
+ * To run scenario and see what is happening, use the following command:
+ *
+ *     NS_LOG=ndn.Consumer:ndn.Producer ./waf --run=ndn-simple-udp
+ */
+
+int 
+main (int argc, char *argv[])
+{
+  Packet::EnablePrinting ();
+  
+  // setting default parameters for PointToPoint links and channels
+  Config::SetDefault ("ns3::PointToPointNetDevice::DataRate", StringValue ("1Mbps"));
+  Config::SetDefault ("ns3::PointToPointChannel::Delay", StringValue ("10ms"));
+  Config::SetDefault ("ns3::DropTailQueue::MaxPackets", StringValue ("20"));
+
+  // Read optional command-line parameters (e.g., enable visualizer with ./waf --run=<> --visualize
+  CommandLine cmd;
+  cmd.Parse (argc, argv);
+
+  // Creating nodes
+  NodeContainer nodes;
+  nodes.Create (3);
+
+  // Connecting nodes using two links
+  PointToPointHelper p2p;
+  NetDeviceContainer link1 = p2p.Install (nodes.Get (0), nodes.Get (1));
+  NetDeviceContainer link2 = p2p.Install (nodes.Get (1), nodes.Get (2));
+
+  // Install NDN stack on all nodes
+  ndn::StackHelper ndnHelper;
+  ndnHelper.SetForwardingStrategy ("ns3::ndn::fw::BestRoute");
+  ndnHelper.SetDefaultRoutes (false);
+  ndnHelper.InstallAll ();
+
+  InternetStackHelper ipStack;
+  ipStack.SetIpv6StackInstall (false);
+  ipStack.InstallAll ();
+
+  Ipv4AddressHelper ipAddressHelper;
+  ipAddressHelper.SetBase (Ipv4Address ("10.1.1.0"), Ipv4Mask ("255.255.255.0"));
+  ipAddressHelper.Assign (link1);
+  
+  ipAddressHelper.SetBase (Ipv4Address ("10.1.2.0"), Ipv4Mask ("255.255.255.0"));
+  ipAddressHelper.Assign (link2);
+
+  Ipv4StaticRoutingHelper ipStaticRouting;
+  ipStaticRouting.GetStaticRouting (nodes.Get (0)->GetObject<Ipv4> ())->
+    AddNetworkRouteTo (Ipv4Address ("10.1.2.0"), Ipv4Mask ("255.255.255.0"),
+                       Ipv4Address ("10.1.1.2"),
+                       1, 1);
+
+  ipStaticRouting.GetStaticRouting (nodes.Get (2)->GetObject<Ipv4> ())->
+    AddNetworkRouteTo (Ipv4Address ("10.1.1.0"), Ipv4Mask ("255.255.255.0"),
+                       Ipv4Address ("10.1.2.1"),
+                       1, 1);
+  
+  ndn::IpFacesHelper::InstallAll ();
+  ndn::IpFacesHelper::CreateUdpFace (Seconds (1.0), nodes.Get (0), Ipv4Address ("10.1.2.2"), "/udp-route1");
+  ndn::IpFacesHelper::CreateUdpFace (Seconds (1.0), nodes.Get (0), Ipv4Address ("10.1.1.2"), "/udp-route2");
+  
+  // Installing applications
+
+  // Consumer
+  ndn::AppHelper consumerHelper ("ns3::ndn::ConsumerCbr");
+  // consumerHelper.SetAttribute ("Randomize", StringValue ("uniform"));
+  // Consumer will request /udp-route1/0, /udp-route1/1, ...
+  consumerHelper.SetPrefix ("/udp-route1");
+  consumerHelper.SetAttribute ("Frequency", StringValue ("10")); // 10 interests a second
+  consumerHelper.Install (nodes.Get (0)).
+    Start (Seconds (3)); // first node
+
+  // Consumer will request /udp-route1/0, /udp-route1/1, ...
+  consumerHelper.SetPrefix ("/udp-route2");
+  consumerHelper.SetAttribute ("Frequency", StringValue ("10")); // 10 interests a second
+  consumerHelper.Install (nodes.Get (0)).
+    Start (Seconds (3)); // first node
+  
+  // Producer
+  ndn::AppHelper producerHelper ("ns3::ndn::Producer");
+  // Producer will reply to all requests starting with /prefix
+  producerHelper.SetPrefix ("/udp-route1");
+  producerHelper.SetAttribute ("PayloadSize", StringValue("1024"));
+  producerHelper.Install (nodes.Get (2)); // last node
+
+  producerHelper.SetPrefix ("/udp-route2");
+  producerHelper.SetAttribute ("PayloadSize", StringValue("1024"));
+  producerHelper.Install (nodes.Get (1)); // last node
+
+  Simulator::Stop (Seconds (20.0));
+
+  Simulator::Run ();
+  Simulator::Destroy ();
+
+  return 0;
+}
diff --git a/examples/wscript b/examples/wscript
index 49a0c5c..08f6f09 100644
--- a/examples/wscript
+++ b/examples/wscript
@@ -94,3 +94,10 @@
 
     obj = bld.create_ns3_program('ndn-simple-with-link-failure', all_modules)
     obj.source = 'ndn-simple-with-link-failure.cc'
+
+    if 'ip-faces' in bld.env['NDN_plugins']:
+        obj = bld.create_ns3_program('ndn-simple-tcp', all_modules)
+        obj.source = 'ndn-simple-tcp.cc'
+
+        obj = bld.create_ns3_program('ndn-simple-udp', all_modules)
+        obj.source = 'ndn-simple-udp.cc'
diff --git a/model/ndn-l3-protocol.cc b/model/ndn-l3-protocol.cc
index e89c9ea..0c0332f 100644
--- a/model/ndn-l3-protocol.cc
+++ b/model/ndn-l3-protocol.cc
@@ -49,6 +49,7 @@
 namespace ndn {
 
 const uint16_t L3Protocol::ETHERNET_FRAME_TYPE = 0x7777;
+const uint16_t L3Protocol::IP_STACK_PORT = 9695;
 
 NS_OBJECT_ENSURE_REGISTERED (L3Protocol);
 
diff --git a/model/ndn-l3-protocol.h b/model/ndn-l3-protocol.h
index 406e194..552bd19 100644
--- a/model/ndn-l3-protocol.h
+++ b/model/ndn-l3-protocol.h
@@ -74,9 +74,9 @@
    */
   static TypeId GetTypeId ();
 
-  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
+  static const uint16_t ETHERNET_FRAME_TYPE; ///< @brief Ethernet Frame Type of Ndn
+  static const uint16_t IP_STACK_PORT;       ///< @brief TCP/UDP port for NDN stack
+  // static const uint16_t IP_PROTOCOL_TYPE;    ///< \brief IP protocol type of NDN
 
   /**
    * \brief Default constructor. Creates an empty stack without forwarding strategy set
diff --git a/plugins/ip-faces/ndn-ip-face-stack.cc b/plugins/ip-faces/ndn-ip-face-stack.cc
new file mode 100644
index 0000000..da1b31d
--- /dev/null
+++ b/plugins/ip-faces/ndn-ip-face-stack.cc
@@ -0,0 +1,225 @@
+/* -*-  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 "ndn-ip-face-stack.h"
+#include "ndn-tcp-face.h"
+#include "ndn-udp-face.h"
+
+#include "ns3/ndn-l3-protocol.h"
+
+#include "ns3/log.h"
+#include "ns3/assert.h"
+#include "ns3/packet.h"
+#include "ns3/boolean.h"
+
+#include "ns3/socket.h"
+#include "ns3/tcp-socket-factory.h"
+#include "ns3/udp-socket-factory.h"
+#include "ns3/simulator.h"
+
+NS_LOG_COMPONENT_DEFINE ("ndn.IpFaceStack");
+
+namespace ns3 {
+namespace ndn {
+
+NS_OBJECT_ENSURE_REGISTERED (IpFaceStack);
+
+const Callback< void, Ptr<Face> > IpFaceStack::NULL_CREATE_CALLBACK = MakeNullCallback< void, Ptr<Face> > ();
+
+TypeId
+IpFaceStack::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::ndn::IpFaceStack")
+    .SetGroupName ("Ndn")
+    .SetParent<Object> ()
+    .AddConstructor<IpFaceStack> ()
+
+    .AddAttribute ("EnableTCP", "Enable ability to create TCP faces",
+                   BooleanValue (true),
+                   MakeBooleanAccessor (&IpFaceStack::m_enableTcp),
+                   MakeBooleanChecker ())
+
+    .AddAttribute ("EnableUDP", "Enable ability to create UDP faces",
+                   BooleanValue (true),
+                   MakeBooleanAccessor (&IpFaceStack::m_enableUdp),
+                   MakeBooleanChecker ())
+    ;
+  return tid;
+}
+
+IpFaceStack::IpFaceStack ()
+{
+}
+
+IpFaceStack::~IpFaceStack ()
+{
+}
+
+void
+IpFaceStack::NotifyNewAggregate ()
+{
+  if (m_node == 0)
+    {
+      m_node = GetObject<Node> ();
+      if (m_node != 0)
+        {
+          Simulator::ScheduleWithContext (m_node->GetId (), Seconds (0.1), &IpFaceStack::StartServer, this);
+        }
+    }
+}
+
+// Application Methods
+void
+IpFaceStack::StartServer () // Called at time specified by Start
+{
+  NS_LOG_FUNCTION (this);
+
+  if (m_enableTcp)
+    {
+      m_tcpServer = Socket::CreateSocket (m_node, TcpSocketFactory::GetTypeId ());
+
+      m_tcpServer->Bind (InetSocketAddress (Ipv4Address::GetAny (), L3Protocol::IP_STACK_PORT));
+      m_tcpServer->Listen ();
+
+      m_tcpServer->SetAcceptCallback (MakeCallback (&IpFaceStack::OnTcpConnectionRequest, this),
+                                      MakeCallback (&IpFaceStack::OnTcpConnectionAccept, this));
+    }
+
+  if (m_enableUdp)
+    {
+      m_udpServer = Socket::CreateSocket (m_node, UdpSocketFactory::GetTypeId ());
+      m_udpServer->Bind (InetSocketAddress (Ipv4Address::GetAny (), L3Protocol::IP_STACK_PORT));
+
+      m_udpServer->SetRecvCallback (MakeCallback (&IpFaceStack::OnUdpPacket, this));
+    }
+}
+
+bool
+IpFaceStack::OnTcpConnectionRequest (Ptr< Socket > sock, const Address &addr)
+{
+  NS_LOG_FUNCTION (this << sock << InetSocketAddress::ConvertFrom (addr));
+  return true; // accept all connections from anybody
+}
+
+void
+IpFaceStack::OnTcpConnectionAccept (Ptr<Socket> socket, const Address &addr)
+{
+  NS_LOG_FUNCTION (this << socket << InetSocketAddress::ConvertFrom (addr));
+
+  Ptr<L3Protocol> ndn = m_node->GetObject<L3Protocol> ();
+  Ptr<TcpFace> face = CreateObject<TcpFace> (m_node, socket, InetSocketAddress::ConvertFrom (addr).GetIpv4 ());
+
+  ndn->AddFace (face);
+  face->SetUp (true);
+
+  socket->SetCloseCallbacks (MakeCallback (&TcpFace::OnTcpConnectionClosed, face),
+                             MakeCallback (&TcpFace::OnTcpConnectionClosed, face));
+}
+
+void
+IpFaceStack::OnUdpPacket (Ptr< Socket > socket)
+{
+  NS_LOG_FUNCTION (this << socket);
+
+  Ptr<Packet> packet;
+  Address from;
+  while ((packet = socket->RecvFrom (from)))
+    {
+      Ptr<UdpFace> face = CreateOrGetUdpFace (InetSocketAddress::ConvertFrom (from).GetIpv4 ());
+      face->ReceiveFromUdp (packet);
+    }
+}
+
+Ptr<TcpFace>
+IpFaceStack::GetTcpFaceByAddress (const Ipv4Address &address)
+{
+  TcpFaceMap::iterator i = m_tcpFaceMap.find (address);
+  if (i != m_tcpFaceMap.end ())
+    return i->second;
+  else
+    return 0;
+}
+
+void
+IpFaceStack::DestroyTcpFace (Ptr<TcpFace> face)
+{
+  m_tcpFaceMap.erase (face->GetAddress ());
+}
+
+Ptr<UdpFace>
+IpFaceStack::GetUdpFaceByAddress (const Ipv4Address &address)
+{
+  UdpFaceMap::iterator i = m_udpFaceMap.find (address);
+  if (i != m_udpFaceMap.end ())
+    return i->second;
+  else
+    return 0;
+}
+
+Ptr<TcpFace>
+IpFaceStack::CreateOrGetTcpFace (Ipv4Address address, Callback< void, Ptr<Face> > onCreate)
+{
+  NS_LOG_FUNCTION (address);
+
+  TcpFaceMap::iterator i = m_tcpFaceMap.find (address);
+  if (i != m_tcpFaceMap.end ())
+    return i->second;
+
+  Ptr<Socket> socket = Socket::CreateSocket (m_node, TcpSocketFactory::GetTypeId ());
+  Ptr<TcpFace> face = CreateObject<TcpFace> (m_node, socket, address);
+
+  face->SetCreateCallback (onCreate);
+
+  socket->SetConnectCallback (MakeCallback (&TcpFace::OnConnect, face),
+                              MakeNullCallback< void, Ptr< Socket > > ());
+  socket->Connect (InetSocketAddress (address, L3Protocol::IP_STACK_PORT));
+
+  m_tcpFaceMap.insert (std::make_pair (address, face));
+
+  return face;
+}
+
+Ptr<UdpFace>
+IpFaceStack::CreateOrGetUdpFace (Ipv4Address address)
+{
+  NS_LOG_FUNCTION (address);
+
+  UdpFaceMap::iterator i = m_udpFaceMap.find (address);
+  if (i != m_udpFaceMap.end ())
+    return i->second;
+
+  Ptr<Socket> socket = Socket::CreateSocket (m_node, UdpSocketFactory::GetTypeId ());
+  socket->Bind (InetSocketAddress (Ipv4Address::GetAny (), L3Protocol::IP_STACK_PORT)); // not sure if it going to work...
+  // socket->Bind ();
+  socket->Connect (InetSocketAddress (address, L3Protocol::IP_STACK_PORT));
+
+  Ptr<UdpFace> face = CreateObject<UdpFace> (m_node, socket, address);
+  Ptr<L3Protocol> ndn = m_node->GetObject<L3Protocol> ();
+
+  ndn->AddFace (face);
+  face->SetUp (true);
+
+  m_udpFaceMap.insert (std::make_pair (address, face));
+  return face;
+}
+
+
+} // namespace ndn
+} // namespace ns3
diff --git a/plugins/ip-faces/ndn-ip-face-stack.h b/plugins/ip-faces/ndn-ip-face-stack.h
new file mode 100644
index 0000000..ecb80b6
--- /dev/null
+++ b/plugins/ip-faces/ndn-ip-face-stack.h
@@ -0,0 +1,136 @@
+/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2013 University of California, Los Angeles
+ *                    Alexander Afanasyev
+ *
+ * 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_IP_FACE_STACK_H
+#define NDN_IP_FACE_STACK_H
+
+#include "ns3/application.h"
+#include "ns3/socket.h"
+#include "ns3/inet-socket-address.h"
+#include "ns3/ptr.h"
+#include "ns3/ndn-name.h"
+
+#include <map>
+
+namespace ns3 {
+
+class Packet;
+
+namespace ndn {
+
+class Face;
+class TcpFace;
+class UdpFace;
+
+/**
+ * @ingroup ndn
+ * @brief Application that provides functionality of creating IP-based faces on NDN nodes
+ *
+ * The class implements virtual calls onInterest, onNack, and onContentObject
+ */
+class IpFaceStack: public Object
+{
+public:
+  static TypeId GetTypeId ();
+
+  /**
+   * @brief Default constructor
+   */
+  IpFaceStack ();
+  virtual ~IpFaceStack ();
+
+  /**
+   * @brief Lookup TcpFace for a given address
+   */
+  Ptr<TcpFace>
+  GetTcpFaceByAddress (const Ipv4Address &addr);
+
+  /**
+   * @brief Destroy TcpFace, e.g., after TCP connection got dropped
+   */
+  void
+  DestroyTcpFace (Ptr<TcpFace> face);
+
+  /**
+   * @brief Lookup UdpFace for a given address
+   */
+  Ptr<UdpFace>
+  GetUdpFaceByAddress (const Ipv4Address &addr);
+
+  /**
+   * @brief Method allowing creation and lookup of faces
+   *
+   * All created UDP faces are stored internally in the map, and if the same face is created, it will simply be looked up
+   */
+  Ptr<TcpFace>
+  CreateOrGetTcpFace (Ipv4Address address,
+                      Callback< void, Ptr<Face> > onCreate = NULL_CREATE_CALLBACK);
+
+  /**
+   * @brief Method allowing creation and lookup of faces
+   *
+   * All created TCP faces are stored internally in the map, and if the same face is created, it will simply be looked up
+   */
+  Ptr<UdpFace>
+  CreateOrGetUdpFace (Ipv4Address address);
+
+protected:
+  void
+  NotifyNewAggregate ();
+
+private:
+  void
+  StartServer ();
+
+  bool
+  OnTcpConnectionRequest (Ptr< Socket > sock, const Address &addr);
+
+  void
+  OnTcpConnectionAccept (Ptr< Socket > sock, const Address &addr);
+
+  void
+  OnTcpConnectionClosed (Ptr< Socket > sock);
+
+  void
+  OnUdpPacket (Ptr< Socket > sock);
+
+public:
+  const static Callback< void, Ptr<Face> > NULL_CREATE_CALLBACK;
+
+protected:
+  Ptr<Node> m_node;
+
+  bool m_enableTcp;
+  bool m_enableUdp;
+
+  Ptr<Socket> m_tcpServer;
+  Ptr<Socket> m_udpServer;
+
+  typedef std::map< Ipv4Address, Ptr<TcpFace> > TcpFaceMap;
+  typedef std::map< Ipv4Address, Ptr<UdpFace> > UdpFaceMap;
+  TcpFaceMap m_tcpFaceMap;
+  UdpFaceMap m_udpFaceMap;
+};
+
+} // namespace ndn
+} // namespace ns3
+
+#endif // NDN_IP_FACE_STACK_H
diff --git a/plugins/ip-faces/ndn-ip-faces-helper.cc b/plugins/ip-faces/ndn-ip-faces-helper.cc
new file mode 100644
index 0000000..26a766d
--- /dev/null
+++ b/plugins/ip-faces/ndn-ip-faces-helper.cc
@@ -0,0 +1,125 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2013 University of California, Los Angeles
+ *                    Alexander Afanasyev
+ *
+ * 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-ip-faces-helper.h"
+#include "ndn-ip-face-stack.h"
+
+#include "ns3/ndn-stack-helper.h"
+#include "ns3/node-container.h"
+#include "ns3/log.h"
+#include "ns3/simulator.h"
+#include "ndn-tcp-face.h"
+#include "ndn-udp-face.h"
+
+NS_LOG_COMPONENT_DEFINE ("ndn.IpFacesHelper");
+
+using namespace std;
+
+namespace ns3 {
+namespace ndn {
+
+void
+IpFacesHelper::Install (Ptr<Node> node)
+{
+  Ptr<IpFaceStack> stack = CreateObject<IpFaceStack> ();
+  node->AggregateObject (stack);
+}
+
+void
+IpFacesHelper::Install (const NodeContainer &nodes)
+{
+  for (NodeContainer::Iterator node = nodes.Begin ();
+       node != nodes.End ();
+       node ++)
+    {
+      Install (*node);
+    }
+}
+
+void
+IpFacesHelper::InstallAll ()
+{
+  Install (NodeContainer::GetGlobal ());
+}
+
+
+struct TcpPrefixRegistrator : SimpleRefCount<TcpPrefixRegistrator>
+{
+  TcpPrefixRegistrator (Ptr<Node> node, const std::string &prefix, int16_t metric)
+    : m_node (node)
+    , m_prefix (prefix)
+    , m_metric (metric)
+  {
+  }
+
+  void
+  Run (Ptr<Face> face)
+  {
+    ndn::StackHelper::AddRoute (m_node, m_prefix, face, m_metric);
+  }
+private:
+  Ptr<Node> m_node;
+  std::string m_prefix;
+  int16_t m_metric;
+};
+
+static void
+ScheduledCreateTcp (Ptr<Node> node, Ipv4Address address, const std::string &prefix, int16_t metric)
+{
+  Ptr<IpFaceStack> stack = node->GetObject<IpFaceStack> ();
+  NS_ASSERT_MSG (stack != 0, "ndn::IpFaceStack needs to be installed on the node");
+
+  Ptr<Face> face = stack->GetTcpFaceByAddress (address);
+  if (face == 0)
+    {
+      Ptr<TcpPrefixRegistrator> registrator = Create<TcpPrefixRegistrator> (node, prefix, metric);
+      stack->CreateOrGetTcpFace (address, MakeCallback (&TcpPrefixRegistrator::Run, registrator));
+    }
+  else
+    {
+      ndn::StackHelper::AddRoute (node, prefix, face, metric);
+    }
+}
+
+void
+IpFacesHelper::CreateTcpFace (const Time &when, Ptr<Node> node, Ipv4Address address, const std::string &prefix, int16_t metric/* = 1*/)
+{
+  Simulator::ScheduleWithContext (node->GetId (), when, ScheduledCreateTcp, node, address, prefix, metric);
+}
+
+static void
+ScheduledCreateUdp (Ptr<Node> node, Ipv4Address address, const std::string &prefix, int16_t metric)
+{
+  Ptr<IpFaceStack> stack = node->GetObject<IpFaceStack> ();
+  NS_ASSERT_MSG (stack != 0, "ndn::IpFaceStack needs to be installed on the node");
+
+  Ptr<Face> face = stack->CreateOrGetUdpFace (address);
+  ndn::StackHelper::AddRoute (node, prefix, face, metric);
+}
+
+void
+IpFacesHelper::CreateUdpFace (const Time &when, Ptr<Node> node, Ipv4Address address, const std::string &prefix, int16_t metric/* = 1*/)
+{
+  Simulator::ScheduleWithContext (node->GetId (), when, ScheduledCreateUdp, node, address, prefix, metric);
+}
+
+} // namespace ndn
+} // namespace ns3
diff --git a/plugins/ip-faces/ndn-ip-faces-helper.h b/plugins/ip-faces/ndn-ip-faces-helper.h
new file mode 100644
index 0000000..ccaf3cd
--- /dev/null
+++ b/plugins/ip-faces/ndn-ip-faces-helper.h
@@ -0,0 +1,91 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2013 University of California, Los Angeles
+ *                    Alexander Afanasyev
+ *
+ * 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_IP_FACES_HELPER_H
+#define NDN_IP_FACES_HELPER_H
+
+#include "ns3/ptr.h"
+#include "ns3/nstime.h"
+#include "ns3/ipv4-address.h"
+
+namespace ns3 {
+
+class Node;
+class NodeContainer;
+class Channel;
+
+namespace ndn {
+
+/**
+ * @ingroup ndn
+ * @brief Helper for NDN IP-based face creation
+ */
+class IpFacesHelper
+{
+public:
+  /**
+   * @brief Install IpFaceStack interface on a node
+   * @param node Node to install IpFaceStack interface
+   */
+  static void
+  Install (Ptr<Node> node);
+
+  /**
+   * @brief Install IpFaceStack interface on nodes
+   * @param nodes NodeContainer to install IpFaceStack interface
+   */
+  static void
+  Install (const NodeContainer &nodes);
+
+  /**
+   * @brief Install IpFaceStack interface on all nodes
+   */
+  static void
+  InstallAll ();
+
+  /**
+   * @brief Create TCP face
+   * @param when    Time when to create face (use `Seconds (0)' if face should be created right away)
+   * @param node    Node to add TCP face (will initiate connection)
+   * @param address IP address to connect (using standard 9695 port)
+   * @param prefix  Prefix to associate with the face
+   * @param metric  Metric that will be assigned to the face
+   *
+   * This call schedules connection initiation and after successful connection it will add new face
+   * to NDN stack and add the requested route
+   *
+   * If face has been already created before (same IP address), then this call will simply
+   * update FIB with requested prefix
+   */
+  static void
+  CreateTcpFace (const Time &when, Ptr<Node> node, Ipv4Address address, const std::string &prefix, int16_t metric = 1);
+
+  /**
+   * @brief Create TCP face
+   */
+  static void
+  CreateUdpFace (const Time &when, Ptr<Node> node, Ipv4Address address, const std::string &prefix, int16_t metric = 1);
+};
+
+} // namespace ndn
+} // namespace ns3
+
+#endif // NDN_IP_FACES_HELPER_H
diff --git a/plugins/ip-faces/ndn-tcp-face.cc b/plugins/ip-faces/ndn-tcp-face.cc
new file mode 100644
index 0000000..07c3d4d
--- /dev/null
+++ b/plugins/ip-faces/ndn-tcp-face.cc
@@ -0,0 +1,286 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2013 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 "ndn-tcp-face.h"
+#include "ndn-ip-face-stack.h"
+
+#include "ns3/ndn-l3-protocol.h"
+
+#include "ns3/log.h"
+#include "ns3/packet.h"
+#include "ns3/node.h"
+#include "ns3/pointer.h"
+#include "ns3/tcp-socket-factory.h"
+
+#include "ns3/ndn-name.h"
+
+using namespace std;
+
+NS_LOG_COMPONENT_DEFINE ("ndn.TcpFace");
+
+namespace ns3 {
+namespace ndn {
+
+class TcpBoundaryHeader : public Header
+{
+public:
+  static TypeId GetTypeId (void)
+  {
+    static TypeId tid = TypeId ("ns3::ndn::TcpFace::BoundaryHeader")
+      .SetGroupName ("Ndn")
+      .SetParent<Header> ()
+      ;
+    return tid;
+  }
+
+  TcpBoundaryHeader ()
+    : m_length (0)
+  {
+  }
+  
+  TcpBoundaryHeader (Ptr<Packet> packet)
+    : m_length (packet->GetSize ())
+  {
+    
+  }
+
+  TcpBoundaryHeader (uint32_t length)
+    : m_length (length)
+  {
+  }
+
+  uint32_t
+  GetLength () const
+  {
+    return m_length;
+  }
+  
+  virtual TypeId
+  GetInstanceTypeId (void) const
+  {
+    return TcpBoundaryHeader::GetTypeId ();
+  }
+  
+  virtual void
+  Print (std::ostream &os) const
+  {
+    os << "[" << m_length << "]";
+  }
+  
+  virtual uint32_t
+  GetSerializedSize (void) const
+  {
+    return 4;
+  }
+  
+  virtual void
+  Serialize (Buffer::Iterator start) const
+  {
+    start.WriteU32 (m_length);
+  }
+  
+  virtual uint32_t
+  Deserialize (Buffer::Iterator start)
+  {
+    m_length = start.ReadU32 ();
+    return 4;
+  }
+
+private:
+  uint32_t m_length;
+};
+
+NS_OBJECT_ENSURE_REGISTERED (TcpFace);
+
+TypeId
+TcpFace::GetTypeId ()
+{
+  static TypeId tid = TypeId ("ns3::ndn::TcpFace")
+    .SetParent<Face> ()
+    .SetGroupName ("Ndn")
+    ;
+  return tid;
+}
+
+/**
+ * By default, Ndn face are created in the "down" state.  Before
+ * becoming useable, the user must invoke SetUp on the face
+ */
+TcpFace::TcpFace (Ptr<Node> node, Ptr<Socket> socket, Ipv4Address address)
+  : Face (node)
+  , m_socket (socket)
+  , m_address (address)
+  , m_pendingPacketLength (0)
+{
+  SetMetric (1); // default metric
+}
+
+TcpFace::~TcpFace ()
+{
+  NS_LOG_FUNCTION_NOARGS ();
+}
+
+TcpFace& TcpFace::operator= (const TcpFace &)
+{
+  return *this;
+}
+
+void
+TcpFace::RegisterProtocolHandlers (const InterestHandler &interestHandler, const DataHandler &dataHandler)
+{
+  NS_LOG_FUNCTION (this);
+
+  Face::RegisterProtocolHandlers (interestHandler, dataHandler);
+  m_socket->SetRecvCallback (MakeCallback (&TcpFace::ReceiveFromTcp, this));
+}
+
+void
+TcpFace::UnRegisterProtocolHandlers ()
+{
+  m_socket->SetRecvCallback (MakeNullCallback< void, Ptr<Socket> > ());
+  Face::UnRegisterProtocolHandlers ();
+}
+
+bool
+TcpFace::Send (Ptr<Packet> packet)
+{
+  if (!Face::Send (packet))
+    {
+      return false;
+    }
+  
+  NS_LOG_FUNCTION (this << packet);
+
+  Ptr<Packet> boundary = Create<Packet> ();
+  TcpBoundaryHeader hdr (packet);
+  boundary->AddHeader (hdr);
+  
+  m_socket->Send (boundary);
+  m_socket->Send (packet);
+
+  return true;
+}
+
+void
+TcpFace::ReceiveFromTcp (Ptr< Socket > clientSocket)
+{
+  NS_LOG_FUNCTION (this << clientSocket);
+  TcpBoundaryHeader hdr;
+
+  if (m_pendingPacketLength > 0)
+    {
+      if (clientSocket->GetRxAvailable () >= m_pendingPacketLength)
+        {
+          Ptr<Packet> realPacket = clientSocket->Recv (m_pendingPacketLength, 0);
+          NS_LOG_DEBUG ("+++ Expected " << m_pendingPacketLength << " bytes, got " << realPacket->GetSize () << " bytes");
+          if (realPacket == 0)
+            return;
+          
+          Receive (realPacket);
+        }
+      else
+        return; // still not ready
+    }
+  
+  m_pendingPacketLength = 0;
+  
+  while (clientSocket->GetRxAvailable () >= hdr.GetSerializedSize ())
+    {
+      Ptr<Packet> boundary = clientSocket->Recv (hdr.GetSerializedSize (), 0);
+      if (boundary == 0)
+        return; // no idea why it would happen...
+
+      NS_LOG_DEBUG ("Expected 4 bytes, got " << boundary->GetSize () << " bytes");
+      
+      boundary->RemoveHeader (hdr);
+      NS_LOG_DEBUG ("Header specifies length: " << hdr.GetLength ());
+      m_pendingPacketLength = hdr.GetLength ();
+      
+      if (clientSocket->GetRxAvailable () >= hdr.GetLength ())
+        {
+          Ptr<Packet> realPacket = clientSocket->Recv (hdr.GetLength (), 0);
+          if (realPacket == 0)
+            {
+              NS_LOG_DEBUG ("Got nothing, but requested at least " << hdr.GetLength ());
+              return;
+            }
+          
+          NS_LOG_DEBUG ("Receiving data " << hdr.GetLength () << " bytes, got " << realPacket->GetSize () << " bytes");
+
+          Receive (realPacket);
+          m_pendingPacketLength = 0;
+        }
+      else
+        {
+          return;
+        }
+    }
+}
+
+void
+TcpFace::OnTcpConnectionClosed (Ptr<Socket> socket)
+{
+  NS_LOG_FUNCTION (this << socket);
+  GetNode ()->GetObject<IpFaceStack> ()->DestroyTcpFace (this);
+}
+
+Ipv4Address
+TcpFace::GetAddress () const
+{
+  return m_address;
+}
+
+void
+TcpFace::SetCreateCallback (Callback< void, Ptr<Face> > callback)
+{
+  m_onCreateCallback = callback;
+}
+
+void
+TcpFace::OnConnect (Ptr<Socket> socket)
+{
+  NS_LOG_FUNCTION (this << socket);
+
+  Ptr<L3Protocol> ndn = GetNode ()->GetObject<L3Protocol> ();
+  
+  ndn->AddFace (this);
+  this->SetUp (true);
+
+  socket->SetCloseCallbacks (MakeCallback (&TcpFace::OnTcpConnectionClosed, this),
+                             MakeCallback (&TcpFace::OnTcpConnectionClosed, this));
+
+  if (!m_onCreateCallback.IsNull ())
+    {
+      m_onCreateCallback (this);
+      m_onCreateCallback = IpFaceStack::NULL_CREATE_CALLBACK;
+    }
+}
+    
+std::ostream&
+TcpFace::Print (std::ostream& os) const
+{
+  os << "dev=tcp(" << GetId () << ", " << m_address << ")";
+  return os;
+}
+
+} // namespace ndn
+} // namespace ns3
+
diff --git a/plugins/ip-faces/ndn-tcp-face.h b/plugins/ip-faces/ndn-tcp-face.h
new file mode 100644
index 0000000..56cb0e9
--- /dev/null
+++ b/plugins/ip-faces/ndn-tcp-face.h
@@ -0,0 +1,102 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2013 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
+ *
+ * Authors: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
+ */
+
+#ifndef NDN_TCP_FACE_H
+#define NDN_TCP_FACE_H
+
+#include "ns3/ndn-face.h"
+#include "ns3/socket.h"
+#include "ns3/ptr.h"
+#include "ns3/callback.h"
+
+#include <map>
+
+namespace ns3 {
+namespace ndn {
+  
+/**
+ * \ingroup ndn-face
+ * \brief Implementation of TCP/IP NDN face
+ *
+ * \see NdnAppFace, NdnNetDeviceFace, NdnIpv4Face, NdnUdpFace
+ */
+class TcpFace : public Face
+{
+public:
+  static TypeId
+  GetTypeId ();
+  
+  /**
+   * \brief Constructor
+   *
+   * @param node Node associated with the face
+   */
+  TcpFace (Ptr<Node> node, Ptr<Socket> socket, Ipv4Address address);
+  virtual ~TcpFace();
+
+  void
+  OnTcpConnectionClosed (Ptr<Socket> socket);
+
+  Ipv4Address
+  GetAddress () const;
+
+  static Ptr<TcpFace>
+  GetFaceByAddress (const Ipv4Address &addr);
+
+  void
+  SetCreateCallback (Callback< void, Ptr<Face> > callback);
+
+  void
+  OnConnect (Ptr<Socket> socket);
+
+  ////////////////////////////////////////////////////////////////////
+  // methods overloaded from ndn::Face
+  virtual void
+  RegisterProtocolHandlers (const InterestHandler &interestHandler, const DataHandler &dataHandler);
+
+  virtual void
+  UnRegisterProtocolHandlers ();
+
+  virtual std::ostream&
+  Print (std::ostream &os) const;
+  
+protected:
+  // also from ndn::Face
+  virtual bool
+  Send (Ptr<Packet> p);
+
+private:  
+  TcpFace (const TcpFace &); ///< \brief Disabled copy constructor
+  TcpFace& operator= (const TcpFace &); ///< \brief Disabled copy operator
+
+  void
+  ReceiveFromTcp (Ptr< Socket > clientSocket);
+
+private:
+  Ptr<Socket> m_socket;
+  Ipv4Address m_address;
+  uint32_t m_pendingPacketLength;
+  Callback< void, Ptr<Face> > m_onCreateCallback;
+};
+
+} // namespace ndn
+} // namespace ns3
+
+#endif // NDN_TCP_FACE_H
diff --git a/plugins/ip-faces/ndn-udp-face.cc b/plugins/ip-faces/ndn-udp-face.cc
new file mode 100644
index 0000000..346c623
--- /dev/null
+++ b/plugins/ip-faces/ndn-udp-face.cc
@@ -0,0 +1,108 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2013 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 "ndn-udp-face.h"
+#include "ns3/ndn-l3-protocol.h"
+
+#include "ns3/log.h"
+#include "ns3/packet.h"
+#include "ns3/node.h"
+#include "ns3/pointer.h"
+#include "ns3/udp-socket-factory.h"
+
+#include "ns3/ndn-name.h"
+
+using namespace std;
+
+NS_LOG_COMPONENT_DEFINE ("ndn.UdpFace");
+
+namespace ns3 {
+namespace ndn {
+
+NS_OBJECT_ENSURE_REGISTERED (UdpFace);
+
+TypeId
+UdpFace::GetTypeId ()
+{
+  static TypeId tid = TypeId ("ns3::ndn::UdpFace")
+    .SetParent<Face> ()
+    .SetGroupName ("Ndn")
+    ;
+  return tid;
+}
+
+/**
+ * By default, Ndn face are created in the "down" state.  Before
+ * becoming useable, the user must invoke SetUp on the face
+ */
+UdpFace::UdpFace (Ptr<Node> node, Ptr<Socket> socket, Ipv4Address address)
+  : Face (node)
+  , m_socket (socket)
+  , m_address (address)
+{
+  SetMetric (1); // default metric
+}
+
+UdpFace::~UdpFace ()
+{
+  NS_LOG_FUNCTION_NOARGS ();
+}
+
+UdpFace& UdpFace::operator= (const UdpFace &)
+{
+  return *this;
+}
+
+bool
+UdpFace::ReceiveFromUdp (Ptr<const Packet> p)
+{
+  return Face::Receive (p);
+}
+
+bool
+UdpFace::Send (Ptr<Packet> packet)
+{
+  if (!Face::Send (packet))
+    {
+      return false;
+    }
+  
+  NS_LOG_FUNCTION (this << packet);
+  m_socket->Send (packet);
+
+  return true;
+}
+
+Ipv4Address
+UdpFace::GetAddress () const
+{
+  return m_address;
+}
+
+std::ostream&
+UdpFace::Print (std::ostream& os) const
+{
+  os << "dev=udp(" << GetId () << "," << GetAddress () << ")";
+  return os;
+}
+
+} // namespace ndn
+} // namespace ns3
diff --git a/plugins/ip-faces/ndn-udp-face.h b/plugins/ip-faces/ndn-udp-face.h
new file mode 100644
index 0000000..f4b6a97
--- /dev/null
+++ b/plugins/ip-faces/ndn-udp-face.h
@@ -0,0 +1,81 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2013 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
+ *
+ * Authors: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
+ */
+
+#ifndef NDN_UDP_FACE_H
+#define NDN_UDP_FACE_H
+
+#include "ns3/ndn-face.h"
+#include "ns3/socket.h"
+#include "ns3/ptr.h"
+
+#include <map>
+
+namespace ns3 {
+namespace ndn {
+  
+/**
+ * \ingroup ndn-face
+ * \brief Implementation of UDP/IP NDN face
+ *
+ * \see ndn::AppFace, ndn::NetDeviceFace, ndn::Ipv4Face, ndn::TcpFace
+ */
+class UdpFace : public Face
+{
+public:
+  static TypeId
+  GetTypeId ();
+  
+  /**
+   * \brief Constructor
+   *
+   * @param node Node associated with the face
+   */
+  UdpFace (Ptr<Node> node, Ptr<Socket> socket, Ipv4Address address);
+  virtual ~UdpFace();
+
+  Ipv4Address
+  GetAddress () const;
+
+  virtual bool
+  ReceiveFromUdp (Ptr<const Packet> p);
+
+  ////////////////////////////////////////////////////////////////////
+  // methods overloaded from ndn::Face
+  virtual std::ostream&
+  Print (std::ostream &os) const;
+
+protected:
+  // also from ndn::Face
+  virtual bool
+  Send (Ptr<Packet> p);
+
+private:  
+  UdpFace (const UdpFace &); ///< \brief Disabled copy constructor
+  UdpFace& operator= (const UdpFace &); ///< \brief Disabled copy operator
+
+private:
+  Ptr<Socket> m_socket;
+  Ipv4Address m_address;
+};
+
+} // namespace ndn
+} // namespace ns3
+
+#endif // NDN_UDP_FACE_H
diff --git a/wscript b/wscript
index f53492a..4cc1ee2 100644
--- a/wscript
+++ b/wscript
@@ -67,7 +67,7 @@
             Logs.error ("Please upgrade your distribution or install custom boost libraries (http://ndnsim.net/faq.html#boost-libraries)")
             return
 
-    conf.env['NDN_plugins'] = ['topology']
+    conf.env['NDN_plugins'] = ['topology', 'ip-faces']
     if Options.options.enable_ndn_plugins:
         conf.env['NDN_plugins'] = conf.env['NDN_plugins'] + Options.options.enable_ndn_plugins.split(',')
 
@@ -181,6 +181,13 @@
         module.source.extend (bld.path.ant_glob(['plugins/mobility/*.cc']))
         module.full_headers.extend ([p.path_from(bld.path) for p in bld.path.ant_glob(['plugins/mobility/**/*.h'])])
 
+    if 'ip-faces' in bld.env['NDN_plugins']:
+        headers.source.extend ([
+            "plugins/ip-faces/ndn-ip-faces-helper.h",
+            ])
+        module.source.extend (bld.path.ant_glob(['plugins/ip-faces/*.cc']))
+        module.full_headers.extend ([p.path_from(bld.path) for p in bld.path.ant_glob(['plugins/ip-faces/**/*.h'])])
+
     # bld.install_files('${INCLUDEDIR}/%s%s/ns3/ndnSIM' % (wutils.APPNAME, wutils.VERSION), ndnSIM_headers, relative_trick=True)
     # bld.install_files('$PREFIX/include', ndnSIM_headers)