diff --git a/apps/stupid-interest-generator.cc b/apps/stupid-interest-generator.cc
new file mode 100644
index 0000000..0dfcf51
--- /dev/null
+++ b/apps/stupid-interest-generator.cc
@@ -0,0 +1,180 @@
+//
+//  ndn_stupidinterestgenerator.cpp
+//  Abstraction
+//
+//  Created by Ilya Moiseenko on 05.08.11.
+//  Copyright 2011 UCLA. All rights reserved.
+//
+
+#include "stupid-interest-generator.h"
+
+#include "ns3/socket-factory.h"
+#include "ns3/simulator.h"
+
+#include "ns3/interest-header.h"
+#include "ns3/content-object-header.h"
+
+NS_LOG_COMPONENT_DEFINE ("StupidInterestGenerator");
+
+namespace ns3
+{
+//namespace NDNabstraction
+//{
+    using namespace NDNabstraction;
+    
+    NS_OBJECT_ENSURE_REGISTERED (StupidInterestGenerator);
+    
+    TypeId
+    StupidInterestGenerator::GetTypeId (void)
+    {
+        static TypeId tid = TypeId ("ns3::StupidInterestGenerator")
+        .SetParent<Application> ()
+        .AddConstructor<StupidInterestGenerator> ()
+        .AddAttribute ("Remote", "The address of the destination",
+                       AddressValue (),
+                       MakeAddressAccessor (&StupidInterestGenerator::m_peer),
+                       MakeAddressChecker ())
+        .AddAttribute ("OffTime", "Time interval between packets",
+                       TimeValue (Seconds (0.1)),
+                       MakeTimeAccessor (&StupidInterestGenerator::m_offTime),
+                       MakeTimeChecker ())
+        .AddAttribute ("Protocol", "The type of protocol to use.",
+                       TypeIdValue (UdpSocketFactory::GetTypeId ()),
+                       MakeTypeIdAccessor (&StupidInterestGenerator::m_tid),
+                       MakeTypeIdChecker ())
+        ;
+        return tid;
+    }
+
+    StupidInterestGenerator::StupidInterestGenerator ()
+    {
+        NS_LOG_FUNCTION_NOARGS ();
+        m_socket = 0;
+        //m_connected = false;
+        //m_residualBits = 0;
+        //m_lastStartTime = Seconds (0);
+        //m_totBytes = 0;
+    }
+    
+    StupidInterestGenerator::~StupidInterestGenerator()
+    {
+        NS_LOG_FUNCTION_NOARGS ();
+    }
+    
+    void
+    StupidInterestGenerator::DoDispose (void)
+    {
+        NS_LOG_FUNCTION_NOARGS ();
+        
+        m_socket = 0;
+        // chain up
+        Application::DoDispose ();
+    }
+    
+    // Application Methods
+    void StupidInterestGenerator::StartApplication () // Called at time specified by Start
+    {
+        NS_LOG_FUNCTION_NOARGS ();
+        
+        // Create the socket if not already
+        if (!m_socket)
+        {
+            m_socket = Socket::CreateSocket (GetNode (), m_tid);
+            m_socket->Bind ();
+            m_socket->Connect (m_peer);
+            m_socket->SetAllowBroadcast (true);
+            m_socket->ShutdownRecv ();
+        }
+        // Insure no pending event
+        CancelEvents ();
+        // If we are not yet connected, there is nothing to do here
+        // The ConnectionComplete upcall will start timers at that time
+        //if (!m_connected) return;
+        ScheduleStartEvent ();
+    }
+    
+    void StupidInterestGenerator::StopApplication () // Called at time specified by Stop
+    {
+        NS_LOG_FUNCTION_NOARGS ();
+        
+        CancelEvents ();
+        if(m_socket != 0)
+        {
+            m_socket->Close ();
+        }
+        else
+        {
+            NS_LOG_WARN ("OnOffApplication found null socket to close in StopApplication");
+        }
+    }
+    
+    void StupidInterestGenerator::CancelEvents ()
+    {
+        NS_LOG_FUNCTION_NOARGS ();
+        
+        Simulator::Cancel (m_sendEvent);
+        Simulator::Cancel (m_startStopEvent);
+    }
+
+    void StupidInterestGenerator::ScheduleStartEvent ()
+    {  // Schedules the event to start sending data (switch to the "On" state)
+        NS_LOG_FUNCTION_NOARGS ();
+        
+        Time offInterval = Seconds (m_offTime);
+        NS_LOG_LOGIC ("start at " << offInterval);
+        m_startStopEvent = Simulator::Schedule (offInterval, &StupidInterestGenerator::StartSending, this);
+    }
+    
+    // Event handlers
+    void StupidInterestGenerator::StartSending ()
+    {
+        NS_LOG_FUNCTION_NOARGS ();
+        //m_lastStartTime = Simulator::Now ();
+        ScheduleNextTx ();  // Schedule the send packet event
+        //ScheduleStopEvent ();
+    }
+    
+    void StupidInterestGenerator::StopSending ()
+    {
+        NS_LOG_FUNCTION_NOARGS ();
+        CancelEvents ();
+        
+        ScheduleStartEvent ();
+    }
+    
+    // Private helpers
+    void StupidInterestGenerator::ScheduleNextTx ()
+    {
+        NS_LOG_FUNCTION_NOARGS ();
+        
+
+        Time nextTime = Seconds(0.); //send now
+        m_sendEvent = Simulator::Schedule (nextTime,
+                                               &StupidInterestGenerator::SendPacket, this);
+    }
+
+        
+    void StupidInterestGenerator::SendPacket ()
+    {
+        // NS_LOG_FUNCTION_NOARGS ();
+        // NS_LOG_LOGIC ("sending packet at " << Simulator::Now ());
+        // NS_ASSERT (m_sendEvent.IsExpired ());
+        
+        // NameBuilder name;
+		// name("prefix1")("prefix2")("filename");
+		InterestHeader ();
+
+		ContentObjectHeader ();
+		
+        // const ccn_charbuf *output = name.GetName();
+        // Ptr<InterestPacket> packet = Create<InterestPacket>(name,(uint32_t)output->length);
+        // packet->AddTimeout(4000);
+        // UniformVariable var;
+        // packet->AddNonce(var.GetInteger(1,10000));
+        // m_socket->Send(packet);
+        
+        // ScheduleStartEvent();
+    }
+
+//}
+}
diff --git a/apps/stupid-interest-generator.h b/apps/stupid-interest-generator.h
new file mode 100644
index 0000000..395bc3f
--- /dev/null
+++ b/apps/stupid-interest-generator.h
@@ -0,0 +1,78 @@
+//
+//  ndn_stupidinterestgenerator.h
+//  Abstraction
+//
+//  Created by Ilya Moiseenko on 05.08.11.
+//  Copyright 2011 UCLA. All rights reserved.
+//
+
+#include "ns3/application.h"
+#include "ns3/log.h"
+#include "ns3/address.h"
+#include "ns3/random-variable.h"
+#include "ns3/nstime.h"
+#include "ns3/event-id.h"
+#include "ns3/ptr.h"
+#include "ns3/udp-socket-factory.h"
+#include "ns3/socket.h"
+
+namespace ns3 
+{
+
+    
+//namespace NDNabstraction
+//{
+    class Socket; //dynamic linking works in a somehow strange way
+    
+    class StupidInterestGenerator: public Application
+    {
+    public: 
+        static TypeId GetTypeId (void);
+        
+        StupidInterestGenerator ();
+        
+        virtual ~StupidInterestGenerator();
+        
+                
+    protected:
+        virtual void DoDispose (void);
+    private:
+        // inherited from Application base class.
+        virtual void StartApplication (void);    // Called at time specified by Start
+        virtual void StopApplication (void);     // Called at time specified by Stop
+        
+        //Time m_onTime;
+        Time m_offTime;
+        
+        Address         m_peer;         // Peer address
+        Ptr<Socket>     m_socket;
+        EventId         m_startStopEvent;     // Event id for next start or stop event
+        EventId         m_sendEvent;    // Eventid of pending "send packet" event
+        TypeId          m_tid;
+        
+        //helpers
+        void CancelEvents ();
+        
+        void Construct (Ptr<Node> n,
+                        const Address &remote,
+                        std::string tid,
+                        const RandomVariable& ontime,
+                        const RandomVariable& offtime,
+                        uint32_t size);
+        
+        // Event handlers
+        void StartSending ();
+        void StopSending ();
+        void SendPacket ();
+        
+    private:
+        void ScheduleNextTx ();
+        void ScheduleStartEvent ();
+        void ScheduleStopEvent ();
+        void ConnectionSucceeded (Ptr<Socket>);
+        void ConnectionFailed (Ptr<Socket>);
+        void Ignore (Ptr<Socket>);
+
+    };
+//}
+}
diff --git a/apps/stupid-interest-sink.cc b/apps/stupid-interest-sink.cc
new file mode 100644
index 0000000..febd621
--- /dev/null
+++ b/apps/stupid-interest-sink.cc
@@ -0,0 +1,188 @@
+//
+//  stupid-interest-sink.cpp
+//  Abstraction
+//
+//  Created by Ilya Moiseenko on 10.08.11.
+//  Copyright 2011 UCLA. All rights reserved.
+//
+
+#include "stupid-interest-sink.h"
+
+#include "ns3/address.h"
+#include "ns3/address-utils.h"
+#include "ns3/log.h"
+#include "ns3/inet-socket-address.h"
+#include "ns3/node.h"
+#include "ns3/socket.h"
+#include "ns3/udp-socket.h"
+#include "ns3/simulator.h"
+#include "ns3/socket-factory.h"
+#include "ns3/packet.h"
+#include "ns3/trace-source-accessor.h"
+#include "ns3/udp-socket-factory.h"
+
+using namespace std;
+
+namespace ns3 {
+    
+    NS_LOG_COMPONENT_DEFINE ("StupidInterestSink");
+    NS_OBJECT_ENSURE_REGISTERED (StupidInterestSink);
+    
+    TypeId 
+    StupidInterestSink::GetTypeId (void)
+    {
+        static TypeId tid = TypeId ("ns3::StupidInterestSink")
+        .SetParent<Application> ()
+        .AddConstructor<StupidInterestSink> ()
+        .AddAttribute ("Local", "The Address on which to Bind the rx socket.",
+                       AddressValue (),
+                       MakeAddressAccessor (&StupidInterestSink::m_local),
+                       MakeAddressChecker ())
+        .AddAttribute ("Protocol", "The type id of the protocol to use for the rx socket.",
+                       TypeIdValue (UdpSocketFactory::GetTypeId ()),
+                       MakeTypeIdAccessor (&StupidInterestSink::m_tid),
+                       MakeTypeIdChecker ())
+        .AddTraceSource ("Rx", "A packet has been received",
+                         MakeTraceSourceAccessor (&StupidInterestSink::m_rxTrace))
+        ;
+        return tid;
+    }
+    
+    StupidInterestSink::StupidInterestSink ()
+    {
+        NS_LOG_FUNCTION (this);
+        m_socket = 0;
+        m_totalRx = 0;
+    }
+    
+    StupidInterestSink::~StupidInterestSink()
+    {
+        NS_LOG_FUNCTION (this);
+    }
+    
+    uint32_t StupidInterestSink::GetTotalRx () const
+    {
+        return m_totalRx;
+    }
+    
+    Ptr<Socket>
+    StupidInterestSink::GetListeningSocket (void) const
+    {
+        NS_LOG_FUNCTION (this);
+        return m_socket;
+    }
+    
+    std::list<Ptr<Socket> >
+    StupidInterestSink::GetAcceptedSockets (void) const
+    {
+        NS_LOG_FUNCTION (this);
+        return m_socketList;
+    }
+    
+    void StupidInterestSink::DoDispose (void)
+    {
+        NS_LOG_FUNCTION (this);
+        m_socket = 0;
+        m_socketList.clear ();
+        
+        // chain up
+        Application::DoDispose ();
+    }
+    
+    
+    // Application Methods
+    void StupidInterestSink::StartApplication ()    // Called at time specified by Start
+    {
+        NS_LOG_FUNCTION (this);
+        // Create the socket if not already
+        if (!m_socket)
+        {
+            m_socket = Socket::CreateSocket (GetNode (), m_tid);
+            m_socket->Bind (m_local);
+            m_socket->Listen ();
+            m_socket->ShutdownSend ();
+            if (addressUtils::IsMulticast (m_local))
+            {
+                Ptr<UdpSocket> udpSocket = DynamicCast<UdpSocket> (m_socket);
+                if (udpSocket)
+                {
+                    // equivalent to setsockopt (MCAST_JOIN_GROUP)
+                    udpSocket->MulticastJoinGroup (0, m_local);
+                }
+                else
+                {
+                    NS_FATAL_ERROR ("Error: joining multicast on a non-UDP socket");
+                }
+            }
+        }
+        
+        m_socket->SetRecvCallback (MakeCallback (&StupidInterestSink::HandleRead, this));
+        m_socket->SetAcceptCallback (
+                                     MakeNullCallback<bool, Ptr<Socket>, const Address &> (),
+                                     MakeCallback (&StupidInterestSink::HandleAccept, this));
+        m_socket->SetCloseCallbacks (
+                                     MakeCallback (&StupidInterestSink::HandlePeerClose, this),
+                                     MakeCallback (&StupidInterestSink::HandlePeerError, this));
+    }
+    
+    void StupidInterestSink::StopApplication ()     // Called at time specified by Stop
+    {
+        NS_LOG_FUNCTION (this);
+        while(!m_socketList.empty ()) //these are accepted sockets, close them
+        {
+            Ptr<Socket> acceptedSocket = m_socketList.front ();
+            m_socketList.pop_front ();
+            acceptedSocket->Close ();
+        }
+        if (m_socket) 
+        {
+            m_socket->Close ();
+            m_socket->SetRecvCallback (MakeNullCallback<void, Ptr<Socket> > ());
+        }
+    }
+    
+    void StupidInterestSink::HandleRead (Ptr<Socket> socket)
+    {
+        NS_LOG_FUNCTION (this << socket);
+        Ptr<Packet> packet;
+        Address from;
+        while (packet = socket->RecvFrom (from))
+        {
+            if (packet->GetSize () == 0)
+            { //EOF
+                break;
+            }
+            if (InetSocketAddress::IsMatchingType (from))
+            {
+                m_totalRx += packet->GetSize ();
+                InetSocketAddress address = InetSocketAddress::ConvertFrom (from);
+                NS_LOG_INFO ("Received " << packet->GetSize () << " bytes from " <<
+                             address.GetIpv4 () << " [" << address << "]"
+                             << " total Rx " << m_totalRx);
+                //cast address to void , to suppress 'address' set but not used 
+                //compiler warning in optimized builds
+                (void) address;
+            }
+            m_rxTrace (packet, from);
+        }
+    }
+    
+    void StupidInterestSink::HandlePeerClose (Ptr<Socket> socket)
+    {
+        NS_LOG_INFO ("PktSink, peerClose");
+    }
+    
+    void StupidInterestSink::HandlePeerError (Ptr<Socket> socket)
+    {
+        NS_LOG_INFO ("PktSink, peerError");
+    }
+    
+    
+    void StupidInterestSink::HandleAccept (Ptr<Socket> s, const Address& from)
+    {
+        NS_LOG_FUNCTION (this << s << from);
+        s->SetRecvCallback (MakeCallback (&StupidInterestSink::HandleRead, this));
+        m_socketList.push_back (s);
+    }
+    
+} // Namespace ns3
diff --git a/apps/stupid-interest-sink.h b/apps/stupid-interest-sink.h
new file mode 100644
index 0000000..66cedd9
--- /dev/null
+++ b/apps/stupid-interest-sink.h
@@ -0,0 +1,67 @@
+//
+//  stupid-interest-sink.h
+//  Abstraction
+//
+//  Created by Ilya Moiseenko on 10.08.11.
+//  Copyright 2011 UCLA. All rights reserved.
+//
+
+#include "ns3/application.h"
+#include "ns3/event-id.h"
+#include "ns3/ptr.h"
+#include "ns3/traced-callback.h"
+#include "ns3/address.h"
+
+namespace ns3 
+{
+    
+    class Address;
+    class Socket;
+    class Packet;
+
+    class StupidInterestSink : public Application
+    {
+    public:
+        static TypeId GetTypeId (void);
+        StupidInterestSink ();
+        
+        virtual ~StupidInterestSink ();
+        
+        /**
+         * \return the total bytes received in this sink app
+         */
+        uint32_t GetTotalRx () const;
+        
+        /**
+         * \return pointer to listening socket
+         */
+        Ptr<Socket> GetListeningSocket (void) const;
+        
+        /**
+         * \return list of pointers to accepted sockets
+         */
+        std::list<Ptr<Socket> > GetAcceptedSockets (void) const;
+        
+    protected:
+        virtual void DoDispose (void);
+    private:
+        // inherited from Application base class.
+        virtual void StartApplication (void);    // Called at time specified by Start
+        virtual void StopApplication (void);     // Called at time specified by Stop
+        
+        void HandleRead (Ptr<Socket>);
+        void HandleAccept (Ptr<Socket>, const Address& from);
+        void HandlePeerClose (Ptr<Socket>);
+        void HandlePeerError (Ptr<Socket>);
+        
+        // In the case of TCP, each socket accept returns a new socket, so the 
+        // listening socket is stored seperately from the accepted sockets
+        Ptr<Socket>     m_socket;       // Listening socket
+        std::list<Ptr<Socket> > m_socketList; //the accepted sockets
+        
+        Address         m_local;        // Local address to bind to
+        uint32_t        m_totalRx;      // Total bytes received
+        TypeId          m_tid;          // Protocol TypeId
+        TracedCallback<Ptr<const Packet>, const Address &> m_rxTrace;
+    };
+}
\ No newline at end of file