NS-3 based Named Data Networking (NDN) simulator
ndnSIM: NDN, CCN, CCNx, content centric networks
API Documentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Groups Pages
ndn-forwarding-strategy.cc
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
2 /*
3  * Copyright (c) 2011 University of California, Los Angeles
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
19  * Ilya Moiseenko <iliamo@cs.ucla.edu>
20  */
21 
22 #include "ndn-forwarding-strategy.h"
23 
24 #include "ns3/ndn-pit.h"
25 #include "ns3/ndn-pit-entry.h"
26 #include "ns3/ndn-interest.h"
27 #include "ns3/ndn-data.h"
28 #include "ns3/ndn-pit.h"
29 #include "ns3/ndn-fib.h"
30 #include "ns3/ndn-content-store.h"
31 #include "ns3/ndn-face.h"
32 
33 #include "ns3/assert.h"
34 #include "ns3/ptr.h"
35 #include "ns3/log.h"
36 #include "ns3/simulator.h"
37 #include "ns3/boolean.h"
38 #include "ns3/string.h"
39 
40 #include "ns3/ndnSIM/utils/ndn-fw-hop-count-tag.h"
41 
42 #include <boost/ref.hpp>
43 #include <boost/foreach.hpp>
44 #include <boost/lambda/lambda.hpp>
45 #include <boost/lambda/bind.hpp>
46 #include <boost/tuple/tuple.hpp>
47 namespace ll = boost::lambda;
48 
49 namespace ns3 {
50 namespace ndn {
51 
52 NS_OBJECT_ENSURE_REGISTERED (ForwardingStrategy);
53 
54 NS_LOG_COMPONENT_DEFINE (ForwardingStrategy::GetLogName ().c_str ());
55 
56 std::string
58 {
59  return "ndn.fw";
60 }
61 
62 TypeId ForwardingStrategy::GetTypeId (void)
63 {
64  static TypeId tid = TypeId ("ns3::ndn::ForwardingStrategy")
65  .SetGroupName ("Ndn")
66  .SetParent<Object> ()
67 
70 
71  .AddTraceSource ("OutInterests", "OutInterests", MakeTraceSourceAccessor (&ForwardingStrategy::m_outInterests))
72  .AddTraceSource ("InInterests", "InInterests", MakeTraceSourceAccessor (&ForwardingStrategy::m_inInterests))
73  .AddTraceSource ("DropInterests", "DropInterests", MakeTraceSourceAccessor (&ForwardingStrategy::m_dropInterests))
74 
77 
78  .AddTraceSource ("OutData", "OutData", MakeTraceSourceAccessor (&ForwardingStrategy::m_outData))
79  .AddTraceSource ("InData", "InData", MakeTraceSourceAccessor (&ForwardingStrategy::m_inData))
80  .AddTraceSource ("DropData", "DropData", MakeTraceSourceAccessor (&ForwardingStrategy::m_dropData))
81 
84 
85  .AddTraceSource ("SatisfiedInterests", "SatisfiedInterests", MakeTraceSourceAccessor (&ForwardingStrategy::m_satisfiedInterests))
86  .AddTraceSource ("TimedOutInterests", "TimedOutInterests", MakeTraceSourceAccessor (&ForwardingStrategy::m_timedOutInterests))
87 
88  .AddAttribute ("CacheUnsolicitedDataFromApps", "Cache unsolicited data that has been pushed from applications",
89  BooleanValue (true),
90  MakeBooleanAccessor (&ForwardingStrategy::m_cacheUnsolicitedDataFromApps),
91  MakeBooleanChecker ())
92 
93  .AddAttribute ("CacheUnsolicitedData", "Cache overheard data that have not been requested",
94  BooleanValue (false),
95  MakeBooleanAccessor (&ForwardingStrategy::m_cacheUnsolicitedData),
96  MakeBooleanChecker ())
97 
98  .AddAttribute ("DetectRetransmissions", "If non-duplicate interest is received on the same face more than once, "
99  "it is considered a retransmission",
100  BooleanValue (true),
101  MakeBooleanAccessor (&ForwardingStrategy::m_detectRetransmissions),
102  MakeBooleanChecker ())
103  ;
104  return tid;
105 }
106 
108 {
109 }
110 
111 ForwardingStrategy::~ForwardingStrategy ()
112 {
113 }
114 
115 void
117 {
118  if (m_pit == 0)
119  {
120  m_pit = GetObject<Pit> ();
121  }
122  if (m_fib == 0)
123  {
124  m_fib = GetObject<Fib> ();
125  }
126  if (m_contentStore == 0)
127  {
128  m_contentStore = GetObject<ContentStore> ();
129  }
130 
131  Object::NotifyNewAggregate ();
132 }
133 
134 void
136 {
137  m_pit = 0;
138  m_contentStore = 0;
139  m_fib = 0;
140 
141  Object::DoDispose ();
142 }
143 
144 void
146  Ptr<Interest> interest)
147 {
148  NS_LOG_FUNCTION (inFace << interest->GetName ());
149  m_inInterests (interest, inFace);
150 
151  Ptr<pit::Entry> pitEntry = m_pit->Lookup (*interest);
152  bool similarInterest = true;
153  if (pitEntry == 0)
154  {
155  similarInterest = false;
156  pitEntry = m_pit->Create (interest);
157  if (pitEntry != 0)
158  {
159  DidCreatePitEntry (inFace, interest, pitEntry);
160  }
161  else
162  {
163  FailedToCreatePitEntry (inFace, interest);
164  return;
165  }
166  }
167 
168  bool isDuplicated = true;
169  if (!pitEntry->IsNonceSeen (interest->GetNonce ()))
170  {
171  pitEntry->AddSeenNonce (interest->GetNonce ());
172  isDuplicated = false;
173  }
174 
175  if (isDuplicated)
176  {
177  DidReceiveDuplicateInterest (inFace, interest, pitEntry);
178  return;
179  }
180 
181  Ptr<Data> contentObject;
182  contentObject = m_contentStore->Lookup (interest);
183  if (contentObject != 0)
184  {
185  FwHopCountTag hopCountTag;
186  if (interest->GetPayload ()->PeekPacketTag (hopCountTag))
187  {
188  contentObject->GetPayload ()->AddPacketTag (hopCountTag);
189  }
190 
191  pitEntry->AddIncoming (inFace/*, Seconds (1.0)*/);
192 
193  // Do data plane performance measurements
194  WillSatisfyPendingInterest (0, pitEntry);
195 
196  // Actually satisfy pending interest
197  SatisfyPendingInterest (0, contentObject, pitEntry);
198  return;
199  }
200 
201  if (similarInterest && ShouldSuppressIncomingInterest (inFace, interest, pitEntry))
202  {
203  pitEntry->AddIncoming (inFace/*, interest->GetInterestLifetime ()*/);
204  // update PIT entry lifetime
205  pitEntry->UpdateLifetime (interest->GetInterestLifetime ());
206 
207  // Suppress this interest if we're still expecting data from some other face
208  NS_LOG_DEBUG ("Suppress interests");
209  m_dropInterests (interest, inFace);
210 
211  DidSuppressSimilarInterest (inFace, interest, pitEntry);
212  return;
213  }
214 
215  if (similarInterest)
216  {
217  DidForwardSimilarInterest (inFace, interest, pitEntry);
218  }
219 
220  PropagateInterest (inFace, interest, pitEntry);
221 }
222 
223 void
224 ForwardingStrategy::OnData (Ptr<Face> inFace,
225  Ptr<Data> data)
226 {
227  NS_LOG_FUNCTION (inFace << data->GetName ());
228  m_inData (data, inFace);
229 
230  // Lookup PIT entry
231  Ptr<pit::Entry> pitEntry = m_pit->Lookup (*data);
232  if (pitEntry == 0)
233  {
234  bool cached = false;
235 
236  if (m_cacheUnsolicitedData || (m_cacheUnsolicitedDataFromApps && (inFace->GetFlags () & Face::APPLICATION)))
237  {
238  // Optimistically add or update entry in the content store
239  cached = m_contentStore->Add (data);
240  }
241  else
242  {
243  // Drop data packet if PIT entry is not found
244  // (unsolicited data packets should not "poison" content store)
245 
246  //drop dulicated or not requested data packet
247  m_dropData (data, inFace);
248  }
249 
250  DidReceiveUnsolicitedData (inFace, data, cached);
251  return;
252  }
253  else
254  {
255  bool cached = m_contentStore->Add (data);
256  DidReceiveSolicitedData (inFace, data, cached);
257  }
258 
259  while (pitEntry != 0)
260  {
261  // Do data plane performance measurements
262  WillSatisfyPendingInterest (inFace, pitEntry);
263 
264  // Actually satisfy pending interest
265  SatisfyPendingInterest (inFace, data, pitEntry);
266 
267  // Lookup another PIT entry
268  pitEntry = m_pit->Lookup (*data);
269  }
270 }
271 
272 void
274  Ptr<const Interest> interest,
275  Ptr<pit::Entry> pitEntrypitEntry)
276 {
277 }
278 
279 void
281  Ptr<const Interest> interest)
282 {
283  m_dropInterests (interest, inFace);
284 }
285 
286 void
288  Ptr<const Interest> interest,
289  Ptr<pit::Entry> pitEntry)
290 {
292  // //
293  // !!!! IMPORTANT CHANGE !!!! Duplicate interests will create incoming face entry !!!! //
294  // //
296  pitEntry->AddIncoming (inFace);
297  m_dropInterests (interest, inFace);
298 }
299 
300 void
302  Ptr<const Interest> interest,
303  Ptr<pit::Entry> pitEntry)
304 {
305 }
306 
307 void
309  Ptr<const Interest> interest,
310  Ptr<pit::Entry> pitEntry)
311 {
312 }
313 
314 void
316  Ptr<const Interest> interest,
317  Ptr<pit::Entry> pitEntry)
318 {
319  NS_LOG_FUNCTION (this << boost::cref (*inFace));
320  if (pitEntry->AreAllOutgoingInVain ())
321  {
322  m_dropInterests (interest, inFace);
323 
324  // All incoming interests cannot be satisfied. Remove them
325  pitEntry->ClearIncoming ();
326 
327  // Remove also outgoing
328  pitEntry->ClearOutgoing ();
329 
330  // Set pruning timout on PIT entry (instead of deleting the record)
331  m_pit->MarkErased (pitEntry);
332  }
333 }
334 
335 
336 
337 bool
339  Ptr<const Interest> interest,
340  Ptr<pit::Entry> pitEntry)
341 {
342  pit::Entry::in_iterator existingInFace = pitEntry->GetIncoming ().find (inFace);
343 
344  bool isRetransmitted = false;
345 
346  if (existingInFace != pitEntry->GetIncoming ().end ())
347  {
348  // this is almost definitely a retransmission. But should we trust the user on that?
349  isRetransmitted = true;
350  }
351 
352  return isRetransmitted;
353 }
354 
355 void
357  Ptr<const Data> data,
358  Ptr<pit::Entry> pitEntry)
359 {
360  if (inFace != 0)
361  pitEntry->RemoveIncoming (inFace);
362 
363  //satisfy all pending incoming Interests
364  BOOST_FOREACH (const pit::IncomingFace &incoming, pitEntry->GetIncoming ())
365  {
366  bool ok = incoming.m_face->SendData (data);
367 
368  DidSendOutData (inFace, incoming.m_face, data, pitEntry);
369  NS_LOG_DEBUG ("Satisfy " << *incoming.m_face);
370 
371  if (!ok)
372  {
373  m_dropData (data, incoming.m_face);
374  NS_LOG_DEBUG ("Cannot satisfy data to " << *incoming.m_face);
375  }
376  }
377 
378  // All incoming interests are satisfied. Remove them
379  pitEntry->ClearIncoming ();
380 
381  // Remove all outgoing faces
382  pitEntry->ClearOutgoing ();
383 
384  // Set pruning timout on PIT entry (instead of deleting the record)
385  m_pit->MarkErased (pitEntry);
386 }
387 
388 void
390  Ptr<const Data> data,
391  bool didCreateCacheEntry)
392 {
393  // do nothing
394 }
395 
396 void
398  Ptr<const Data> data,
399  bool didCreateCacheEntry)
400 {
401  // do nothing
402 }
403 
404 void
406  Ptr<pit::Entry> pitEntry)
407 {
408  pit::Entry::out_iterator out = pitEntry->GetOutgoing ().find (inFace);
409 
410  // If we have sent interest for this data via this face, then update stats.
411  if (out != pitEntry->GetOutgoing ().end ())
412  {
413  pitEntry->GetFibEntry ()->UpdateFaceRtt (inFace, Simulator::Now () - out->m_sendTime);
414  }
415 
416  m_satisfiedInterests (pitEntry);
417 }
418 
419 bool
421  Ptr<const Interest> interest,
422  Ptr<pit::Entry> pitEntry)
423 {
424  bool isNew = pitEntry->GetIncoming ().size () == 0 && pitEntry->GetOutgoing ().size () == 0;
425 
426  if (isNew) return false; // never suppress new interests
427 
428  bool isRetransmitted = m_detectRetransmissions && // a small guard
429  DetectRetransmittedInterest (inFace, interest, pitEntry);
430 
431  if (pitEntry->GetOutgoing ().find (inFace) != pitEntry->GetOutgoing ().end ())
432  {
433  NS_LOG_DEBUG ("Non duplicate interests from the face we have sent interest to. Don't suppress");
434  // got a non-duplicate interest from the face we have sent interest to
435  // Probably, there is no point in waiting data from that face... Not sure yet
436 
437  // If we're expecting data from the interface we got the interest from ("producer" asks us for "his own" data)
438  // Mark interface YELLOW, but keep a small hope that data will come eventually.
439 
440  // ?? not sure if we need to do that ?? ...
441 
442  // pitEntry->GetFibEntry ()->UpdateStatus (inFace, fib::FaceMetric::NDN_FIB_YELLOW);
443  }
444  else
445  if (!isNew && !isRetransmitted)
446  {
447  return true;
448  }
449 
450  return false;
451 }
452 
453 void
455  Ptr<const Interest> interest,
456  Ptr<pit::Entry> pitEntry)
457 {
458  bool isRetransmitted = m_detectRetransmissions && // a small guard
459  DetectRetransmittedInterest (inFace, interest, pitEntry);
460 
461  pitEntry->AddIncoming (inFace/*, interest->GetInterestLifetime ()*/);
463  pitEntry->UpdateLifetime (interest->GetInterestLifetime ());
464 
465  bool propagated = DoPropagateInterest (inFace, interest, pitEntry);
466 
467  if (!propagated && isRetransmitted) //give another chance if retransmitted
468  {
469  // increase max number of allowed retransmissions
470  pitEntry->IncreaseAllowedRetxCount ();
471 
472  // try again
473  propagated = DoPropagateInterest (inFace, interest, pitEntry);
474  }
475 
476  // if (!propagated)
477  // {
478  // NS_LOG_DEBUG ("++++++++++++++++++++++++++++++++++++++++++++++++++++++");
479  // NS_LOG_DEBUG ("+++ Not propagated ["<< interest->GetName () <<"], but number of outgoing faces: " << pitEntry->GetOutgoing ().size ());
480  // NS_LOG_DEBUG ("++++++++++++++++++++++++++++++++++++++++++++++++++++++");
481  // }
482 
483  // ForwardingStrategy will try its best to forward packet to at least one interface.
484  // If no interests was propagated, then there is not other option for forwarding or
485  // ForwardingStrategy failed to find it.
486  if (!propagated && pitEntry->AreAllOutgoingInVain ())
487  {
488  DidExhaustForwardingOptions (inFace, interest, pitEntry);
489  }
490 }
491 
492 bool
494  Ptr<Face> outFace,
495  Ptr<const Interest> interest,
496  Ptr<pit::Entry> pitEntry)
497 {
498  if (outFace == inFace)
499  {
500  // NS_LOG_DEBUG ("Same as incoming");
501  return false; // same face as incoming, don't forward
502  }
503 
504  pit::Entry::out_iterator outgoing =
505  pitEntry->GetOutgoing ().find (outFace);
506 
507  if (outgoing != pitEntry->GetOutgoing ().end ())
508  {
509  if (!m_detectRetransmissions)
510  return false; // suppress
511  else if (outgoing->m_retxCount >= pitEntry->GetMaxRetxCount ())
512  {
513  // NS_LOG_DEBUG ("Already forwarded before during this retransmission cycle (" <<outgoing->m_retxCount << " >= " << pitEntry->GetMaxRetxCount () << ")");
514  return false; // already forwarded before during this retransmission cycle
515  }
516  }
517 
518  return true;
519 }
520 
521 
522 bool
524  Ptr<Face> outFace,
525  Ptr<const Interest> interest,
526  Ptr<pit::Entry> pitEntry)
527 {
528  if (!CanSendOutInterest (inFace, outFace, interest, pitEntry))
529  {
530  return false;
531  }
532 
533  pitEntry->AddOutgoing (outFace);
534 
535  //transmission
536  bool successSend = outFace->SendInterest (interest);
537  if (!successSend)
538  {
539  m_dropInterests (interest, outFace);
540  }
541 
542  DidSendOutInterest (inFace, outFace, interest, pitEntry);
543 
544  return true;
545 }
546 
547 void
549  Ptr<Face> outFace,
550  Ptr<const Interest> interest,
551  Ptr<pit::Entry> pitEntry)
552 {
553  m_outInterests (interest, outFace);
554 }
555 
556 void
558  Ptr<Face> outFace,
559  Ptr<const Data> data,
560  Ptr<pit::Entry> pitEntry)
561 {
562  m_outData (data, inFace == 0, outFace);
563 }
564 
565 void
567 {
568  m_timedOutInterests (pitEntry);
569 }
570 
571 void
573 {
574  // do nothing here
575 }
576 
577 void
579 {
580  // do nothing here
581 }
582 
583 void
584 ForwardingStrategy::DidAddFibEntry (Ptr<fib::Entry> fibEntry)
585 {
586  // do nothing here
587 }
588 
589 void
590 ForwardingStrategy::WillRemoveFibEntry (Ptr<fib::Entry> fibEntry)
591 {
592  // do nothing here
593 }
594 
595 
596 } // namespace ndn
597 } // namespace ns3
virtual bool DetectRetransmittedInterest(Ptr< Face > inFace, Ptr< const Interest > interest, Ptr< pit::Entry > pitEntry)
Method that implements logic to distinguish between new and retransmitted interest.
virtual void FailedToCreatePitEntry(Ptr< Face > inFace, Ptr< const Interest > interest)
An event that is fired every time a new PIT entry cannot be created (e.g., PIT container imposes a li...
virtual void OnInterest(Ptr< Face > face, Ptr< Interest > interest)
Actual processing of incoming Ndn interests.
TracedCallback< Ptr< const Interest >, Ptr< const Face > > m_outInterests
Transmitted interests trace.
virtual bool CanSendOutInterest(Ptr< Face > inFace, Ptr< Face > outFace, Ptr< const Interest > interest, Ptr< pit::Entry > pitEntry)
Method to check whether Interest can be send out on the particular face or not.
virtual bool DoPropagateInterest(Ptr< Face > inFace, Ptr< const Interest > interest, Ptr< pit::Entry > pitEntry)=0
Virtual method to perform Interest propagation according to the forwarding strategy logic...
virtual void DidReceiveSolicitedData(Ptr< Face > inFace, Ptr< const Data > data, bool didCreateCacheEntry)
Event which is fired every time a requested (solicited) DATA packet (there is an active PIT entry) is...
virtual void DidExhaustForwardingOptions(Ptr< Face > inFace, Ptr< const Interest > interest, Ptr< pit::Entry > pitEntry)
An even that is fired when Interest cannot be forwarded.
virtual void DidReceiveUnsolicitedData(Ptr< Face > inFace, Ptr< const Data > data, bool didCreateCacheEntry)
Event which is fired every time an unsolicited DATA packet (no active PIT entry) is received...
virtual void WillSatisfyPendingInterest(Ptr< Face > inFace, Ptr< pit::Entry > pitEntry)
Even fired just before Interest will be satisfied.
Ptr< Face > m_face
face of the incoming Interest
virtual void NotifyNewAggregate()
Even when object is aggregated to another Object.
virtual void DidSuppressSimilarInterest(Ptr< Face > inFace, Ptr< const Interest > interest, Ptr< pit::Entry > pitEntry)
An event that is fired every time when a similar Interest is received and suppressed (collapsed) ...
static std::string GetLogName()
Helper function to retrieve logging name for the forwarding strategy.
virtual void DidSendOutData(Ptr< Face > inFace, Ptr< Face > outFace, Ptr< const Data > data, Ptr< pit::Entry > pitEntry)
Event which is fired just after data was send out on the face.
in_container::iterator in_iterator
iterator to incoming faces
Definition: ndn-pit-entry.h:61
An application face.
Definition: ndn-face.h:191
virtual void DidReceiveDuplicateInterest(Ptr< Face > inFace, Ptr< const Interest > interest, Ptr< pit::Entry > pitEntry)
An event that is fired every time a duplicated Interest is received.
virtual bool ShouldSuppressIncomingInterest(Ptr< Face > inFace, Ptr< const Interest > interest, Ptr< pit::Entry > pitEntry)
Method implementing logic to suppress (collapse) similar Interests.
TracedCallback< Ptr< const Data >, bool, Ptr< const Face > > m_outData
trace of outgoing Data
virtual void WillEraseTimedOutPendingInterest(Ptr< pit::Entry > pitEntry)
Event fired just before PIT entry is removed by timeout.
TracedCallback< Ptr< const Interest >, Ptr< const Face > > m_dropInterests
trace of dropped Interests
virtual void RemoveFace(Ptr< Face > face)
Event fired every time face is removed from NDN stack.
virtual void DoDispose()
Do cleanup.
virtual void DidSendOutInterest(Ptr< Face > inFace, Ptr< Face > outFace, Ptr< const Interest > interest, Ptr< pit::Entry > pitEntry)
Event fired just after forwarding the Interest.
TracedCallback< Ptr< const Data >, Ptr< const Face > > m_dropData
trace of dropped Data
ForwardingStrategy()
Default constructor.
virtual void DidCreatePitEntry(Ptr< Face > inFace, Ptr< const Interest > interest, Ptr< pit::Entry > pitEntry)
An event that is fired every time a new PIT entry is created.
virtual void OnData(Ptr< Face > face, Ptr< Data > data)
Actual processing of incoming Ndn content objects.
virtual void PropagateInterest(Ptr< Face > inFace, Ptr< const Interest > interest, Ptr< pit::Entry > pitEntry)
Wrapper method, which performs general tasks and calls DoPropagateInterest method.
virtual void WillRemoveFibEntry(Ptr< fib::Entry > fibEntry)
Fired just before FIB entry will be removed from FIB.
Ptr< ContentStore > m_contentStore
Content store (for caching purposes only)
virtual void DidAddFibEntry(Ptr< fib::Entry > fibEntry)
Event fired every time a FIB entry is added to FIB.
Ptr< Pit > m_pit
Reference to PIT to which this forwarding strategy is associated.
Packet tag that is used to track hop count for Interest-Data pairs.
TracedCallback< Ptr< const Interest >, Ptr< const Face > > m_inInterests
trace of incoming Interests
virtual void DidForwardSimilarInterest(Ptr< Face > inFace, Ptr< const Interest > interest, Ptr< pit::Entry > pitEntry)
An event that is fired every time when a similar Interest is received and further forwarded (not supp...
virtual void AddFace(Ptr< Face > face)
Event fired every time face is added to NDN stack.
virtual bool TrySendOutInterest(Ptr< Face > inFace, Ptr< Face > outFace, Ptr< const Interest > interest, Ptr< pit::Entry > pitEntry)
Method implementing actual interest forwarding, taking into account CanSendOutInterest decision...
TracedCallback< Ptr< const Data >, Ptr< const Face > > m_inData
trace of incoming Data
out_container::iterator out_iterator
iterator to outgoing faces
Definition: ndn-pit-entry.h:65
virtual void SatisfyPendingInterest(Ptr< Face > inFace, Ptr< const Data > data, Ptr< pit::Entry > pitEntry)
Actual procedure to satisfy Interest.
PIT state component for each incoming interest (not including duplicates)