blob: fbaee2620b83d617d83a75286b97a6083e709f2e [file] [log] [blame]
Alexander Afanasyevc169a812014-05-20 20:37:29 -04001/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
Jeff Thompsonaa4e6db2013-07-15 17:25:23 -07002/**
Alexander Afanasyev57e00362016-06-23 13:22:54 -07003 * Copyright (c) 2013-2016 Regents of the University of California.
Alexander Afanasyevdfa52c42014-04-24 21:10:11 -07004 *
5 * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
Alexander Afanasyevdfa52c42014-04-24 21:10:11 -07006 *
Alexander Afanasyevc169a812014-05-20 20:37:29 -04007 * ndn-cxx library is free software: you can redistribute it and/or modify it under the
8 * terms of the GNU Lesser General Public License as published by the Free Software
9 * Foundation, either version 3 of the License, or (at your option) any later version.
10 *
11 * ndn-cxx library is distributed in the hope that it will be useful, but WITHOUT ANY
12 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
13 * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
14 *
15 * You should have received copies of the GNU General Public License and GNU Lesser
16 * General Public License along with ndn-cxx, e.g., in COPYING.md file. If not, see
17 * <http://www.gnu.org/licenses/>.
18 *
19 * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
Jeff Thompsonaa4e6db2013-07-15 17:25:23 -070020 */
21
Alexander Afanasyev09c613f2014-01-29 00:23:58 -080022#include "face.hpp"
Alexander Afanasyev258ec2b2014-05-14 16:15:37 -070023#include "detail/face-impl.hpp"
Jeff Thompsonaa4e6db2013-07-15 17:25:23 -070024
Junxiao Shi468abc32014-11-04 09:12:47 -070025#include "encoding/tlv.hpp"
Junxiao Shiedd834e2014-10-28 20:28:58 -070026#include "security/key-chain.hpp"
Junxiao Shic6acc7a2015-06-23 10:03:56 -070027#include "security/signing-helpers.hpp"
Alexander Afanasyev0222fba2014-02-09 23:16:02 -080028#include "util/time.hpp"
29#include "util/random.hpp"
Steve DiBenedettoa8659ff2014-12-04 14:50:28 -070030#include "util/face-uri.hpp"
Jeff Thompsonb982b6d2013-07-15 18:15:45 -070031
Junxiao Shiae0b4182016-08-08 22:53:17 +000032// A callback scheduled through io.post and io.dispatch may be invoked after the face
33// is destructed. To prevent this situation, these macros captures Face::m_impl as weak_ptr,
34// and skips callback execution if the face has been destructed.
35#define IO_CAPTURE_WEAK_IMPL(OP) \
36 { \
37 weak_ptr<Impl> implWeak(m_impl); \
38 m_ioService.OP([=] { \
39 auto impl = implWeak.lock(); \
40 if (impl != nullptr) {
41#define IO_CAPTURE_WEAK_IMPL_END \
42 } \
43 }); \
44 }
45
Jeff Thompsonaa4e6db2013-07-15 17:25:23 -070046namespace ndn {
Alexander Afanasyevb790d952014-01-24 12:07:53 -080047
Junxiao Shi103d8ed2016-08-07 20:34:10 +000048Face::Face(shared_ptr<Transport> transport)
Junxiao Shi2cced062014-11-02 21:27:38 -070049 : m_internalIoService(new boost::asio::io_service())
50 , m_ioService(*m_internalIoService)
51 , m_internalKeyChain(new KeyChain())
Junxiao Shiae0b4182016-08-08 22:53:17 +000052 , m_impl(make_shared<Impl>(*this))
Jeff Thompsonfb29cda2013-08-24 10:26:54 -070053{
Junxiao Shi103d8ed2016-08-07 20:34:10 +000054 construct(transport, *m_internalKeyChain);
Alexander Afanasyev0222fba2014-02-09 23:16:02 -080055}
56
Alexander Afanasyev691c3ce2014-04-23 14:28:04 -070057Face::Face(boost::asio::io_service& ioService)
Junxiao Shi2cced062014-11-02 21:27:38 -070058 : m_ioService(ioService)
59 , m_internalKeyChain(new KeyChain())
Junxiao Shiae0b4182016-08-08 22:53:17 +000060 , m_impl(make_shared<Impl>(*this))
Alexander Afanasyev691c3ce2014-04-23 14:28:04 -070061{
Alexander Afanasyevbb64c172015-12-29 20:32:45 -080062 construct(nullptr, *m_internalKeyChain);
Alexander Afanasyev691c3ce2014-04-23 14:28:04 -070063}
64
Junxiao Shi103d8ed2016-08-07 20:34:10 +000065Face::Face(const std::string& host, const std::string& port)
Junxiao Shi2cced062014-11-02 21:27:38 -070066 : m_internalIoService(new boost::asio::io_service())
67 , m_ioService(*m_internalIoService)
68 , m_internalKeyChain(new KeyChain())
Junxiao Shiae0b4182016-08-08 22:53:17 +000069 , m_impl(make_shared<Impl>(*this))
Alexander Afanasyev0222fba2014-02-09 23:16:02 -080070{
Joao Pereira68c0d882015-05-19 14:27:55 -040071 construct(make_shared<TcpTransport>(host, port), *m_internalKeyChain);
Alexander Afanasyev0222fba2014-02-09 23:16:02 -080072}
73
Alexander Afanasyev8cf1c562016-06-23 16:01:55 -070074Face::Face(shared_ptr<Transport> transport, KeyChain& keyChain)
75 : m_internalIoService(new boost::asio::io_service())
76 , m_ioService(*m_internalIoService)
Junxiao Shiae0b4182016-08-08 22:53:17 +000077 , m_impl(make_shared<Impl>(*this))
Alexander Afanasyev8cf1c562016-06-23 16:01:55 -070078{
79 construct(transport, keyChain);
80}
81
82Face::Face(shared_ptr<Transport> transport, boost::asio::io_service& ioService)
Junxiao Shi2cced062014-11-02 21:27:38 -070083 : m_ioService(ioService)
84 , m_internalKeyChain(new KeyChain())
Junxiao Shiae0b4182016-08-08 22:53:17 +000085 , m_impl(make_shared<Impl>(*this))
Alexander Afanasyev0222fba2014-02-09 23:16:02 -080086{
Joao Pereira68c0d882015-05-19 14:27:55 -040087 construct(transport, *m_internalKeyChain);
Junxiao Shiedd834e2014-10-28 20:28:58 -070088}
89
Alexander Afanasyev8cf1c562016-06-23 16:01:55 -070090Face::Face(shared_ptr<Transport> transport, boost::asio::io_service& ioService, KeyChain& keyChain)
Junxiao Shi2cced062014-11-02 21:27:38 -070091 : m_ioService(ioService)
Junxiao Shiae0b4182016-08-08 22:53:17 +000092 , m_impl(make_shared<Impl>(*this))
Junxiao Shiedd834e2014-10-28 20:28:58 -070093{
Joao Pereira68c0d882015-05-19 14:27:55 -040094 construct(transport, keyChain);
Alexander Afanasyev7682ccb2014-02-20 10:29:35 -080095}
96
Alexander Afanasyevbb64c172015-12-29 20:32:45 -080097shared_ptr<Transport>
98Face::makeDefaultTransport()
Steve DiBenedettoa8659ff2014-12-04 14:50:28 -070099{
100 // transport=unix:///var/run/nfd.sock
101 // transport=tcp://localhost:6363
102
Alexander Afanasyev57e00362016-06-23 13:22:54 -0700103 std::string transportUri;
104
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000105 const char* transportEnviron = getenv("NDN_CLIENT_TRANSPORT");
106 if (transportEnviron != nullptr) {
107 transportUri = transportEnviron;
Alexander Afanasyev57e00362016-06-23 13:22:54 -0700108 }
109 else {
110 ConfigFile config;
111 transportUri = config.getParsedConfiguration().get<std::string>("transport", "");
112 }
113
114 if (transportUri.empty()) {
Alexander Afanasyev9d158f02015-02-17 21:30:19 -0800115 // transport not specified, use default Unix transport.
Alexander Afanasyev57e00362016-06-23 13:22:54 -0700116 return UnixTransport::create("");
Alexander Afanasyev9d158f02015-02-17 21:30:19 -0800117 }
Steve DiBenedettoa8659ff2014-12-04 14:50:28 -0700118
Alexander Afanasyevbb64c172015-12-29 20:32:45 -0800119 std::string protocol;
Alexander Afanasyev9d158f02015-02-17 21:30:19 -0800120 try {
Alexander Afanasyev57e00362016-06-23 13:22:54 -0700121 util::FaceUri uri(transportUri);
Alexander Afanasyevbb64c172015-12-29 20:32:45 -0800122 protocol = uri.getScheme();
Alexander Afanasyev57e00362016-06-23 13:22:54 -0700123
124 if (protocol == "unix") {
125 return UnixTransport::create(transportUri);
126 }
127 else if (protocol == "tcp" || protocol == "tcp4" || protocol == "tcp6") {
128 return TcpTransport::create(transportUri);
129 }
130 else {
131 BOOST_THROW_EXCEPTION(ConfigFile::Error("Unsupported transport protocol \"" + protocol + "\""));
132 }
133 }
134 catch (const Transport::Error& error) {
135 BOOST_THROW_EXCEPTION(ConfigFile::Error(error.what()));
Alexander Afanasyev9d158f02015-02-17 21:30:19 -0800136 }
137 catch (const util::FaceUri::Error& error) {
Spyridon Mastorakis0d2ed2e2015-07-27 19:09:12 -0700138 BOOST_THROW_EXCEPTION(ConfigFile::Error(error.what()));
Alexander Afanasyev9d158f02015-02-17 21:30:19 -0800139 }
Steve DiBenedettoa8659ff2014-12-04 14:50:28 -0700140}
141
142void
Joao Pereira68c0d882015-05-19 14:27:55 -0400143Face::construct(shared_ptr<Transport> transport, KeyChain& keyChain)
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800144{
Alexander Afanasyevbb64c172015-12-29 20:32:45 -0800145 if (transport == nullptr) {
146 transport = makeDefaultTransport();
147 }
148 BOOST_ASSERT(transport != nullptr);
Alexander Afanasyevf39c5372014-02-17 19:42:56 -0800149 m_transport = transport;
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800150
Alexander Afanasyevbb64c172015-12-29 20:32:45 -0800151 m_nfdController.reset(new nfd::Controller(*this, keyChain));
152
Junxiao Shiae0b4182016-08-08 22:53:17 +0000153 IO_CAPTURE_WEAK_IMPL(post) {
154 impl->ensureConnected(false);
155 } IO_CAPTURE_WEAK_IMPL_END
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800156}
157
Joao Pereira68c0d882015-05-19 14:27:55 -0400158Face::~Face() = default;
Junxiao Shiedd834e2014-10-28 20:28:58 -0700159
Alexander Afanasyev3a6da362015-12-29 20:31:03 -0800160shared_ptr<Transport>
161Face::getTransport()
162{
163 return m_transport;
164}
165
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800166const PendingInterestId*
Eric Newberry83872fd2015-08-06 17:01:24 -0700167Face::expressInterest(const Interest& interest,
168 const DataCallback& afterSatisfied,
169 const NackCallback& afterNacked,
170 const TimeoutCallback& afterTimeout)
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800171{
Alexander Afanasyevf73f0632014-05-12 18:02:37 -0700172 shared_ptr<Interest> interestToExpress = make_shared<Interest>(interest);
Alexander Afanasyeva68aa7f2014-02-11 15:42:33 -0800173
Alexander Afanasyev49bb1fb2014-07-21 12:54:01 -0700174 // Use `interestToExpress` to avoid wire format creation for the original Interest
Eric Newberry83872fd2015-08-06 17:01:24 -0700175 if (interestToExpress->wireEncode().size() > MAX_NDN_PACKET_SIZE) {
Spyridon Mastorakis0d2ed2e2015-07-27 19:09:12 -0700176 BOOST_THROW_EXCEPTION(Error("Interest size exceeds maximum limit"));
Eric Newberry83872fd2015-08-06 17:01:24 -0700177 }
Alexander Afanasyev49bb1fb2014-07-21 12:54:01 -0700178
Alexander Afanasyev4e50b972014-03-25 10:57:50 -0700179 // If the same ioService thread, dispatch directly calls the method
Junxiao Shiae0b4182016-08-08 22:53:17 +0000180 IO_CAPTURE_WEAK_IMPL(dispatch) {
181 impl->asyncExpressInterest(interestToExpress, afterSatisfied, afterNacked, afterTimeout);
182 } IO_CAPTURE_WEAK_IMPL_END
Alexander Afanasyeva68aa7f2014-02-11 15:42:33 -0800183
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800184 return reinterpret_cast<const PendingInterestId*>(interestToExpress.get());
185}
186
187const PendingInterestId*
Eric Newberry83872fd2015-08-06 17:01:24 -0700188Face::expressInterest(const Interest& interest,
189 const OnData& onData,
190 const OnTimeout& onTimeout)
191{
192 return this->expressInterest(
193 interest,
194 [onData] (const Interest& interest, const Data& data) {
195 if (onData != nullptr) {
196 onData(interest, const_cast<Data&>(data));
197 }
198 },
199 [onTimeout] (const Interest& interest, const lp::Nack& nack) {
200 if (onTimeout != nullptr) {
201 onTimeout(interest);
202 }
203 },
204 onTimeout
205 );
206}
207
208const PendingInterestId*
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000209Face::expressInterest(const Name& name, const Interest& tmpl,
210 const OnData& onData, const OnTimeout& onTimeout)
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800211{
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000212 return expressInterest(Interest(tmpl).setName(name).setNonce(0),
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800213 onData, onTimeout);
214}
215
216void
Junxiao Shiae0b4182016-08-08 22:53:17 +0000217Face::removePendingInterest(const PendingInterestId* pendingInterestId)
218{
219 IO_CAPTURE_WEAK_IMPL(post) {
220 impl->asyncRemovePendingInterest(pendingInterestId);
221 } IO_CAPTURE_WEAK_IMPL_END
222}
223
224void
225Face::removeAllPendingInterests()
226{
227 IO_CAPTURE_WEAK_IMPL(post) {
228 impl->asyncRemoveAllPendingInterests();
229 } IO_CAPTURE_WEAK_IMPL_END
230}
231
232size_t
233Face::getNPendingInterests() const
234{
235 return m_impl->m_pendingInterestTable.size();
236}
237
238void
Alexander Afanasyev7682ccb2014-02-20 10:29:35 -0800239Face::put(const Data& data)
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800240{
Junxiao Shie7bb6c82016-08-08 23:16:35 +0000241 Block wire = data.wireEncode();
242
243 shared_ptr<lp::CachePolicyTag> cachePolicyTag = data.getTag<lp::CachePolicyTag>();
244 if (cachePolicyTag != nullptr) {
245 lp::Packet packet;
246 packet.add<lp::CachePolicyField>(*cachePolicyTag);
247 packet.add<lp::FragmentField>(std::make_pair(wire.begin(), wire.end()));
248 wire = packet.wireEncode();
249 }
250
251 if (wire.size() > MAX_NDN_PACKET_SIZE)
Spyridon Mastorakis0d2ed2e2015-07-27 19:09:12 -0700252 BOOST_THROW_EXCEPTION(Error("Data size exceeds maximum limit"));
Alexander Afanasyev49bb1fb2014-07-21 12:54:01 -0700253
Junxiao Shiae0b4182016-08-08 22:53:17 +0000254 IO_CAPTURE_WEAK_IMPL(dispatch) {
Junxiao Shie7bb6c82016-08-08 23:16:35 +0000255 impl->asyncSend(wire);
Junxiao Shiae0b4182016-08-08 22:53:17 +0000256 } IO_CAPTURE_WEAK_IMPL_END
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800257}
258
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800259void
Eric Newberry83872fd2015-08-06 17:01:24 -0700260Face::put(const lp::Nack& nack)
261{
Junxiao Shie7bb6c82016-08-08 23:16:35 +0000262 lp::Packet packet;
263 packet.add<lp::NackField>(nack.getHeader());
264 const Block& interestWire = nack.getInterest().wireEncode();
265 packet.add<lp::FragmentField>(std::make_pair(interestWire.begin(), interestWire.end()));
266
267 Block wire = packet.wireEncode();
268
269 if (wire.size() > MAX_NDN_PACKET_SIZE)
270 BOOST_THROW_EXCEPTION(Error("Nack size exceeds maximum limit"));
Eric Newberry83872fd2015-08-06 17:01:24 -0700271
Junxiao Shiae0b4182016-08-08 22:53:17 +0000272 IO_CAPTURE_WEAK_IMPL(dispatch) {
Junxiao Shie7bb6c82016-08-08 23:16:35 +0000273 impl->asyncSend(wire);
Junxiao Shiae0b4182016-08-08 22:53:17 +0000274 } IO_CAPTURE_WEAK_IMPL_END
Alexander Afanasyev6fcdde22014-08-22 19:03:36 -0700275}
276
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800277const RegisteredPrefixId*
Alexander Afanasyev90164962014-03-06 08:29:59 +0000278Face::setInterestFilter(const InterestFilter& interestFilter,
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000279 const InterestCallback& onInterest,
280 const RegisterPrefixFailureCallback& onFailure,
281 const security::SigningInfo& signingInfo,
282 uint64_t flags)
Yingdi Yue66bf2a2014-04-28 17:07:36 -0700283{
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000284 return setInterestFilter(interestFilter, onInterest, nullptr, onFailure, signingInfo, flags);
Yingdi Yue66bf2a2014-04-28 17:07:36 -0700285}
286
287const RegisteredPrefixId*
Alexander Afanasyev90164962014-03-06 08:29:59 +0000288Face::setInterestFilter(const InterestFilter& interestFilter,
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000289 const InterestCallback& onInterest,
290 const RegisterPrefixSuccessCallback& onSuccess,
291 const RegisterPrefixFailureCallback& onFailure,
292 const security::SigningInfo& signingInfo,
293 uint64_t flags)
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700294{
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000295 auto filter = make_shared<InterestFilterRecord>(interestFilter, onInterest);
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700296
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000297 nfd::CommandOptions options;
298 options.setSigningInfo(signingInfo);
Junxiao Shi388ec252014-11-02 15:19:57 -0700299
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000300 return m_impl->registerPrefix(interestFilter.getPrefix(), filter,
301 onSuccess, onFailure, flags, options);
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700302}
303
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700304const InterestFilterId*
305Face::setInterestFilter(const InterestFilter& interestFilter,
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000306 const InterestCallback& onInterest)
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700307{
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000308 auto filter = make_shared<InterestFilterRecord>(interestFilter, onInterest);
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700309
Junxiao Shiae0b4182016-08-08 22:53:17 +0000310 IO_CAPTURE_WEAK_IMPL(post) {
311 impl->asyncSetInterestFilter(filter);
312 } IO_CAPTURE_WEAK_IMPL_END
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700313
314 return reinterpret_cast<const InterestFilterId*>(filter.get());
Yingdi Yue66bf2a2014-04-28 17:07:36 -0700315}
316
Joao Pereira0b3cac52015-07-02 14:49:49 -0400317#ifdef NDN_FACE_KEEP_DEPRECATED_REGISTRATION_SIGNING
318
319const RegisteredPrefixId*
320Face::setInterestFilter(const InterestFilter& interestFilter,
321 const OnInterest& onInterest,
322 const RegisterPrefixSuccessCallback& onSuccess,
323 const RegisterPrefixFailureCallback& onFailure,
324 const IdentityCertificate& certificate,
325 uint64_t flags)
326{
327 security::SigningInfo signingInfo;
328 if (!certificate.getName().empty()) {
329 signingInfo = signingByCertificate(certificate.getName());
330 }
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000331 return setInterestFilter(interestFilter, onInterest, onSuccess, onFailure, signingInfo, flags);
Joao Pereira0b3cac52015-07-02 14:49:49 -0400332}
333
334const RegisteredPrefixId*
335Face::setInterestFilter(const InterestFilter& interestFilter,
336 const OnInterest& onInterest,
337 const RegisterPrefixFailureCallback& onFailure,
338 const IdentityCertificate& certificate,
339 uint64_t flags)
340{
341 security::SigningInfo signingInfo;
342 if (!certificate.getName().empty()) {
343 signingInfo = signingByCertificate(certificate.getName());
344 }
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000345 return setInterestFilter(interestFilter, onInterest, onFailure, signingInfo, flags);
Joao Pereira0b3cac52015-07-02 14:49:49 -0400346}
347
348const RegisteredPrefixId*
349Face::setInterestFilter(const InterestFilter& interestFilter,
350 const OnInterest& onInterest,
351 const RegisterPrefixSuccessCallback& onSuccess,
352 const RegisterPrefixFailureCallback& onFailure,
353 const Name& identity,
354 uint64_t flags)
355{
356 security::SigningInfo signingInfo = signingByIdentity(identity);
Joao Pereira0b3cac52015-07-02 14:49:49 -0400357 return setInterestFilter(interestFilter, onInterest,
358 onSuccess, onFailure,
359 signingInfo, flags);
360}
361
362const RegisteredPrefixId*
363Face::setInterestFilter(const InterestFilter& interestFilter,
364 const OnInterest& onInterest,
365 const RegisterPrefixFailureCallback& onFailure,
366 const Name& identity,
367 uint64_t flags)
368{
369 security::SigningInfo signingInfo = signingByIdentity(identity);
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000370 return setInterestFilter(interestFilter, onInterest, onFailure, signingInfo, flags);
Joao Pereira0b3cac52015-07-02 14:49:49 -0400371}
372
373#endif // NDN_FACE_KEEP_DEPRECATED_REGISTRATION_SIGNING
374
375const RegisteredPrefixId*
376Face::registerPrefix(const Name& prefix,
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000377 const RegisterPrefixSuccessCallback& onSuccess,
378 const RegisterPrefixFailureCallback& onFailure,
379 const security::SigningInfo& signingInfo,
380 uint64_t flags)
Joao Pereira0b3cac52015-07-02 14:49:49 -0400381{
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000382 nfd::CommandOptions options;
383 options.setSigningInfo(signingInfo);
Joao Pereira0b3cac52015-07-02 14:49:49 -0400384
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000385 return m_impl->registerPrefix(prefix, nullptr, onSuccess, onFailure, flags, options);
Joao Pereira0b3cac52015-07-02 14:49:49 -0400386}
387
388#ifdef NDN_FACE_KEEP_DEPRECATED_REGISTRATION_SIGNING
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700389const RegisteredPrefixId*
390Face::registerPrefix(const Name& prefix,
391 const RegisterPrefixSuccessCallback& onSuccess,
392 const RegisterPrefixFailureCallback& onFailure,
Alexander Afanasyev0866f512014-08-11 13:25:09 -0700393 const IdentityCertificate& certificate,
394 uint64_t flags)
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700395{
Joao Pereira0b3cac52015-07-02 14:49:49 -0400396 security::SigningInfo signingInfo;
Junxiao Shic6acc7a2015-06-23 10:03:56 -0700397 if (!certificate.getName().empty()) {
Joao Pereira0b3cac52015-07-02 14:49:49 -0400398 signingInfo = signingByCertificate(certificate.getName());
Junxiao Shi388ec252014-11-02 15:19:57 -0700399 }
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000400 return registerPrefix(prefix, onSuccess, onFailure, signingInfo, flags);
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700401}
402
403const RegisteredPrefixId*
404Face::registerPrefix(const Name& prefix,
405 const RegisterPrefixSuccessCallback& onSuccess,
406 const RegisterPrefixFailureCallback& onFailure,
Alexander Afanasyev0866f512014-08-11 13:25:09 -0700407 const Name& identity,
408 uint64_t flags)
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700409{
Joao Pereira0b3cac52015-07-02 14:49:49 -0400410 security::SigningInfo signingInfo = signingByIdentity(identity);
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000411 return registerPrefix(prefix, onSuccess, onFailure, signingInfo, flags);
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700412}
Joao Pereira0b3cac52015-07-02 14:49:49 -0400413#endif // NDN_FACE_KEEP_DEPRECATED_REGISTRATION_SIGNING
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700414
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700415void
Alexander Afanasyev7682ccb2014-02-20 10:29:35 -0800416Face::unsetInterestFilter(const RegisteredPrefixId* registeredPrefixId)
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800417{
Junxiao Shiae0b4182016-08-08 22:53:17 +0000418 IO_CAPTURE_WEAK_IMPL(post) {
419 impl->asyncUnregisterPrefix(registeredPrefixId, nullptr, nullptr);
420 } IO_CAPTURE_WEAK_IMPL_END
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800421}
422
Alexander Afanasyev258ec2b2014-05-14 16:15:37 -0700423void
424Face::unsetInterestFilter(const InterestFilterId* interestFilterId)
425{
Junxiao Shiae0b4182016-08-08 22:53:17 +0000426 IO_CAPTURE_WEAK_IMPL(post) {
427 impl->asyncUnsetInterestFilter(interestFilterId);
428 } IO_CAPTURE_WEAK_IMPL_END
Alexander Afanasyev258ec2b2014-05-14 16:15:37 -0700429}
Yingdi Yue66bf2a2014-04-28 17:07:36 -0700430
431void
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700432Face::unregisterPrefix(const RegisteredPrefixId* registeredPrefixId,
433 const UnregisterPrefixSuccessCallback& onSuccess,
434 const UnregisterPrefixFailureCallback& onFailure)
435{
Junxiao Shiae0b4182016-08-08 22:53:17 +0000436 IO_CAPTURE_WEAK_IMPL(post) {
437 impl->asyncUnregisterPrefix(registeredPrefixId, onSuccess, onFailure);
438 } IO_CAPTURE_WEAK_IMPL_END
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700439}
440
Alexander Afanasyeva68aa7f2014-02-11 15:42:33 -0800441void
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000442Face::processEvents(const time::milliseconds& timeout, bool keepThread)
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800443{
Alexander Afanasyev8e158542014-11-18 00:47:18 -0500444 if (m_ioService.stopped()) {
445 m_ioService.reset(); // ensure that run()/poll() will do some work
446 }
447
Alexander Afanasyev49bb1fb2014-07-21 12:54:01 -0700448 try {
Alexander Afanasyev9d158f02015-02-17 21:30:19 -0800449 if (timeout < time::milliseconds::zero()) {
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000450 // do not block if timeout is negative, but process pending events
451 m_ioService.poll();
452 return;
453 }
Alexander Afanasyeva68aa7f2014-02-11 15:42:33 -0800454
Alexander Afanasyev9d158f02015-02-17 21:30:19 -0800455 if (timeout > time::milliseconds::zero()) {
456 boost::asio::io_service& ioService = m_ioService;
457 unique_ptr<boost::asio::io_service::work>& work = m_impl->m_ioServiceWork;
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000458 m_impl->m_processEventsTimeoutEvent = m_impl->m_scheduler.scheduleEvent(timeout,
459 [&ioService, &work] {
460 ioService.stop();
461 work.reset();
462 });
Alexander Afanasyev9d158f02015-02-17 21:30:19 -0800463 }
Alexander Afanasyev49bb1fb2014-07-21 12:54:01 -0700464
465 if (keepThread) {
466 // work will ensure that m_ioService is running until work object exists
Alexander Afanasyev9d158f02015-02-17 21:30:19 -0800467 m_impl->m_ioServiceWork.reset(new boost::asio::io_service::work(m_ioService));
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800468 }
Alexander Afanasyev49bb1fb2014-07-21 12:54:01 -0700469
Junxiao Shi2cced062014-11-02 21:27:38 -0700470 m_ioService.run();
Alexander Afanasyev49bb1fb2014-07-21 12:54:01 -0700471 }
Alexander Afanasyev49bb1fb2014-07-21 12:54:01 -0700472 catch (...) {
473 m_impl->m_ioServiceWork.reset();
Alexander Afanasyev49bb1fb2014-07-21 12:54:01 -0700474 m_impl->m_pendingInterestTable.clear();
475 m_impl->m_registeredPrefixTable.clear();
476 throw;
477 }
Jeff Thompsonfb29cda2013-08-24 10:26:54 -0700478}
479
Alexander Afanasyeva68aa7f2014-02-11 15:42:33 -0800480void
Jeff Thompson0050abe2013-09-17 12:50:25 -0700481Face::shutdown()
Jeff Thompson517ffa82013-08-05 16:04:34 -0700482{
Junxiao Shiae0b4182016-08-08 22:53:17 +0000483 IO_CAPTURE_WEAK_IMPL(post) {
484 this->asyncShutdown();
485 } IO_CAPTURE_WEAK_IMPL_END
Alexander Afanasyev7dced462014-03-19 15:12:32 -0700486}
487
488void
489Face::asyncShutdown()
490{
Alexander Afanasyev258ec2b2014-05-14 16:15:37 -0700491 m_impl->m_pendingInterestTable.clear();
492 m_impl->m_registeredPrefixTable.clear();
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800493
Alexander Afanasyev984ad192014-05-02 19:11:15 -0700494 if (m_transport->isConnected())
495 m_transport->close();
496
Alexander Afanasyev1f5486e2014-07-10 17:45:49 -0700497 m_impl->m_ioServiceWork.reset();
Jeff Thompsonaa4e6db2013-07-15 17:25:23 -0700498}
499
Eric Newberry83872fd2015-08-06 17:01:24 -0700500/**
501 * @brief extract local fields from NDNLPv2 packet and tag onto a network layer packet
502 */
503template<typename NETPKT>
504static void
505extractLpLocalFields(NETPKT& netPacket, const lp::Packet& lpPacket)
506{
507 if (lpPacket.has<lp::IncomingFaceIdField>()) {
Junxiao Shi4b469982015-12-03 18:20:19 +0000508 netPacket.setTag(make_shared<lp::IncomingFaceIdTag>(lpPacket.get<lp::IncomingFaceIdField>()));
Eric Newberry83872fd2015-08-06 17:01:24 -0700509 }
510}
511
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800512void
Alexander Afanasyev6d48bc12014-02-18 00:10:51 -0800513Face::onReceiveElement(const Block& blockFromDaemon)
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800514{
Eric Newberry83872fd2015-08-06 17:01:24 -0700515 lp::Packet lpPacket(blockFromDaemon); // bare Interest/Data is a valid lp::Packet,
516 // no need to distinguish
Alexander Afanasyev6d48bc12014-02-18 00:10:51 -0800517
Eric Newberry83872fd2015-08-06 17:01:24 -0700518 Buffer::const_iterator begin, end;
519 std::tie(begin, end) = lpPacket.get<lp::FragmentField>();
520 Block netPacket(&*begin, std::distance(begin, end));
521 switch (netPacket.type()) {
522 case tlv::Interest: {
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000523 auto interest = make_shared<Interest>(netPacket);
Eric Newberry83872fd2015-08-06 17:01:24 -0700524 if (lpPacket.has<lp::NackField>()) {
525 auto nack = make_shared<lp::Nack>(std::move(*interest));
526 nack->setHeader(lpPacket.get<lp::NackField>());
527 extractLpLocalFields(*nack, lpPacket);
528 m_impl->nackPendingInterests(*nack);
529 }
530 else {
531 extractLpLocalFields(*interest, lpPacket);
532 m_impl->processInterestFilters(*interest);
533 }
534 break;
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800535 }
Eric Newberry83872fd2015-08-06 17:01:24 -0700536 case tlv::Data: {
Junxiao Shi103d8ed2016-08-07 20:34:10 +0000537 auto data = make_shared<Data>(netPacket);
Eric Newberry83872fd2015-08-06 17:01:24 -0700538 extractLpLocalFields(*data, lpPacket);
Alexander Afanasyev258ec2b2014-05-14 16:15:37 -0700539 m_impl->satisfyPendingInterests(*data);
Eric Newberry83872fd2015-08-06 17:01:24 -0700540 break;
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800541 }
Eric Newberry83872fd2015-08-06 17:01:24 -0700542 }
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800543}
544
Alexander Afanasyev0222fba2014-02-09 23:16:02 -0800545} // namespace ndn