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" |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 24 | #include "ndn-cxx/encoding/buffer-stream.hpp" |
| 25 | #include "ndn-cxx/security/transform/digest-filter.hpp" |
| 26 | #include "ndn-cxx/security/transform/step-source.hpp" |
| 27 | #include "ndn-cxx/security/transform/stream-sink.hpp" |
Davide Pesavento | 7e78064 | 2018-11-24 15:51:34 -0500 | [diff] [blame] | 28 | #include "ndn-cxx/util/random.hpp" |
Alexander Afanasyev | 840139f | 2013-12-28 15:02:50 -0800 | [diff] [blame] | 29 | |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 30 | #include <boost/scope_exit.hpp> |
| 31 | |
Davide Pesavento | 4bb06bc | 2019-04-06 13:59:10 -0400 | [diff] [blame] | 32 | #ifdef NDN_CXX_HAVE_STACKTRACE |
| 33 | #include <boost/stacktrace/stacktrace.hpp> |
| 34 | #endif |
| 35 | |
Davide Pesavento | e178989 | 2017-02-26 15:50:52 -0500 | [diff] [blame] | 36 | #include <cstring> |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 37 | #include <iostream> |
Davide Pesavento | a84f464 | 2017-08-23 16:14:51 -0400 | [diff] [blame] | 38 | #include <sstream> |
Davide Pesavento | e178989 | 2017-02-26 15:50:52 -0500 | [diff] [blame] | 39 | |
Jeff Thompson | b7f9556 | 2013-07-03 18:36:42 -0700 | [diff] [blame] | 40 | namespace ndn { |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 41 | |
Junxiao Shi | c2b8d24 | 2014-11-04 08:35:29 -0700 | [diff] [blame] | 42 | BOOST_CONCEPT_ASSERT((boost::EqualityComparable<Interest>)); |
| 43 | BOOST_CONCEPT_ASSERT((WireEncodable<Interest>)); |
Alexander Afanasyev | d5c48e0 | 2015-06-24 11:58:14 -0700 | [diff] [blame] | 44 | BOOST_CONCEPT_ASSERT((WireEncodableWithEncodingBuffer<Interest>)); |
Junxiao Shi | c2b8d24 | 2014-11-04 08:35:29 -0700 | [diff] [blame] | 45 | BOOST_CONCEPT_ASSERT((WireDecodable<Interest>)); |
| 46 | static_assert(std::is_base_of<tlv::Error, Interest::Error>::value, |
| 47 | "Interest::Error must inherit from tlv::Error"); |
| 48 | |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 49 | #ifdef NDN_CXX_HAVE_TESTS |
| 50 | bool Interest::s_errorIfCanBePrefixUnset = true; |
| 51 | #endif // NDN_CXX_HAVE_TESTS |
| 52 | boost::logic::tribool Interest::s_defaultCanBePrefix = boost::logic::indeterminate; |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 53 | bool Interest::s_autoCheckParametersDigest = true; |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 54 | |
Junxiao Shi | 8d3f834 | 2018-04-04 12:46:37 +0000 | [diff] [blame] | 55 | Interest::Interest(const Name& name, time::milliseconds lifetime) |
Junxiao Shi | 2af905b | 2014-11-27 13:10:54 -0700 | [diff] [blame] | 56 | { |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 57 | setName(name); |
| 58 | setInterestLifetime(lifetime); |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 59 | |
| 60 | if (!boost::logic::indeterminate(s_defaultCanBePrefix)) { |
Davide Pesavento | 4bb06bc | 2019-04-06 13:59:10 -0400 | [diff] [blame] | 61 | setCanBePrefix(bool(s_defaultCanBePrefix)); |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 62 | } |
Junxiao Shi | 2af905b | 2014-11-27 13:10:54 -0700 | [diff] [blame] | 63 | } |
| 64 | |
Junxiao Shi | 2af905b | 2014-11-27 13:10:54 -0700 | [diff] [blame] | 65 | Interest::Interest(const Block& wire) |
| 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 | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 101 | if (getHopLimit() || 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 | { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 113 | // Encode as NDN Packet Format v0.2 |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 114 | // Interest ::= INTEREST-TYPE TLV-LENGTH |
| 115 | // Name |
| 116 | // Selectors? |
| 117 | // Nonce |
| 118 | // InterestLifetime? |
Junxiao Shi | 9c154cb | 2017-07-07 22:14:54 +0000 | [diff] [blame] | 119 | // ForwardingHint? |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 120 | // (elements are encoded in reverse order) |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 121 | |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 122 | size_t totalLength = 0; |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 123 | |
Junxiao Shi | 9c154cb | 2017-07-07 22:14:54 +0000 | [diff] [blame] | 124 | // ForwardingHint |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 125 | if (getForwardingHint().size() > 0) { |
| 126 | totalLength += getForwardingHint().wireEncode(encoder); |
Junxiao Shi | 9c154cb | 2017-07-07 22:14:54 +0000 | [diff] [blame] | 127 | } |
| 128 | |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 129 | // InterestLifetime |
| 130 | if (getInterestLifetime() != DEFAULT_INTEREST_LIFETIME) { |
Davide Pesavento | fccb2dc | 2019-02-09 01:02:35 -0500 | [diff] [blame] | 131 | totalLength += prependNonNegativeIntegerBlock(encoder, tlv::InterestLifetime, |
| 132 | static_cast<uint64_t>(getInterestLifetime().count())); |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 133 | } |
| 134 | |
| 135 | // Nonce |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 136 | uint32_t nonce = getNonce(); // if nonce was unset, this generates a fresh nonce |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 137 | totalLength += encoder.prependByteArrayBlock(tlv::Nonce, reinterpret_cast<uint8_t*>(&nonce), sizeof(nonce)); |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 138 | |
| 139 | // Selectors |
| 140 | if (hasSelectors()) { |
| 141 | totalLength += getSelectors().wireEncode(encoder); |
| 142 | } |
| 143 | |
| 144 | // Name |
| 145 | totalLength += getName().wireEncode(encoder); |
| 146 | |
| 147 | totalLength += encoder.prependVarNumber(totalLength); |
| 148 | totalLength += encoder.prependVarNumber(tlv::Interest); |
| 149 | return totalLength; |
Alexander Afanasyev | 840139f | 2013-12-28 15:02:50 -0800 | [diff] [blame] | 150 | } |
| 151 | |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 152 | template<encoding::Tag TAG> |
| 153 | size_t |
| 154 | Interest::encode03(EncodingImpl<TAG>& encoder) const |
| 155 | { |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 156 | // Encode as NDN Packet Format v0.3 |
| 157 | // Interest = INTEREST-TYPE TLV-LENGTH |
| 158 | // Name |
| 159 | // [CanBePrefix] |
| 160 | // [MustBeFresh] |
| 161 | // [ForwardingHint] |
| 162 | // [Nonce] |
| 163 | // [InterestLifetime] |
| 164 | // [HopLimit] |
| 165 | // [ApplicationParameters [InterestSignature]] |
| 166 | // (elements are encoded in reverse order) |
| 167 | |
| 168 | // sanity check of ApplicationParameters and ParametersSha256DigestComponent |
| 169 | ssize_t digestIndex = findParametersDigestComponent(getName()); |
| 170 | BOOST_ASSERT(digestIndex != -2); // guaranteed by the checks in setName() and wireDecode() |
| 171 | if (digestIndex == -1) { |
| 172 | if (hasApplicationParameters()) |
| 173 | NDN_THROW(Error("Interest with parameters must have a ParametersSha256DigestComponent")); |
| 174 | } |
| 175 | else if (!hasApplicationParameters()) { |
| 176 | NDN_THROW(Error("Interest without parameters must not have a ParametersSha256DigestComponent")); |
| 177 | } |
| 178 | |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 179 | size_t totalLength = 0; |
| 180 | |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 181 | // ApplicationParameters and following elements (in reverse order) |
| 182 | std::for_each(m_parameters.rbegin(), m_parameters.rend(), [&] (const Block& b) { |
| 183 | totalLength += encoder.prependBlock(b); |
| 184 | }); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 185 | |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 186 | // HopLimit |
| 187 | if (getHopLimit()) { |
| 188 | uint8_t hopLimit = *getHopLimit(); |
| 189 | totalLength += encoder.prependByteArrayBlock(tlv::HopLimit, &hopLimit, sizeof(hopLimit)); |
| 190 | } |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 191 | |
| 192 | // InterestLifetime |
| 193 | if (getInterestLifetime() != DEFAULT_INTEREST_LIFETIME) { |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 194 | totalLength += prependNonNegativeIntegerBlock(encoder, tlv::InterestLifetime, |
| 195 | static_cast<uint64_t>(getInterestLifetime().count())); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 196 | } |
| 197 | |
| 198 | // Nonce |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 199 | uint32_t nonce = getNonce(); // if nonce was unset, this generates a fresh nonce |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 200 | totalLength += encoder.prependByteArrayBlock(tlv::Nonce, reinterpret_cast<uint8_t*>(&nonce), sizeof(nonce)); |
| 201 | |
| 202 | // ForwardingHint |
Davide Pesavento | fccb2dc | 2019-02-09 01:02:35 -0500 | [diff] [blame] | 203 | if (!getForwardingHint().empty()) { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 204 | totalLength += getForwardingHint().wireEncode(encoder); |
| 205 | } |
| 206 | |
| 207 | // MustBeFresh |
| 208 | if (getMustBeFresh()) { |
| 209 | totalLength += prependEmptyBlock(encoder, tlv::MustBeFresh); |
| 210 | } |
| 211 | |
| 212 | // CanBePrefix |
| 213 | if (getCanBePrefix()) { |
| 214 | totalLength += prependEmptyBlock(encoder, tlv::CanBePrefix); |
| 215 | } |
| 216 | |
| 217 | // Name |
| 218 | totalLength += getName().wireEncode(encoder); |
| 219 | |
| 220 | totalLength += encoder.prependVarNumber(totalLength); |
| 221 | totalLength += encoder.prependVarNumber(tlv::Interest); |
| 222 | return totalLength; |
| 223 | } |
| 224 | |
Davide Pesavento | 88a0d81 | 2017-08-19 21:31:42 -0400 | [diff] [blame] | 225 | NDN_CXX_DEFINE_WIRE_ENCODE_INSTANTIATIONS(Interest); |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 226 | |
| 227 | const Block& |
| 228 | Interest::wireEncode() const |
Alexander Afanasyev | e881e93 | 2014-06-08 14:47:03 +0300 | [diff] [blame] | 229 | { |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 230 | if (m_wire.hasWire()) |
| 231 | return m_wire; |
| 232 | |
| 233 | EncodingEstimator estimator; |
| 234 | size_t estimatedSize = wireEncode(estimator); |
| 235 | |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 236 | EncodingBuffer encoder(estimatedSize, 0); |
| 237 | wireEncode(encoder); |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 238 | |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 239 | const_cast<Interest*>(this)->wireDecode(encoder.block()); |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 240 | return m_wire; |
Alexander Afanasyev | e881e93 | 2014-06-08 14:47:03 +0300 | [diff] [blame] | 241 | } |
Alexander Afanasyev | 840139f | 2013-12-28 15:02:50 -0800 | [diff] [blame] | 242 | |
Alexander Afanasyev | c393217 | 2014-07-10 18:53:56 -0700 | [diff] [blame] | 243 | void |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 244 | Interest::wireDecode(const Block& wire) |
Alexander Afanasyev | c393217 | 2014-07-10 18:53:56 -0700 | [diff] [blame] | 245 | { |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 246 | if (wire.type() != tlv::Interest) { |
| 247 | NDN_THROW(Error("Interest", wire.type())); |
| 248 | } |
| 249 | |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 250 | m_wire = wire; |
| 251 | m_wire.parse(); |
Alexander Afanasyev | c393217 | 2014-07-10 18:53:56 -0700 | [diff] [blame] | 252 | |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 253 | if (!decode02()) { |
| 254 | decode03(); |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 255 | getNonce(); // force generation of nonce |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 256 | } |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 257 | |
| 258 | m_isCanBePrefixSet = true; // don't trigger warning from decoded packet |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 259 | } |
| 260 | |
| 261 | bool |
| 262 | Interest::decode02() |
| 263 | { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 264 | auto element = m_wire.elements_begin(); |
Alexander Afanasyev | c393217 | 2014-07-10 18:53:56 -0700 | [diff] [blame] | 265 | |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 266 | // Name |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 267 | if (element != m_wire.elements_end() && element->type() == tlv::Name) { |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 268 | // decode into a temporary object until we determine that the name is valid, in order |
| 269 | // to maintain class invariants and thus provide a basic form of exception safety |
| 270 | Name tempName(*element); |
| 271 | ssize_t digestIndex = findParametersDigestComponent(tempName); |
| 272 | if (digestIndex == -2) { |
| 273 | NDN_THROW(Error("Name has more than one ParametersSha256DigestComponent")); |
| 274 | } |
| 275 | m_name = std::move(tempName); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 276 | ++element; |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 277 | } |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 278 | else { |
| 279 | return false; |
| 280 | } |
| 281 | |
| 282 | // Selectors? |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 283 | if (element != m_wire.elements_end() && element->type() == tlv::Selectors) { |
| 284 | m_selectors.wireDecode(*element); |
| 285 | ++element; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 286 | } |
| 287 | else { |
Davide Pesavento | fccb2dc | 2019-02-09 01:02:35 -0500 | [diff] [blame] | 288 | m_selectors = {}; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 289 | } |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 290 | |
| 291 | // Nonce |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 292 | if (element != m_wire.elements_end() && element->type() == tlv::Nonce) { |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 293 | uint32_t nonce = 0; |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 294 | if (element->value_size() != sizeof(nonce)) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 295 | NDN_THROW(Error("Nonce element is malformed")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 296 | } |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 297 | std::memcpy(&nonce, element->value(), sizeof(nonce)); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 298 | m_nonce = nonce; |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 299 | ++element; |
Junxiao Shi | 2dd711d | 2017-07-21 13:40:52 +0000 | [diff] [blame] | 300 | } |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 301 | else { |
| 302 | return false; |
Junxiao Shi | 2dd711d | 2017-07-21 13:40:52 +0000 | [diff] [blame] | 303 | } |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 304 | |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 305 | // InterestLifetime? |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 306 | if (element != m_wire.elements_end() && element->type() == tlv::InterestLifetime) { |
| 307 | m_interestLifetime = time::milliseconds(readNonNegativeInteger(*element)); |
| 308 | ++element; |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 309 | } |
| 310 | else { |
| 311 | m_interestLifetime = DEFAULT_INTEREST_LIFETIME; |
| 312 | } |
| 313 | |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 314 | // ForwardingHint? |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 315 | if (element != m_wire.elements_end() && element->type() == tlv::ForwardingHint) { |
| 316 | m_forwardingHint.wireDecode(*element, false); |
| 317 | ++element; |
Junxiao Shi | 9c154cb | 2017-07-07 22:14:54 +0000 | [diff] [blame] | 318 | } |
| 319 | else { |
Davide Pesavento | fccb2dc | 2019-02-09 01:02:35 -0500 | [diff] [blame] | 320 | m_forwardingHint = {}; |
Junxiao Shi | 9c154cb | 2017-07-07 22:14:54 +0000 | [diff] [blame] | 321 | } |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 322 | |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 323 | return element == m_wire.elements_end(); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 324 | } |
| 325 | |
| 326 | void |
| 327 | Interest::decode03() |
| 328 | { |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 329 | // Interest = INTEREST-TYPE TLV-LENGTH |
| 330 | // Name |
| 331 | // [CanBePrefix] |
| 332 | // [MustBeFresh] |
| 333 | // [ForwardingHint] |
| 334 | // [Nonce] |
| 335 | // [InterestLifetime] |
| 336 | // [HopLimit] |
| 337 | // [ApplicationParameters [InterestSignature]] |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 338 | |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 339 | auto element = m_wire.elements_begin(); |
| 340 | if (element == m_wire.elements_end() || element->type() != tlv::Name) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 341 | NDN_THROW(Error("Name element is missing or out of order")); |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 342 | } |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 343 | // decode into a temporary object until we determine that the name is valid, in order |
| 344 | // to maintain class invariants and thus provide a basic form of exception safety |
| 345 | Name tempName(*element); |
| 346 | if (tempName.empty()) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 347 | NDN_THROW(Error("Name has zero name components")); |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 348 | } |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 349 | ssize_t digestIndex = findParametersDigestComponent(tempName); |
| 350 | if (digestIndex == -2) { |
| 351 | NDN_THROW(Error("Name has more than one ParametersSha256DigestComponent")); |
| 352 | } |
| 353 | m_name = std::move(tempName); |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 354 | |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 355 | m_selectors = Selectors().setMaxSuffixComponents(1); // CanBePrefix=0 |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 356 | m_forwardingHint = {}; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 357 | m_nonce.reset(); |
| 358 | m_interestLifetime = DEFAULT_INTEREST_LIFETIME; |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 359 | m_hopLimit.reset(); |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 360 | m_parameters.clear(); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 361 | |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 362 | int lastElement = 1; // last recognized element index, in spec order |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 363 | for (++element; element != m_wire.elements_end(); ++element) { |
| 364 | switch (element->type()) { |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 365 | case tlv::CanBePrefix: { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 366 | if (lastElement >= 2) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 367 | NDN_THROW(Error("CanBePrefix element is out of order")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 368 | } |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 369 | if (element->value_size() != 0) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 370 | NDN_THROW(Error("CanBePrefix element has non-zero TLV-LENGTH")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 371 | } |
| 372 | m_selectors.setMaxSuffixComponents(-1); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 373 | lastElement = 2; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 374 | break; |
| 375 | } |
| 376 | case tlv::MustBeFresh: { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 377 | if (lastElement >= 3) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 378 | NDN_THROW(Error("MustBeFresh element is out of order")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 379 | } |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 380 | if (element->value_size() != 0) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 381 | NDN_THROW(Error("MustBeFresh element has non-zero TLV-LENGTH")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 382 | } |
| 383 | m_selectors.setMustBeFresh(true); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 384 | lastElement = 3; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 385 | break; |
| 386 | } |
| 387 | case tlv::ForwardingHint: { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 388 | if (lastElement >= 4) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 389 | NDN_THROW(Error("ForwardingHint element is out of order")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 390 | } |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 391 | m_forwardingHint.wireDecode(*element); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 392 | lastElement = 4; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 393 | break; |
| 394 | } |
| 395 | case tlv::Nonce: { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 396 | if (lastElement >= 5) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 397 | NDN_THROW(Error("Nonce element is out of order")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 398 | } |
| 399 | uint32_t nonce = 0; |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 400 | if (element->value_size() != sizeof(nonce)) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 401 | NDN_THROW(Error("Nonce element is malformed")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 402 | } |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 403 | std::memcpy(&nonce, element->value(), sizeof(nonce)); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 404 | m_nonce = nonce; |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 405 | lastElement = 5; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 406 | break; |
| 407 | } |
| 408 | case tlv::InterestLifetime: { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 409 | if (lastElement >= 6) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 410 | NDN_THROW(Error("InterestLifetime element is out of order")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 411 | } |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 412 | m_interestLifetime = time::milliseconds(readNonNegativeInteger(*element)); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 413 | lastElement = 6; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 414 | break; |
| 415 | } |
| 416 | case tlv::HopLimit: { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 417 | if (lastElement >= 7) { |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 418 | break; // HopLimit is non-critical, ignore out-of-order appearance |
| 419 | } |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 420 | if (element->value_size() != 1) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 421 | NDN_THROW(Error("HopLimit element is malformed")); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 422 | } |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 423 | m_hopLimit = *element->value(); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 424 | lastElement = 7; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 425 | break; |
| 426 | } |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 427 | case tlv::ApplicationParameters: { |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 428 | if (lastElement >= 8) { |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 429 | break; // ApplicationParameters is non-critical, ignore out-of-order appearance |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 430 | } |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 431 | BOOST_ASSERT(!hasApplicationParameters()); |
| 432 | m_parameters.push_back(*element); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 433 | lastElement = 8; |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 434 | break; |
| 435 | } |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 436 | default: { // unrecognized element |
| 437 | // if the TLV-TYPE is critical, abort decoding |
Junxiao Shi | 8b753a2 | 2018-10-24 01:51:40 +0000 | [diff] [blame] | 438 | if (tlv::isCriticalType(element->type())) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 439 | NDN_THROW(Error("Unrecognized element of critical type " + to_string(element->type()))); |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 440 | } |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 441 | // if we already encountered ApplicationParameters, store this element as parameter |
| 442 | if (hasApplicationParameters()) { |
| 443 | m_parameters.push_back(*element); |
| 444 | } |
| 445 | // otherwise, ignore it |
Junxiao Shi | 6efa3b7 | 2018-04-14 15:54:08 +0000 | [diff] [blame] | 446 | break; |
| 447 | } |
| 448 | } |
| 449 | } |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 450 | |
| 451 | if (s_autoCheckParametersDigest && !isParametersDigestValid()) { |
| 452 | NDN_THROW(Error("ParametersSha256DigestComponent does not match the SHA-256 of Interest parameters")); |
| 453 | } |
Alexander Afanasyev | c393217 | 2014-07-10 18:53:56 -0700 | [diff] [blame] | 454 | } |
| 455 | |
Davide Pesavento | a84f464 | 2017-08-23 16:14:51 -0400 | [diff] [blame] | 456 | std::string |
| 457 | Interest::toUri() const |
| 458 | { |
| 459 | std::ostringstream os; |
| 460 | os << *this; |
| 461 | return os.str(); |
| 462 | } |
| 463 | |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 464 | // ---- matching ---- |
| 465 | |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 466 | bool |
Alexander Afanasyev | ff2d08f | 2014-04-07 18:28:25 -0700 | [diff] [blame] | 467 | Interest::matchesName(const Name& name) const |
Jeff Thompson | 25b4e61 | 2013-10-10 16:03:24 -0700 | [diff] [blame] | 468 | { |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 469 | if (name.size() < m_name.size()) |
| 470 | return false; |
| 471 | |
Alexander Afanasyev | c348f83 | 2014-02-17 16:35:17 -0800 | [diff] [blame] | 472 | if (!m_name.isPrefixOf(name)) |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 473 | return false; |
Alexander Afanasyev | aa0e7da | 2014-03-17 14:37:33 -0700 | [diff] [blame] | 474 | |
Alexander Afanasyev | c348f83 | 2014-02-17 16:35:17 -0800 | [diff] [blame] | 475 | if (getMinSuffixComponents() >= 0 && |
Alexander Afanasyev | 3b70310 | 2014-06-13 17:01:14 -0700 | [diff] [blame] | 476 | // name must include implicit digest |
| 477 | !(name.size() - m_name.size() >= static_cast<size_t>(getMinSuffixComponents()))) |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 478 | return false; |
| 479 | |
Alexander Afanasyev | c348f83 | 2014-02-17 16:35:17 -0800 | [diff] [blame] | 480 | if (getMaxSuffixComponents() >= 0 && |
Alexander Afanasyev | 3b70310 | 2014-06-13 17:01:14 -0700 | [diff] [blame] | 481 | // name must include implicit digest |
| 482 | !(name.size() - m_name.size() <= static_cast<size_t>(getMaxSuffixComponents()))) |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 483 | return false; |
| 484 | |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 485 | if (!getExclude().empty() && |
| 486 | name.size() > m_name.size() && |
Alexander Afanasyev | c348f83 | 2014-02-17 16:35:17 -0800 | [diff] [blame] | 487 | getExclude().isExcluded(name[m_name.size()])) |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 488 | return false; |
| 489 | |
| 490 | return true; |
Jeff Thompson | 25b4e61 | 2013-10-10 16:03:24 -0700 | [diff] [blame] | 491 | } |
| 492 | |
Junxiao Shi | af8eeea | 2014-03-31 20:10:56 -0700 | [diff] [blame] | 493 | bool |
| 494 | Interest::matchesData(const Data& data) const |
| 495 | { |
Junxiao Shi | 42c2362 | 2014-07-03 00:55:11 -0700 | [diff] [blame] | 496 | size_t interestNameLength = m_name.size(); |
| 497 | const Name& dataName = data.getName(); |
| 498 | size_t fullNameLength = dataName.size() + 1; |
| 499 | |
Junxiao Shi | 2ad2fbe | 2019-05-24 03:11:05 +0000 | [diff] [blame] | 500 | // check Name and CanBePrefix |
Junxiao Shi | 42c2362 | 2014-07-03 00:55:11 -0700 | [diff] [blame] | 501 | if (interestNameLength == fullNameLength) { |
Alexander Afanasyev | 56860f5 | 2014-11-07 11:51:17 -0800 | [diff] [blame] | 502 | if (m_name.get(-1).isImplicitSha256Digest()) { |
Junxiao Shi | 2ad2fbe | 2019-05-24 03:11:05 +0000 | [diff] [blame] | 503 | if (m_name != data.getFullName()) { |
Junxiao Shi | 42c2362 | 2014-07-03 00:55:11 -0700 | [diff] [blame] | 504 | return false; |
Junxiao Shi | 2ad2fbe | 2019-05-24 03:11:05 +0000 | [diff] [blame] | 505 | } |
Junxiao Shi | 42c2362 | 2014-07-03 00:55:11 -0700 | [diff] [blame] | 506 | } |
| 507 | else { |
| 508 | // Interest Name is same length as Data full Name, but last component isn't digest |
| 509 | // so there's no possibility of matching |
| 510 | return false; |
| 511 | } |
| 512 | } |
Junxiao Shi | 2ad2fbe | 2019-05-24 03:11:05 +0000 | [diff] [blame] | 513 | else if (getCanBePrefix() ? !m_name.isPrefixOf(dataName) : (m_name != dataName)) { |
| 514 | return false; |
Junxiao Shi | af8eeea | 2014-03-31 20:10:56 -0700 | [diff] [blame] | 515 | } |
| 516 | |
Junxiao Shi | 2ad2fbe | 2019-05-24 03:11:05 +0000 | [diff] [blame] | 517 | // check MustBeFresh |
| 518 | if (getMustBeFresh() && data.getFreshnessPeriod() <= 0_ms) { |
| 519 | return false; |
Junxiao Shi | af8eeea | 2014-03-31 20:10:56 -0700 | [diff] [blame] | 520 | } |
| 521 | |
| 522 | return true; |
| 523 | } |
| 524 | |
Alexander Afanasyev | 1013fd0 | 2017-01-03 13:19:03 -0800 | [diff] [blame] | 525 | bool |
| 526 | Interest::matchesInterest(const Interest& other) const |
| 527 | { |
Junxiao Shi | 2ad2fbe | 2019-05-24 03:11:05 +0000 | [diff] [blame] | 528 | return getName() == other.getName() && |
| 529 | getCanBePrefix() == other.getCanBePrefix() && |
| 530 | getMustBeFresh() == other.getMustBeFresh(); |
Alexander Afanasyev | 1013fd0 | 2017-01-03 13:19:03 -0800 | [diff] [blame] | 531 | } |
| 532 | |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 533 | // ---- field accessors and modifiers ---- |
| 534 | |
| 535 | Interest& |
| 536 | Interest::setName(const Name& name) |
| 537 | { |
| 538 | ssize_t digestIndex = findParametersDigestComponent(name); |
| 539 | if (digestIndex == -2) { |
| 540 | NDN_THROW(std::invalid_argument("Name cannot have more than one ParametersSha256DigestComponent")); |
| 541 | } |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 542 | if (name != m_name) { |
| 543 | m_name = name; |
| 544 | if (hasApplicationParameters()) { |
| 545 | addOrReplaceParametersDigestComponent(); |
| 546 | } |
| 547 | m_wire.reset(); |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 548 | } |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 549 | return *this; |
| 550 | } |
| 551 | |
| 552 | Interest& |
| 553 | Interest::setForwardingHint(const DelegationList& value) |
| 554 | { |
| 555 | m_forwardingHint = value; |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 556 | m_wire.reset(); |
| 557 | return *this; |
| 558 | } |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 559 | |
| 560 | uint32_t |
| 561 | Interest::getNonce() const |
| 562 | { |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 563 | if (!hasNonce()) { |
Junxiao Shi | 2dd711d | 2017-07-21 13:40:52 +0000 | [diff] [blame] | 564 | m_nonce = random::generateWord32(); |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 565 | m_wire.reset(); |
Junxiao Shi | c2ac5d2 | 2017-07-17 22:18:31 +0000 | [diff] [blame] | 566 | } |
Junxiao Shi | 2dd711d | 2017-07-21 13:40:52 +0000 | [diff] [blame] | 567 | return *m_nonce; |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 568 | } |
| 569 | |
| 570 | Interest& |
| 571 | Interest::setNonce(uint32_t nonce) |
| 572 | { |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 573 | if (nonce != m_nonce) { |
| 574 | m_nonce = nonce; |
| 575 | m_wire.reset(); |
| 576 | } |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 577 | return *this; |
| 578 | } |
| 579 | |
| 580 | void |
| 581 | Interest::refreshNonce() |
| 582 | { |
| 583 | if (!hasNonce()) |
| 584 | return; |
| 585 | |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 586 | uint32_t oldNonce = *m_nonce; |
| 587 | while (m_nonce == oldNonce) |
| 588 | m_nonce = random::generateWord32(); |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 589 | |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 590 | m_wire.reset(); |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 591 | } |
| 592 | |
Eric Newberry | b555b00 | 2017-05-17 00:30:44 -0700 | [diff] [blame] | 593 | Interest& |
Junxiao Shi | 8d3f834 | 2018-04-04 12:46:37 +0000 | [diff] [blame] | 594 | Interest::setInterestLifetime(time::milliseconds lifetime) |
Eric Newberry | b555b00 | 2017-05-17 00:30:44 -0700 | [diff] [blame] | 595 | { |
Davide Pesavento | fccb2dc | 2019-02-09 01:02:35 -0500 | [diff] [blame] | 596 | if (lifetime < 0_ms) { |
Davide Pesavento | 923ba44 | 2019-02-12 22:00:38 -0500 | [diff] [blame] | 597 | NDN_THROW(std::invalid_argument("InterestLifetime must be >= 0")); |
Eric Newberry | b555b00 | 2017-05-17 00:30:44 -0700 | [diff] [blame] | 598 | } |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 599 | if (lifetime != m_interestLifetime) { |
| 600 | m_interestLifetime = lifetime; |
| 601 | m_wire.reset(); |
| 602 | } |
Eric Newberry | b555b00 | 2017-05-17 00:30:44 -0700 | [diff] [blame] | 603 | return *this; |
| 604 | } |
| 605 | |
Junxiao Shi | 9c154cb | 2017-07-07 22:14:54 +0000 | [diff] [blame] | 606 | Interest& |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 607 | Interest::setHopLimit(optional<uint8_t> hopLimit) |
Junxiao Shi | 9c154cb | 2017-07-07 22:14:54 +0000 | [diff] [blame] | 608 | { |
Davide Pesavento | 2b0cc7b | 2019-07-14 16:50:04 -0400 | [diff] [blame^] | 609 | if (hopLimit != m_hopLimit) { |
| 610 | m_hopLimit = hopLimit; |
| 611 | m_wire.reset(); |
| 612 | } |
Junxiao Shi | 9c154cb | 2017-07-07 22:14:54 +0000 | [diff] [blame] | 613 | return *this; |
| 614 | } |
| 615 | |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 616 | void |
| 617 | Interest::setApplicationParametersInternal(Block parameters) |
| 618 | { |
| 619 | parameters.encode(); // ensure we have wire encoding needed by computeParametersDigest() |
| 620 | if (m_parameters.empty()) { |
| 621 | m_parameters.push_back(std::move(parameters)); |
| 622 | } |
| 623 | else { |
| 624 | BOOST_ASSERT(m_parameters[0].type() == tlv::ApplicationParameters); |
| 625 | m_parameters[0] = std::move(parameters); |
| 626 | } |
| 627 | } |
| 628 | |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 629 | Interest& |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 630 | Interest::setApplicationParameters(const Block& parameters) |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 631 | { |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 632 | if (!parameters.isValid()) { |
| 633 | setApplicationParametersInternal(Block(tlv::ApplicationParameters)); |
Davide Pesavento | 3891244 | 2019-04-06 22:03:39 -0400 | [diff] [blame] | 634 | } |
| 635 | else if (parameters.type() == tlv::ApplicationParameters) { |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 636 | setApplicationParametersInternal(parameters); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 637 | } |
| 638 | else { |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 639 | setApplicationParametersInternal(Block(tlv::ApplicationParameters, parameters)); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 640 | } |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 641 | addOrReplaceParametersDigestComponent(); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 642 | m_wire.reset(); |
| 643 | return *this; |
| 644 | } |
| 645 | |
| 646 | Interest& |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 647 | Interest::setApplicationParameters(const uint8_t* value, size_t length) |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 648 | { |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 649 | if (value == nullptr && length != 0) { |
Davide Pesavento | 3891244 | 2019-04-06 22:03:39 -0400 | [diff] [blame] | 650 | NDN_THROW(std::invalid_argument("ApplicationParameters buffer cannot be nullptr")); |
| 651 | } |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 652 | setApplicationParametersInternal(makeBinaryBlock(tlv::ApplicationParameters, value, length)); |
| 653 | addOrReplaceParametersDigestComponent(); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 654 | m_wire.reset(); |
| 655 | return *this; |
| 656 | } |
| 657 | |
| 658 | Interest& |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 659 | Interest::setApplicationParameters(ConstBufferPtr value) |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 660 | { |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 661 | if (value == nullptr) { |
Davide Pesavento | 3891244 | 2019-04-06 22:03:39 -0400 | [diff] [blame] | 662 | NDN_THROW(std::invalid_argument("ApplicationParameters buffer cannot be nullptr")); |
| 663 | } |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 664 | setApplicationParametersInternal(Block(tlv::ApplicationParameters, std::move(value))); |
| 665 | addOrReplaceParametersDigestComponent(); |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 666 | m_wire.reset(); |
| 667 | return *this; |
| 668 | } |
| 669 | |
| 670 | Interest& |
Davide Pesavento | 9c19a39 | 2019-04-06 15:07:54 -0400 | [diff] [blame] | 671 | Interest::unsetApplicationParameters() |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 672 | { |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 673 | m_parameters.clear(); |
| 674 | ssize_t digestIndex = findParametersDigestComponent(getName()); |
| 675 | if (digestIndex >= 0) { |
| 676 | m_name.erase(digestIndex); |
| 677 | } |
Arthi Padmanabhan | b38664e | 2018-07-18 11:13:12 -0700 | [diff] [blame] | 678 | m_wire.reset(); |
| 679 | return *this; |
| 680 | } |
| 681 | |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 682 | // ---- ParametersSha256DigestComponent support ---- |
| 683 | |
| 684 | bool |
| 685 | Interest::isParametersDigestValid() const |
| 686 | { |
| 687 | ssize_t digestIndex = findParametersDigestComponent(getName()); |
| 688 | if (digestIndex == -1) { |
| 689 | return !hasApplicationParameters(); |
| 690 | } |
| 691 | // cannot be -2 because of the checks in setName() and wireDecode() |
| 692 | BOOST_ASSERT(digestIndex >= 0); |
| 693 | |
| 694 | if (!hasApplicationParameters()) { |
| 695 | return false; |
| 696 | } |
| 697 | |
| 698 | const auto& digestComponent = getName()[digestIndex]; |
| 699 | auto digest = computeParametersDigest(); |
| 700 | |
| 701 | return std::equal(digestComponent.value_begin(), digestComponent.value_end(), |
| 702 | digest->begin(), digest->end()); |
| 703 | } |
| 704 | |
| 705 | shared_ptr<Buffer> |
| 706 | Interest::computeParametersDigest() const |
| 707 | { |
| 708 | using namespace security::transform; |
| 709 | |
| 710 | StepSource in; |
| 711 | OBufferStream out; |
| 712 | in >> digestFilter(DigestAlgorithm::SHA256) >> streamSink(out); |
| 713 | |
| 714 | std::for_each(m_parameters.begin(), m_parameters.end(), [&] (const Block& b) { |
| 715 | in.write(b.wire(), b.size()); |
| 716 | }); |
| 717 | in.end(); |
| 718 | |
| 719 | return out.buf(); |
| 720 | } |
| 721 | |
| 722 | void |
| 723 | Interest::addOrReplaceParametersDigestComponent() |
| 724 | { |
| 725 | BOOST_ASSERT(hasApplicationParameters()); |
| 726 | |
| 727 | ssize_t digestIndex = findParametersDigestComponent(getName()); |
| 728 | auto digestComponent = name::Component::fromParametersSha256Digest(computeParametersDigest()); |
| 729 | |
| 730 | if (digestIndex == -1) { |
| 731 | // no existing digest components, append one |
| 732 | m_name.append(std::move(digestComponent)); |
| 733 | } |
| 734 | else { |
| 735 | // cannot be -2 because of the checks in setName() and wireDecode() |
| 736 | BOOST_ASSERT(digestIndex >= 0); |
| 737 | // replace the existing digest component |
| 738 | m_name.set(digestIndex, std::move(digestComponent)); |
| 739 | } |
| 740 | } |
| 741 | |
| 742 | ssize_t |
| 743 | Interest::findParametersDigestComponent(const Name& name) |
| 744 | { |
| 745 | ssize_t pos = -1; |
| 746 | for (ssize_t i = 0; i < static_cast<ssize_t>(name.size()); i++) { |
| 747 | if (name[i].isParametersSha256Digest()) { |
| 748 | if (pos != -1) |
| 749 | return -2; |
| 750 | pos = i; |
| 751 | } |
| 752 | } |
| 753 | return pos; |
| 754 | } |
| 755 | |
Junxiao Shi | 899277a | 2017-07-07 22:12:12 +0000 | [diff] [blame] | 756 | // ---- operators ---- |
| 757 | |
Junxiao Shi | b55e5d3 | 2018-07-18 13:32:00 -0600 | [diff] [blame] | 758 | bool |
| 759 | operator==(const Interest& lhs, const Interest& rhs) |
| 760 | { |
| 761 | bool wasCanBePrefixSetOnLhs = lhs.m_isCanBePrefixSet; |
| 762 | bool wasCanBePrefixSetOnRhs = rhs.m_isCanBePrefixSet; |
| 763 | lhs.m_isCanBePrefixSet = true; |
| 764 | rhs.m_isCanBePrefixSet = true; |
| 765 | BOOST_SCOPE_EXIT_ALL(&) { |
| 766 | lhs.m_isCanBePrefixSet = wasCanBePrefixSetOnLhs; |
| 767 | rhs.m_isCanBePrefixSet = wasCanBePrefixSetOnRhs; |
| 768 | }; |
| 769 | |
| 770 | return lhs.wireEncode() == rhs.wireEncode(); |
| 771 | } |
| 772 | |
Alexander Afanasyev | ff2d08f | 2014-04-07 18:28:25 -0700 | [diff] [blame] | 773 | std::ostream& |
| 774 | operator<<(std::ostream& os, const Interest& interest) |
Jeff Thompson | fe55686 | 2013-07-09 13:52:55 -0700 | [diff] [blame] | 775 | { |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 776 | os << interest.getName(); |
Jeff Thompson | fe55686 | 2013-07-09 13:52:55 -0700 | [diff] [blame] | 777 | |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 778 | char delim = '?'; |
| 779 | |
| 780 | if (interest.getMinSuffixComponents() >= 0) { |
| 781 | os << delim << "ndn.MinSuffixComponents=" << interest.getMinSuffixComponents(); |
| 782 | delim = '&'; |
Jeff Thompson | fe55686 | 2013-07-09 13:52:55 -0700 | [diff] [blame] | 783 | } |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 784 | if (interest.getMaxSuffixComponents() >= 0) { |
| 785 | os << delim << "ndn.MaxSuffixComponents=" << interest.getMaxSuffixComponents(); |
| 786 | delim = '&'; |
Jeff Thompson | 37527d6 | 2013-08-21 11:15:54 -0700 | [diff] [blame] | 787 | } |
Eric Newberry | b555b00 | 2017-05-17 00:30:44 -0700 | [diff] [blame] | 788 | if (interest.getChildSelector() != DEFAULT_CHILD_SELECTOR) { |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 789 | os << delim << "ndn.ChildSelector=" << interest.getChildSelector(); |
| 790 | delim = '&'; |
Jeff Thompson | 13e280b | 2013-12-03 13:12:23 -0800 | [diff] [blame] | 791 | } |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 792 | if (interest.getMustBeFresh()) { |
| 793 | os << delim << "ndn.MustBeFresh=" << interest.getMustBeFresh(); |
| 794 | delim = '&'; |
Jeff Thompson | 13e280b | 2013-12-03 13:12:23 -0800 | [diff] [blame] | 795 | } |
Eric Newberry | b555b00 | 2017-05-17 00:30:44 -0700 | [diff] [blame] | 796 | if (interest.getInterestLifetime() != DEFAULT_INTEREST_LIFETIME) { |
Alexander Afanasyev | a0c5f83 | 2014-06-19 13:27:56 -0700 | [diff] [blame] | 797 | os << delim << "ndn.InterestLifetime=" << interest.getInterestLifetime().count(); |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 798 | delim = '&'; |
| 799 | } |
Alexander Afanasyev | e881e93 | 2014-06-08 14:47:03 +0300 | [diff] [blame] | 800 | if (interest.hasNonce()) { |
Alexander Afanasyev | 8468198 | 2014-01-03 13:26:09 -0800 | [diff] [blame] | 801 | os << delim << "ndn.Nonce=" << interest.getNonce(); |
| 802 | delim = '&'; |
| 803 | } |
| 804 | if (!interest.getExclude().empty()) { |
| 805 | os << delim << "ndn.Exclude=" << interest.getExclude(); |
| 806 | delim = '&'; |
| 807 | } |
| 808 | |
| 809 | return os; |
Jeff Thompson | 13e280b | 2013-12-03 13:12:23 -0800 | [diff] [blame] | 810 | } |
| 811 | |
Junxiao Shi | 08d0708 | 2014-12-03 11:31:44 -0700 | [diff] [blame] | 812 | } // namespace ndn |