blob: a5c8aded33176b6a94c2fec9997fc102947304ff [file] [log] [blame]
Jeff Thompson47eecfc2013-07-07 22:56:46 -07001/**
2 * @author: Jeff Thompson
3 * See COPYING for copyright and distribution information.
Jeff Thompson9c41dfe2013-06-27 12:10:25 -07004 */
5
Jeff Thompson54909772013-07-07 22:38:57 -07006#include <stdexcept>
Jeff Thompsone6063512013-07-01 15:11:28 -07007#include <sstream>
Jeff Thompson9c41dfe2013-06-27 12:10:25 -07008#include "Name.hpp"
9
10using namespace std;
11
12namespace ndn {
13
Jeff Thompson4b2479a2013-07-02 15:37:39 -070014/**
15 * Write the value to result, escaping characters according to the NDN URI Scheme.
16 * This also adds "..." to a value with zero or more ".".
17 * @param value the buffer with the value to escape
18 * @param result the string stream to write to.
19 */
20static void toEscapedString(const vector<unsigned char> &value, ostringstream &result)
21{
22 bool gotNonDot = false;
23 for (unsigned i = 0; i < value.size(); ++i) {
24 if (value[i] != 0x2e) {
25 gotNonDot = true;
26 break;
27 }
28 }
29 if (!gotNonDot) {
30 // Special case for component of zero or more periods. Add 3 periods.
31 result << "...";
32 for (unsigned int i = 0; i < value.size(); ++i)
33 result << ".";
34 }
35 else {
36 // In case we need to escape, set to upper case hex and save the previous flags.
37 ios::fmtflags saveFlags = result.flags(ios::hex | ios::uppercase);
38
39 for (unsigned int i = 0; i < value.size(); ++i) {
40 unsigned char x = value[i];
41 // Check for 0-9, A-Z, a-z, (+), (-), (.), (_)
42 if (x >= 0x30 && x <= 0x39 || x >= 0x41 && x <= 0x5a ||
43 x >= 0x61 && x <= 0x7a || x == 0x2b || x == 0x2d ||
44 x == 0x2e || x == 0x5f)
45 result << x;
46 else {
47 result << "%";
48 if (x < 16)
49 result << "0";
50 result << (unsigned int)x;
51 }
52 }
53
54 // Restore.
55 result.flags(saveFlags);
56 }
57}
Jeff Thompson26c63d62013-07-02 18:00:26 -070058
59static const char *WHITESPACE_CHARS = " \n\r\t";
60
61/**
62 * Modify str in place to erase whitespace on the left.
63 * @param str
64 */
65static inline void trimLeft(string &str)
66{
67 size_t found = str.find_first_not_of(WHITESPACE_CHARS);
68 if (found != string::npos) {
69 if (found > 0)
70 str.erase(0, found);
71 }
72 else
73 // All whitespace
74 str.clear();
75}
76
77/**
78 * Modify str in place to erase whitespace on the right.
79 * @param str
80 */
81static inline void trimRight(string &str)
82{
83 size_t found = str.find_last_not_of(WHITESPACE_CHARS);
84 if (found != string::npos) {
85 if (found + 1 < str.size())
86 str.erase(found + 1);
87 }
88 else
89 // All whitespace
90 str.clear();
91}
92
93/**
94 * Modify str in place to erase whitespace on the left and right.
95 * @param str
96 */
97static void trim(string &str)
98{
99 trimLeft(str);
100 trimRight(str);
101}
Jeff Thompson443398d2013-07-02 19:45:46 -0700102
Jeff Thompson26c63d62013-07-02 18:00:26 -0700103/**
104 * Convert the hex character to an integer from 0 to 15, or -1 if not a hex character.
105 * @param c
106 * @return
107 */
108static int fromHexChar(unsigned char c)
109{
110 if (c >= '0' && c <= '9')
111 return (int)c - (int)'0';
112 else if (c >= 'A' && c <= 'F')
113 return (int)c - (int)'A' + 10;
114 else if (c >= 'a' && c <= 'f')
115 return (int)c - (int)'a' + 10;
116 else
117 return -1;
118}
119
120/**
121 * Return a copy of str, converting each escaped "%XX" to the char value.
122 * @param str
123 */
124static string unescape(const string &str)
125{
126 ostringstream result;
127
128 for (unsigned int i = 0; i < str.size(); ++i) {
129 if (str[i] == '%' && i + 2 < str.size()) {
130 int hi = fromHexChar(str[i + 1]);
131 int lo = fromHexChar(str[i + 2]);
132
133 if (hi < 0 || lo < 0)
134 // Invalid hex characters, so just keep the escaped string.
135 result << str[i] << str[i + 1] << str[i + 2];
136 else
137 result << (unsigned char)(16 * hi + lo);
138
139 // Skip ahead past the escaped value.
140 i += 2;
141 }
142 else
143 // Just copy through.
144 result << str[i];
145 }
146
147 return result.str();
148}
149
Jeff Thompson443398d2013-07-02 19:45:46 -0700150bool NameComponent::setFromEscapedString(const char *first, const char *last)
151{
152 string trimmedString(first, last);
153 trim(trimmedString);
154 string component = unescape(trimmedString);
155
156 if (component.find_first_not_of(".") == string::npos) {
157 // Special case for component of only periods.
158 if (component.size() <= 2)
159 // Zero, one or two periods is illegal. Ignore this component.
160 return false;
161 else {
162 // Remove 3 periods.
163 value_.clear();
164 value_.insert(value_.begin(), component.begin() + 3, component.end());
165 }
166 }
167 else {
168 value_.clear();
169 value_.insert(value_.begin(), component.begin(), component.end());
170 }
171
172 return true;
173}
174
175Name::Name(const char *uri_cstr)
176{
177 string uri = uri_cstr;
178 trim(uri);
179 if (uri.size() == 0)
180 return;
181
182 size_t iColon = uri.find(':');
183 if (iColon != string::npos) {
184 // Make sure the colon came before a '/'.
185 size_t iFirstSlash = uri.find('/');
186 if (iFirstSlash == string::npos || iColon < iFirstSlash) {
187 // Omit the leading protocol such as ndn:
188 uri.erase(0, iColon + 1);
189 trim(uri);
190 }
191 }
192
193 // Trim the leading slash and possibly the authority.
194 if (uri[0] == '/') {
195 if (uri.size() >= 2 && uri[1] == '/') {
196 // Strip the authority following "//".
197 size_t iAfterAuthority = uri.find('/', 2);
198 if (iAfterAuthority == string::npos)
199 // Unusual case: there was only an authority.
200 return;
201 else {
202 uri.erase(0, iAfterAuthority + 1);
203 trim(uri);
204 }
205 }
206 else {
207 uri.erase(0, 1);
208 trim(uri);
209 }
210 }
211
212 size_t iComponentStart = 0;
213
214 // Unescape the components.
215 while (iComponentStart < uri.size()) {
216 size_t iComponentEnd = uri.find("/", iComponentStart);
217 if (iComponentEnd == string::npos)
218 iComponentEnd = uri.size();
219
220 components_.push_back(NameComponent());
221 if (!components_[components_.size() - 1].setFromEscapedString(&uri[iComponentStart], &uri[iComponentEnd]))
222 // Ignore the illegal component. This also gets rid of a trailing '/'.
223 components_.pop_back();
224
225 iComponentStart = iComponentEnd + 1;
226 }
227}
228
Jeff Thompson016ed642013-07-02 14:39:06 -0700229void Name::get(struct ndn_Name &nameStruct)
Jeff Thompson48815112013-06-28 18:22:48 -0700230{
Jeff Thompson016ed642013-07-02 14:39:06 -0700231 if (nameStruct.maxComponents < components_.size())
232 throw runtime_error("nameStruct.maxComponents must be >= this name getNComponents()");
233
234 nameStruct.nComponents = components_.size();
235 for (unsigned int i = 0; i < nameStruct.nComponents; ++i)
236 components_[i].get(nameStruct.components[i]);
Jeff Thompson48815112013-06-28 18:22:48 -0700237}
238
Jeff Thompsonb468c312013-07-01 17:50:14 -0700239void Name::set(struct ndn_Name &nameStruct)
240{
241 clear();
Jeff Thompsonccb13c12013-07-01 18:16:00 -0700242 for (unsigned int i = 0; i < nameStruct.nComponents; ++i)
Jeff Thompsonb468c312013-07-01 17:50:14 -0700243 addComponent(nameStruct.components[i].value, nameStruct.components[i].valueLength);
244}
245
Jeff Thompsone6063512013-07-01 15:11:28 -0700246std::string Name::to_uri()
247{
Jeff Thompson4b2479a2013-07-02 15:37:39 -0700248 if (components_.size() == 0)
249 return "/";
250
251 ostringstream result;
Jeff Thompsonccb13c12013-07-01 18:16:00 -0700252 for (unsigned int i = 0; i < components_.size(); ++i) {
Jeff Thompson4b2479a2013-07-02 15:37:39 -0700253 result << "/";
254 toEscapedString(components_[i].getValue(), result);
Jeff Thompsone6063512013-07-01 15:11:28 -0700255 }
256
Jeff Thompson4b2479a2013-07-02 15:37:39 -0700257 return result.str();
Jeff Thompsone6063512013-07-01 15:11:28 -0700258}
259
Jeff Thompson9c41dfe2013-06-27 12:10:25 -0700260}