blob: 4d8a64c28a633041346a8808def421757502591d [file] [log] [blame]
Wentao Shangbd63e462012-12-03 16:19:33 -08001/**
Jeff Thompson87021f72012-11-18 17:40:06 -08002 * @author: Meki Cheraoui, Jeff Thompson
Jeff Thompson745026e2012-10-13 12:49:20 -07003 * See COPYING for copyright and distribution information.
Jeff Thompson4e8b7702012-10-21 23:42:27 -07004 * This class represents a Name as an array of components where each is a byte array.
Meki Cherkaouif441d3a2012-04-22 15:17:52 -07005 */
6
Jeff Thompson87021f72012-11-18 17:40:06 -08007/*
8 * Create a new Name from _components.
9 * If _components is a string, parse it as a URI. Otherwise it is an array of components
10 * where each is a string, byte array, ArrayBuffer or Uint8Array.
11 * Convert and store as an array of Uint8Array.
12 * If a component is a string, encode as utf8.
13 */
Jeff Thompsonf3bd3592012-09-29 23:25:30 -070014var Name = function Name(_components){
Jeff Thompson87021f72012-11-18 17:40:06 -080015 if( typeof _components == 'string') {
Jeff Thompson86aea882012-09-29 17:32:48 -070016 if(LOG>3)console.log('Content Name String '+_components);
Jeff Thompson87021f72012-11-18 17:40:06 -080017 this.components = Name.createNameArray(_components);
Meki Cherkaouif441d3a2012-04-22 15:17:52 -070018 }
Jeff Thompson87021f72012-11-18 17:40:06 -080019 else if(typeof _components === 'object'){
Jeff Thompson86aea882012-09-29 17:32:48 -070020 if(LOG>4)console.log('Content Name Array '+_components);
Jeff Thompson87021f72012-11-18 17:40:06 -080021 this.components = [];
22 for (var i = 0; i < _components.length; ++i)
23 this.add(_components[i]);
Meki Cherkaouif441d3a2012-04-22 15:17:52 -070024 }
Jeff Thompson87021f72012-11-18 17:40:06 -080025 else if(_components==null)
Jeff Thompsone85ff1d2012-09-29 21:21:57 -070026 this.components =[];
Jeff Thompson87021f72012-11-18 17:40:06 -080027 else
Meki Cherkaouif3d8f692012-05-18 15:44:28 -070028 if(LOG>1)console.log("NO CONTENT NAME GIVEN");
Meki Cherkaouif441d3a2012-04-22 15:17:52 -070029};
30
Jeff Thompson0d3f2032012-11-04 12:55:27 -080031Name.prototype.getName = function() {
32 return this.to_uri();
Meki Cherkaoui8f173612012-06-06 01:05:40 -070033};
Meki Cherkaouif441d3a2012-04-22 15:17:52 -070034
Jeff Thompson87021f72012-11-18 17:40:06 -080035/* Parse name as a URI and return an array of Uint8Array components.
36 *
37 */
Jeff Thompson0d3f2032012-11-04 12:55:27 -080038Name.createNameArray = function(name) {
39 name = name.trim();
40 if (name.length <= 0)
41 return [];
42
43 var iColon = name.indexOf(':');
44 if (iColon >= 0) {
45 // Make sure the colon came before a '/'.
46 var iFirstSlash = name.indexOf('/');
47 if (iFirstSlash < 0 || iColon < iFirstSlash)
Jeff Thompsonbd829262012-11-30 22:28:37 -080048 // Omit the leading protocol such as ndn:
Jeff Thompson0d3f2032012-11-04 12:55:27 -080049 name = name.substr(iColon + 1, name.length - iColon - 1).trim();
Jeff Thompson4e8b7702012-10-21 23:42:27 -070050 }
Jeff Thompson0d3f2032012-11-04 12:55:27 -080051
52 if (name[0] == '/') {
53 if (name.length >= 2 && name[1] == '/') {
54 // Strip the authority following "//".
55 var iAfterAuthority = name.indexOf('/', 2);
56 if (iAfterAuthority < 0)
57 // Unusual case: there was only an authority.
58 return [];
59 else
60 name = name.substr(iAfterAuthority + 1, name.length - iAfterAuthority - 1).trim();
61 }
62 else
63 name = name.substr(1, name.length - 1).trim();
64 }
65
66 var array = name.split('/');
Jeff Thompson9b411002012-10-21 17:35:16 -070067
68 // Unescape the components.
Jeff Thompson4e8b7702012-10-21 23:42:27 -070069 for (var i = 0; i < array.length; ++i) {
Jeff Thompson78849a72013-02-03 22:35:54 -080070 var component = Name.fromEscapedString(array[i]);
Jeff Thompson4e8b7702012-10-21 23:42:27 -070071
Jeff Thompson78849a72013-02-03 22:35:54 -080072 if (component == null) {
73 // Ignore the illegal componenent. This also gets rid of a trailing '/'.
74 array.splice(i, 1);
75 --i;
76 continue;
Jeff Thompson4e8b7702012-10-21 23:42:27 -070077 }
78 else
79 array[i] = component;
80 }
Jeff Thompson9b411002012-10-21 17:35:16 -070081
Meki Cherkaouif3d8f692012-05-18 15:44:28 -070082 return array;
83}
Meki Cherkaouif441d3a2012-04-22 15:17:52 -070084
85
Jeff Thompsonf3bd3592012-09-29 23:25:30 -070086Name.prototype.from_ccnb = function(/*XMLDecoder*/ decoder) {
Meki Cherkaouif441d3a2012-04-22 15:17:52 -070087 decoder.readStartElement(this.getElementLabel());
88
89
Jeff Thompsone85ff1d2012-09-29 21:21:57 -070090 this.components = new Array(); //new ArrayList<byte []>();
Meki Cherkaouif441d3a2012-04-22 15:17:52 -070091
92 while (decoder.peekStartElement(CCNProtocolDTags.Component)) {
93 this.add(decoder.readBinaryElement(CCNProtocolDTags.Component));
94 }
95
96 decoder.readEndElement();
97};
98
Jeff Thompsonf3bd3592012-09-29 23:25:30 -070099Name.prototype.to_ccnb = function(/*XMLEncoder*/ encoder) {
Meki Cherkaouif441d3a2012-04-22 15:17:52 -0700100
Jeff Thompsone85ff1d2012-09-29 21:21:57 -0700101 if( this.components ==null )
Jeff Thompson34a2ec02012-09-29 21:47:05 -0700102 throw new Error("CANNOT ENCODE EMPTY CONTENT NAME");
Meki Cherkaouif441d3a2012-04-22 15:17:52 -0700103
104 encoder.writeStartElement(this.getElementLabel());
Jeff Thompsone85ff1d2012-09-29 21:21:57 -0700105 var count = this.components.length;
Meki Cherkaouif441d3a2012-04-22 15:17:52 -0700106 for (var i=0; i < count; i++) {
Jeff Thompsone85ff1d2012-09-29 21:21:57 -0700107 encoder.writeElement(CCNProtocolDTags.Component, this.components[i]);
Meki Cherkaouif441d3a2012-04-22 15:17:52 -0700108 }
109 encoder.writeEndElement();
110};
111
Jeff Thompsonf3bd3592012-09-29 23:25:30 -0700112Name.prototype.getElementLabel = function(){
Meki Cherkaouif441d3a2012-04-22 15:17:52 -0700113 return CCNProtocolDTags.Name;
114};
115
Jeff Thompson87021f72012-11-18 17:40:06 -0800116/*
117 * component is a string, byte array, ArrayBuffer or Uint8Array.
118 * Convert to Uint8Array and add to this Name.
119 * If a component is a string, encode as utf8.
120 * Return the converted value.
121 */
122Name.prototype.add = function(component){
Jeff Thompson9ab151a2012-11-24 21:22:30 -0800123 var result;
Jeff Thompson87021f72012-11-18 17:40:06 -0800124 if(typeof component == 'string')
125 result = DataUtils.stringToUtf8Array(component);
Jeff Thompson87021f72012-11-18 17:40:06 -0800126 else if(typeof component == 'object' && component instanceof Uint8Array)
127 result = new Uint8Array(component);
Jeff Thompson8a97ac52012-11-24 23:16:02 -0800128 else if(typeof component == 'object' && component instanceof ArrayBuffer) {
129 // Make a copy. Don't use ArrayBuffer.slice since it isn't always supported.
130 result = new Uint8Array(new ArrayBuffer(component.byteLength));
131 result.set(new Uint8Array(component));
132 }
Jeff Thompson51ab7652012-11-24 21:57:37 -0800133 else if(typeof component == 'object')
134 // Assume component is a byte array. We can't check instanceof Array because
135 // this doesn't work in JavaScript if the array comes from a different module.
136 result = new Uint8Array(component);
Jeff Thompson87021f72012-11-18 17:40:06 -0800137 else
Jeff Thompson9ab151a2012-11-24 21:22:30 -0800138 throw new Error("Cannot add Name element at index " + this.components.length +
139 ": Invalid type");
Jeff Thompson87021f72012-11-18 17:40:06 -0800140
141 return this.components.push(result);
Meki Cherkaouif441d3a2012-04-22 15:17:52 -0700142};
143
Jeff Thompsonbd829262012-11-30 22:28:37 -0800144// Return the escaped name string according to "CCNx URI Scheme".
Jeff Thompson4e8b7702012-10-21 23:42:27 -0700145Name.prototype.to_uri = function() {
Jeff Thompson95306632013-01-23 19:20:37 -0800146 if (this.components.length == 0)
147 return "/";
148
Jeff Thompson4e8b7702012-10-21 23:42:27 -0700149 var result = "";
150
151 for(var i = 0; i < this.components.length; ++i)
152 result += "/"+ Name.toEscapedString(this.components[i]);
153
154 return result;
155};
156
Jeff Thompson87021f72012-11-18 17:40:06 -0800157/*
158 * Return a new Name with the first nComponents components of this Name.
159 */
160Name.prototype.getPrefix = function(nComponents) {
161 return new Name(this.components.slice(0, nComponents));
162}
163
164/*
165 * Return a new ArrayBuffer of the component at i.
166 */
167Name.prototype.getComponent = function(i) {
168 var result = new ArrayBuffer(this.components[i].length);
169 new Uint8Array(result).set(this.components[i]);
170 return result;
171}
172
Jeff Thompson16a35f72012-11-25 08:07:33 -0800173/*
174 * The "file name" in a name is the last component that isn't blank and doesn't start with one of the
175 * special marker octets (for version, etc.). Return the index in this.components of
176 * the file name, or -1 if not found.
177 */
178Name.prototype.indexOfFileName = function() {
179 for (var i = this.components.length - 1; i >= 0; --i) {
180 var component = this.components[i];
181 if (component.length <= 0)
182 continue;
183
184 if (component[0] == 0 || component[0] == 0xC0 || component[0] == 0xC1 ||
185 (component[0] >= 0xF5 && component[0] <= 0xFF))
186 continue;
187
188 return i;
189 }
190
191 return -1;
192}
193
Jeff Thompson990e3002012-12-02 23:29:36 -0800194/*
Jeff Thompson77fc9b72012-12-16 12:38:09 -0800195 * Return true if this Name has the same components as name.
196 */
197Name.prototype.equalsName = function(name) {
198 if (this.components.length != name.components.length)
199 return false;
200
201 // Start from the last component because they are more likely to differ.
202 for (var i = this.components.length - 1; i >= 0; --i) {
203 if (!DataUtils.arraysEqual(this.components[i], name.components[i]))
204 return false;
205 }
206
207 return true;
208}
209
210/*
Jeff Thompson990e3002012-12-02 23:29:36 -0800211 * Find the last component in name that has a ContentDigest and return the digest value as Uint8Array,
Jeff Thompsonac3e62c2012-12-16 19:39:58 -0800212 * or null if not found. See Name.getComponentContentDigestValue.
Jeff Thompson990e3002012-12-02 23:29:36 -0800213 */
214Name.prototype.getContentDigestValue = function() {
Jeff Thompson990e3002012-12-02 23:29:36 -0800215 for (var i = this.components.length - 1; i >= 0; --i) {
Jeff Thompsonac3e62c2012-12-16 19:39:58 -0800216 var digestValue = Name.getComponentContentDigestValue(this.components[i]);
217 if (digestValue != null)
218 return digestValue;
Jeff Thompson990e3002012-12-02 23:29:36 -0800219 }
220
221 return null;
222}
223
Jeff Thompsonac3e62c2012-12-16 19:39:58 -0800224/*
225 * If component is a ContentDigest, return the digest value as a Uint8Array subarray (don't modify!).
226 * If not a ContentDigest, return null.
227 * A ContentDigest component is Name.ContentDigestPrefix + 32 bytes + Name.ContentDigestSuffix.
228 */
229Name.getComponentContentDigestValue = function(component) {
230 var digestComponentLength = Name.ContentDigestPrefix.length + 32 + Name.ContentDigestSuffix.length;
231 // Check for the correct length and equal ContentDigestPrefix and ContentDigestSuffix.
232 if (component.length == digestComponentLength &&
233 DataUtils.arraysEqual(component.subarray(0, Name.ContentDigestPrefix.length),
234 Name.ContentDigestPrefix) &&
235 DataUtils.arraysEqual(component.subarray
236 (component.length - Name.ContentDigestSuffix.length, component.length),
237 Name.ContentDigestSuffix))
238 return component.subarray(Name.ContentDigestPrefix.length, Name.ContentDigestPrefix.length + 32);
239 else
240 return null;
241}
242
Jeff Thompson990e3002012-12-02 23:29:36 -0800243// Meta GUID "%C1.M.G%C1" + ContentDigest with a 32 byte BLOB.
244Name.ContentDigestPrefix = new Uint8Array([0xc1, 0x2e, 0x4d, 0x2e, 0x47, 0xc1, 0x01, 0xaa, 0x02, 0x85]);
245Name.ContentDigestSuffix = new Uint8Array([0x00]);
246
Jeff Thompson78849a72013-02-03 22:35:54 -0800247/*
Jeff Thompson4e8b7702012-10-21 23:42:27 -0700248 * Return component as an escaped string according to "CCNx URI Scheme".
249 * We can't use encodeURIComponent because that doesn't encode all the characters we want to.
250 */
251Name.toEscapedString = function(component) {
252 var result = "";
253 var gotNonDot = false;
254 for (var i = 0; i < component.length; ++i) {
255 if (component[i] != 0x2e) {
256 gotNonDot = true;
257 break;
258 }
259 }
260 if (!gotNonDot) {
261 // Special case for component of zero or more periods. Add 3 periods.
262 result = "...";
263 for (var i = 0; i < component.length; ++i)
264 result += ".";
265 }
266 else {
267 for (var i = 0; i < component.length; ++i) {
268 var value = component[i];
269 // Check for 0-9, A-Z, a-z, (+), (-), (.), (_)
270 if (value >= 0x30 && value <= 0x39 || value >= 0x41 && value <= 0x5a ||
271 value >= 0x61 && value <= 0x7a || value == 0x2b || value == 0x2d ||
272 value == 0x2e || value == 0x5f)
273 result += String.fromCharCode(value);
274 else
275 result += "%" + (value < 16 ? "0" : "") + value.toString(16).toUpperCase();
276 }
277 }
278 return result;
279};
Wentao Shangb42483a2013-01-03 15:32:32 -0800280
Jeff Thompson78849a72013-02-03 22:35:54 -0800281/*
282 * Return component as a Uint8Array by decoding the escapedString according to "CCNx URI Scheme".
283 * If escapedString is "", "." or ".." then return null, which means to skip the component in the name.
284 */
285Name.fromEscapedString = function(escapedString) {
286 var component = unescape(escapedString.trim());
287
288 if (component.match(/[^.]/) == null) {
289 // Special case for component of only periods.
290 if (component.length <= 2)
291 // Zero, one or two periods is illegal. Ignore this componenent to be
292 // consistent with the C implementation.
293 return null;
294 else
295 // Remove 3 periods.
296 return DataUtils.toNumbersFromString(component.substr(3, component.length - 3));
297 }
298 else
299 return DataUtils.toNumbersFromString(component);
300}
301
Wentao Shangb42483a2013-01-03 15:32:32 -0800302Name.prototype.match = function(/*Name*/ name) {
303 var i_name = this.components;
304 var o_name = name.components;
305
306 // The intrest name is longer than the name we are checking it against.
307 if (i_name.length > o_name.length)
308 return false;
309
310 // Check if at least one of given components doesn't match.
311 for (var i = 0; i < i_name.length; ++i) {
312 if (!DataUtils.arraysEqual(i_name[i], o_name[i]))
313 return false;
314 }
315
316 return true;
317};