model/ccnx-l3-protocol.cc

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
/*
 * Copyright (c) 2011 University of California, Los Angeles
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
 *         Ilya Moiseenko <iliamo@cs.ucla.edu>
 */

#include "ccnx-l3-protocol.h"

#include "ns3/packet.h"
#include "ns3/node.h"
#include "ns3/log.h"
#include "ns3/callback.h"
#include "ns3/uinteger.h"
#include "ns3/trace-source-accessor.h"
#include "ns3/object-vector.h"
#include "ns3/boolean.h"

#include "ns3/ccnx-header-helper.h"

#include "ccnx-face.h"
#include "ccnx-route.h"
#include "ccnx-forwarding-strategy.h"
#include "ccnx-interest-header.h"
#include "ccnx-content-object-header.h"

#include <boost/foreach.hpp>

NS_LOG_COMPONENT_DEFINE ("CcnxL3Protocol");

namespace ns3 {

const uint16_t CcnxL3Protocol::ETHERNET_FRAME_TYPE = 0x7777;

NS_OBJECT_ENSURE_REGISTERED (CcnxL3Protocol);

TypeId 
CcnxL3Protocol::GetTypeId (void)
{
  static TypeId tid = TypeId ("ns3::CcnxL3Protocol")
    .SetParent<Ccnx> ()
    .SetGroupName ("Ccnx")
    .AddConstructor<CcnxL3Protocol> ()
    // .AddTraceSource ("Tx", "Send ccnx packet to outgoing interface.",
    //                  MakeTraceSourceAccessor (&CcnxL3Protocol::m_txTrace))
    // .AddTraceSource ("Rx", "Receive ccnx packet from incoming interface.",
    //                  MakeTraceSourceAccessor (&CcnxL3Protocol::m_rxTrace))
    // .AddTraceSource ("Drop", "Drop ccnx packet",
    //                  MakeTraceSourceAccessor (&CcnxL3Protocol::m_dropTrace))
    // .AddAttribute ("InterfaceList", "The set of Ccnx interfaces associated to this Ccnx stack.",
    //                ObjectVectorValue (),
    //                MakeObjectVectorAccessor (&CcnxL3Protocol::m_faces),
    //                MakeObjectVectorChecker<CcnxFace> ())

    // .AddTraceSource ("SendOutgoing", "A newly-generated packet by this node is about to be queued for transmission",
    //                  MakeTraceSourceAccessor (&CcnxL3Protocol::m_sendOutgoingTrace))

  ;
  return tid;
}

CcnxL3Protocol::CcnxL3Protocol()
: m_faceCounter (0)
{
  NS_LOG_FUNCTION (this);
  
  m_rit = CreateObject<CcnxRit> ();
  m_pit = CreateObject<CcnxPit> ();
  m_contentStore = CreateObject<CcnxContentStore> ();
}

CcnxL3Protocol::~CcnxL3Protocol ()
{
  NS_LOG_FUNCTION (this);
}

void
CcnxL3Protocol::SetNode (Ptr<Node> node)
{
  m_node = node;
  m_fib = m_node->GetObject<CcnxFib> ();
  NS_ASSERT_MSG (m_fib != 0, "FIB should be created and aggregated to a node before calling Ccnx::SetNode");

  m_pit->SetFib (m_fib);
}

/*
 * This method is called by AddAgregate and completes the aggregation
 * by setting the node in the ccnx stack
 */
void
CcnxL3Protocol::NotifyNewAggregate ()
{
  if (m_node == 0)
    {
      Ptr<Node>node = this->GetObject<Node>();
      // verify that it's a valid node and that
      // the node has not been set before
      if (node != 0)
        {
          this->SetNode (node);
        }
    }
  Object::NotifyNewAggregate ();
}

void 
CcnxL3Protocol::DoDispose (void)
{
  NS_LOG_FUNCTION (this);

  for (CcnxFaceList::iterator i = m_faces.begin (); i != m_faces.end (); ++i)
    {
      *i = 0;
    }
  m_faces.clear ();
  m_node = 0;
  // m_forwardingStrategy = 0;
  Object::DoDispose ();
}

void
CcnxL3Protocol::SetForwardingStrategy (Ptr<CcnxForwardingStrategy> forwardingStrategy)
{
  NS_LOG_FUNCTION (this);
  m_forwardingStrategy = forwardingStrategy;
  // m_forwardingStrategy->SetCcnx (this);
}

Ptr<CcnxForwardingStrategy>
CcnxL3Protocol::GetForwardingStrategy (void) const
{
  return m_forwardingStrategy;
}

uint32_t 
CcnxL3Protocol::AddFace (const Ptr<CcnxFace> &face)
{
  NS_LOG_FUNCTION (this << &face);

  face->SetNode (m_node);
  face->SetId (m_faceCounter); // sets a unique ID of the face. This ID serves only informational purposes

  // ask face to register in lower-layer stack
  face->RegisterProtocolHandler (MakeCallback (&CcnxL3Protocol::Receive, this));

  m_faces.push_back (face);
  m_faceCounter ++;
  return face->GetId ();
}

void
CcnxL3Protocol::RemoveFace (Ptr<CcnxFace> face)
{
  // ask face to register in lower-layer stack
  face->RegisterProtocolHandler (MakeNullCallback<void,const Ptr<CcnxFace>&,const Ptr<const Packet>&> ());
  CcnxFaceList::iterator face_it = find (m_faces.begin(), m_faces.end(), face);
  NS_ASSERT_MSG (face_it != m_faces.end (), "Attempt to remove face that doesn't exist");
  m_faces.erase (face_it);
}

Ptr<CcnxFace>
CcnxL3Protocol::GetFace (uint32_t index) const
{
  BOOST_FOREACH (const Ptr<CcnxFace> &face, m_faces) // this function is not supposed to be called often, so linear search is fine
    {
      if (face->GetId () == index)
        return face;
    }
  return 0;
}

uint32_t 
CcnxL3Protocol::GetNFaces (void) const
{
  return m_faces.size ();
}

void
CcnxL3Protocol::TransmittedDataTrace (Ptr<Packet> packet,
                                      ContentObjectSource type,
                                      Ptr<Ccnx> ccnx, Ptr<const CcnxFace> face)
{
  // a "small" inefficiency for logging purposes
  Ptr<CcnxContentObjectHeader> header = Create<CcnxContentObjectHeader> ();
  static CcnxContentObjectTail tail;
  packet->RemoveHeader (*header);
  packet->RemoveTrailer (tail);
      
  m_transmittedDataTrace (header, packet/*payload*/, type, ccnx, face);
  
  packet->AddHeader (*header);
  packet->AddTrailer (tail);
}


// Callback from lower layer
void 
CcnxL3Protocol::Receive (const Ptr<CcnxFace> &face, const Ptr<const Packet> &p)
{
  if (!face->IsUp ())
    {
      NS_LOG_LOGIC ("Dropping received packet -- interface is down");
      // m_dropTrace (p, INTERFACE_DOWN, m_node->GetObject<Ccnx> ()/*this*/, face);
      return;
    }
  NS_LOG_LOGIC ("Packet from face " << *face << " received on node " <<  m_node->GetId ());

  Ptr<Packet> packet = p->Copy (); // give upper layers a rw copy of the packet
  try
    {
      CcnxHeaderHelper::Type type = CcnxHeaderHelper::GetCcnxHeaderType (p);
      switch (type)
        {
        case CcnxHeaderHelper::INTEREST:
          {
            Ptr<CcnxInterestHeader> header = Create<CcnxInterestHeader> ();

            // Deserialization. Exception may be thrown
            packet->RemoveHeader (*header);
            NS_ASSERT_MSG (packet->GetSize () == 0, "Payload of Interests should be zero");
            
            OnInterest (face, header, p/*original packet*/);  
            break;
          }
        case CcnxHeaderHelper::CONTENT_OBJECT:
          {
            Ptr<CcnxContentObjectHeader> header = Create<CcnxContentObjectHeader> ();
            
            static CcnxContentObjectTail contentObjectTrailer; //there is no data in this object

            // Deserialization. Exception may be thrown
            packet->RemoveHeader (*header);
            packet->RemoveTrailer (contentObjectTrailer);

            OnData (face, header, packet/*payload*/, p/*original packet*/);  
            break;
          }
        }
      
      // exception will be thrown if packet is not recognized
    }
  catch (CcnxUnknownHeaderException)
    {
      NS_ASSERT_MSG (false, "Unknown CCNx header. Should not happen");
    }
}

// Processing Interests
void CcnxL3Protocol::OnInterest (const Ptr<CcnxFace> &incomingFace,
                                 Ptr<CcnxInterestHeader> &header,
                                 const Ptr<const Packet> &packet)
{
  NS_LOG_LOGIC ("Receiving interest from " << &incomingFace);
  m_receivedInterestsTrace (header, m_node->GetObject<Ccnx> (), incomingFace);

  // Lookup of Pit and Fib entries for this Interest 
  CcnxFibEntryContainer::type::iterator fibEntry;
  CcnxPitEntryContainer::type::iterator pitEntry = m_pit->Lookup (*header, fibEntry);  
    
  // No matter is it duplicate or not, if it is a NACK message, remove all possible incoming
  // entries for this interface (NACK means that neighbor gave up trying and there is no
  // point of sending data in this direction)
    NS_LOG_INFO("Before (header->IsNack()) && (pitEntry != m_pit->end ())");
  if ((header->IsNack()) && (pitEntry != m_pit->end ()))
    {
      //m_pit->erase (pitEntry);
        m_pit->modify(pitEntry, CcnxPitEntry::DeleteIncoming(incomingFace));
    }
    
    NS_LOG_INFO("Before WasRecentlySatisfied");
  if (m_rit->WasRecentlySatisfied (*header))
    {
        NS_LOG_INFO("Entering WasRecentlySatisfied");
      // duplicate interests (same nonce) from applications are just ignored
      if (incomingFace->IsLocal() == true) 
          return;
        
      // Update metric status for the incoming interface in the corresponding FIB entry
      if (fibEntry != m_fib->end())
        m_fib->modify (m_fib->iterator_to (pitEntry->m_fibEntry),
                       CcnxFibEntry::UpdateStatus(incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW));
      
      //Trace duplicate interest  
      m_droppedInterestsTrace (header, NDN_DUPLICATE_INTEREST,
                               m_node->GetObject<Ccnx> (), incomingFace);
        
      bool isMine = false;
      TypeId tid = TypeId ("ns3::CcnxProducer");
      for(uint32_t i=0; i<m_node->GetNApplications();i++)
        {
            Ptr<Application> app = m_node->GetApplication(i);
            if(app->GetTypeId() == tid)
              {
                if((DynamicCast<CcnxProducer>(app))->GetPrefix () == header->GetName ())
                {
                    isMine = true;
                    break;
                }
              }
        }
    
      Ptr<Packet> contentObject = m_contentStore->Lookup (header);
      if ((isMine == true) || (contentObject != NULL))
        {
            //never respond with NACK to NACK
            if(header->IsNack () )
                return;
            
            // always return a duplicate packet
            header->SetNack(true);
            //Trace duplicate interest  
            m_droppedInterestsTrace (header, NDN_DUPLICATE_INTEREST,
                                     m_node->GetObject<Ccnx> (), incomingFace);

            SendInterest(incomingFace, header, packet->Copy());
			
			return;
        }  
           
        
      // check PIT.  or there is no outgoing entry for this interface,
      // silently drop the duplicate packet
        
      // If no entry found, silently drop
      if( pitEntry == m_pit->end() ) 
        return;
        
      // If PIT entry timed out, silently drop
      if( pitEntry->m_timerExpired == true ) 
        return;
        
      // loop?
        
      // Check if there is no outgoing entry for the interface or different nonce
      // (i.e., got a duplicate packet, but we haven't sent interest to this
      // interface)
      //
      // This case means that there is a loop in the network.
      // So, prune this link, but do not remove PIT entry
        
      // Alex, check this condition!!
      if(pitEntry->m_outgoing.size () == 0)
        {
            //never respond with NACK to NACK
            if(header->IsNack () )
                return;
            
            // always return a duplicate packet
            header->SetNack(true);
            //Trace duplicate interest  
            m_droppedInterestsTrace (header, NDN_DUPLICATE_INTEREST,
                                     m_node->GetObject<Ccnx> (), incomingFace);

            SendInterest(incomingFace, header, packet->Copy());
            return;
        }
      
        
        // At this point:
		// - there is a non-expired PIT entry,
		// - there is an outgoing interest to the interface, and
		// - a nonce in outgoing entry is equal to a nonce in the received duplicate packet
        
		// Should perform:
		// Cleaning outgoing entry
		// If there are no outgoing interests and available interfaces left (pe->availableInterfaces),
		// prune all incoming interests, otherwise allow forwarding of the interest
		if( header->IsNack () )
		{
			if( header->IsCongested () == false )
                m_pit->LeakBucket(incomingFace,1);
            
            m_pit->modify(pitEntry, CcnxPitEntry::DeleteOutgoing(incomingFace));
        }
		else
		{
			//poit->waitingInVain = true;
		}

        
        // prune all incoming interests
        if((pitEntry->m_outgoing.size() ==0) && (pitEntry->m_fibEntry.m_faces.size() == 0))
        {
            BOOST_FOREACH (const CcnxPitEntryIncomingFace face, pitEntry->m_incoming)
            {
                if(face.m_face->IsLocal() == false)
                {
                  // check all entries if the name of RIT entry matches the name of interest
                  for (CcnxRitByNonce::type::iterator it = m_rit->begin(); it != m_rit->end(); it++)
                  {
                    if (it->m_prefix == pitEntry->GetPrefix() )
                      {
                        
                        header->SetNonce(it->m_nonce);
                        header->SetNack(true);
                        SendInterest(face.m_face, header, packet->Copy());
                        break;
                      }
                  }
                }
             }
            
            // Finally, remote the PIT entry
            m_pit->erase (pitEntry);
            
            return; // stop processing
        }
        
      if(pitEntry->m_fibEntry.m_faces.size() == 0)  
        return;
    }
    
  // Otherwise,
  // propagate the interest
  //
  // method `propagateInterest' can/should try different interface
  // from `availableInterfaces' list
    
  NS_LOG_INFO("Before SetRecentlySatisfied");
  m_rit->SetRecentlySatisfied (*header); 

  NS_LOG_INFO("Cache Lookup for " << header->GetName());
  Ptr<Packet> contentObject = m_contentStore->Lookup (header);
  if (contentObject != NULL)
    {
      NS_LOG_INFO("Found in cache");
        
      TransmittedDataTrace (contentObject, CACHED,
                            m_node->GetObject<Ccnx> (), incomingFace);
      incomingFace->Send (contentObject);
      return;
    }
  
  // Data is not in cache
  NS_LOG_INFO("Before inFace and OutFace");
  CcnxPitEntryIncomingFaceContainer::type::iterator inFace = pitEntry->m_incoming.find (incomingFace);
  CcnxPitEntryOutgoingFaceContainer::type::iterator outFace = pitEntry->m_outgoing.find (incomingFace);
    
     NS_LOG_INFO("Before (pitEntry != m_pit->end()) && (pitEntry->m_timerExpired == false)");
  if ((pitEntry != m_pit->end()) && (pitEntry->m_timerExpired == false))
    {
        NS_LOG_INFO("Entering (pitEntry != m_pit->end()) && (pitEntry->m_timerExpired == false)");
        
        if(inFace->m_face == NULL)
            NS_LOG_INFO("in face is null");
        if(outFace->m_face == NULL)
            NS_LOG_INFO("outface is null");
        
        // If we're expecting data from the interface we got the interest from ("producer" asks us for "his own" data)
        // Give up this interface, but keep a small hope when the returned packet doesn't have PRUNE status
        if( outFace != pitEntry->m_outgoing.end())
        {
            NS_LOG_INFO("Entering outFace != pitEntry->m_outgoing.end()");
            if( header->IsCongested() == true )
            {
                NS_LOG_INFO("Entering header->IsCongested() == true");
                m_pit->LeakBucket(incomingFace, 1);
                m_pit->modify (pitEntry, CcnxPitEntry::DeleteOutgoing(outFace->m_face));
            }
            //else
            //    poit->waitingInVain = true;
            
            // Update metric status for the incoming interface in the corresponding FIB entry
            if(fibEntry != m_fib->end())
                m_fib->modify(m_fib->iterator_to (pitEntry->m_fibEntry),
                              CcnxFibEntry::UpdateStatus(incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW));
        }
    }

  NS_LOG_INFO("Before (pitEntry->m_outgoing.size() == 0) && (pitEntry->m_fibEntry.m_faces.size() == 0)");
  if((pitEntry->m_outgoing.size() == 0) && (pitEntry->m_fibEntry.m_faces.size() == 0))
      // prune all incoming interests
    {
        
        for(CcnxPitEntryContainer::type::iterator iter = m_pit->begin();
            iter != m_pit->end(); 
            iter++)
        {
            /*for(CcnxPitEntryIncomingFaceContainer::type::iterator face = iter->m_incoming.begin();
                face != iter->m_incoming.end();
                face++)*/
            BOOST_FOREACH (const CcnxPitEntryIncomingFace face, iter->m_incoming)
            {
              if(face.m_face->IsLocal() == true)
                {
                    //returnInterestToApp( pkt, -piit->interfaceIndex );
                    //continue;
                }
                
                // check all entries if the name of RIT entry matches the name of interest
                for (CcnxRitByNonce::type::iterator it = m_rit->begin(); it != m_rit->end(); it++)
              {
                if (it->m_prefix == iter->GetPrefix() )
                  {
                    header->SetNonce(it->m_nonce);
                    header->SetNack(true);
                    SendInterest(face.m_face, header, packet->Copy());
                  }
              }
            }

        }
            
        m_pit->erase(pitEntry);
        
        return; // there is nothing else to do
    }

    // Suppress this interest only if we're still expecting data from some other interface
    if( pitEntry->m_outgoing.size() > 0 ) 
    {
        return; //ok. Now we can suppress this interest
    }
    
    
    // Prune and delete PIT entry if there are no available interfaces to propagate interest
    if( pitEntry->m_fibEntry.m_faces.size() == 0)
    {
        //if no match is found in the FIB, drop packet
        //printf( "Node %d: cannot process Interest packet %s (no interfaces left)\n", _node->nodeId, pkt->contentName );
		
        if(incomingFace->IsLocal() == false)
        {
            header->SetNack(true);
            m_droppedInterestsTrace (header, NDN_SUPPRESSED_INTEREST,
                                     m_node->GetObject<Ccnx> (), incomingFace);
            SendInterest(incomingFace, header, packet->Copy());
        }
        
        m_pit->erase(pitEntry);
        
    }

    
    
    // otherwise, try one of the available interfaces
    
  // suppress interest if 
  /*if (pitEntry->m_incoming.size () != 0 && // not a new PIT entry and
      inFace != pitEntry->m_incoming.end ()) // existing entry, but interest received via different face
    {
      m_droppedInterestsTrace (header, NDN_SUPPRESSED_INTEREST,
                                m_node->GetObject<Ccnx> (), incomingFace);
      return;
    }*/
    
    
    //just in case of bug
    header->SetNack(false);
    header->SetCongested(false);
  
      NS_ASSERT_MSG (m_forwardingStrategy != 0, "Need a forwarding protocol object to process packets");

      m_pit->modify (pitEntry, CcnxPitEntry::AddIncoming(incomingFace));
    
      bool propagated = m_forwardingStrategy->
        PropagateInterest (pitEntry, fibEntry,incomingFace, header, packet,
                       MakeCallback (&CcnxL3Protocol::SendInterest, this)
                       );

      // If interest wasn't propagated further (probably, a limit is reached),
      // prune and delete PIT entry if there are no outstanding interests.
      // Stop processing otherwise.
      if( (!propagated) && (pitEntry->m_outgoing.size() == 0))
        {
          BOOST_FOREACH (const CcnxPitEntryIncomingFace face, pitEntry->m_incoming)
            {
                
                
                header->SetNack(true);
                header->SetCongested(true);
                SendInterest (face.m_face, header, packet->Copy());
                
                m_droppedInterestsTrace (header, DROP_CONGESTION,
                                         m_node->GetObject<Ccnx> (), incomingFace);
            }
      
          m_pit->erase (pitEntry);
        }
    /*}
  else
    {
      m_droppedInterestsTrace (header, NDN_PIT_TIMER_EXPIRED,
                                 m_node->GetObject<Ccnx> (), incomingFace);
      return;
    }*/
}

// Processing ContentObjects
void CcnxL3Protocol::OnData (const Ptr<CcnxFace> &incomingFace,
                             Ptr<CcnxContentObjectHeader> &header,
                             Ptr<Packet> &payload,
                             const Ptr<const Packet> &packet)
{
    
  NS_LOG_LOGIC ("Receiving contentObject from " << &incomingFace);
  m_receivedDataTrace (header, payload, m_node->GetObject<Ccnx> ()/*this*/, incomingFace);

  // 1. Lookup PIT entry
  try
    {
      const CcnxPitEntry &pitEntry = m_pit->Lookup (*header);

      // Note that with MultiIndex we need to modify entries indirectly
  
      // Update metric status for the incoming interface in the corresponding FIB entry
      m_fib->modify (m_fib->iterator_to (pitEntry.m_fibEntry),
                     CcnxFibEntry::UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_GREEN));
  
      // Add or update entry in the content store
      NS_LOG_INFO("Cached " << header->GetName());
      m_contentStore->Add (header, payload);

      CcnxPitEntryOutgoingFaceContainer::type::iterator
        out = pitEntry.m_outgoing.find (incomingFace);
  
      // If we have sent interest for this data via this face, then update stats.
      if (out != pitEntry.m_outgoing.end ())
        {
          m_pit->modify (m_pit->iterator_to (pitEntry),
                         CcnxPitEntry::EstimateRttAndRemoveFace(out, m_fib));
          // face will be removed in the above call
        }
      else
        {
          NS_LOG_WARN ("Node "<< m_node->GetId() <<
                          ". PIT entry for "<< header->GetName ()<<" is valid, "
                          "but outgoing entry for interface "<< incomingFace <<" doesn't exist\n");
        }

      //satisfy all pending incoming Interests
      BOOST_FOREACH (const CcnxPitEntryIncomingFace &interest, pitEntry.m_incoming)
        {
          if (interest.m_face == incomingFace) continue; 

          // may not work either because of 'const' thing
          interest.m_face->Send (packet->Copy ()); // unfortunately, we have to copy packet... 
          m_transmittedDataTrace (header, payload, FORWARDED, m_node->GetObject<Ccnx> (), interest.m_face);
        }

      m_pit->modify (m_pit->iterator_to (pitEntry), CcnxPitEntry::ClearIncoming()); // satisfy all incoming interests

      if( pitEntry.m_outgoing.size()==0 ) // remove PIT when all outgoing interests are "satisfied"
        {
          m_pit->erase (m_pit->iterator_to (pitEntry));
        }

    }
  catch (CcnxPitEntryNotFound)
    {
      // 2. Drop data packet if PIT entry is not found
      //    (unsolicited data packets should not "poison" content store)
      
      //drop dulicated or not requested data packet
      m_droppedDataTrace (header, payload, NDN_UNSOLICITED_DATA, m_node->GetObject<Ccnx> (), incomingFace);
      return; // do not process unsoliced data packets
    }
}

void
CcnxL3Protocol::SendInterest (const Ptr<CcnxFace> &face,
                              const Ptr<CcnxInterestHeader> &header,
                              const Ptr<Packet> &packet)
{
  NS_LOG_FUNCTION (this << "packet: " << &packet << ", face: "<< &face);
  NS_ASSERT_MSG (face != 0, "Face should never be NULL");

  if (face->IsUp ())
    {
      NS_LOG_LOGIC ("Sending via face " << &face); //
      m_transmittedInterestsTrace (header, m_node->GetObject<Ccnx> (), face);
      face->Send (packet);
    }
  else
    {
      NS_LOG_LOGIC ("Dropping -- outgoing interface is down: " << &face);
      m_droppedInterestsTrace (header, INTERFACE_DOWN, m_node->GetObject<Ccnx> (), face);
    }
}

void
CcnxL3Protocol::SendContentObject (const Ptr<CcnxFace> &face,
                                   const Ptr<CcnxContentObjectHeader> &header,
                                   const Ptr<Packet> &packet)
{
  NS_LOG_FUNCTION (this << "packet: " << &packet << ", face: "<< &face);
  NS_ASSERT_MSG (face != 0, "Face should never be NULL");

  NS_ASSERT_MSG (false, "Should not be called for now");
  
  if (face->IsUp ())
    {
      NS_LOG_LOGIC ("Sending via face " << &face); //
      // m_txTrace (packet, m_node->GetObject<Ccnx> (), face);
      face->Send (packet);
    }
  else
    {
      NS_LOG_LOGIC ("Dropping -- outgoing interface is down: " << &face);
      // m_dropTrace (packet, INTERFACE_DOWN, m_node->GetObject<Ccnx> (), face);
    }
}

Ptr<CcnxPit>
CcnxL3Protocol::GetPit()
{
    return m_pit;
}
} //namespace ns3