blob: 8cebc0016813e153f7fa479b402c87bb248b0b49 [file] [log] [blame]
Alexander Afanasyevc74a6022011-08-15 20:01:35 -07001/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
Alexander Afanasyevab1d5602011-08-17 19:17:18 -07002/*
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>
Ilya Moiseenko172763c2011-10-28 13:21:53 -070019 * Ilya Moiseenko <iliamo@cs.ucla.edu>
Alexander Afanasyevab1d5602011-08-17 19:17:18 -070020 */
Alexander Afanasyev08d984e2011-08-13 19:20:22 -070021
Alexander Afanasyev45b92d42011-08-14 23:11:38 -070022#include "ccnx-l3-protocol.h"
23
Alexander Afanasyev08d984e2011-08-13 19:20:22 -070024#include "ns3/packet.h"
Alexander Afanasyev45b92d42011-08-14 23:11:38 -070025#include "ns3/node.h"
Alexander Afanasyev08d984e2011-08-13 19:20:22 -070026#include "ns3/log.h"
27#include "ns3/callback.h"
Alexander Afanasyev08d984e2011-08-13 19:20:22 -070028#include "ns3/uinteger.h"
29#include "ns3/trace-source-accessor.h"
30#include "ns3/object-vector.h"
Alexander Afanasyevcbe92ae2011-12-16 13:06:18 -080031#include "ns3/pointer.h"
Alexander Afanasyev08d984e2011-08-13 19:20:22 -070032#include "ns3/boolean.h"
Alexander Afanasyev07827182011-12-13 01:07:32 -080033#include "ns3/string.h"
Alexander Afanasyev4975f732011-12-20 17:52:19 -080034#include "ns3/simulator.h"
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -070035#include "ns3/random-variable.h"
Alexander Afanasyev08d984e2011-08-13 19:20:22 -070036
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070037#include "ns3/ccnx-header-helper.h"
38
Alexander Afanasyev45b92d42011-08-14 23:11:38 -070039#include "ccnx-face.h"
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070040#include "ccnx-forwarding-strategy.h"
41#include "ccnx-interest-header.h"
42#include "ccnx-content-object-header.h"
Alexander Afanasyev78057c32012-07-06 15:18:46 -070043#include "ccnx-fib-impl.h"
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070044
Alexander Afanasyev52e9aa92011-11-15 20:23:20 -080045#include "ccnx-net-device-face.h"
46
Alexander Afanasyev56f79ea2011-08-17 23:54:27 -070047#include <boost/foreach.hpp>
Alexander Afanasyeva46844b2011-11-21 19:13:26 -080048#include <boost/lambda/lambda.hpp>
Alexander Afanasyeva5bbe0e2011-11-22 17:28:39 -080049#include <boost/lambda/bind.hpp>
Alexander Afanasyeva46844b2011-11-21 19:13:26 -080050
51using namespace boost::tuples;
Alexander Afanasyeva5bbe0e2011-11-22 17:28:39 -080052namespace ll = boost::lambda;
Alexander Afanasyev08d984e2011-08-13 19:20:22 -070053
54NS_LOG_COMPONENT_DEFINE ("CcnxL3Protocol");
55
56namespace ns3 {
57
Alexander Afanasyev7112f482011-08-17 14:05:57 -070058const uint16_t CcnxL3Protocol::ETHERNET_FRAME_TYPE = 0x7777;
Alexander Afanasyev08d984e2011-08-13 19:20:22 -070059
Alexander Afanasyev07827182011-12-13 01:07:32 -080060
Alexander Afanasyev08d984e2011-08-13 19:20:22 -070061NS_OBJECT_ENSURE_REGISTERED (CcnxL3Protocol);
62
63TypeId
64CcnxL3Protocol::GetTypeId (void)
65{
66 static TypeId tid = TypeId ("ns3::CcnxL3Protocol")
67 .SetParent<Ccnx> ()
Alexander Afanasyev070aa482011-08-20 00:38:25 -070068 .SetGroupName ("Ccnx")
Alexander Afanasyev08d984e2011-08-13 19:20:22 -070069 .AddConstructor<CcnxL3Protocol> ()
Alexander Afanasyevcbe92ae2011-12-16 13:06:18 -080070 .AddAttribute ("FaceList", "List of faces associated with CCNx stack",
71 ObjectVectorValue (),
72 MakeObjectVectorAccessor (&CcnxL3Protocol::m_faces),
73 MakeObjectVectorChecker<CcnxFace> ())
74
Alexander Afanasyevbab81b12012-02-04 14:20:09 -080075 .AddAttribute ("EnableNACKs", "Enabling support of NACKs",
Alexander Afanasyev082dbca2012-02-14 18:43:13 -080076 BooleanValue (false),
Alexander Afanasyevbab81b12012-02-04 14:20:09 -080077 MakeBooleanAccessor (&CcnxL3Protocol::m_nacksEnabled),
78 MakeBooleanChecker ())
Alexander Afanasyevde009992012-02-04 18:54:54 -080079 .AddAttribute ("CacheUnsolicitedData", "Cache overheard data that have not been requested",
80 BooleanValue (false),
81 MakeBooleanAccessor (&CcnxL3Protocol::m_cacheUnsolicitedData),
82 MakeBooleanChecker ())
Alexander Afanasyev08d984e2011-08-13 19:20:22 -070083 ;
84 return tid;
85}
86
87CcnxL3Protocol::CcnxL3Protocol()
Alexander Afanasyevab1d5602011-08-17 19:17:18 -070088: m_faceCounter (0)
Alexander Afanasyev08d984e2011-08-13 19:20:22 -070089{
90 NS_LOG_FUNCTION (this);
91}
92
93CcnxL3Protocol::~CcnxL3Protocol ()
94{
95 NS_LOG_FUNCTION (this);
96}
97
Alexander Afanasyev08d984e2011-08-13 19:20:22 -070098/*
99 * This method is called by AddAgregate and completes the aggregation
100 * by setting the node in the ccnx stack
101 */
102void
103CcnxL3Protocol::NotifyNewAggregate ()
104{
Alexander Afanasyev3a4a0b32012-06-28 14:14:22 -0700105 // not really efficient, but this will work only once
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700106 if (m_node == 0)
107 {
Alexander Afanasyev3a4a0b32012-06-28 14:14:22 -0700108 m_node = GetObject<Node> ();
109 if (m_node != 0)
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700110 {
Alexander Afanasyev3a4a0b32012-06-28 14:14:22 -0700111 NS_ASSERT_MSG (m_pit != 0 && m_fib != 0 && m_contentStore != 0 && m_forwardingStrategy != 0,
112 "PIT, FIB, and ContentStore should be aggregated before CcnxL3Protocol");
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700113 }
114 }
Alexander Afanasyev3a4a0b32012-06-28 14:14:22 -0700115 if (m_pit == 0)
116 {
117 m_pit = GetObject<CcnxPit> ();
118 }
119 if (m_fib == 0)
120 {
121 m_fib = GetObject<CcnxFib> ();
122 }
123 if (m_forwardingStrategy == 0)
124 {
125 m_forwardingStrategy = GetObject<CcnxForwardingStrategy> ();
126 }
Alexander Afanasyevd9fecdd2012-06-08 16:22:24 -0700127 if (m_contentStore == 0)
128 {
Alexander Afanasyev3a4a0b32012-06-28 14:14:22 -0700129 m_contentStore = GetObject<CcnxContentStore> ();
Alexander Afanasyevd9fecdd2012-06-08 16:22:24 -0700130 }
131
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700132 Object::NotifyNewAggregate ();
133}
134
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700135void
136CcnxL3Protocol::DoDispose (void)
137{
138 NS_LOG_FUNCTION (this);
139
Alexander Afanasyev45b92d42011-08-14 23:11:38 -0700140 for (CcnxFaceList::iterator i = m_faces.begin (); i != m_faces.end (); ++i)
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700141 {
142 *i = 0;
143 }
Alexander Afanasyev98256102011-08-14 01:00:02 -0700144 m_faces.clear ();
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700145 m_node = 0;
Alexander Afanasyevd02a5d62011-11-21 11:01:51 -0800146
147 // Force delete on objects
Alexander Afanasyev18252852011-11-21 13:35:31 -0800148 m_forwardingStrategy = 0; // there is a reference to PIT stored in here
Alexander Afanasyevd02a5d62011-11-21 11:01:51 -0800149 m_pit = 0;
150 m_contentStore = 0;
Alexander Afanasyev18252852011-11-21 13:35:31 -0800151 m_fib = 0;
152
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700153 Object::DoDispose ();
154}
155
156uint32_t
Alexander Afanasyev7112f482011-08-17 14:05:57 -0700157CcnxL3Protocol::AddFace (const Ptr<CcnxFace> &face)
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700158{
Alexander Afanasyev56f79ea2011-08-17 23:54:27 -0700159 NS_LOG_FUNCTION (this << &face);
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700160
Alexander Afanasyevab1d5602011-08-17 19:17:18 -0700161 face->SetId (m_faceCounter); // sets a unique ID of the face. This ID serves only informational purposes
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700162
Alexander Afanasyeva67e28c2011-08-31 21:16:25 -0700163 // ask face to register in lower-layer stack
Alexander Afanasyev56f79ea2011-08-17 23:54:27 -0700164 face->RegisterProtocolHandler (MakeCallback (&CcnxL3Protocol::Receive, this));
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700165
Alexander Afanasyev45b92d42011-08-14 23:11:38 -0700166 m_faces.push_back (face);
Alexander Afanasyev09c7deb2011-11-23 14:50:10 -0800167 m_faceCounter++;
Alexander Afanasyev0ab833e2011-08-18 15:49:13 -0700168 return face->GetId ();
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700169}
170
Alexander Afanasyevc5a23e22011-09-07 00:37:36 -0700171void
172CcnxL3Protocol::RemoveFace (Ptr<CcnxFace> face)
173{
174 // ask face to register in lower-layer stack
175 face->RegisterProtocolHandler (MakeNullCallback<void,const Ptr<CcnxFace>&,const Ptr<const Packet>&> ());
Alexander Afanasyev09c7deb2011-11-23 14:50:10 -0800176
177 // just to be on a safe side. Do the process in two steps
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700178 std::list< Ptr<CcnxPitEntry> > entriesToRemoves;
179 for (Ptr<CcnxPitEntry> pitEntry = m_pit->Begin (); pitEntry != 0; pitEntry = m_pit->Next (pitEntry))
Alexander Afanasyev09c7deb2011-11-23 14:50:10 -0800180 {
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700181 pitEntry->RemoveAllReferencesToFace (face);
182
183 // If this face is the only for the associated FIB entry, then FIB entry will be removed soon.
184 // Thus, we have to remove the whole PIT entry
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700185 if (pitEntry->GetFibEntry ()->m_faces.size () == 1 &&
186 pitEntry->GetFibEntry ()->m_faces.begin ()->m_face == face)
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700187 {
188 entriesToRemoves.push_back (pitEntry);
189 }
190 }
191 BOOST_FOREACH (Ptr<CcnxPitEntry> removedEntry, entriesToRemoves)
192 {
193 m_pit->MarkErased (removedEntry);
Alexander Afanasyev09c7deb2011-11-23 14:50:10 -0800194 }
195
Alexander Afanasyevc5a23e22011-09-07 00:37:36 -0700196 CcnxFaceList::iterator face_it = find (m_faces.begin(), m_faces.end(), face);
197 NS_ASSERT_MSG (face_it != m_faces.end (), "Attempt to remove face that doesn't exist");
198 m_faces.erase (face_it);
199}
200
Alexander Afanasyev45b92d42011-08-14 23:11:38 -0700201Ptr<CcnxFace>
Alexander Afanasyev98256102011-08-14 01:00:02 -0700202CcnxL3Protocol::GetFace (uint32_t index) const
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700203{
Alexander Afanasyev56f79ea2011-08-17 23:54:27 -0700204 BOOST_FOREACH (const Ptr<CcnxFace> &face, m_faces) // this function is not supposed to be called often, so linear search is fine
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700205 {
Alexander Afanasyev56f79ea2011-08-17 23:54:27 -0700206 if (face->GetId () == index)
207 return face;
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700208 }
209 return 0;
210}
211
Alexander Afanasyev52e9aa92011-11-15 20:23:20 -0800212Ptr<CcnxFace>
213CcnxL3Protocol::GetFaceByNetDevice (Ptr<NetDevice> netDevice) const
214{
215 BOOST_FOREACH (const Ptr<CcnxFace> &face, m_faces) // this function is not supposed to be called often, so linear search is fine
216 {
217 Ptr<CcnxNetDeviceFace> netDeviceFace = DynamicCast<CcnxNetDeviceFace> (face);
218 if (netDeviceFace == 0) continue;
219
220 if (netDeviceFace->GetNetDevice () == netDevice)
221 return face;
222 }
223 return 0;
224}
225
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700226uint32_t
Alexander Afanasyev98256102011-08-14 01:00:02 -0700227CcnxL3Protocol::GetNFaces (void) const
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700228{
Alexander Afanasyev98256102011-08-14 01:00:02 -0700229 return m_faces.size ();
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700230}
231
Alexander Afanasyev98256102011-08-14 01:00:02 -0700232// Callback from lower layer
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700233void
Alexander Afanasyev0ab833e2011-08-18 15:49:13 -0700234CcnxL3Protocol::Receive (const Ptr<CcnxFace> &face, const Ptr<const Packet> &p)
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700235{
Alexander Afanasyevd459ec32012-04-30 13:58:20 -0700236 if (!face->IsUp ())
237 return;
238
239 NS_LOG_DEBUG (*p);
240
Alexander Afanasyevc5a23e22011-09-07 00:37:36 -0700241 NS_LOG_LOGIC ("Packet from face " << *face << " received on node " << m_node->GetId ());
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700242
Alexander Afanasyev45b92d42011-08-14 23:11:38 -0700243 Ptr<Packet> packet = p->Copy (); // give upper layers a rw copy of the packet
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700244 try
245 {
Alexander Afanasyevc5a23e22011-09-07 00:37:36 -0700246 CcnxHeaderHelper::Type type = CcnxHeaderHelper::GetCcnxHeaderType (p);
Alexander Afanasyeva67e28c2011-08-31 21:16:25 -0700247 switch (type)
248 {
249 case CcnxHeaderHelper::INTEREST:
250 {
251 Ptr<CcnxInterestHeader> header = Create<CcnxInterestHeader> ();
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700252
253 // Deserialization. Exception may be thrown
254 packet->RemoveHeader (*header);
255 NS_ASSERT_MSG (packet->GetSize () == 0, "Payload of Interests should be zero");
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800256
257 if (header->GetNack () > 0)
258 OnNack (face, header, p/*original packet*/);
259 else
260 OnInterest (face, header, p/*original packet*/);
Alexander Afanasyeva67e28c2011-08-31 21:16:25 -0700261 break;
262 }
263 case CcnxHeaderHelper::CONTENT_OBJECT:
264 {
265 Ptr<CcnxContentObjectHeader> header = Create<CcnxContentObjectHeader> ();
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700266
267 static CcnxContentObjectTail contentObjectTrailer; //there is no data in this object
268
269 // Deserialization. Exception may be thrown
270 packet->RemoveHeader (*header);
271 packet->RemoveTrailer (contentObjectTrailer);
272
273 OnData (face, header, packet/*payload*/, p/*original packet*/);
Alexander Afanasyeva67e28c2011-08-31 21:16:25 -0700274 break;
275 }
276 }
277
278 // exception will be thrown if packet is not recognized
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700279 }
280 catch (CcnxUnknownHeaderException)
281 {
282 NS_ASSERT_MSG (false, "Unknown CCNx header. Should not happen");
Alexander Afanasyevd459ec32012-04-30 13:58:20 -0700283 NS_LOG_ERROR ("Unknown CCNx header. Should not happen");
284 return;
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700285 }
Alexander Afanasyev98256102011-08-14 01:00:02 -0700286}
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700287
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800288void
Alexander Afanasyev9d313d42011-11-25 13:36:15 -0800289CcnxL3Protocol::OnNack (const Ptr<CcnxFace> &incomingFace,
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800290 Ptr<CcnxInterestHeader> &header,
Alexander Afanasyev9d313d42011-11-25 13:36:15 -0800291 const Ptr<const Packet> &packet)
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800292{
Alexander Afanasyev9d313d42011-11-25 13:36:15 -0800293 NS_LOG_FUNCTION (incomingFace << header << packet);
Alexander Afanasyevf377b332011-12-16 15:32:12 -0800294 m_inNacks (header, incomingFace);
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800295
Alexander Afanasyev11f7bb42012-07-09 17:06:30 -0700296 Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
297 if (pitEntry == 0)
Alexander Afanasyeva7a2b8b2011-11-28 18:19:09 -0800298 {
299 // somebody is doing something bad
Alexander Afanasyevf377b332011-12-16 15:32:12 -0800300 m_dropNacks (header, NON_DUPLICATED, incomingFace);
Alexander Afanasyeva7a2b8b2011-11-28 18:19:09 -0800301 return;
302 }
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800303
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700304 // CcnxPitEntryIncomingFaceContainer::type::iterator inFace = pitEntry->GetIncoming ().find (incomingFace);
305 CcnxPitEntryOutgoingFaceContainer::type::iterator outFace = pitEntry->GetOutgoing ().find (incomingFace);
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800306
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700307 if (outFace == pitEntry->GetOutgoing ().end ())
Alexander Afanasyeva7a2b8b2011-11-28 18:19:09 -0800308 {
Alexander Afanasyev8f5a9bb2011-12-18 19:49:02 -0800309// NS_ASSERT_MSG (false,
310// "Node " << GetObject<Node> ()->GetId () << ", outgoing entry should exist for face " << boost::cref(*incomingFace) << "\n" <<
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700311// "size: " << pitEntry.GetOutgoing ().size ());
Alexander Afanasyeva7a2b8b2011-11-28 18:19:09 -0800312
Alexander Afanasyevf377b332011-12-16 15:32:12 -0800313 // m_dropNacks (header, NON_DUPLICATE, incomingFace);
Alexander Afanasyeva7a2b8b2011-11-28 18:19:09 -0800314 return;
315 }
Alexander Afanasyev9d313d42011-11-25 13:36:15 -0800316
Alexander Afanasyev0a61c342011-12-06 12:48:55 -0800317 // This was done in error. Never, never do anything, except normal leakage. This way we ensure that we will not have losses,
318 // at least when there is only one client
319 //
320 // incomingFace->LeakBucketByOnePacket ();
Alexander Afanasyeve67a97f2011-11-29 14:28:59 -0800321
Alexander Afanasyev23d2b542011-12-07 18:54:46 -0800322 NS_LOG_ERROR ("Nack on " << boost::cref(*incomingFace));
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700323
324 pitEntry->SetWaitingInVain (outFace);
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800325
Alexander Afanasyev9d313d42011-11-25 13:36:15 -0800326 // If NACK is NACK_GIVEUP_PIT, then neighbor gave up trying to and removed it's PIT entry.
327 // So, if we had an incoming entry to this neighbor, then we can remove it now
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800328
Alexander Afanasyev9d313d42011-11-25 13:36:15 -0800329 if (header->GetNack () == CcnxInterestHeader::NACK_GIVEUP_PIT)
330 {
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700331 pitEntry->RemoveIncoming (incomingFace);
Alexander Afanasyev9d313d42011-11-25 13:36:15 -0800332 }
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800333
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700334 pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW);
335 // StaticCast<CcnxFibImpl> (m_fib)->modify (pitEntry->GetFibEntry (),
Alexander Afanasyev1aa4bbc2012-07-09 17:17:25 -0700336 // ll::bind (&CcnxFibEntry::UpdateStatus,
337 // ll::_1, incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW));
Alexander Afanasyeva7a2b8b2011-11-28 18:19:09 -0800338
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700339 if (pitEntry->GetIncoming ().size () == 0) // interest was actually satisfied
Alexander Afanasyev23d2b542011-12-07 18:54:46 -0800340 {
341 // no need to do anything
Alexander Afanasyevf377b332011-12-16 15:32:12 -0800342 m_dropNacks (header, AFTER_SATISFIED, incomingFace);
Alexander Afanasyev23d2b542011-12-07 18:54:46 -0800343 return;
344 }
345
Alexander Afanasyevf034cbd2012-06-29 14:28:31 -0700346 if (!pitEntry->AreAllOutgoingInVain ()) // not all ougtoing are in vain
Alexander Afanasyeva7a2b8b2011-11-28 18:19:09 -0800347 {
Alexander Afanasyev23d2b542011-12-07 18:54:46 -0800348 NS_LOG_DEBUG ("Not all outgoing are in vain");
Alexander Afanasyeva7a2b8b2011-11-28 18:19:09 -0800349 // suppress
350 // Don't do anything, we are still expecting data from some other face
Alexander Afanasyevf377b332011-12-16 15:32:12 -0800351 m_dropNacks (header, SUPPRESSED, incomingFace);
Alexander Afanasyeva7a2b8b2011-11-28 18:19:09 -0800352 return;
353 }
Alexander Afanasyev9d313d42011-11-25 13:36:15 -0800354
Alexander Afanasyev9d313d42011-11-25 13:36:15 -0800355 Ptr<Packet> nonNackInterest = Create<Packet> ();
356 header->SetNack (CcnxInterestHeader::NORMAL_INTEREST);
357 nonNackInterest->AddHeader (*header);
358
359 bool propagated = m_forwardingStrategy->
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700360 PropagateInterest (pitEntry, incomingFace, header, nonNackInterest);
Alexander Afanasyev9d313d42011-11-25 13:36:15 -0800361
Alexander Afanasyev23d2b542011-12-07 18:54:46 -0800362 // // ForwardingStrategy will try its best to forward packet to at least one interface.
363 // // If no interests was propagated, then there is not other option for forwarding or
364 // // ForwardingStrategy failed to find it.
Alexander Afanasyeve67a97f2011-11-29 14:28:59 -0800365 if (!propagated)
Alexander Afanasyevf377b332011-12-16 15:32:12 -0800366 {
367 m_dropNacks (header, NO_FACES, incomingFace); // this headers doesn't have NACK flag set
368 GiveUpInterest (pitEntry, header);
369 }
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800370}
371
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700372// Processing Interests
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800373//
374// !!! Key point.
375// !!! All interests should be answerred!!! Either later with data, immediately with data, or immediately with NACK
Alexander Afanasyeva67e28c2011-08-31 21:16:25 -0700376void CcnxL3Protocol::OnInterest (const Ptr<CcnxFace> &incomingFace,
377 Ptr<CcnxInterestHeader> &header,
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700378 const Ptr<const Packet> &packet)
Alexander Afanasyev98256102011-08-14 01:00:02 -0700379{
Alexander Afanasyevf377b332011-12-16 15:32:12 -0800380 m_inInterests (header, incomingFace);
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700381
Alexander Afanasyev11f7bb42012-07-09 17:06:30 -0700382 Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
383 if (pitEntry == 0)
Alexander Afanasyevf034cbd2012-06-29 14:28:31 -0700384 {
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700385 pitEntry = m_pit->Create (header);
Alexander Afanasyevf034cbd2012-06-29 14:28:31 -0700386 }
Ilya Moiseenkod83eb0d2011-11-16 15:23:46 -0800387
Alexander Afanasyev11f7bb42012-07-09 17:06:30 -0700388 if (pitEntry == 0)
Alexander Afanasyevf034cbd2012-06-29 14:28:31 -0700389 {
390 // if it is still not created, then give up processing
391 m_dropInterests (header, PIT_LIMIT, incomingFace);
392 return;
393 }
394
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700395 bool isNew = pitEntry->GetIncoming ().size () == 0 && pitEntry->GetOutgoing ().size () == 0;
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700396 bool isDuplicated = true;
397 if (!pitEntry->IsNonceSeen (header->GetNonce ()))
398 {
399 pitEntry->AddSeenNonce (header->GetNonce ());
400 isDuplicated = false;
401 }
402
Alexander Afanasyev7f3e49e2012-04-30 00:17:07 -0700403 NS_LOG_FUNCTION (header->GetName () << header->GetNonce () << boost::cref (*incomingFace) << isDuplicated);
404
405 /////////////////////////////////////////////////////////////////////////////////////////
406 /////////////////////////////////////////////////////////////////////////////////////////
407 /////////////////////////////////////////////////////////////////////////////////////////
408 // //
409 // !!!! IMPORTANT CHANGE !!!! Duplicate interests will create incoming face entry !!!! //
410 // //
411 /////////////////////////////////////////////////////////////////////////////////////////
412 /////////////////////////////////////////////////////////////////////////////////////////
413 /////////////////////////////////////////////////////////////////////////////////////////
414
415 // Data is not in cache
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700416 CcnxPitEntry::in_iterator inFace = pitEntry->GetIncoming ().find (incomingFace);
417 CcnxPitEntry::out_iterator outFace = pitEntry->GetOutgoing ().find (incomingFace);
Alexander Afanasyev7f3e49e2012-04-30 00:17:07 -0700418
419 bool isRetransmitted = false;
420
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700421 if (inFace != pitEntry->GetIncoming ().end ())
Alexander Afanasyev7f3e49e2012-04-30 00:17:07 -0700422 {
423 // CcnxPitEntryIncomingFace.m_arrivalTime keeps track arrival time of the first packet... why?
424
425 isRetransmitted = true;
426 // this is almost definitely a retransmission. But should we trust the user on that?
427 }
428 else
429 {
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700430 inFace = pitEntry->AddIncoming (incomingFace);
Alexander Afanasyev7f3e49e2012-04-30 00:17:07 -0700431 }
432 //////////////////////////////////////////////////////////////////////////////////
433 //////////////////////////////////////////////////////////////////////////////////
434 //////////////////////////////////////////////////////////////////////////////////
435
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800436 if (isDuplicated)
Ilya Moiseenko172763c2011-10-28 13:21:53 -0700437 {
Alexander Afanasyev7f3e49e2012-04-30 00:17:07 -0700438 NS_LOG_DEBUG ("Received duplicatie interest on " << *incomingFace);
Alexander Afanasyevf377b332011-12-16 15:32:12 -0800439 m_dropInterests (header, DUPLICATED, incomingFace);
440
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800441 /**
442 * This condition will handle "routing" loops and also recently satisfied interests.
443 * Every time interest is satisfied, PIT entry (with empty incoming and outgoing faces)
444 * is kept for another small chunk of time.
445 */
Ilya Moiseenko172763c2011-10-28 13:21:53 -0700446
Alexander Afanasyevbab81b12012-02-04 14:20:09 -0800447 if (m_nacksEnabled)
448 {
449 NS_LOG_DEBUG ("Sending NACK_LOOP");
450 header->SetNack (CcnxInterestHeader::NACK_LOOP);
451 Ptr<Packet> nack = Create<Packet> ();
452 nack->AddHeader (*header);
453
454 incomingFace->Send (nack);
455 m_outNacks (header, incomingFace);
456 }
Ilya Moiseenko172763c2011-10-28 13:21:53 -0700457
Alexander Afanasyevcf133f02011-09-06 12:13:48 -0700458 return;
459 }
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800460
461 Ptr<Packet> contentObject;
Alexander Afanasyevc86c2832011-12-23 02:56:22 -0800462 Ptr<const CcnxContentObjectHeader> contentObjectHeader; // used for tracing
463 Ptr<const Packet> payload; // used for tracing
464 tie (contentObject, contentObjectHeader, payload) = m_contentStore->Lookup (header);
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800465 if (contentObject != 0)
466 {
Alexander Afanasyev7f3e49e2012-04-30 00:17:07 -0700467 NS_ASSERT (contentObjectHeader != 0);
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800468 NS_LOG_LOGIC("Found in cache");
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800469
Alexander Afanasyevd459ec32012-04-30 13:58:20 -0700470 OnDataDelayed (contentObjectHeader, payload, contentObject);
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800471 return;
472 }
473
Alexander Afanasyev0a61c342011-12-06 12:48:55 -0800474 // update PIT entry lifetime
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700475 pitEntry->UpdateLifetime (header->GetInterestLifetime ());
Alexander Afanasyev0a61c342011-12-06 12:48:55 -0800476
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700477 if (outFace != pitEntry->GetOutgoing ().end ())
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800478 {
Alexander Afanasyeve192a2a2012-04-09 14:57:54 -0700479 NS_LOG_DEBUG ("Non duplicate interests from the face we have sent interest to. Don't suppress");
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800480 // got a non-duplicate interest from the face we have sent interest to
481 // Probably, there is no point in waiting data from that face... Not sure yet
482
483 // If we're expecting data from the interface we got the interest from ("producer" asks us for "his own" data)
484 // Mark interface YELLOW, but keep a small hope that data will come eventually.
485
486 // ?? not sure if we need to do that ?? ...
487
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700488 pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW);
489 // StaticCast<CcnxFibImpl> (m_fib)->modify(pitEntry->GetFibEntry (),
Alexander Afanasyev1aa4bbc2012-07-09 17:17:25 -0700490 // ll::bind (&CcnxFibEntry::UpdateStatus,
491 // ll::_1, incomingFace, CcnxFibFaceMetric::NDN_FIB_YELLOW));
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800492 }
Alexander Afanasyeve192a2a2012-04-09 14:57:54 -0700493 else
494 if (!isNew && !isRetransmitted)
495 {
496 // Suppress this interest if we're still expecting data from some other face
497 NS_LOG_DEBUG ("Suppress interests");
498 m_dropInterests (header, SUPPRESSED, incomingFace);
499 return;
500 }
Alexander Afanasyeva7a2b8b2011-11-28 18:19:09 -0800501
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800502 /////////////////////////////////////////////////////////////////////
503 // Propagate
504 /////////////////////////////////////////////////////////////////////
505
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800506 bool propagated = m_forwardingStrategy->
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700507 PropagateInterest (pitEntry, incomingFace, header, packet);
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800508
Alexander Afanasyevd459ec32012-04-30 13:58:20 -0700509 if (!propagated && isRetransmitted) //give another chance if retransmitted
Alexander Afanasyev0a61c342011-12-06 12:48:55 -0800510 {
511 // increase max number of allowed retransmissions
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700512 pitEntry->IncreaseAllowedRetxCount ();
Alexander Afanasyev0a61c342011-12-06 12:48:55 -0800513
514 // try again
515 propagated = m_forwardingStrategy->
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700516 PropagateInterest (pitEntry, incomingFace, header, packet);
Alexander Afanasyev0a61c342011-12-06 12:48:55 -0800517 }
518
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800519 // ForwardingStrategy will try its best to forward packet to at least one interface.
520 // If no interests was propagated, then there is not other option for forwarding or
521 // ForwardingStrategy failed to find it.
Alexander Afanasyeve67a97f2011-11-29 14:28:59 -0800522 if (!propagated)
Alexander Afanasyev9d313d42011-11-25 13:36:15 -0800523 {
Alexander Afanasyev120bf312011-12-19 01:24:47 -0800524 NS_LOG_DEBUG ("Not propagated");
Alexander Afanasyevf377b332011-12-16 15:32:12 -0800525 m_dropInterests (header, NO_FACES, incomingFace);
526 GiveUpInterest (pitEntry, header);
Alexander Afanasyev9d313d42011-11-25 13:36:15 -0800527 }
Alexander Afanasyev9d313d42011-11-25 13:36:15 -0800528}
529
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -0700530void
Alexander Afanasyev7f3e49e2012-04-30 00:17:07 -0700531CcnxL3Protocol::OnDataDelayed (Ptr<const CcnxContentObjectHeader> header,
532 Ptr<const Packet> payload,
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -0700533 const Ptr<const Packet> &packet)
534{
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -0700535 // 1. Lookup PIT entry
Alexander Afanasyev11f7bb42012-07-09 17:06:30 -0700536 Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
537 if (pitEntry != 0)
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -0700538 {
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -0700539 //satisfy all pending incoming Interests
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700540 BOOST_FOREACH (const CcnxPitEntryIncomingFace &incoming, pitEntry->GetIncoming ())
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -0700541 {
542 incoming.m_face->Send (packet->Copy ());
543 m_outData (header, payload, false, incoming.m_face);
544 NS_LOG_DEBUG ("Satisfy " << *incoming.m_face);
545
546 // successfull forwarded data trace
547 }
548
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700549 if (pitEntry->GetIncoming ().size () > 0)
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -0700550 {
551 // All incoming interests are satisfied. Remove them
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700552 pitEntry->ClearIncoming ();
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -0700553
554 // Remove all outgoing faces
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700555 pitEntry->ClearOutgoing ();
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -0700556
557 // Set pruning timout on PIT entry (instead of deleting the record)
Alexander Afanasyevf034cbd2012-06-29 14:28:31 -0700558 m_pit->MarkErased (pitEntry);
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -0700559 }
560 }
Alexander Afanasyevf034cbd2012-06-29 14:28:31 -0700561 else
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -0700562 {
563 NS_LOG_DEBUG ("Pit entry not found (was satisfied and removed before)");
564 return; // do not process unsoliced data packets
565 }
566}
567
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700568// Processing ContentObjects
Alexander Afanasyev19426ef2011-11-23 20:55:28 -0800569void
570CcnxL3Protocol::OnData (const Ptr<CcnxFace> &incomingFace,
571 Ptr<CcnxContentObjectHeader> &header,
572 Ptr<Packet> &payload,
573 const Ptr<const Packet> &packet)
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700574{
Ilya Moiseenko172763c2011-10-28 13:21:53 -0700575
Alexander Afanasyev1aeaf922012-04-23 13:48:09 -0700576 NS_LOG_FUNCTION (incomingFace << header->GetName () << payload << packet);
Alexander Afanasyevc86c2832011-12-23 02:56:22 -0800577 m_inData (header, payload, incomingFace);
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -0700578
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700579 // 1. Lookup PIT entry
Alexander Afanasyev11f7bb42012-07-09 17:06:30 -0700580 Ptr<CcnxPitEntry> pitEntry = m_pit->Lookup (*header);
581 if (pitEntry != 0)
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700582 {
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700583 // Note that with MultiIndex we need to modify entries indirectly
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700584
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700585 CcnxPitEntry::out_iterator out = pitEntry->GetOutgoing ().find (incomingFace);
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700586
587 // If we have sent interest for this data via this face, then update stats.
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700588 if (out != pitEntry->GetOutgoing ().end ())
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700589 {
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700590 pitEntry->GetFibEntry ()->UpdateFaceRtt (incomingFace, Simulator::Now () - out->m_sendTime);
591 // StaticCast<CcnxFibImpl> (m_fib)->modify (pitEntry->GetFibEntry (),
Alexander Afanasyev1aa4bbc2012-07-09 17:17:25 -0700592 // ll::bind (&CcnxFibEntry::UpdateFaceRtt,
593 // ll::_1,
594 // incomingFace,
595 // Simulator::Now () - out->m_sendTime));
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700596 }
597 else
598 {
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800599 // Unsolicited data, but we're interested in it... should we get it?
600 // Potential hole for attacks
Alexander Afanasyeva46844b2011-11-21 19:13:26 -0800601
Alexander Afanasyevde009992012-02-04 18:54:54 -0800602 if (m_cacheUnsolicitedData)
603 {
604 // Optimistically add or update entry in the content store
605 m_contentStore->Add (header, payload);
606 }
607 else
608 {
609 NS_LOG_ERROR ("Node "<< m_node->GetId() <<
610 ". PIT entry for "<< header->GetName ()<<" is valid, "
611 "but outgoing entry for interface "<< boost::cref(*incomingFace) <<" doesn't exist\n");
612 }
Alexander Afanasyev19426ef2011-11-23 20:55:28 -0800613 // ignore unsolicited data
614 return;
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700615 }
616
Alexander Afanasyev19426ef2011-11-23 20:55:28 -0800617 // Update metric status for the incoming interface in the corresponding FIB entry
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700618 pitEntry->GetFibEntry ()->UpdateStatus (incomingFace, CcnxFibFaceMetric::NDN_FIB_GREEN);
619 // StaticCast<CcnxFibImpl>(m_fib)->modify (pitEntry->GetFibEntry (),
Alexander Afanasyev1aa4bbc2012-07-09 17:17:25 -0700620 // ll::bind (&CcnxFibEntry::UpdateStatus, ll::_1,
621 // incomingFace, CcnxFibFaceMetric::NDN_FIB_GREEN));
Alexander Afanasyev19426ef2011-11-23 20:55:28 -0800622
623 // Add or update entry in the content store
624 m_contentStore->Add (header, payload);
625
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700626 pitEntry->RemoveIncoming (incomingFace);
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -0700627
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700628 if (pitEntry->GetIncoming ().size () == 0)
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700629 {
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -0700630 // Set pruning timout on PIT entry (instead of deleting the record)
Alexander Afanasyevf034cbd2012-06-29 14:28:31 -0700631 m_pit->MarkErased (pitEntry);
Alexander Afanasyevff8c5d62012-04-25 15:14:51 -0700632 }
633 else
634 {
Alexander Afanasyev3a4a0b32012-06-28 14:14:22 -0700635 OnDataDelayed (header, payload, packet);
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700636 }
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700637 }
Alexander Afanasyevf034cbd2012-06-29 14:28:31 -0700638 else
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700639 {
Alexander Afanasyev1aeaf922012-04-23 13:48:09 -0700640 NS_LOG_DEBUG ("Pit entry not found");
Alexander Afanasyevde009992012-02-04 18:54:54 -0800641 if (m_cacheUnsolicitedData)
642 {
643 // Optimistically add or update entry in the content store
644 m_contentStore->Add (header, payload);
645 }
646 else
647 {
648 // Drop data packet if PIT entry is not found
649 // (unsolicited data packets should not "poison" content store)
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700650
Alexander Afanasyevde009992012-02-04 18:54:54 -0800651 //drop dulicated or not requested data packet
652 m_dropData (header, payload, UNSOLICITED, incomingFace);
653 }
Alexander Afanasyev78cf0c92011-09-01 19:57:14 -0700654 return; // do not process unsoliced data packets
655 }
656}
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700657
658void
Alexander Afanasyev11f7bb42012-07-09 17:06:30 -0700659CcnxL3Protocol::GiveUpInterest (Ptr<CcnxPitEntry> pitEntry,
Alexander Afanasyevf377b332011-12-16 15:32:12 -0800660 Ptr<CcnxInterestHeader> header)
661{
Alexander Afanasyevf034cbd2012-06-29 14:28:31 -0700662 NS_LOG_FUNCTION (this);
663
Alexander Afanasyevbab81b12012-02-04 14:20:09 -0800664 if (m_nacksEnabled)
Alexander Afanasyevf377b332011-12-16 15:32:12 -0800665 {
Alexander Afanasyevbab81b12012-02-04 14:20:09 -0800666 Ptr<Packet> packet = Create<Packet> ();
667 header->SetNack (CcnxInterestHeader::NACK_GIVEUP_PIT);
668 packet->AddHeader (*header);
Alexander Afanasyevf377b332011-12-16 15:32:12 -0800669
Alexander Afanasyev36b45772012-07-10 16:57:42 -0700670 BOOST_FOREACH (const CcnxPitEntryIncomingFace &incoming, pitEntry->GetIncoming ())
Alexander Afanasyevbab81b12012-02-04 14:20:09 -0800671 {
Alexander Afanasyevde009992012-02-04 18:54:54 -0800672 NS_LOG_DEBUG ("Send NACK for " << boost::cref (header->GetName ()) << " to " << boost::cref (*incoming.m_face));
Alexander Afanasyevbab81b12012-02-04 14:20:09 -0800673 incoming.m_face->Send (packet->Copy ());
674
675 m_outNacks (header, incoming.m_face);
676 }
Alexander Afanasyevbab81b12012-02-04 14:20:09 -0800677
Alexander Afanasyev1aeaf922012-04-23 13:48:09 -0700678 // All incoming interests cannot be satisfied. Remove them
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700679 pitEntry->ClearIncoming ();
Alexander Afanasyevf377b332011-12-16 15:32:12 -0800680
Alexander Afanasyev1aeaf922012-04-23 13:48:09 -0700681 // Remove also outgoing
Alexander Afanasyev30f60e32012-07-10 14:21:16 -0700682 pitEntry->ClearOutgoing ();
Alexander Afanasyev120bf312011-12-19 01:24:47 -0800683
Alexander Afanasyev1aeaf922012-04-23 13:48:09 -0700684 // Set pruning timout on PIT entry (instead of deleting the record)
Alexander Afanasyevf034cbd2012-06-29 14:28:31 -0700685 m_pit->MarkErased (pitEntry);
Alexander Afanasyev1aeaf922012-04-23 13:48:09 -0700686 }
Alexander Afanasyevf377b332011-12-16 15:32:12 -0800687}
688
Alexander Afanasyev08d984e2011-08-13 19:20:22 -0700689} //namespace ns3