blob: c9b5e7fccc8697d26eff68e6abe5b3dc9ca1b54e [file] [log] [blame]
Jeff Thompson25b4e612013-10-10 16:03:24 -07001/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
Jeff Thompson47eecfc2013-07-07 22:56:46 -07002/**
Jeff Thompson7687dc02013-09-13 11:54:07 -07003 * Copyright (C) 2013 Regents of the University of California.
4 * @author: Jeff Thompson <jefft0@remap.ucla.edu>
Jeff Thompson47eecfc2013-07-07 22:56:46 -07005 * See COPYING for copyright and distribution information.
Jeff Thompson9c41dfe2013-06-27 12:10:25 -07006 */
7
Jeff Thompson54909772013-07-07 22:38:57 -07008#include <stdexcept>
Jeff Thompsonb8f1b132013-08-13 11:07:43 -07009#include <algorithm>
Jeff Thompson25b4e612013-10-10 16:03:24 -070010#include <ndn-cpp/name.hpp>
11#include "c/name.h"
Jeff Thompson9c41dfe2013-06-27 12:10:25 -070012
13using namespace std;
Jeff Thompsond4144fe2013-09-18 15:59:57 -070014using namespace ndn::ptr_lib;
Jeff Thompson9c41dfe2013-06-27 12:10:25 -070015
16namespace ndn {
17
Jeff Thompson26c63d62013-07-02 18:00:26 -070018static const char *WHITESPACE_CHARS = " \n\r\t";
19
20/**
21 * Modify str in place to erase whitespace on the left.
22 * @param str
23 */
Jeff Thompson0050abe2013-09-17 12:50:25 -070024static inline void
25trimLeft(string& str)
Jeff Thompson26c63d62013-07-02 18:00:26 -070026{
27 size_t found = str.find_first_not_of(WHITESPACE_CHARS);
28 if (found != string::npos) {
29 if (found > 0)
30 str.erase(0, found);
31 }
32 else
33 // All whitespace
34 str.clear();
35}
36
37/**
38 * Modify str in place to erase whitespace on the right.
39 * @param str
40 */
Jeff Thompson0050abe2013-09-17 12:50:25 -070041static inline void
42trimRight(string& str)
Jeff Thompson26c63d62013-07-02 18:00:26 -070043{
44 size_t found = str.find_last_not_of(WHITESPACE_CHARS);
45 if (found != string::npos) {
46 if (found + 1 < str.size())
47 str.erase(found + 1);
48 }
49 else
50 // All whitespace
51 str.clear();
52}
53
54/**
55 * Modify str in place to erase whitespace on the left and right.
56 * @param str
57 */
Jeff Thompson0050abe2013-09-17 12:50:25 -070058static void
59trim(string& str)
Jeff Thompson26c63d62013-07-02 18:00:26 -070060{
61 trimLeft(str);
62 trimRight(str);
63}
Jeff Thompson443398d2013-07-02 19:45:46 -070064
Jeff Thompson26c63d62013-07-02 18:00:26 -070065/**
66 * Convert the hex character to an integer from 0 to 15, or -1 if not a hex character.
67 * @param c
68 * @return
69 */
Jeff Thompson0050abe2013-09-17 12:50:25 -070070static int
Jeff Thompson10ad12a2013-09-24 16:19:11 -070071fromHexChar(uint8_t c)
Jeff Thompson26c63d62013-07-02 18:00:26 -070072{
73 if (c >= '0' && c <= '9')
74 return (int)c - (int)'0';
75 else if (c >= 'A' && c <= 'F')
76 return (int)c - (int)'A' + 10;
77 else if (c >= 'a' && c <= 'f')
78 return (int)c - (int)'a' + 10;
79 else
80 return -1;
81}
82
83/**
84 * Return a copy of str, converting each escaped "%XX" to the char value.
85 * @param str
86 */
Jeff Thompson0050abe2013-09-17 12:50:25 -070087static string
88unescape(const string& str)
Jeff Thompson26c63d62013-07-02 18:00:26 -070089{
90 ostringstream result;
91
Jeff Thompson97223af2013-09-24 17:01:27 -070092 for (size_t i = 0; i < str.size(); ++i) {
Jeff Thompson26c63d62013-07-02 18:00:26 -070093 if (str[i] == '%' && i + 2 < str.size()) {
94 int hi = fromHexChar(str[i + 1]);
95 int lo = fromHexChar(str[i + 2]);
96
97 if (hi < 0 || lo < 0)
98 // Invalid hex characters, so just keep the escaped string.
99 result << str[i] << str[i + 1] << str[i + 2];
100 else
Jeff Thompson10ad12a2013-09-24 16:19:11 -0700101 result << (uint8_t)(16 * hi + lo);
Jeff Thompson26c63d62013-07-02 18:00:26 -0700102
103 // Skip ahead past the escaped value.
104 i += 2;
105 }
106 else
107 // Just copy through.
108 result << str[i];
109 }
110
111 return result.str();
112}
113
Jeff Thompson27cae532013-10-08 12:52:41 -0700114uint64_t Name::Component::toNumberWithMarker(uint8_t marker) const
115{
116 struct ndn_NameComponent componentStruct;
117 get(componentStruct);
118 uint64_t result;
119
120 ndn_Error error;
121 if ((error = ndn_NameComponent_toNumberWithMarker(&componentStruct, marker, &result)))
122 throw std::runtime_error(ndn_getErrorString(error));
123
124 return result;
125}
126
Jeff Thompsond129ac12013-10-11 14:30:12 -0700127Name::Component
128Name::Component::fromEscapedString(const char *escapedString, size_t beginOffset, size_t endOffset)
Jeff Thompson443398d2013-07-02 19:45:46 -0700129{
Jeff Thompsonc1c12e42013-09-13 19:08:45 -0700130 string trimmedString(escapedString + beginOffset, escapedString + endOffset);
Jeff Thompson443398d2013-07-02 19:45:46 -0700131 trim(trimmedString);
132 string component = unescape(trimmedString);
133
134 if (component.find_first_not_of(".") == string::npos) {
135 // Special case for component of only periods.
136 if (component.size() <= 2)
137 // Zero, one or two periods is illegal. Ignore this component.
Jeff Thompsond129ac12013-10-11 14:30:12 -0700138 return Component();
Jeff Thompson995aba52013-09-12 12:04:52 -0700139 else
Jeff Thompson443398d2013-07-02 19:45:46 -0700140 // Remove 3 periods.
Jeff Thompsond129ac12013-10-11 14:30:12 -0700141 return Component((const uint8_t *)&component[3], component.size() - 3);
Jeff Thompson443398d2013-07-02 19:45:46 -0700142 }
Jeff Thompson995aba52013-09-12 12:04:52 -0700143 else
Jeff Thompsond129ac12013-10-11 14:30:12 -0700144 return Component((const uint8_t *)&component[0], component.size());
Jeff Thompson443398d2013-07-02 19:45:46 -0700145}
146
Jeff Thompsond129ac12013-10-11 14:30:12 -0700147Name::Component
148Name::Component::fromNumber(uint64_t number)
Jeff Thompson8aac1992013-08-12 17:26:02 -0700149{
Jeff Thompson10ad12a2013-09-24 16:19:11 -0700150 shared_ptr<vector<uint8_t> > value(new vector<uint8_t>());
Jeff Thompson8aac1992013-08-12 17:26:02 -0700151
Jeff Thompsond129ac12013-10-11 14:30:12 -0700152 // First encode in little endian.
153 while (number != 0) {
154 value->push_back(number & 0xff);
155 number >>= 8;
156 }
157
158 // Make it big endian.
159 reverse(value->begin(), value->end());
160 return Blob(value);
161}
162
163Name::Component
164Name::Component::fromNumberWithMarker(uint64_t number, uint8_t marker)
165{
166 shared_ptr<vector<uint8_t> > value(new vector<uint8_t>());
167
168 // Add the leading marker.
169 value->push_back(marker);
Jeff Thompsonb8f1b132013-08-13 11:07:43 -0700170
Jeff Thompson8aac1992013-08-12 17:26:02 -0700171 // First encode in little endian.
Jeff Thompsond129ac12013-10-11 14:30:12 -0700172 while (number != 0) {
173 value->push_back(number & 0xff);
174 number >>= 8;
Jeff Thompson8aac1992013-08-12 17:26:02 -0700175 }
176
Jeff Thompson8aac1992013-08-12 17:26:02 -0700177 // Make it big endian.
Jeff Thompson995aba52013-09-12 12:04:52 -0700178 reverse(value->begin() + 1, value->end());
Jeff Thompson46411c92013-09-13 19:31:25 -0700179 return Blob(value);
Jeff Thompson8aac1992013-08-12 17:26:02 -0700180}
181
Jeff Thompson0050abe2013-09-17 12:50:25 -0700182void
Jeff Thompson25b4e612013-10-10 16:03:24 -0700183Name::Component::get(struct ndn_NameComponent& componentStruct) const
184{
185 value_.get(componentStruct.value);
186}
187
188uint64_t
189Name::Component::toNumber() const
190{
191 struct ndn_NameComponent componentStruct;
192 get(componentStruct);
193 return ndn_NameComponent_toNumber(&componentStruct);
194}
195
196void
Jeff Thompson0050abe2013-09-17 12:50:25 -0700197Name::set(const char *uri_cstr)
Jeff Thompson443398d2013-07-02 19:45:46 -0700198{
Jeff Thompson67515bd2013-08-15 17:43:22 -0700199 components_.clear();
200
Jeff Thompson443398d2013-07-02 19:45:46 -0700201 string uri = uri_cstr;
202 trim(uri);
203 if (uri.size() == 0)
204 return;
205
206 size_t iColon = uri.find(':');
207 if (iColon != string::npos) {
208 // Make sure the colon came before a '/'.
209 size_t iFirstSlash = uri.find('/');
210 if (iFirstSlash == string::npos || iColon < iFirstSlash) {
211 // Omit the leading protocol such as ndn:
212 uri.erase(0, iColon + 1);
213 trim(uri);
214 }
215 }
216
217 // Trim the leading slash and possibly the authority.
218 if (uri[0] == '/') {
219 if (uri.size() >= 2 && uri[1] == '/') {
220 // Strip the authority following "//".
221 size_t iAfterAuthority = uri.find('/', 2);
222 if (iAfterAuthority == string::npos)
223 // Unusual case: there was only an authority.
224 return;
225 else {
226 uri.erase(0, iAfterAuthority + 1);
227 trim(uri);
228 }
229 }
230 else {
231 uri.erase(0, 1);
232 trim(uri);
233 }
234 }
235
236 size_t iComponentStart = 0;
237
238 // Unescape the components.
239 while (iComponentStart < uri.size()) {
240 size_t iComponentEnd = uri.find("/", iComponentStart);
241 if (iComponentEnd == string::npos)
242 iComponentEnd = uri.size();
243
Jeff Thompsond129ac12013-10-11 14:30:12 -0700244 Component component = Component::fromEscapedString(&uri[0], iComponentStart, iComponentEnd);
Jeff Thompson46411c92013-09-13 19:31:25 -0700245 // Ignore illegal components. This also gets rid of a trailing '/'.
Jeff Thompsond129ac12013-10-11 14:30:12 -0700246 if (component.getValue())
Jeff Thompson46411c92013-09-13 19:31:25 -0700247 components_.push_back(Component(component));
Jeff Thompson443398d2013-07-02 19:45:46 -0700248
249 iComponentStart = iComponentEnd + 1;
250 }
251}
252
Jeff Thompson0050abe2013-09-17 12:50:25 -0700253void
254Name::get(struct ndn_Name& nameStruct) const
Jeff Thompson48815112013-06-28 18:22:48 -0700255{
Jeff Thompson016ed642013-07-02 14:39:06 -0700256 if (nameStruct.maxComponents < components_.size())
257 throw runtime_error("nameStruct.maxComponents must be >= this name getNComponents()");
258
259 nameStruct.nComponents = components_.size();
Jeff Thompson97223af2013-09-24 17:01:27 -0700260 for (size_t i = 0; i < nameStruct.nComponents; ++i)
Jeff Thompson016ed642013-07-02 14:39:06 -0700261 components_[i].get(nameStruct.components[i]);
Jeff Thompson48815112013-06-28 18:22:48 -0700262}
263
Jeff Thompson0050abe2013-09-17 12:50:25 -0700264void
265Name::set(const struct ndn_Name& nameStruct)
Jeff Thompsonb468c312013-07-01 17:50:14 -0700266{
267 clear();
Jeff Thompson97223af2013-09-24 17:01:27 -0700268 for (size_t i = 0; i < nameStruct.nComponents; ++i)
Jeff Thompson93034532013-10-08 11:52:43 -0700269 addComponent(nameStruct.components[i].value.value, nameStruct.components[i].value.length);
Jeff Thompsonb468c312013-07-01 17:50:14 -0700270}
271
Jeff Thompson26b0d792013-09-23 16:19:01 -0700272Name&
273Name::append(const Name& name)
274{
275 if (&name == this)
276 // Copying from this name, so need to make a copy first.
277 return append(Name(name));
278
279 for (size_t i = 0; i < name.components_.size(); ++i)
280 components_.push_back(name.components_[i]);
281
282 return *this;
283}
284
Jeff Thompson0050abe2013-09-17 12:50:25 -0700285std::string
286Name::toUri() const
Jeff Thompsone6063512013-07-01 15:11:28 -0700287{
Jeff Thompson4b2479a2013-07-02 15:37:39 -0700288 if (components_.size() == 0)
289 return "/";
290
291 ostringstream result;
Jeff Thompson97223af2013-09-24 17:01:27 -0700292 for (size_t i = 0; i < components_.size(); ++i) {
Jeff Thompson4b2479a2013-07-02 15:37:39 -0700293 result << "/";
Jeff Thompson9bdb3b22013-09-12 12:42:13 -0700294 toEscapedString(*components_[i].getValue(), result);
Jeff Thompsone6063512013-07-01 15:11:28 -0700295 }
296
Jeff Thompson4b2479a2013-07-02 15:37:39 -0700297 return result.str();
Jeff Thompsone6063512013-07-01 15:11:28 -0700298}
299
Jeff Thompsond0159d72013-09-23 13:34:15 -0700300Name
301Name::getSubName(size_t iStartComponent, size_t nComponents) const
302{
303 Name result;
304
Jeff Thompson97223af2013-09-24 17:01:27 -0700305 size_t iEnd = iStartComponent + nComponents;
306 for (size_t i = iStartComponent; i < iEnd && i < components_.size(); ++i)
Jeff Thompsond0159d72013-09-23 13:34:15 -0700307 result.components_.push_back(components_[i]);
308
309 return result;
310}
311
312Name
313Name::getSubName(size_t iStartComponent) const
314{
315 Name result;
316
Jeff Thompson97223af2013-09-24 17:01:27 -0700317 for (size_t i = iStartComponent; i < components_.size(); ++i)
Jeff Thompsond0159d72013-09-23 13:34:15 -0700318 result.components_.push_back(components_[i]);
319
320 return result;
321}
322
Jeff Thompson0050abe2013-09-17 12:50:25 -0700323bool
Jeff Thompson3c2ab012013-10-02 14:18:16 -0700324Name::equals(const Name& name) const
325{
326 if (components_.size() != name.components_.size())
327 return false;
328
329 for (size_t i = 0; i < components_.size(); ++i) {
330 if (*components_[i].getValue() != *name.components_[i].getValue())
331 return false;
332 }
333
334 return true;
335}
336
337bool
Jeff Thompson0050abe2013-09-17 12:50:25 -0700338Name::match(const Name& name) const
Jeff Thompsoncc35cd42013-08-20 12:23:14 -0700339{
340 // Imitate ndn_Name_match.
341
342 // This name is longer than the name we are checking it against.
343 if (components_.size() > name.components_.size())
Jeff Thompson3c2ab012013-10-02 14:18:16 -0700344 return false;
Jeff Thompsoncc35cd42013-08-20 12:23:14 -0700345
346 // Check if at least one of given components doesn't match.
Jeff Thompson3c2ab012013-10-02 14:18:16 -0700347 for (size_t i = 0; i < components_.size(); ++i) {
348 if (*components_[i].getValue() != *name.components_[i].getValue())
Jeff Thompsoncc35cd42013-08-20 12:23:14 -0700349 return false;
350 }
351
352 return true;
353}
354
Jeff Thompson0050abe2013-09-17 12:50:25 -0700355void
Jeff Thompson10ad12a2013-09-24 16:19:11 -0700356Name::toEscapedString(const vector<uint8_t>& value, ostringstream& result)
Jeff Thompsonec7789a2013-08-21 11:08:36 -0700357{
358 bool gotNonDot = false;
359 for (unsigned i = 0; i < value.size(); ++i) {
360 if (value[i] != 0x2e) {
361 gotNonDot = true;
362 break;
363 }
364 }
365 if (!gotNonDot) {
366 // Special case for component of zero or more periods. Add 3 periods.
367 result << "...";
Jeff Thompson97223af2013-09-24 17:01:27 -0700368 for (size_t i = 0; i < value.size(); ++i)
Jeff Thompsonec7789a2013-08-21 11:08:36 -0700369 result << '.';
370 }
371 else {
372 // In case we need to escape, set to upper case hex and save the previous flags.
373 ios::fmtflags saveFlags = result.flags(ios::hex | ios::uppercase);
374
Jeff Thompson97223af2013-09-24 17:01:27 -0700375 for (size_t i = 0; i < value.size(); ++i) {
Jeff Thompson10ad12a2013-09-24 16:19:11 -0700376 uint8_t x = value[i];
Jeff Thompsonec7789a2013-08-21 11:08:36 -0700377 // Check for 0-9, A-Z, a-z, (+), (-), (.), (_)
378 if (x >= 0x30 && x <= 0x39 || x >= 0x41 && x <= 0x5a ||
379 x >= 0x61 && x <= 0x7a || x == 0x2b || x == 0x2d ||
380 x == 0x2e || x == 0x5f)
381 result << x;
382 else {
383 result << '%';
384 if (x < 16)
385 result << '0';
386 result << (unsigned int)x;
387 }
388 }
389
390 // Restore.
391 result.flags(saveFlags);
392 }
393}
394
Jeff Thompson6653b0b2013-09-23 12:32:39 -0700395string
Jeff Thompson10ad12a2013-09-24 16:19:11 -0700396Name::toEscapedString(const vector<uint8_t>& value)
Jeff Thompson6653b0b2013-09-23 12:32:39 -0700397{
398 ostringstream result;
399 toEscapedString(value, result);
400 return result.str();
401}
402
Jeff Thompson9c41dfe2013-06-27 12:10:25 -0700403}