blob: 56012dca26abed0ba2dd073bd6dab6e7c05d1146 [file] [log] [blame]
Alexander Afanasyev33b72772014-01-26 23:22:58 -08001/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2/**
Junxiao Shiaf6569a2014-06-14 00:01:34 -07003 * Copyright (c) 2014, Regents of the University of California,
4 * Arizona Board of Regents,
5 * Colorado State University,
6 * University Pierre & Marie Curie, Sorbonne University,
7 * Washington University in St. Louis,
8 * Beijing Institute of Technology,
9 * The University of Memphis
Alexander Afanasyev9bcbc7c2014-04-06 19:37:37 -070010 *
11 * This file is part of NFD (Named Data Networking Forwarding Daemon).
12 * See AUTHORS.md for complete list of NFD authors and contributors.
13 *
14 * NFD is free software: you can redistribute it and/or modify it under the terms
15 * of the GNU General Public License as published by the Free Software Foundation,
16 * either version 3 of the License, or (at your option) any later version.
17 *
18 * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
19 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
20 * PURPOSE. See the GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License along with
23 * NFD, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
Junxiao Shiaf6569a2014-06-14 00:01:34 -070024 */
Alexander Afanasyev33b72772014-01-26 23:22:58 -080025
26#include "forwarder.hpp"
Steve DiBenedettobf6a93d2014-03-21 14:03:02 -060027#include "core/logger.hpp"
Junxiao Shiaf6569a2014-06-14 00:01:34 -070028#include "core/random.hpp"
Junxiao Shid938a6b2014-05-11 23:40:29 -070029#include "available-strategies.hpp"
Junxiao Shiaf6569a2014-06-14 00:01:34 -070030#include <boost/random/uniform_int_distribution.hpp>
Alexander Afanasyev33b72772014-01-26 23:22:58 -080031
Alexander Afanasyev18bbf812014-01-29 01:40:23 -080032namespace nfd {
Alexander Afanasyev33b72772014-01-26 23:22:58 -080033
Junxiao Shi8c8d2182014-01-30 22:33:00 -070034NFD_LOG_INIT("Forwarder");
35
Junxiao Shif3c07812014-03-11 21:48:49 -070036using fw::Strategy;
37
Junxiao Shif3c07812014-03-11 21:48:49 -070038const Name Forwarder::LOCALHOST_NAME("ndn:/localhost");
Junxiao Shi88884492014-02-15 15:57:43 -070039
Junxiao Shic041ca32014-02-25 20:01:15 -070040Forwarder::Forwarder()
Junxiao Shia4f2be82014-03-02 22:56:41 -070041 : m_faceTable(*this)
HangZhangad4afd12014-03-01 11:03:08 +080042 , m_fib(m_nameTree)
Haowei Yuan78c84d12014-02-27 15:35:13 -060043 , m_pit(m_nameTree)
HangZhangc85a23c2014-03-01 15:55:55 +080044 , m_measurements(m_nameTree)
Junxiao Shif3c07812014-03-11 21:48:49 -070045 , m_strategyChoice(m_nameTree, fw::makeDefaultStrategy(*this))
Alexander Afanasyev33b72772014-01-26 23:22:58 -080046{
Junxiao Shif3c07812014-03-11 21:48:49 -070047 fw::installStrategies(*this);
Alexander Afanasyev33b72772014-01-26 23:22:58 -080048}
49
Steve DiBenedettobf6a93d2014-03-21 14:03:02 -060050Forwarder::~Forwarder()
51{
52
53}
54
Alexander Afanasyev33b72772014-01-26 23:22:58 -080055void
Junxiao Shid3c792f2014-01-30 00:46:13 -070056Forwarder::onIncomingInterest(Face& inFace, const Interest& interest)
57{
58 // receive Interest
Junxiao Shif3c07812014-03-11 21:48:49 -070059 NFD_LOG_DEBUG("onIncomingInterest face=" << inFace.getId() <<
60 " interest=" << interest.getName());
Junxiao Shi06887ac2014-02-13 20:15:42 -070061 const_cast<Interest&>(interest).setIncomingFaceId(inFace.getId());
Junxiao Shi6e694322014-04-03 10:27:13 -070062 m_counters.getNInInterests() ++;
Junxiao Shic041ca32014-02-25 20:01:15 -070063
Junxiao Shi88884492014-02-15 15:57:43 -070064 // /localhost scope control
Junxiao Shif3c07812014-03-11 21:48:49 -070065 bool isViolatingLocalhost = !inFace.isLocal() &&
66 LOCALHOST_NAME.isPrefixOf(interest.getName());
67 if (isViolatingLocalhost) {
68 NFD_LOG_DEBUG("onIncomingInterest face=" << inFace.getId() <<
69 " interest=" << interest.getName() << " violates /localhost");
70 // (drop)
Junxiao Shi88884492014-02-15 15:57:43 -070071 return;
72 }
Junxiao Shic041ca32014-02-25 20:01:15 -070073
Junxiao Shid3c792f2014-01-30 00:46:13 -070074 // PIT insert
Junxiao Shi40631842014-03-01 13:52:37 -070075 shared_ptr<pit::Entry> pitEntry = m_pit.insert(interest).first;
Junxiao Shic041ca32014-02-25 20:01:15 -070076
Junxiao Shid3c792f2014-01-30 00:46:13 -070077 // detect loop and record Nonce
78 bool isLoop = ! pitEntry->addNonce(interest.getNonce());
79 if (isLoop) {
80 // goto Interest loop pipeline
81 this->onInterestLoop(inFace, interest, pitEntry);
82 return;
83 }
Junxiao Shic041ca32014-02-25 20:01:15 -070084
Junxiao Shid3c792f2014-01-30 00:46:13 -070085 // cancel unsatisfy & straggler timer
86 this->cancelUnsatisfyAndStragglerTimer(pitEntry);
Junxiao Shic041ca32014-02-25 20:01:15 -070087
Junxiao Shif3c07812014-03-11 21:48:49 -070088 // is pending?
Junxiao Shid3c792f2014-01-30 00:46:13 -070089 const pit::InRecordCollection& inRecords = pitEntry->getInRecords();
Junxiao Shie17349a2014-03-25 00:55:38 -070090 bool isPending = inRecords.begin() != inRecords.end();
Junxiao Shid3c792f2014-01-30 00:46:13 -070091 if (!isPending) {
92 // CS lookup
93 const Data* csMatch = m_cs.find(interest);
94 if (csMatch != 0) {
95 // XXX should we lookup PIT for other Interests that also match csMatch?
96
97 // goto outgoing Data pipeline
98 this->onOutgoingData(*csMatch, inFace);
99 return;
100 }
101 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700102
Junxiao Shid3c792f2014-01-30 00:46:13 -0700103 // insert InRecord
Junxiao Shi9b27bd22014-02-26 20:29:58 -0700104 pitEntry->insertOrUpdateInRecord(inFace.shared_from_this(), interest);
Junxiao Shic041ca32014-02-25 20:01:15 -0700105
Junxiao Shid3c792f2014-01-30 00:46:13 -0700106 // FIB lookup
Junxiao Shi40631842014-03-01 13:52:37 -0700107 shared_ptr<fib::Entry> fibEntry = m_fib.findLongestPrefixMatch(*pitEntry);
Junxiao Shic041ca32014-02-25 20:01:15 -0700108
Junxiao Shid3c792f2014-01-30 00:46:13 -0700109 // dispatch to strategy
Junxiao Shif3c07812014-03-11 21:48:49 -0700110 this->dispatchToStrategy(pitEntry, bind(&Strategy::afterReceiveInterest, _1,
Alexander Afanasyevf6980282014-05-13 18:28:40 -0700111 cref(inFace), cref(interest), fibEntry, pitEntry));
Junxiao Shid3c792f2014-01-30 00:46:13 -0700112}
113
114void
115Forwarder::onInterestLoop(Face& inFace, const Interest& interest,
116 shared_ptr<pit::Entry> pitEntry)
117{
Junxiao Shif3c07812014-03-11 21:48:49 -0700118 NFD_LOG_DEBUG("onInterestLoop face=" << inFace.getId() <<
119 " interest=" << interest.getName());
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700120
Junxiao Shif3c07812014-03-11 21:48:49 -0700121 // (drop)
122}
123
124/** \brief compare two InRecords for picking outgoing Interest
125 * \return true if b is preferred over a
126 *
127 * This function should be passed to std::max_element over InRecordCollection.
128 * The outgoing Interest picked is the last incoming Interest
129 * that does not come from outFace.
130 * If all InRecords come from outFace, it's fine to pick that. This happens when
131 * there's only one InRecord that comes from outFace. The legit use is for
132 * vehicular network; otherwise, strategy shouldn't send to the sole inFace.
133 */
134static inline bool
135compare_pickInterest(const pit::InRecord& a, const pit::InRecord& b, const Face* outFace)
136{
137 bool isOutFaceA = a.getFace().get() == outFace;
138 bool isOutFaceB = b.getFace().get() == outFace;
139
140 if (!isOutFaceA && isOutFaceB) {
141 return false;
142 }
143 if (isOutFaceA && !isOutFaceB) {
144 return true;
145 }
146
147 return a.getLastRenewed() > b.getLastRenewed();
Junxiao Shid3c792f2014-01-30 00:46:13 -0700148}
149
150void
Junxiao Shid938a6b2014-05-11 23:40:29 -0700151Forwarder::onOutgoingInterest(shared_ptr<pit::Entry> pitEntry, Face& outFace,
152 bool wantNewNonce)
Junxiao Shid3c792f2014-01-30 00:46:13 -0700153{
Junxiao Shi223271b2014-07-03 22:06:13 -0700154 if (outFace.getId() == INVALID_FACEID) {
155 NFD_LOG_WARN("onOutgoingInterest face=invalid interest=" << pitEntry->getName());
156 return;
157 }
Junxiao Shif3c07812014-03-11 21:48:49 -0700158 NFD_LOG_DEBUG("onOutgoingInterest face=" << outFace.getId() <<
159 " interest=" << pitEntry->getName());
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700160
Junxiao Shi57f0f312014-03-16 11:52:20 -0700161 // scope control
162 if (pitEntry->violatesScope(outFace)) {
Junxiao Shif3c07812014-03-11 21:48:49 -0700163 NFD_LOG_DEBUG("onOutgoingInterest face=" << outFace.getId() <<
Junxiao Shi57f0f312014-03-16 11:52:20 -0700164 " interest=" << pitEntry->getName() << " violates scope");
Junxiao Shi11bd9c22014-03-13 20:44:13 -0700165 return;
166 }
167
Junxiao Shid3c792f2014-01-30 00:46:13 -0700168 // pick Interest
Junxiao Shif3c07812014-03-11 21:48:49 -0700169 const pit::InRecordCollection& inRecords = pitEntry->getInRecords();
170 pit::InRecordCollection::const_iterator pickedInRecord = std::max_element(
171 inRecords.begin(), inRecords.end(), bind(&compare_pickInterest, _1, _2, &outFace));
172 BOOST_ASSERT(pickedInRecord != inRecords.end());
Junxiao Shid938a6b2014-05-11 23:40:29 -0700173 shared_ptr<Interest> interest = const_pointer_cast<Interest>(
174 pickedInRecord->getInterest().shared_from_this());
175
176 if (wantNewNonce) {
177 interest = make_shared<Interest>(*interest);
Junxiao Shiaf6569a2014-06-14 00:01:34 -0700178 static boost::random::uniform_int_distribution<uint32_t> dist;
179 interest->setNonce(dist(getGlobalRng()));
Junxiao Shid938a6b2014-05-11 23:40:29 -0700180 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700181
Junxiao Shid3c792f2014-01-30 00:46:13 -0700182 // insert OutRecord
Junxiao Shid938a6b2014-05-11 23:40:29 -0700183 pitEntry->insertOrUpdateOutRecord(outFace.shared_from_this(), *interest);
Junxiao Shic041ca32014-02-25 20:01:15 -0700184
Junxiao Shid3c792f2014-01-30 00:46:13 -0700185 // set PIT unsatisfy timer
186 this->setUnsatisfyTimer(pitEntry);
Junxiao Shic041ca32014-02-25 20:01:15 -0700187
Junxiao Shid3c792f2014-01-30 00:46:13 -0700188 // send Interest
Junxiao Shid938a6b2014-05-11 23:40:29 -0700189 outFace.sendInterest(*interest);
Junxiao Shi6e694322014-04-03 10:27:13 -0700190 m_counters.getNOutInterests() ++;
Junxiao Shid3c792f2014-01-30 00:46:13 -0700191}
192
193void
Junxiao Shi09498f02014-02-26 19:41:08 -0700194Forwarder::onInterestReject(shared_ptr<pit::Entry> pitEntry)
Junxiao Shid3c792f2014-01-30 00:46:13 -0700195{
Junxiao Shid938a6b2014-05-11 23:40:29 -0700196 if (pitEntry->hasUnexpiredOutRecords()) {
197 NFD_LOG_ERROR("onInterestReject interest=" << pitEntry->getName() <<
198 " cannot reject forwarded Interest");
199 return;
200 }
Junxiao Shi09498f02014-02-26 19:41:08 -0700201 NFD_LOG_DEBUG("onInterestReject interest=" << pitEntry->getName());
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700202
Junxiao Shid3c792f2014-01-30 00:46:13 -0700203 // set PIT straggler timer
204 this->setStragglerTimer(pitEntry);
205}
206
207void
208Forwarder::onInterestUnsatisfied(shared_ptr<pit::Entry> pitEntry)
209{
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700210 NFD_LOG_DEBUG("onInterestUnsatisfied interest=" << pitEntry->getName());
211
Junxiao Shid3c792f2014-01-30 00:46:13 -0700212 // invoke PIT unsatisfied callback
Junxiao Shif3c07812014-03-11 21:48:49 -0700213 this->dispatchToStrategy(pitEntry, bind(&Strategy::beforeExpirePendingInterest, _1,
Alexander Afanasyevf6980282014-05-13 18:28:40 -0700214 pitEntry));
Junxiao Shic041ca32014-02-25 20:01:15 -0700215
Junxiao Shif3c07812014-03-11 21:48:49 -0700216 // PIT delete
Junxiao Shid938a6b2014-05-11 23:40:29 -0700217 this->cancelUnsatisfyAndStragglerTimer(pitEntry);
Haowei Yuan78c84d12014-02-27 15:35:13 -0600218 m_pit.erase(pitEntry);
Junxiao Shid3c792f2014-01-30 00:46:13 -0700219}
220
221void
222Forwarder::onIncomingData(Face& inFace, const Data& data)
223{
224 // receive Data
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700225 NFD_LOG_DEBUG("onIncomingData face=" << inFace.getId() << " data=" << data.getName());
Junxiao Shi06887ac2014-02-13 20:15:42 -0700226 const_cast<Data&>(data).setIncomingFaceId(inFace.getId());
Junxiao Shi6e694322014-04-03 10:27:13 -0700227 m_counters.getNInDatas() ++;
Junxiao Shic041ca32014-02-25 20:01:15 -0700228
Junxiao Shi88884492014-02-15 15:57:43 -0700229 // /localhost scope control
Junxiao Shif3c07812014-03-11 21:48:49 -0700230 bool isViolatingLocalhost = !inFace.isLocal() &&
231 LOCALHOST_NAME.isPrefixOf(data.getName());
232 if (isViolatingLocalhost) {
233 NFD_LOG_DEBUG("onIncomingData face=" << inFace.getId() <<
234 " data=" << data.getName() << " violates /localhost");
235 // (drop)
Junxiao Shi88884492014-02-15 15:57:43 -0700236 return;
237 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700238
Junxiao Shid3c792f2014-01-30 00:46:13 -0700239 // PIT match
240 shared_ptr<pit::DataMatchResult> pitMatches = m_pit.findAllDataMatches(data);
241 if (pitMatches->begin() == pitMatches->end()) {
242 // goto Data unsolicited pipeline
243 this->onDataUnsolicited(inFace, data);
244 return;
245 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700246
Junxiao Shid3c792f2014-01-30 00:46:13 -0700247 // CS insert
248 m_cs.insert(data);
Junxiao Shic041ca32014-02-25 20:01:15 -0700249
Junxiao Shid3c792f2014-01-30 00:46:13 -0700250 std::set<shared_ptr<Face> > pendingDownstreams;
251 // foreach PitEntry
252 for (pit::DataMatchResult::iterator it = pitMatches->begin();
253 it != pitMatches->end(); ++it) {
254 shared_ptr<pit::Entry> pitEntry = *it;
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700255 NFD_LOG_DEBUG("onIncomingData matching=" << pitEntry->getName());
Junxiao Shic041ca32014-02-25 20:01:15 -0700256
Junxiao Shid3c792f2014-01-30 00:46:13 -0700257 // cancel unsatisfy & straggler timer
258 this->cancelUnsatisfyAndStragglerTimer(pitEntry);
Junxiao Shic041ca32014-02-25 20:01:15 -0700259
Junxiao Shid3c792f2014-01-30 00:46:13 -0700260 // remember pending downstreams
261 const pit::InRecordCollection& inRecords = pitEntry->getInRecords();
262 for (pit::InRecordCollection::const_iterator it = inRecords.begin();
263 it != inRecords.end(); ++it) {
Alexander Afanasyeveb3197f2014-03-17 19:28:18 -0700264 if (it->getExpiry() > time::steady_clock::now()) {
Junxiao Shid3c792f2014-01-30 00:46:13 -0700265 pendingDownstreams.insert(it->getFace());
266 }
267 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700268
Junxiao Shid938a6b2014-05-11 23:40:29 -0700269 // invoke PIT satisfy callback
270 this->dispatchToStrategy(pitEntry, bind(&Strategy::beforeSatisfyPendingInterest, _1,
271 pitEntry, cref(inFace), cref(data)));
272
Junxiao Shid3c792f2014-01-30 00:46:13 -0700273 // mark PIT satisfied
274 pitEntry->deleteInRecords();
275 pitEntry->deleteOutRecord(inFace.shared_from_this());
Junxiao Shic041ca32014-02-25 20:01:15 -0700276
Junxiao Shid3c792f2014-01-30 00:46:13 -0700277 // set PIT straggler timer
278 this->setStragglerTimer(pitEntry);
Junxiao Shid3c792f2014-01-30 00:46:13 -0700279 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700280
Junxiao Shid3c792f2014-01-30 00:46:13 -0700281 // foreach pending downstream
282 for (std::set<shared_ptr<Face> >::iterator it = pendingDownstreams.begin();
283 it != pendingDownstreams.end(); ++it) {
Junxiao Shida006f52014-05-16 11:18:00 -0700284 shared_ptr<Face> pendingDownstream = *it;
285 if (pendingDownstream.get() == &inFace) {
286 continue;
287 }
Junxiao Shid3c792f2014-01-30 00:46:13 -0700288 // goto outgoing Data pipeline
Junxiao Shida006f52014-05-16 11:18:00 -0700289 this->onOutgoingData(data, *pendingDownstream);
Junxiao Shid3c792f2014-01-30 00:46:13 -0700290 }
291}
292
293void
294Forwarder::onDataUnsolicited(Face& inFace, const Data& data)
295{
296 // accept to cache?
Junxiao Shif3c07812014-03-11 21:48:49 -0700297 bool acceptToCache = inFace.isLocal();
Junxiao Shid3c792f2014-01-30 00:46:13 -0700298 if (acceptToCache) {
299 // CS insert
Junxiao Shif3c07812014-03-11 21:48:49 -0700300 m_cs.insert(data, true);
Junxiao Shid3c792f2014-01-30 00:46:13 -0700301 }
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700302
Junxiao Shif3c07812014-03-11 21:48:49 -0700303 NFD_LOG_DEBUG("onDataUnsolicited face=" << inFace.getId() <<
304 " data=" << data.getName() <<
305 (acceptToCache ? " cached" : " not cached"));
Junxiao Shid3c792f2014-01-30 00:46:13 -0700306}
307
308void
309Forwarder::onOutgoingData(const Data& data, Face& outFace)
310{
Junxiao Shi223271b2014-07-03 22:06:13 -0700311 if (outFace.getId() == INVALID_FACEID) {
312 NFD_LOG_WARN("onOutgoingData face=invalid data=" << data.getName());
313 return;
314 }
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700315 NFD_LOG_DEBUG("onOutgoingData face=" << outFace.getId() << " data=" << data.getName());
316
Junxiao Shi9b27bd22014-02-26 20:29:58 -0700317 // /localhost scope control
Junxiao Shif3c07812014-03-11 21:48:49 -0700318 bool isViolatingLocalhost = !outFace.isLocal() &&
319 LOCALHOST_NAME.isPrefixOf(data.getName());
320 if (isViolatingLocalhost) {
321 NFD_LOG_DEBUG("onOutgoingData face=" << outFace.getId() <<
322 " data=" << data.getName() << " violates /localhost");
323 // (drop)
Junxiao Shi9b27bd22014-02-26 20:29:58 -0700324 return;
325 }
326
Junxiao Shif3c07812014-03-11 21:48:49 -0700327 // TODO traffic manager
Junxiao Shic041ca32014-02-25 20:01:15 -0700328
Junxiao Shid3c792f2014-01-30 00:46:13 -0700329 // send Data
330 outFace.sendData(data);
Junxiao Shi6e694322014-04-03 10:27:13 -0700331 m_counters.getNOutDatas() ++;
Junxiao Shid3c792f2014-01-30 00:46:13 -0700332}
333
334static inline bool
335compare_InRecord_expiry(const pit::InRecord& a, const pit::InRecord& b)
336{
337 return a.getExpiry() < b.getExpiry();
338}
339
340void
341Forwarder::setUnsatisfyTimer(shared_ptr<pit::Entry> pitEntry)
342{
343 const pit::InRecordCollection& inRecords = pitEntry->getInRecords();
344 pit::InRecordCollection::const_iterator lastExpiring =
345 std::max_element(inRecords.begin(), inRecords.end(),
346 &compare_InRecord_expiry);
347
Alexander Afanasyeveb3197f2014-03-17 19:28:18 -0700348 time::steady_clock::TimePoint lastExpiry = lastExpiring->getExpiry();
349 time::nanoseconds lastExpiryFromNow = lastExpiry - time::steady_clock::now();
Junxiao Shid3c792f2014-01-30 00:46:13 -0700350 if (lastExpiryFromNow <= time::seconds(0)) {
351 // TODO all InRecords are already expired; will this happen?
352 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700353
Junxiao Shi9f7455b2014-04-07 21:02:16 -0700354 scheduler::cancel(pitEntry->m_unsatisfyTimer);
Junxiao Shic041ca32014-02-25 20:01:15 -0700355 pitEntry->m_unsatisfyTimer = scheduler::schedule(lastExpiryFromNow,
Junxiao Shid3c792f2014-01-30 00:46:13 -0700356 bind(&Forwarder::onInterestUnsatisfied, this, pitEntry));
357}
358
359void
360Forwarder::setStragglerTimer(shared_ptr<pit::Entry> pitEntry)
361{
Junxiao Shi57f0f312014-03-16 11:52:20 -0700362 if (pitEntry->hasUnexpiredOutRecords()) {
363 NFD_LOG_DEBUG("setStragglerTimer " << pitEntry->getName() <<
364 " cannot set StragglerTimer when an OutRecord is pending");
365 return;
366 }
367
Alexander Afanasyeveb3197f2014-03-17 19:28:18 -0700368 time::nanoseconds stragglerTime = time::milliseconds(100);
Junxiao Shic041ca32014-02-25 20:01:15 -0700369
Junxiao Shi9f7455b2014-04-07 21:02:16 -0700370 scheduler::cancel(pitEntry->m_stragglerTimer);
Junxiao Shic041ca32014-02-25 20:01:15 -0700371 pitEntry->m_stragglerTimer = scheduler::schedule(stragglerTime,
Haowei Yuan78c84d12014-02-27 15:35:13 -0600372 bind(&Pit::erase, &m_pit, pitEntry));
Junxiao Shid3c792f2014-01-30 00:46:13 -0700373}
374
375void
376Forwarder::cancelUnsatisfyAndStragglerTimer(shared_ptr<pit::Entry> pitEntry)
377{
Junxiao Shic041ca32014-02-25 20:01:15 -0700378 scheduler::cancel(pitEntry->m_unsatisfyTimer);
379 scheduler::cancel(pitEntry->m_stragglerTimer);
Junxiao Shid3c792f2014-01-30 00:46:13 -0700380}
381
Alexander Afanasyev18bbf812014-01-29 01:40:23 -0800382} // namespace nfd