Alexander Afanasyev | c169a81 | 2014-05-20 20:37:29 -0400 | [diff] [blame] | 1 | /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 2 | /* |
Davide Pesavento | fccb2dc | 2019-02-09 01:02:35 -0500 | [diff] [blame] | 3 | * Copyright (c) 2013-2019 Regents of the University of California. |
Alexander Afanasyev | dfa52c4 | 2014-04-24 21:10:11 -0700 | [diff] [blame] | 4 | * |
| 5 | * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions). |
Alexander Afanasyev | dfa52c4 | 2014-04-24 21:10:11 -0700 | [diff] [blame] | 6 | * |
Alexander Afanasyev | c169a81 | 2014-05-20 20:37:29 -0400 | [diff] [blame] | 7 | * 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 Thompson | b7f9556 | 2013-07-03 18:36:42 -0700 | [diff] [blame] | 20 | */ |
| 21 | |
Davide Pesavento | 7e78064 | 2018-11-24 15:51:34 -0500 | [diff] [blame] | 22 | #include "ndn-cxx/interest.hpp" |
| 23 | #include "ndn-cxx/data.hpp" |
| 24 | #include "ndn-cxx/util/random.hpp" |
Alexander Afanasyev | 840139f | 2013-12-28 15:02:50 -0800 | [diff] [blame] | 25 | |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 26 | #include <boost/scope_exit.hpp> |
| 27 | |
Davide Pesavento | 4bb06bc | 2019-04-06 13:59:10 -0400 | [diff] [blame] | 28 | #ifdef NDN_CXX_HAVE_STACKTRACE |
| 29 | #include <boost/stacktrace/stacktrace.hpp> |
| 30 | #endif |
| 31 | |
Davide Pesavento | e178989 | 2017-02-26 15:50:52 -0500 | [diff] [blame] | 32 | #include <cstring> |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 33 | #include <iostream> |
Davide Pesavento | a84f464 | 2017-08-23 16:14:51 -0400 | [diff] [blame] | 34 | #include <sstream> |
Davide Pesavento | e178989 | 2017-02-26 15:50:52 -0500 | [diff] [blame] | 35 | |
Jeff Thompson | b7f9556 | 2013-07-03 18:36:42 -0700 | [diff] [blame] | 36 | namespace ndn { |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 37 | |
Junxiao Shi | c2b8d24 | 2014-11-04 08:35:29 -0700 | [diff] [blame] | 38 | BOOST_CONCEPT_ASSERT((boost::EqualityComparable<Interest>)); |
| 39 | BOOST_CONCEPT_ASSERT((WireEncodable<Interest>)); |
Alexander Afanasyev | d5c48e0 | 2015-06-24 11:58:14 -0700 | [diff] [blame] | 40 | BOOST_CONCEPT_ASSERT((WireEncodableWithEncodingBuffer<Interest>)); |
Junxiao Shi | c2b8d24 | 2014-11-04 08:35:29 -0700 | [diff] [blame] | 41 | BOOST_CONCEPT_ASSERT((WireDecodable<Interest>)); |
| 42 | static_assert(std::is_base_of<tlv::Error, Interest::Error>::value, |
| 43 | "Interest::Error must inherit from tlv::Error"); |
| 44 | |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 45 | #ifdef NDN_CXX_HAVE_TESTS |
| 46 | bool Interest::s_errorIfCanBePrefixUnset = true; |
| 47 | #endif // NDN_CXX_HAVE_TESTS |
| 48 | boost::logic::tribool Interest::s_defaultCanBePrefix = boost::logic::indeterminate; |
| 49 | |
Junxiao Shi | 8d3f834 | 2018-04-04 12:46:37 +0000 | [diff] [blame] | 50 | Interest::Interest(const Name& name, time::milliseconds lifetime) |
Junxiao Shi | 2af905b | 2014-11-27 13:10:54 -0700 | [diff] [blame] | 51 | : m_name(name) |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 52 | , m_isCanBePrefixSet(false) |
Junxiao Shi | 8d3f834 | 2018-04-04 12:46:37 +0000 | [diff] [blame] | 53 | , m_interestLifetime(lifetime) |
Junxiao Shi | 2af905b | 2014-11-27 13:10:54 -0700 | [diff] [blame] | 54 | { |
Davide Pesavento | fccb2dc | 2019-02-09 01:02:35 -0500 | [diff] [blame] | 55 | if (lifetime < 0_ms) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 56 | NDN_THROW(std::invalid_argument("InterestLifetime must be >= 0")); |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 57 | } |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 58 | |
| 59 | if (!boost::logic::indeterminate(s_defaultCanBePrefix)) { |
Davide Pesavento | 4bb06bc | 2019-04-06 13:59:10 -0400 | [diff] [blame] | 60 | setCanBePrefix(bool(s_defaultCanBePrefix)); |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 61 | } |
Junxiao Shi | 2af905b | 2014-11-27 13:10:54 -0700 | [diff] [blame] | 62 | } |
| 63 | |
Junxiao Shi | 2af905b | 2014-11-27 13:10:54 -0700 | [diff] [blame] | 64 | Interest::Interest(const Block& wire) |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 65 | : m_isCanBePrefixSet(true) |
Junxiao Shi | 2af905b | 2014-11-27 13:10:54 -0700 | [diff] [blame] | 66 | { |
| 67 | wireDecode(wire); |
| 68 | } |
| 69 | |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 70 | // ---- encode and decode ---- |
Alexander Afanasyev | 840139f | 2013-12-28 15:02:50 -0800 | [diff] [blame] | 71 | |
Davide Pesavento | 4bb06bc | 2019-04-06 13:59:10 -0400 | [diff] [blame] | 72 | static void |
| 73 | warnOnceCanBePrefixUnset() |
| 74 | { |
| 75 | static bool didWarn = false; |
| 76 | if (!didWarn) { |
| 77 | didWarn = true; |
| 78 | std::cerr << "WARNING: Interest.CanBePrefix will be set to false in the near future. " |
| 79 | << "Please declare a preferred setting via Interest::setDefaultCanBePrefix.\n"; |
| 80 | #ifdef NDN_CXX_HAVE_STACKTRACE |
| 81 | if (std::getenv("NDN_CXX_VERBOSE_CANBEPREFIX_UNSET_WARNING") != nullptr) { |
| 82 | std::cerr << boost::stacktrace::stacktrace(2, 64); |
| 83 | } |
| 84 | #endif |
| 85 | } |
| 86 | } |
| 87 | |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 88 | template<encoding::Tag TAG> |
| 89 | size_t |
| 90 | Interest::wireEncode(EncodingImpl<TAG>& encoder) const |
| 91 | { |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 92 | if (!m_isCanBePrefixSet) { |
Davide Pesavento | 4bb06bc | 2019-04-06 13:59:10 -0400 | [diff] [blame] | 93 | warnOnceCanBePrefixUnset(); |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 94 | #ifdef NDN_CXX_HAVE_TESTS |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 95 | if (s_errorIfCanBePrefixUnset) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 96 | NDN_THROW(std::logic_error("Interest.CanBePrefix is unset")); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 97 | } |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 98 | #endif // NDN_CXX_HAVE_TESTS |
| 99 | } |
| 100 | |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 101 | if (hasApplicationParameters()) { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 102 | return encode03(encoder); |
| 103 | } |
| 104 | else { |
| 105 | return encode02(encoder); |
| 106 | } |
| 107 | } |
| 108 | |
| 109 | template<encoding::Tag TAG> |
| 110 | size_t |
| 111 | Interest::encode02(EncodingImpl<TAG>& encoder) const |
| 112 | { |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 113 | size_t totalLength = 0; |
| 114 | |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 115 | // Encode as NDN Packet Format v0.2 |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 116 | // Interest ::= INTEREST-TYPE TLV-LENGTH |
| 117 | // Name |
| 118 | // Selectors? |
| 119 | // Nonce |
| 120 | // InterestLifetime? |
Junxiao Shi | 9c154cb | 2017-07-07 22:14:54 +0000 | [diff] [blame] | 121 | // ForwardingHint? |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 122 | |
| 123 | // (reverse encoding) |
| 124 | |
Junxiao Shi | 9c154cb | 2017-07-07 22:14:54 +0000 | [diff] [blame] | 125 | // ForwardingHint |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 126 | if (getForwardingHint().size() > 0) { |
| 127 | totalLength += getForwardingHint().wireEncode(encoder); |
Junxiao Shi | 9c154cb | 2017-07-07 22:14:54 +0000 | [diff] [blame] | 128 | } |
| 129 | |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 130 | // InterestLifetime |
| 131 | if (getInterestLifetime() != DEFAULT_INTEREST_LIFETIME) { |
Davide Pesavento | fccb2dc | 2019-02-09 01:02:35 -0500 | [diff] [blame] | 132 | totalLength += prependNonNegativeIntegerBlock(encoder, tlv::InterestLifetime, |
| 133 | static_cast<uint64_t>(getInterestLifetime().count())); |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 134 | } |
| 135 | |
| 136 | // Nonce |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 137 | uint32_t nonce = getNonce(); // if nonce was unset, getNonce generates a random nonce |
| 138 | totalLength += encoder.prependByteArrayBlock(tlv::Nonce, reinterpret_cast<uint8_t*>(&nonce), sizeof(nonce)); |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 139 | |
| 140 | // Selectors |
| 141 | if (hasSelectors()) { |
| 142 | totalLength += getSelectors().wireEncode(encoder); |
| 143 | } |
| 144 | |
| 145 | // Name |
| 146 | totalLength += getName().wireEncode(encoder); |
| 147 | |
| 148 | totalLength += encoder.prependVarNumber(totalLength); |
| 149 | totalLength += encoder.prependVarNumber(tlv::Interest); |
| 150 | return totalLength; |
Alexander Afanasyev | 840139f | 2013-12-28 15:02:50 -0800 | [diff] [blame] | 151 | } |
| 152 | |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 153 | template<encoding::Tag TAG> |
| 154 | size_t |
| 155 | Interest::encode03(EncodingImpl<TAG>& encoder) const |
| 156 | { |
| 157 | size_t totalLength = 0; |
| 158 | |
| 159 | // Encode as NDN Packet Format v0.3 |
| 160 | // Interest ::= INTEREST-TYPE TLV-LENGTH |
| 161 | // Name |
| 162 | // CanBePrefix? |
| 163 | // MustBeFresh? |
| 164 | // ForwardingHint? |
| 165 | // Nonce? |
| 166 | // InterestLifetime? |
| 167 | // HopLimit? |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 168 | // ApplicationParameters? |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 169 | |
| 170 | // (reverse encoding) |
| 171 | |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 172 | // ApplicationParameters |
| 173 | if (hasApplicationParameters()) { |
| 174 | totalLength += encoder.prependBlock(getApplicationParameters()); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 175 | } |
| 176 | |
| 177 | // HopLimit: not yet supported |
| 178 | |
| 179 | // InterestLifetime |
| 180 | if (getInterestLifetime() != DEFAULT_INTEREST_LIFETIME) { |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 181 | totalLength += prependNonNegativeIntegerBlock(encoder, tlv::InterestLifetime, |
| 182 | static_cast<uint64_t>(getInterestLifetime().count())); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 183 | } |
| 184 | |
| 185 | // Nonce |
| 186 | uint32_t nonce = getNonce(); // if nonce was unset, getNonce generates a random nonce |
| 187 | totalLength += encoder.prependByteArrayBlock(tlv::Nonce, reinterpret_cast<uint8_t*>(&nonce), sizeof(nonce)); |
| 188 | |
| 189 | // ForwardingHint |
Davide Pesavento | fccb2dc | 2019-02-09 01:02:35 -0500 | [diff] [blame] | 190 | if (!getForwardingHint().empty()) { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 191 | totalLength += getForwardingHint().wireEncode(encoder); |
| 192 | } |
| 193 | |
| 194 | // MustBeFresh |
| 195 | if (getMustBeFresh()) { |
| 196 | totalLength += prependEmptyBlock(encoder, tlv::MustBeFresh); |
| 197 | } |
| 198 | |
| 199 | // CanBePrefix |
| 200 | if (getCanBePrefix()) { |
| 201 | totalLength += prependEmptyBlock(encoder, tlv::CanBePrefix); |
| 202 | } |
| 203 | |
| 204 | // Name |
| 205 | totalLength += getName().wireEncode(encoder); |
| 206 | |
| 207 | totalLength += encoder.prependVarNumber(totalLength); |
| 208 | totalLength += encoder.prependVarNumber(tlv::Interest); |
| 209 | return totalLength; |
| 210 | } |
| 211 | |
Davide Pesavento | 88a0d81 | 2017-08-19 21:31:42 -0400 | [diff] [blame] | 212 | NDN_CXX_DEFINE_WIRE_ENCODE_INSTANTIATIONS(Interest); |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 213 | |
| 214 | const Block& |
| 215 | Interest::wireEncode() const |
Alexander Afanasyev | e881e93 | 2014-06-08 14:47:03 +0300 | [diff] [blame] | 216 | { |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 217 | if (m_wire.hasWire()) |
| 218 | return m_wire; |
| 219 | |
| 220 | EncodingEstimator estimator; |
| 221 | size_t estimatedSize = wireEncode(estimator); |
| 222 | |
| 223 | EncodingBuffer buffer(estimatedSize, 0); |
| 224 | wireEncode(buffer); |
| 225 | |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 226 | const_cast<Interest*>(this)->wireDecode(buffer.block()); |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 227 | return m_wire; |
Alexander Afanasyev | e881e93 | 2014-06-08 14:47:03 +0300 | [diff] [blame] | 228 | } |
Alexander Afanasyev | 840139f | 2013-12-28 15:02:50 -0800 | [diff] [blame] | 229 | |
Alexander Afanasyev | c393217 | 2014-07-10 18:53:56 -0700 | [diff] [blame] | 230 | void |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 231 | Interest::wireDecode(const Block& wire) |
Alexander Afanasyev | c393217 | 2014-07-10 18:53:56 -0700 | [diff] [blame] | 232 | { |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 233 | m_wire = wire; |
| 234 | m_wire.parse(); |
Alexander Afanasyev | c393217 | 2014-07-10 18:53:56 -0700 | [diff] [blame] | 235 | |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 236 | if (m_wire.type() != tlv::Interest) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 237 | NDN_THROW(Error("Interest", m_wire.type())); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 238 | } |
| 239 | |
| 240 | if (!decode02()) { |
| 241 | decode03(); |
| 242 | if (!hasNonce()) { |
| 243 | setNonce(getNonce()); |
| 244 | } |
| 245 | } |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 246 | |
| 247 | m_isCanBePrefixSet = true; // don't trigger warning from decoded packet |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 248 | } |
| 249 | |
| 250 | bool |
| 251 | Interest::decode02() |
| 252 | { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 253 | auto element = m_wire.elements_begin(); |
Alexander Afanasyev | c393217 | 2014-07-10 18:53:56 -0700 | [diff] [blame] | 254 | |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 255 | // Name |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 256 | if (element != m_wire.elements_end() && element->type() == tlv::Name) { |
| 257 | m_name.wireDecode(*element); |
| 258 | ++element; |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 259 | } |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 260 | else { |
| 261 | return false; |
| 262 | } |
| 263 | |
| 264 | // Selectors? |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 265 | if (element != m_wire.elements_end() && element->type() == tlv::Selectors) { |
| 266 | m_selectors.wireDecode(*element); |
| 267 | ++element; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 268 | } |
| 269 | else { |
Davide Pesavento | fccb2dc | 2019-02-09 01:02:35 -0500 | [diff] [blame] | 270 | m_selectors = {}; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 271 | } |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 272 | |
| 273 | // Nonce |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 274 | if (element != m_wire.elements_end() && element->type() == tlv::Nonce) { |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 275 | uint32_t nonce = 0; |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 276 | if (element->value_size() != sizeof(nonce)) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 277 | NDN_THROW(Error("Nonce element is malformed")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 278 | } |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 279 | std::memcpy(&nonce, element->value(), sizeof(nonce)); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 280 | m_nonce = nonce; |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 281 | ++element; |
Junxiao Shi | 2dd711d | 2017-07-21 13:40:52 +0000 | [diff] [blame] | 282 | } |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 283 | else { |
| 284 | return false; |
Junxiao Shi | 2dd711d | 2017-07-21 13:40:52 +0000 | [diff] [blame] | 285 | } |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 286 | |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 287 | // InterestLifetime? |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 288 | if (element != m_wire.elements_end() && element->type() == tlv::InterestLifetime) { |
| 289 | m_interestLifetime = time::milliseconds(readNonNegativeInteger(*element)); |
| 290 | ++element; |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 291 | } |
| 292 | else { |
| 293 | m_interestLifetime = DEFAULT_INTEREST_LIFETIME; |
| 294 | } |
| 295 | |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 296 | // ForwardingHint? |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 297 | if (element != m_wire.elements_end() && element->type() == tlv::ForwardingHint) { |
| 298 | m_forwardingHint.wireDecode(*element, false); |
| 299 | ++element; |
Junxiao Shi | 9c154cb | 2017-07-07 22:14:54 +0000 | [diff] [blame] | 300 | } |
| 301 | else { |
Davide Pesavento | fccb2dc | 2019-02-09 01:02:35 -0500 | [diff] [blame] | 302 | m_forwardingHint = {}; |
Junxiao Shi | 9c154cb | 2017-07-07 22:14:54 +0000 | [diff] [blame] | 303 | } |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 304 | |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 305 | return element == m_wire.elements_end(); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 306 | } |
| 307 | |
| 308 | void |
| 309 | Interest::decode03() |
| 310 | { |
| 311 | // Interest ::= INTEREST-TYPE TLV-LENGTH |
| 312 | // Name |
| 313 | // CanBePrefix? |
| 314 | // MustBeFresh? |
| 315 | // ForwardingHint? |
| 316 | // Nonce? |
| 317 | // InterestLifetime? |
| 318 | // HopLimit? |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 319 | // ApplicationParameters? |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 320 | |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 321 | auto element = m_wire.elements_begin(); |
| 322 | if (element == m_wire.elements_end() || element->type() != tlv::Name) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 323 | NDN_THROW(Error("Name element is missing or out of order")); |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 324 | } |
| 325 | m_name.wireDecode(*element); |
| 326 | if (m_name.empty()) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 327 | NDN_THROW(Error("Name has zero name components")); |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 328 | } |
| 329 | int lastElement = 1; // last recognized element index, in spec order |
| 330 | |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 331 | m_selectors = Selectors().setMaxSuffixComponents(1); // CanBePrefix=0 |
| 332 | m_nonce.reset(); |
| 333 | m_interestLifetime = DEFAULT_INTEREST_LIFETIME; |
Davide Pesavento | fccb2dc | 2019-02-09 01:02:35 -0500 | [diff] [blame] | 334 | m_forwardingHint = {}; |
| 335 | m_parameters = {}; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 336 | |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 337 | for (++element; element != m_wire.elements_end(); ++element) { |
| 338 | switch (element->type()) { |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 339 | case tlv::CanBePrefix: { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 340 | if (lastElement >= 2) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 341 | NDN_THROW(Error("CanBePrefix element is out of order")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 342 | } |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 343 | if (element->value_size() != 0) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 344 | NDN_THROW(Error("CanBePrefix element has non-zero TLV-LENGTH")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 345 | } |
| 346 | m_selectors.setMaxSuffixComponents(-1); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 347 | lastElement = 2; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 348 | break; |
| 349 | } |
| 350 | case tlv::MustBeFresh: { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 351 | if (lastElement >= 3) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 352 | NDN_THROW(Error("MustBeFresh element is out of order")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 353 | } |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 354 | if (element->value_size() != 0) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 355 | NDN_THROW(Error("MustBeFresh element has non-zero TLV-LENGTH")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 356 | } |
| 357 | m_selectors.setMustBeFresh(true); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 358 | lastElement = 3; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 359 | break; |
| 360 | } |
| 361 | case tlv::ForwardingHint: { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 362 | if (lastElement >= 4) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 363 | NDN_THROW(Error("ForwardingHint element is out of order")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 364 | } |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 365 | m_forwardingHint.wireDecode(*element); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 366 | lastElement = 4; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 367 | break; |
| 368 | } |
| 369 | case tlv::Nonce: { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 370 | if (lastElement >= 5) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 371 | NDN_THROW(Error("Nonce element is out of order")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 372 | } |
| 373 | uint32_t nonce = 0; |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 374 | if (element->value_size() != sizeof(nonce)) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 375 | NDN_THROW(Error("Nonce element is malformed")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 376 | } |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 377 | std::memcpy(&nonce, element->value(), sizeof(nonce)); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 378 | m_nonce = nonce; |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 379 | lastElement = 5; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 380 | break; |
| 381 | } |
| 382 | case tlv::InterestLifetime: { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 383 | if (lastElement >= 6) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 384 | NDN_THROW(Error("InterestLifetime element is out of order")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 385 | } |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 386 | m_interestLifetime = time::milliseconds(readNonNegativeInteger(*element)); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 387 | lastElement = 6; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 388 | break; |
| 389 | } |
| 390 | case tlv::HopLimit: { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 391 | if (lastElement >= 7) { |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 392 | break; // HopLimit is non-critical, ignore out-of-order appearance |
| 393 | } |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 394 | if (element->value_size() != 1) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 395 | NDN_THROW(Error("HopLimit element is malformed")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 396 | } |
| 397 | // TLV-VALUE is ignored |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 398 | lastElement = 7; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 399 | break; |
| 400 | } |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 401 | case tlv::ApplicationParameters: { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 402 | if (lastElement >= 8) { |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 403 | break; // ApplicationParameters is non-critical, ignore out-of-order appearance |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 404 | } |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 405 | m_parameters = *element; |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 406 | lastElement = 8; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 407 | break; |
| 408 | } |
| 409 | default: { |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 410 | if (tlv::isCriticalType(element->type())) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 411 | NDN_THROW(Error("Unrecognized element of critical type " + to_string(element->type()))); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 412 | } |
| 413 | break; |
| 414 | } |
| 415 | } |
| 416 | } |
Alexander Afanasyev | c393217 | 2014-07-10 18:53:56 -0700 | [diff] [blame] | 417 | } |
| 418 | |
Davide Pesavento | a84f464 | 2017-08-23 16:14:51 -0400 | [diff] [blame] | 419 | std::string |
| 420 | Interest::toUri() const |
| 421 | { |
| 422 | std::ostringstream os; |
| 423 | os << *this; |
| 424 | return os.str(); |
| 425 | } |
| 426 | |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 427 | // ---- matching ---- |
| 428 | |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 429 | bool |
Alexander Afanasyev | ff2d08f | 2014-04-07 18:28:25 -0700 | [diff] [blame] | 430 | Interest::matchesName(const Name& name) const |
Jeff Thompson | 25b4e61 | 2013-10-10 16:03:24 -0700 | [diff] [blame] | 431 | { |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 432 | if (name.size() < m_name.size()) |
| 433 | return false; |
| 434 | |
Alexander Afanasyev | c348f83 | 2014-02-17 16:35:17 -0800 | [diff] [blame] | 435 | if (!m_name.isPrefixOf(name)) |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 436 | return false; |
Alexander Afanasyev | aa0e7da | 2014-03-17 14:37:33 -0700 | [diff] [blame] | 437 | |
Alexander Afanasyev | c348f83 | 2014-02-17 16:35:17 -0800 | [diff] [blame] | 438 | if (getMinSuffixComponents() >= 0 && |
Alexander Afanasyev | 3b70310 | 2014-06-13 17:01:14 -0700 | [diff] [blame] | 439 | // name must include implicit digest |
| 440 | !(name.size() - m_name.size() >= static_cast<size_t>(getMinSuffixComponents()))) |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 441 | return false; |
| 442 | |
Alexander Afanasyev | c348f83 | 2014-02-17 16:35:17 -0800 | [diff] [blame] | 443 | if (getMaxSuffixComponents() >= 0 && |
Alexander Afanasyev | 3b70310 | 2014-06-13 17:01:14 -0700 | [diff] [blame] | 444 | // name must include implicit digest |
| 445 | !(name.size() - m_name.size() <= static_cast<size_t>(getMaxSuffixComponents()))) |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 446 | return false; |
| 447 | |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 448 | if (!getExclude().empty() && |
| 449 | name.size() > m_name.size() && |
Alexander Afanasyev | c348f83 | 2014-02-17 16:35:17 -0800 | [diff] [blame] | 450 | getExclude().isExcluded(name[m_name.size()])) |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 451 | return false; |
| 452 | |
| 453 | return true; |
Jeff Thompson | 25b4e61 | 2013-10-10 16:03:24 -0700 | [diff] [blame] | 454 | } |
| 455 | |
Junxiao Shi | af8eeea | 2014-03-31 20:10:56 -0700 | [diff] [blame] | 456 | bool |
| 457 | Interest::matchesData(const Data& data) const |
| 458 | { |
Junxiao Shi | 42c2362 | 2014-07-03 00:55:11 -0700 | [diff] [blame] | 459 | size_t interestNameLength = m_name.size(); |
| 460 | const Name& dataName = data.getName(); |
| 461 | size_t fullNameLength = dataName.size() + 1; |
| 462 | |
Junxiao Shi | 2ad2fbe | 2019-05-24 03:11:05 +0000 | [diff] [blame^] | 463 | // check Name and CanBePrefix |
Junxiao Shi | 42c2362 | 2014-07-03 00:55:11 -0700 | [diff] [blame] | 464 | if (interestNameLength == fullNameLength) { |
Alexander Afanasyev | 56860f5 | 2014-11-07 11:51:17 -0800 | [diff] [blame] | 465 | if (m_name.get(-1).isImplicitSha256Digest()) { |
Junxiao Shi | 2ad2fbe | 2019-05-24 03:11:05 +0000 | [diff] [blame^] | 466 | if (m_name != data.getFullName()) { |
Junxiao Shi | 42c2362 | 2014-07-03 00:55:11 -0700 | [diff] [blame] | 467 | return false; |
Junxiao Shi | 2ad2fbe | 2019-05-24 03:11:05 +0000 | [diff] [blame^] | 468 | } |
Junxiao Shi | 42c2362 | 2014-07-03 00:55:11 -0700 | [diff] [blame] | 469 | } |
| 470 | else { |
| 471 | // Interest Name is same length as Data full Name, but last component isn't digest |
| 472 | // so there's no possibility of matching |
| 473 | return false; |
| 474 | } |
| 475 | } |
Junxiao Shi | 2ad2fbe | 2019-05-24 03:11:05 +0000 | [diff] [blame^] | 476 | else if (getCanBePrefix() ? !m_name.isPrefixOf(dataName) : (m_name != dataName)) { |
| 477 | return false; |
Junxiao Shi | af8eeea | 2014-03-31 20:10:56 -0700 | [diff] [blame] | 478 | } |
| 479 | |
Junxiao Shi | 2ad2fbe | 2019-05-24 03:11:05 +0000 | [diff] [blame^] | 480 | // check MustBeFresh |
| 481 | if (getMustBeFresh() && data.getFreshnessPeriod() <= 0_ms) { |
| 482 | return false; |
Junxiao Shi | af8eeea | 2014-03-31 20:10:56 -0700 | [diff] [blame] | 483 | } |
| 484 | |
| 485 | return true; |
| 486 | } |
| 487 | |
Alexander Afanasyev | 1013fd0 | 2017-01-03 13:19:03 -0800 | [diff] [blame] | 488 | bool |
| 489 | Interest::matchesInterest(const Interest& other) const |
| 490 | { |
Junxiao Shi | 2ad2fbe | 2019-05-24 03:11:05 +0000 | [diff] [blame^] | 491 | return getName() == other.getName() && |
| 492 | getCanBePrefix() == other.getCanBePrefix() && |
| 493 | getMustBeFresh() == other.getMustBeFresh(); |
Alexander Afanasyev | 1013fd0 | 2017-01-03 13:19:03 -0800 | [diff] [blame] | 494 | } |
| 495 | |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 496 | // ---- field accessors ---- |
| 497 | |
| 498 | uint32_t |
| 499 | Interest::getNonce() const |
| 500 | { |
Junxiao Shi | 2dd711d | 2017-07-21 13:40:52 +0000 | [diff] [blame] | 501 | if (!m_nonce) { |
| 502 | m_nonce = random::generateWord32(); |
Junxiao Shi | c2ac5d2 | 2017-07-17 22:18:31 +0000 | [diff] [blame] | 503 | } |
Junxiao Shi | 2dd711d | 2017-07-21 13:40:52 +0000 | [diff] [blame] | 504 | return *m_nonce; |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 505 | } |
| 506 | |
| 507 | Interest& |
| 508 | Interest::setNonce(uint32_t nonce) |
| 509 | { |
Junxiao Shi | 2dd711d | 2017-07-21 13:40:52 +0000 | [diff] [blame] | 510 | m_nonce = nonce; |
| 511 | m_wire.reset(); |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 512 | return *this; |
| 513 | } |
| 514 | |
| 515 | void |
| 516 | Interest::refreshNonce() |
| 517 | { |
| 518 | if (!hasNonce()) |
| 519 | return; |
| 520 | |
| 521 | uint32_t oldNonce = getNonce(); |
| 522 | uint32_t newNonce = oldNonce; |
| 523 | while (newNonce == oldNonce) |
| 524 | newNonce = random::generateWord32(); |
| 525 | |
| 526 | setNonce(newNonce); |
| 527 | } |
| 528 | |
Eric Newberry | b555b00 | 2017-05-17 00:30:44 -0700 | [diff] [blame] | 529 | Interest& |
Junxiao Shi | 8d3f834 | 2018-04-04 12:46:37 +0000 | [diff] [blame] | 530 | Interest::setInterestLifetime(time::milliseconds lifetime) |
Eric Newberry | b555b00 | 2017-05-17 00:30:44 -0700 | [diff] [blame] | 531 | { |
Davide Pesavento | fccb2dc | 2019-02-09 01:02:35 -0500 | [diff] [blame] | 532 | if (lifetime < 0_ms) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 533 | NDN_THROW(std::invalid_argument("InterestLifetime must be >= 0")); |
Eric Newberry | b555b00 | 2017-05-17 00:30:44 -0700 | [diff] [blame] | 534 | } |
Junxiao Shi | 8d3f834 | 2018-04-04 12:46:37 +0000 | [diff] [blame] | 535 | m_interestLifetime = lifetime; |
Eric Newberry | b555b00 | 2017-05-17 00:30:44 -0700 | [diff] [blame] | 536 | m_wire.reset(); |
| 537 | return *this; |
| 538 | } |
| 539 | |
Junxiao Shi | 9c154cb | 2017-07-07 22:14:54 +0000 | [diff] [blame] | 540 | Interest& |
| 541 | Interest::setForwardingHint(const DelegationList& value) |
| 542 | { |
| 543 | m_forwardingHint = value; |
| 544 | m_wire.reset(); |
| 545 | return *this; |
| 546 | } |
| 547 | |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 548 | Interest& |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 549 | Interest::setApplicationParameters(const Block& parameters) |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 550 | { |
Davide Pesavento | 3891244 | 2019-04-06 22:03:39 -0400 | [diff] [blame] | 551 | if (parameters.empty()) { |
| 552 | m_parameters = Block(tlv::ApplicationParameters); |
| 553 | } |
| 554 | else if (parameters.type() == tlv::ApplicationParameters) { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 555 | m_parameters = parameters; |
| 556 | } |
| 557 | else { |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 558 | m_parameters = Block(tlv::ApplicationParameters, parameters); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 559 | } |
| 560 | m_wire.reset(); |
| 561 | return *this; |
| 562 | } |
| 563 | |
| 564 | Interest& |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 565 | Interest::setApplicationParameters(const uint8_t* buffer, size_t bufferSize) |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 566 | { |
Davide Pesavento | 3891244 | 2019-04-06 22:03:39 -0400 | [diff] [blame] | 567 | if (buffer == nullptr && bufferSize != 0) { |
| 568 | NDN_THROW(std::invalid_argument("ApplicationParameters buffer cannot be nullptr")); |
| 569 | } |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 570 | m_parameters = makeBinaryBlock(tlv::ApplicationParameters, buffer, bufferSize); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 571 | m_wire.reset(); |
| 572 | return *this; |
| 573 | } |
| 574 | |
| 575 | Interest& |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 576 | Interest::setApplicationParameters(ConstBufferPtr buffer) |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 577 | { |
Davide Pesavento | 3891244 | 2019-04-06 22:03:39 -0400 | [diff] [blame] | 578 | if (buffer == nullptr) { |
| 579 | NDN_THROW(std::invalid_argument("ApplicationParameters buffer cannot be nullptr")); |
| 580 | } |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 581 | m_parameters = Block(tlv::ApplicationParameters, std::move(buffer)); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 582 | m_wire.reset(); |
| 583 | return *this; |
| 584 | } |
| 585 | |
| 586 | Interest& |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 587 | Interest::unsetApplicationParameters() |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 588 | { |
Davide Pesavento | fccb2dc | 2019-02-09 01:02:35 -0500 | [diff] [blame] | 589 | m_parameters = {}; |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 590 | m_wire.reset(); |
| 591 | return *this; |
| 592 | } |
| 593 | |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 594 | // ---- operators ---- |
| 595 | |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 596 | bool |
| 597 | operator==(const Interest& lhs, const Interest& rhs) |
| 598 | { |
| 599 | bool wasCanBePrefixSetOnLhs = lhs.m_isCanBePrefixSet; |
| 600 | bool wasCanBePrefixSetOnRhs = rhs.m_isCanBePrefixSet; |
| 601 | lhs.m_isCanBePrefixSet = true; |
| 602 | rhs.m_isCanBePrefixSet = true; |
| 603 | BOOST_SCOPE_EXIT_ALL(&) { |
| 604 | lhs.m_isCanBePrefixSet = wasCanBePrefixSetOnLhs; |
| 605 | rhs.m_isCanBePrefixSet = wasCanBePrefixSetOnRhs; |
| 606 | }; |
| 607 | |
| 608 | return lhs.wireEncode() == rhs.wireEncode(); |
| 609 | } |
| 610 | |
Alexander Afanasyev | ff2d08f | 2014-04-07 18:28:25 -0700 | [diff] [blame] | 611 | std::ostream& |
| 612 | operator<<(std::ostream& os, const Interest& interest) |
Jeff Thompson | fe55686 | 2013-07-09 13:52:55 -0700 | [diff] [blame] | 613 | { |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 614 | os << interest.getName(); |
Jeff Thompson | fe55686 | 2013-07-09 13:52:55 -0700 | [diff] [blame] | 615 | |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 616 | char delim = '?'; |
| 617 | |
| 618 | if (interest.getMinSuffixComponents() >= 0) { |
| 619 | os << delim << "ndn.MinSuffixComponents=" << interest.getMinSuffixComponents(); |
| 620 | delim = '&'; |
Jeff Thompson | fe55686 | 2013-07-09 13:52:55 -0700 | [diff] [blame] | 621 | } |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 622 | if (interest.getMaxSuffixComponents() >= 0) { |
| 623 | os << delim << "ndn.MaxSuffixComponents=" << interest.getMaxSuffixComponents(); |
| 624 | delim = '&'; |
Jeff Thompson | 37527d6 | 2013-08-21 11:15:54 -0700 | [diff] [blame] | 625 | } |
Eric Newberry | b555b00 | 2017-05-17 00:30:44 -0700 | [diff] [blame] | 626 | if (interest.getChildSelector() != DEFAULT_CHILD_SELECTOR) { |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 627 | os << delim << "ndn.ChildSelector=" << interest.getChildSelector(); |
| 628 | delim = '&'; |
Jeff Thompson | 13e280b | 2013-12-03 13:12:23 -0800 | [diff] [blame] | 629 | } |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 630 | if (interest.getMustBeFresh()) { |
| 631 | os << delim << "ndn.MustBeFresh=" << interest.getMustBeFresh(); |
| 632 | delim = '&'; |
Jeff Thompson | 13e280b | 2013-12-03 13:12:23 -0800 | [diff] [blame] | 633 | } |
Eric Newberry | b555b00 | 2017-05-17 00:30:44 -0700 | [diff] [blame] | 634 | if (interest.getInterestLifetime() != DEFAULT_INTEREST_LIFETIME) { |
Alexander Afanasyev | a0c5f83 | 2014-06-19 13:27:56 -0700 | [diff] [blame] | 635 | os << delim << "ndn.InterestLifetime=" << interest.getInterestLifetime().count(); |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 636 | delim = '&'; |
| 637 | } |
Alexander Afanasyev | e881e93 | 2014-06-08 14:47:03 +0300 | [diff] [blame] | 638 | if (interest.hasNonce()) { |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 639 | os << delim << "ndn.Nonce=" << interest.getNonce(); |
| 640 | delim = '&'; |
| 641 | } |
| 642 | if (!interest.getExclude().empty()) { |
| 643 | os << delim << "ndn.Exclude=" << interest.getExclude(); |
| 644 | delim = '&'; |
| 645 | } |
| 646 | |
| 647 | return os; |
Jeff Thompson | 13e280b | 2013-12-03 13:12:23 -0800 | [diff] [blame] | 648 | } |
| 649 | |
Junxiao Shi | 08d0708 | 2014-12-03 11:31:44 -0700 | [diff] [blame] | 650 | } // namespace ndn |