blob: 0e2f0d2ffa3e5a57fcec5895aadf525822f711ee [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
Alexander Afanasyeva57f8b42014-07-10 20:11:32 -0700106 // set PIT unsatisfy timer
107 this->setUnsatisfyTimer(pitEntry);
108
Junxiao Shid3c792f2014-01-30 00:46:13 -0700109 // FIB lookup
Junxiao Shi40631842014-03-01 13:52:37 -0700110 shared_ptr<fib::Entry> fibEntry = m_fib.findLongestPrefixMatch(*pitEntry);
Junxiao Shic041ca32014-02-25 20:01:15 -0700111
Junxiao Shid3c792f2014-01-30 00:46:13 -0700112 // dispatch to strategy
Junxiao Shif3c07812014-03-11 21:48:49 -0700113 this->dispatchToStrategy(pitEntry, bind(&Strategy::afterReceiveInterest, _1,
Alexander Afanasyevf6980282014-05-13 18:28:40 -0700114 cref(inFace), cref(interest), fibEntry, pitEntry));
Junxiao Shid3c792f2014-01-30 00:46:13 -0700115}
116
117void
118Forwarder::onInterestLoop(Face& inFace, const Interest& interest,
119 shared_ptr<pit::Entry> pitEntry)
120{
Junxiao Shif3c07812014-03-11 21:48:49 -0700121 NFD_LOG_DEBUG("onInterestLoop face=" << inFace.getId() <<
122 " interest=" << interest.getName());
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700123
Junxiao Shif3c07812014-03-11 21:48:49 -0700124 // (drop)
125}
126
127/** \brief compare two InRecords for picking outgoing Interest
128 * \return true if b is preferred over a
129 *
130 * This function should be passed to std::max_element over InRecordCollection.
131 * The outgoing Interest picked is the last incoming Interest
132 * that does not come from outFace.
133 * If all InRecords come from outFace, it's fine to pick that. This happens when
134 * there's only one InRecord that comes from outFace. The legit use is for
135 * vehicular network; otherwise, strategy shouldn't send to the sole inFace.
136 */
137static inline bool
138compare_pickInterest(const pit::InRecord& a, const pit::InRecord& b, const Face* outFace)
139{
140 bool isOutFaceA = a.getFace().get() == outFace;
141 bool isOutFaceB = b.getFace().get() == outFace;
142
143 if (!isOutFaceA && isOutFaceB) {
144 return false;
145 }
146 if (isOutFaceA && !isOutFaceB) {
147 return true;
148 }
149
150 return a.getLastRenewed() > b.getLastRenewed();
Junxiao Shid3c792f2014-01-30 00:46:13 -0700151}
152
153void
Junxiao Shid938a6b2014-05-11 23:40:29 -0700154Forwarder::onOutgoingInterest(shared_ptr<pit::Entry> pitEntry, Face& outFace,
155 bool wantNewNonce)
Junxiao Shid3c792f2014-01-30 00:46:13 -0700156{
Junxiao Shi223271b2014-07-03 22:06:13 -0700157 if (outFace.getId() == INVALID_FACEID) {
158 NFD_LOG_WARN("onOutgoingInterest face=invalid interest=" << pitEntry->getName());
159 return;
160 }
Junxiao Shif3c07812014-03-11 21:48:49 -0700161 NFD_LOG_DEBUG("onOutgoingInterest face=" << outFace.getId() <<
162 " interest=" << pitEntry->getName());
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700163
Junxiao Shi57f0f312014-03-16 11:52:20 -0700164 // scope control
165 if (pitEntry->violatesScope(outFace)) {
Junxiao Shif3c07812014-03-11 21:48:49 -0700166 NFD_LOG_DEBUG("onOutgoingInterest face=" << outFace.getId() <<
Junxiao Shi57f0f312014-03-16 11:52:20 -0700167 " interest=" << pitEntry->getName() << " violates scope");
Junxiao Shi11bd9c22014-03-13 20:44:13 -0700168 return;
169 }
170
Junxiao Shid3c792f2014-01-30 00:46:13 -0700171 // pick Interest
Junxiao Shif3c07812014-03-11 21:48:49 -0700172 const pit::InRecordCollection& inRecords = pitEntry->getInRecords();
173 pit::InRecordCollection::const_iterator pickedInRecord = std::max_element(
174 inRecords.begin(), inRecords.end(), bind(&compare_pickInterest, _1, _2, &outFace));
175 BOOST_ASSERT(pickedInRecord != inRecords.end());
Junxiao Shid938a6b2014-05-11 23:40:29 -0700176 shared_ptr<Interest> interest = const_pointer_cast<Interest>(
177 pickedInRecord->getInterest().shared_from_this());
178
179 if (wantNewNonce) {
180 interest = make_shared<Interest>(*interest);
Junxiao Shiaf6569a2014-06-14 00:01:34 -0700181 static boost::random::uniform_int_distribution<uint32_t> dist;
182 interest->setNonce(dist(getGlobalRng()));
Junxiao Shid938a6b2014-05-11 23:40:29 -0700183 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700184
Junxiao Shid3c792f2014-01-30 00:46:13 -0700185 // insert OutRecord
Junxiao Shid938a6b2014-05-11 23:40:29 -0700186 pitEntry->insertOrUpdateOutRecord(outFace.shared_from_this(), *interest);
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
Alexander Afanasyeva57f8b42014-07-10 20:11:32 -0700203 // cancel unsatisfy & straggler timer
204 this->cancelUnsatisfyAndStragglerTimer(pitEntry);
205
Junxiao Shid3c792f2014-01-30 00:46:13 -0700206 // set PIT straggler timer
207 this->setStragglerTimer(pitEntry);
208}
209
210void
211Forwarder::onInterestUnsatisfied(shared_ptr<pit::Entry> pitEntry)
212{
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700213 NFD_LOG_DEBUG("onInterestUnsatisfied interest=" << pitEntry->getName());
214
Junxiao Shid3c792f2014-01-30 00:46:13 -0700215 // invoke PIT unsatisfied callback
Junxiao Shif3c07812014-03-11 21:48:49 -0700216 this->dispatchToStrategy(pitEntry, bind(&Strategy::beforeExpirePendingInterest, _1,
Alexander Afanasyevf6980282014-05-13 18:28:40 -0700217 pitEntry));
Junxiao Shic041ca32014-02-25 20:01:15 -0700218
Junxiao Shif3c07812014-03-11 21:48:49 -0700219 // PIT delete
Junxiao Shid938a6b2014-05-11 23:40:29 -0700220 this->cancelUnsatisfyAndStragglerTimer(pitEntry);
Haowei Yuan78c84d12014-02-27 15:35:13 -0600221 m_pit.erase(pitEntry);
Junxiao Shid3c792f2014-01-30 00:46:13 -0700222}
223
224void
225Forwarder::onIncomingData(Face& inFace, const Data& data)
226{
227 // receive Data
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700228 NFD_LOG_DEBUG("onIncomingData face=" << inFace.getId() << " data=" << data.getName());
Junxiao Shi06887ac2014-02-13 20:15:42 -0700229 const_cast<Data&>(data).setIncomingFaceId(inFace.getId());
Junxiao Shi6e694322014-04-03 10:27:13 -0700230 m_counters.getNInDatas() ++;
Junxiao Shic041ca32014-02-25 20:01:15 -0700231
Junxiao Shi88884492014-02-15 15:57:43 -0700232 // /localhost scope control
Junxiao Shif3c07812014-03-11 21:48:49 -0700233 bool isViolatingLocalhost = !inFace.isLocal() &&
234 LOCALHOST_NAME.isPrefixOf(data.getName());
235 if (isViolatingLocalhost) {
236 NFD_LOG_DEBUG("onIncomingData face=" << inFace.getId() <<
237 " data=" << data.getName() << " violates /localhost");
238 // (drop)
Junxiao Shi88884492014-02-15 15:57:43 -0700239 return;
240 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700241
Junxiao Shid3c792f2014-01-30 00:46:13 -0700242 // PIT match
243 shared_ptr<pit::DataMatchResult> pitMatches = m_pit.findAllDataMatches(data);
244 if (pitMatches->begin() == pitMatches->end()) {
245 // goto Data unsolicited pipeline
246 this->onDataUnsolicited(inFace, data);
247 return;
248 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700249
Junxiao Shid3c792f2014-01-30 00:46:13 -0700250 // CS insert
251 m_cs.insert(data);
Junxiao Shic041ca32014-02-25 20:01:15 -0700252
Junxiao Shid3c792f2014-01-30 00:46:13 -0700253 std::set<shared_ptr<Face> > pendingDownstreams;
254 // foreach PitEntry
255 for (pit::DataMatchResult::iterator it = pitMatches->begin();
256 it != pitMatches->end(); ++it) {
257 shared_ptr<pit::Entry> pitEntry = *it;
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700258 NFD_LOG_DEBUG("onIncomingData matching=" << pitEntry->getName());
Junxiao Shic041ca32014-02-25 20:01:15 -0700259
Junxiao Shid3c792f2014-01-30 00:46:13 -0700260 // cancel unsatisfy & straggler timer
261 this->cancelUnsatisfyAndStragglerTimer(pitEntry);
Junxiao Shic041ca32014-02-25 20:01:15 -0700262
Junxiao Shid3c792f2014-01-30 00:46:13 -0700263 // remember pending downstreams
264 const pit::InRecordCollection& inRecords = pitEntry->getInRecords();
265 for (pit::InRecordCollection::const_iterator it = inRecords.begin();
266 it != inRecords.end(); ++it) {
Alexander Afanasyeveb3197f2014-03-17 19:28:18 -0700267 if (it->getExpiry() > time::steady_clock::now()) {
Junxiao Shid3c792f2014-01-30 00:46:13 -0700268 pendingDownstreams.insert(it->getFace());
269 }
270 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700271
Junxiao Shid938a6b2014-05-11 23:40:29 -0700272 // invoke PIT satisfy callback
273 this->dispatchToStrategy(pitEntry, bind(&Strategy::beforeSatisfyPendingInterest, _1,
274 pitEntry, cref(inFace), cref(data)));
275
Junxiao Shid3c792f2014-01-30 00:46:13 -0700276 // mark PIT satisfied
277 pitEntry->deleteInRecords();
278 pitEntry->deleteOutRecord(inFace.shared_from_this());
Junxiao Shic041ca32014-02-25 20:01:15 -0700279
Junxiao Shid3c792f2014-01-30 00:46:13 -0700280 // set PIT straggler timer
281 this->setStragglerTimer(pitEntry);
Junxiao Shid3c792f2014-01-30 00:46:13 -0700282 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700283
Junxiao Shid3c792f2014-01-30 00:46:13 -0700284 // foreach pending downstream
285 for (std::set<shared_ptr<Face> >::iterator it = pendingDownstreams.begin();
286 it != pendingDownstreams.end(); ++it) {
Junxiao Shida006f52014-05-16 11:18:00 -0700287 shared_ptr<Face> pendingDownstream = *it;
288 if (pendingDownstream.get() == &inFace) {
289 continue;
290 }
Junxiao Shid3c792f2014-01-30 00:46:13 -0700291 // goto outgoing Data pipeline
Junxiao Shida006f52014-05-16 11:18:00 -0700292 this->onOutgoingData(data, *pendingDownstream);
Junxiao Shid3c792f2014-01-30 00:46:13 -0700293 }
294}
295
296void
297Forwarder::onDataUnsolicited(Face& inFace, const Data& data)
298{
299 // accept to cache?
Junxiao Shif3c07812014-03-11 21:48:49 -0700300 bool acceptToCache = inFace.isLocal();
Junxiao Shid3c792f2014-01-30 00:46:13 -0700301 if (acceptToCache) {
302 // CS insert
Junxiao Shif3c07812014-03-11 21:48:49 -0700303 m_cs.insert(data, true);
Junxiao Shid3c792f2014-01-30 00:46:13 -0700304 }
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700305
Junxiao Shif3c07812014-03-11 21:48:49 -0700306 NFD_LOG_DEBUG("onDataUnsolicited face=" << inFace.getId() <<
307 " data=" << data.getName() <<
308 (acceptToCache ? " cached" : " not cached"));
Junxiao Shid3c792f2014-01-30 00:46:13 -0700309}
310
311void
312Forwarder::onOutgoingData(const Data& data, Face& outFace)
313{
Junxiao Shi223271b2014-07-03 22:06:13 -0700314 if (outFace.getId() == INVALID_FACEID) {
315 NFD_LOG_WARN("onOutgoingData face=invalid data=" << data.getName());
316 return;
317 }
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700318 NFD_LOG_DEBUG("onOutgoingData face=" << outFace.getId() << " data=" << data.getName());
319
Junxiao Shi9b27bd22014-02-26 20:29:58 -0700320 // /localhost scope control
Junxiao Shif3c07812014-03-11 21:48:49 -0700321 bool isViolatingLocalhost = !outFace.isLocal() &&
322 LOCALHOST_NAME.isPrefixOf(data.getName());
323 if (isViolatingLocalhost) {
324 NFD_LOG_DEBUG("onOutgoingData face=" << outFace.getId() <<
325 " data=" << data.getName() << " violates /localhost");
326 // (drop)
Junxiao Shi9b27bd22014-02-26 20:29:58 -0700327 return;
328 }
329
Junxiao Shif3c07812014-03-11 21:48:49 -0700330 // TODO traffic manager
Junxiao Shic041ca32014-02-25 20:01:15 -0700331
Junxiao Shid3c792f2014-01-30 00:46:13 -0700332 // send Data
333 outFace.sendData(data);
Junxiao Shi6e694322014-04-03 10:27:13 -0700334 m_counters.getNOutDatas() ++;
Junxiao Shid3c792f2014-01-30 00:46:13 -0700335}
336
337static inline bool
338compare_InRecord_expiry(const pit::InRecord& a, const pit::InRecord& b)
339{
340 return a.getExpiry() < b.getExpiry();
341}
342
343void
344Forwarder::setUnsatisfyTimer(shared_ptr<pit::Entry> pitEntry)
345{
346 const pit::InRecordCollection& inRecords = pitEntry->getInRecords();
347 pit::InRecordCollection::const_iterator lastExpiring =
348 std::max_element(inRecords.begin(), inRecords.end(),
349 &compare_InRecord_expiry);
350
Alexander Afanasyeveb3197f2014-03-17 19:28:18 -0700351 time::steady_clock::TimePoint lastExpiry = lastExpiring->getExpiry();
352 time::nanoseconds lastExpiryFromNow = lastExpiry - time::steady_clock::now();
Junxiao Shid3c792f2014-01-30 00:46:13 -0700353 if (lastExpiryFromNow <= time::seconds(0)) {
354 // TODO all InRecords are already expired; will this happen?
355 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700356
Junxiao Shi9f7455b2014-04-07 21:02:16 -0700357 scheduler::cancel(pitEntry->m_unsatisfyTimer);
Junxiao Shic041ca32014-02-25 20:01:15 -0700358 pitEntry->m_unsatisfyTimer = scheduler::schedule(lastExpiryFromNow,
Junxiao Shid3c792f2014-01-30 00:46:13 -0700359 bind(&Forwarder::onInterestUnsatisfied, this, pitEntry));
360}
361
362void
363Forwarder::setStragglerTimer(shared_ptr<pit::Entry> pitEntry)
364{
Alexander Afanasyeveb3197f2014-03-17 19:28:18 -0700365 time::nanoseconds stragglerTime = time::milliseconds(100);
Junxiao Shic041ca32014-02-25 20:01:15 -0700366
Junxiao Shi9f7455b2014-04-07 21:02:16 -0700367 scheduler::cancel(pitEntry->m_stragglerTimer);
Junxiao Shic041ca32014-02-25 20:01:15 -0700368 pitEntry->m_stragglerTimer = scheduler::schedule(stragglerTime,
Haowei Yuan78c84d12014-02-27 15:35:13 -0600369 bind(&Pit::erase, &m_pit, pitEntry));
Junxiao Shid3c792f2014-01-30 00:46:13 -0700370}
371
372void
373Forwarder::cancelUnsatisfyAndStragglerTimer(shared_ptr<pit::Entry> pitEntry)
374{
Junxiao Shic041ca32014-02-25 20:01:15 -0700375 scheduler::cancel(pitEntry->m_unsatisfyTimer);
376 scheduler::cancel(pitEntry->m_stragglerTimer);
Junxiao Shid3c792f2014-01-30 00:46:13 -0700377}
378
Alexander Afanasyev18bbf812014-01-29 01:40:23 -0800379} // namespace nfd