blob: dbfffa40254fe3c5137a3c7bca5aa6b35b7849c9 [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 Shi33152f12014-07-16 19:54:32 -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) {
Junxiao Shi7b984c62014-07-17 22:18:34 -070095 const_cast<Data*>(csMatch)->setIncomingFaceId(FACEID_CONTENT_STORE);
Junxiao Shid3c792f2014-01-30 00:46:13 -070096 // XXX should we lookup PIT for other Interests that also match csMatch?
97
Junxiao Shiad3f1cb2014-08-18 11:12:30 -070098 // set PIT straggler timer
99 this->setStragglerTimer(pitEntry);
100
Junxiao Shid3c792f2014-01-30 00:46:13 -0700101 // goto outgoing Data pipeline
102 this->onOutgoingData(*csMatch, inFace);
103 return;
104 }
105 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700106
Junxiao Shid3c792f2014-01-30 00:46:13 -0700107 // insert InRecord
Junxiao Shi9b27bd22014-02-26 20:29:58 -0700108 pitEntry->insertOrUpdateInRecord(inFace.shared_from_this(), interest);
Junxiao Shic041ca32014-02-25 20:01:15 -0700109
Alexander Afanasyeva57f8b42014-07-10 20:11:32 -0700110 // set PIT unsatisfy timer
111 this->setUnsatisfyTimer(pitEntry);
112
Junxiao Shid3c792f2014-01-30 00:46:13 -0700113 // FIB lookup
Junxiao Shi40631842014-03-01 13:52:37 -0700114 shared_ptr<fib::Entry> fibEntry = m_fib.findLongestPrefixMatch(*pitEntry);
Junxiao Shic041ca32014-02-25 20:01:15 -0700115
Junxiao Shid3c792f2014-01-30 00:46:13 -0700116 // dispatch to strategy
Junxiao Shif3c07812014-03-11 21:48:49 -0700117 this->dispatchToStrategy(pitEntry, bind(&Strategy::afterReceiveInterest, _1,
Alexander Afanasyevf6980282014-05-13 18:28:40 -0700118 cref(inFace), cref(interest), fibEntry, pitEntry));
Junxiao Shid3c792f2014-01-30 00:46:13 -0700119}
120
121void
122Forwarder::onInterestLoop(Face& inFace, const Interest& interest,
123 shared_ptr<pit::Entry> pitEntry)
124{
Junxiao Shif3c07812014-03-11 21:48:49 -0700125 NFD_LOG_DEBUG("onInterestLoop face=" << inFace.getId() <<
126 " interest=" << interest.getName());
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700127
Junxiao Shif3c07812014-03-11 21:48:49 -0700128 // (drop)
129}
130
131/** \brief compare two InRecords for picking outgoing Interest
132 * \return true if b is preferred over a
133 *
134 * This function should be passed to std::max_element over InRecordCollection.
135 * The outgoing Interest picked is the last incoming Interest
136 * that does not come from outFace.
137 * If all InRecords come from outFace, it's fine to pick that. This happens when
138 * there's only one InRecord that comes from outFace. The legit use is for
139 * vehicular network; otherwise, strategy shouldn't send to the sole inFace.
140 */
141static inline bool
142compare_pickInterest(const pit::InRecord& a, const pit::InRecord& b, const Face* outFace)
143{
144 bool isOutFaceA = a.getFace().get() == outFace;
145 bool isOutFaceB = b.getFace().get() == outFace;
146
147 if (!isOutFaceA && isOutFaceB) {
148 return false;
149 }
150 if (isOutFaceA && !isOutFaceB) {
151 return true;
152 }
153
154 return a.getLastRenewed() > b.getLastRenewed();
Junxiao Shid3c792f2014-01-30 00:46:13 -0700155}
156
157void
Junxiao Shid938a6b2014-05-11 23:40:29 -0700158Forwarder::onOutgoingInterest(shared_ptr<pit::Entry> pitEntry, Face& outFace,
159 bool wantNewNonce)
Junxiao Shid3c792f2014-01-30 00:46:13 -0700160{
Junxiao Shi223271b2014-07-03 22:06:13 -0700161 if (outFace.getId() == INVALID_FACEID) {
162 NFD_LOG_WARN("onOutgoingInterest face=invalid interest=" << pitEntry->getName());
163 return;
164 }
Junxiao Shif3c07812014-03-11 21:48:49 -0700165 NFD_LOG_DEBUG("onOutgoingInterest face=" << outFace.getId() <<
166 " interest=" << pitEntry->getName());
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700167
Junxiao Shi57f0f312014-03-16 11:52:20 -0700168 // scope control
169 if (pitEntry->violatesScope(outFace)) {
Junxiao Shif3c07812014-03-11 21:48:49 -0700170 NFD_LOG_DEBUG("onOutgoingInterest face=" << outFace.getId() <<
Junxiao Shi57f0f312014-03-16 11:52:20 -0700171 " interest=" << pitEntry->getName() << " violates scope");
Junxiao Shi11bd9c22014-03-13 20:44:13 -0700172 return;
173 }
174
Junxiao Shid3c792f2014-01-30 00:46:13 -0700175 // pick Interest
Junxiao Shif3c07812014-03-11 21:48:49 -0700176 const pit::InRecordCollection& inRecords = pitEntry->getInRecords();
177 pit::InRecordCollection::const_iterator pickedInRecord = std::max_element(
178 inRecords.begin(), inRecords.end(), bind(&compare_pickInterest, _1, _2, &outFace));
179 BOOST_ASSERT(pickedInRecord != inRecords.end());
Junxiao Shid938a6b2014-05-11 23:40:29 -0700180 shared_ptr<Interest> interest = const_pointer_cast<Interest>(
181 pickedInRecord->getInterest().shared_from_this());
182
183 if (wantNewNonce) {
184 interest = make_shared<Interest>(*interest);
Junxiao Shiaf6569a2014-06-14 00:01:34 -0700185 static boost::random::uniform_int_distribution<uint32_t> dist;
186 interest->setNonce(dist(getGlobalRng()));
Junxiao Shid938a6b2014-05-11 23:40:29 -0700187 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700188
Junxiao Shid3c792f2014-01-30 00:46:13 -0700189 // insert OutRecord
Junxiao Shid938a6b2014-05-11 23:40:29 -0700190 pitEntry->insertOrUpdateOutRecord(outFace.shared_from_this(), *interest);
Junxiao Shic041ca32014-02-25 20:01:15 -0700191
Junxiao Shid3c792f2014-01-30 00:46:13 -0700192 // send Interest
Junxiao Shid938a6b2014-05-11 23:40:29 -0700193 outFace.sendInterest(*interest);
Junxiao Shi33152f12014-07-16 19:54:32 -0700194 ++m_counters.getNOutInterests();
Junxiao Shid3c792f2014-01-30 00:46:13 -0700195}
196
197void
Junxiao Shi09498f02014-02-26 19:41:08 -0700198Forwarder::onInterestReject(shared_ptr<pit::Entry> pitEntry)
Junxiao Shid3c792f2014-01-30 00:46:13 -0700199{
Junxiao Shid938a6b2014-05-11 23:40:29 -0700200 if (pitEntry->hasUnexpiredOutRecords()) {
201 NFD_LOG_ERROR("onInterestReject interest=" << pitEntry->getName() <<
202 " cannot reject forwarded Interest");
203 return;
204 }
Junxiao Shi09498f02014-02-26 19:41:08 -0700205 NFD_LOG_DEBUG("onInterestReject interest=" << pitEntry->getName());
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700206
Alexander Afanasyeva57f8b42014-07-10 20:11:32 -0700207 // cancel unsatisfy & straggler timer
208 this->cancelUnsatisfyAndStragglerTimer(pitEntry);
209
Junxiao Shid3c792f2014-01-30 00:46:13 -0700210 // set PIT straggler timer
211 this->setStragglerTimer(pitEntry);
212}
213
214void
215Forwarder::onInterestUnsatisfied(shared_ptr<pit::Entry> pitEntry)
216{
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700217 NFD_LOG_DEBUG("onInterestUnsatisfied interest=" << pitEntry->getName());
218
Junxiao Shid3c792f2014-01-30 00:46:13 -0700219 // invoke PIT unsatisfied callback
Junxiao Shif3c07812014-03-11 21:48:49 -0700220 this->dispatchToStrategy(pitEntry, bind(&Strategy::beforeExpirePendingInterest, _1,
Alexander Afanasyevf6980282014-05-13 18:28:40 -0700221 pitEntry));
Junxiao Shic041ca32014-02-25 20:01:15 -0700222
Junxiao Shif3c07812014-03-11 21:48:49 -0700223 // PIT delete
Junxiao Shid938a6b2014-05-11 23:40:29 -0700224 this->cancelUnsatisfyAndStragglerTimer(pitEntry);
Haowei Yuan78c84d12014-02-27 15:35:13 -0600225 m_pit.erase(pitEntry);
Junxiao Shid3c792f2014-01-30 00:46:13 -0700226}
227
228void
229Forwarder::onIncomingData(Face& inFace, const Data& data)
230{
231 // receive Data
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700232 NFD_LOG_DEBUG("onIncomingData face=" << inFace.getId() << " data=" << data.getName());
Junxiao Shi06887ac2014-02-13 20:15:42 -0700233 const_cast<Data&>(data).setIncomingFaceId(inFace.getId());
Junxiao Shi33152f12014-07-16 19:54:32 -0700234 ++m_counters.getNInDatas();
Junxiao Shic041ca32014-02-25 20:01:15 -0700235
Junxiao Shi88884492014-02-15 15:57:43 -0700236 // /localhost scope control
Junxiao Shif3c07812014-03-11 21:48:49 -0700237 bool isViolatingLocalhost = !inFace.isLocal() &&
238 LOCALHOST_NAME.isPrefixOf(data.getName());
239 if (isViolatingLocalhost) {
240 NFD_LOG_DEBUG("onIncomingData face=" << inFace.getId() <<
241 " data=" << data.getName() << " violates /localhost");
242 // (drop)
Junxiao Shi88884492014-02-15 15:57:43 -0700243 return;
244 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700245
Junxiao Shid3c792f2014-01-30 00:46:13 -0700246 // PIT match
247 shared_ptr<pit::DataMatchResult> pitMatches = m_pit.findAllDataMatches(data);
248 if (pitMatches->begin() == pitMatches->end()) {
249 // goto Data unsolicited pipeline
250 this->onDataUnsolicited(inFace, data);
251 return;
252 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700253
Junxiao Shid3c792f2014-01-30 00:46:13 -0700254 // CS insert
255 m_cs.insert(data);
Junxiao Shic041ca32014-02-25 20:01:15 -0700256
Junxiao Shid3c792f2014-01-30 00:46:13 -0700257 std::set<shared_ptr<Face> > pendingDownstreams;
258 // foreach PitEntry
259 for (pit::DataMatchResult::iterator it = pitMatches->begin();
260 it != pitMatches->end(); ++it) {
261 shared_ptr<pit::Entry> pitEntry = *it;
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700262 NFD_LOG_DEBUG("onIncomingData matching=" << pitEntry->getName());
Junxiao Shic041ca32014-02-25 20:01:15 -0700263
Junxiao Shid3c792f2014-01-30 00:46:13 -0700264 // cancel unsatisfy & straggler timer
265 this->cancelUnsatisfyAndStragglerTimer(pitEntry);
Junxiao Shic041ca32014-02-25 20:01:15 -0700266
Junxiao Shid3c792f2014-01-30 00:46:13 -0700267 // remember pending downstreams
268 const pit::InRecordCollection& inRecords = pitEntry->getInRecords();
269 for (pit::InRecordCollection::const_iterator it = inRecords.begin();
270 it != inRecords.end(); ++it) {
Alexander Afanasyeveb3197f2014-03-17 19:28:18 -0700271 if (it->getExpiry() > time::steady_clock::now()) {
Junxiao Shid3c792f2014-01-30 00:46:13 -0700272 pendingDownstreams.insert(it->getFace());
273 }
274 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700275
Junxiao Shid938a6b2014-05-11 23:40:29 -0700276 // invoke PIT satisfy callback
277 this->dispatchToStrategy(pitEntry, bind(&Strategy::beforeSatisfyPendingInterest, _1,
278 pitEntry, cref(inFace), cref(data)));
279
Junxiao Shid3c792f2014-01-30 00:46:13 -0700280 // mark PIT satisfied
281 pitEntry->deleteInRecords();
282 pitEntry->deleteOutRecord(inFace.shared_from_this());
Junxiao Shic041ca32014-02-25 20:01:15 -0700283
Junxiao Shid3c792f2014-01-30 00:46:13 -0700284 // set PIT straggler timer
285 this->setStragglerTimer(pitEntry);
Junxiao Shid3c792f2014-01-30 00:46:13 -0700286 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700287
Junxiao Shid3c792f2014-01-30 00:46:13 -0700288 // foreach pending downstream
289 for (std::set<shared_ptr<Face> >::iterator it = pendingDownstreams.begin();
290 it != pendingDownstreams.end(); ++it) {
Junxiao Shida006f52014-05-16 11:18:00 -0700291 shared_ptr<Face> pendingDownstream = *it;
292 if (pendingDownstream.get() == &inFace) {
293 continue;
294 }
Junxiao Shid3c792f2014-01-30 00:46:13 -0700295 // goto outgoing Data pipeline
Junxiao Shida006f52014-05-16 11:18:00 -0700296 this->onOutgoingData(data, *pendingDownstream);
Junxiao Shid3c792f2014-01-30 00:46:13 -0700297 }
298}
299
300void
301Forwarder::onDataUnsolicited(Face& inFace, const Data& data)
302{
303 // accept to cache?
Junxiao Shif3c07812014-03-11 21:48:49 -0700304 bool acceptToCache = inFace.isLocal();
Junxiao Shid3c792f2014-01-30 00:46:13 -0700305 if (acceptToCache) {
306 // CS insert
Junxiao Shif3c07812014-03-11 21:48:49 -0700307 m_cs.insert(data, true);
Junxiao Shid3c792f2014-01-30 00:46:13 -0700308 }
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700309
Junxiao Shif3c07812014-03-11 21:48:49 -0700310 NFD_LOG_DEBUG("onDataUnsolicited face=" << inFace.getId() <<
311 " data=" << data.getName() <<
312 (acceptToCache ? " cached" : " not cached"));
Junxiao Shid3c792f2014-01-30 00:46:13 -0700313}
314
315void
316Forwarder::onOutgoingData(const Data& data, Face& outFace)
317{
Junxiao Shi223271b2014-07-03 22:06:13 -0700318 if (outFace.getId() == INVALID_FACEID) {
319 NFD_LOG_WARN("onOutgoingData face=invalid data=" << data.getName());
320 return;
321 }
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700322 NFD_LOG_DEBUG("onOutgoingData face=" << outFace.getId() << " data=" << data.getName());
323
Junxiao Shi9b27bd22014-02-26 20:29:58 -0700324 // /localhost scope control
Junxiao Shif3c07812014-03-11 21:48:49 -0700325 bool isViolatingLocalhost = !outFace.isLocal() &&
326 LOCALHOST_NAME.isPrefixOf(data.getName());
327 if (isViolatingLocalhost) {
328 NFD_LOG_DEBUG("onOutgoingData face=" << outFace.getId() <<
329 " data=" << data.getName() << " violates /localhost");
330 // (drop)
Junxiao Shi9b27bd22014-02-26 20:29:58 -0700331 return;
332 }
333
Junxiao Shif3c07812014-03-11 21:48:49 -0700334 // TODO traffic manager
Junxiao Shic041ca32014-02-25 20:01:15 -0700335
Junxiao Shid3c792f2014-01-30 00:46:13 -0700336 // send Data
337 outFace.sendData(data);
Junxiao Shi33152f12014-07-16 19:54:32 -0700338 ++m_counters.getNOutDatas();
Junxiao Shid3c792f2014-01-30 00:46:13 -0700339}
340
341static inline bool
342compare_InRecord_expiry(const pit::InRecord& a, const pit::InRecord& b)
343{
344 return a.getExpiry() < b.getExpiry();
345}
346
347void
348Forwarder::setUnsatisfyTimer(shared_ptr<pit::Entry> pitEntry)
349{
350 const pit::InRecordCollection& inRecords = pitEntry->getInRecords();
351 pit::InRecordCollection::const_iterator lastExpiring =
352 std::max_element(inRecords.begin(), inRecords.end(),
353 &compare_InRecord_expiry);
354
Alexander Afanasyeveb3197f2014-03-17 19:28:18 -0700355 time::steady_clock::TimePoint lastExpiry = lastExpiring->getExpiry();
356 time::nanoseconds lastExpiryFromNow = lastExpiry - time::steady_clock::now();
Junxiao Shid3c792f2014-01-30 00:46:13 -0700357 if (lastExpiryFromNow <= time::seconds(0)) {
358 // TODO all InRecords are already expired; will this happen?
359 }
Junxiao Shic041ca32014-02-25 20:01:15 -0700360
Junxiao Shi9f7455b2014-04-07 21:02:16 -0700361 scheduler::cancel(pitEntry->m_unsatisfyTimer);
Junxiao Shic041ca32014-02-25 20:01:15 -0700362 pitEntry->m_unsatisfyTimer = scheduler::schedule(lastExpiryFromNow,
Junxiao Shid3c792f2014-01-30 00:46:13 -0700363 bind(&Forwarder::onInterestUnsatisfied, this, pitEntry));
364}
365
366void
367Forwarder::setStragglerTimer(shared_ptr<pit::Entry> pitEntry)
368{
Alexander Afanasyeveb3197f2014-03-17 19:28:18 -0700369 time::nanoseconds stragglerTime = time::milliseconds(100);
Junxiao Shic041ca32014-02-25 20:01:15 -0700370
Junxiao Shi9f7455b2014-04-07 21:02:16 -0700371 scheduler::cancel(pitEntry->m_stragglerTimer);
Junxiao Shic041ca32014-02-25 20:01:15 -0700372 pitEntry->m_stragglerTimer = scheduler::schedule(stragglerTime,
Haowei Yuan78c84d12014-02-27 15:35:13 -0600373 bind(&Pit::erase, &m_pit, pitEntry));
Junxiao Shid3c792f2014-01-30 00:46:13 -0700374}
375
376void
377Forwarder::cancelUnsatisfyAndStragglerTimer(shared_ptr<pit::Entry> pitEntry)
378{
Junxiao Shic041ca32014-02-25 20:01:15 -0700379 scheduler::cancel(pitEntry->m_unsatisfyTimer);
380 scheduler::cancel(pitEntry->m_stragglerTimer);
Junxiao Shid3c792f2014-01-30 00:46:13 -0700381}
382
Alexander Afanasyev18bbf812014-01-29 01:40:23 -0800383} // namespace nfd