blob: 49b0200c78fd0757ed3e7d163f6ac5540c4ecb48 [file] [log] [blame]
Alexander Afanasyevc74a6022011-08-15 20:01:35 -07001/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil -*- */
2/*
3 * Copyright (c) 2011 University of California, Los Angeles
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation;
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 *
18 * Author:
19 */
20
Alexander Afanasyev834f35c2011-08-16 17:13:50 -070021#include "ccnx-encoding-helper.h"
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070022
Ilya Moiseenkod26e6822011-08-23 17:48:38 -070023#include "ns3/ccnx-name-components.h"
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070024#include "ns3/ccnx-interest-header.h"
25#include "ns3/ccnx-content-object-header.h"
26
27#include <sstream>
Alexander Afanasyev2a5df202011-08-15 22:39:05 -070028#include <boost/foreach.hpp>
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070029
30namespace ns3 {
31
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070032size_t
Alexander Afanasyev834f35c2011-08-16 17:13:50 -070033CcnxEncodingHelper::Serialize (Buffer::Iterator start, const CcnxInterestHeader &interest)
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070034{
35 size_t written = 0;
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -070036 written += AppendBlockHeader (start, CcnbParser::CCN_DTAG_Interest, CcnbParser::CCN_DTAG); // <Interest>
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070037
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -070038 written += AppendBlockHeader (start, CcnbParser::CCN_DTAG_Name, CcnbParser::CCN_DTAG); // <Name>
Alexander Afanasyev2a5df202011-08-15 22:39:05 -070039 written += AppendNameComponents (start, interest.GetName()); // <Component>...</Component>...
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070040 written += AppendCloser (start); // </Name>
41
42 if (interest.GetMinSuffixComponents() >= 0)
43 {
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -070044 written += AppendBlockHeader (start, CcnbParser::CCN_DTAG_MinSuffixComponents, CcnbParser::CCN_DTAG);
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070045 written += AppendNumber (start, interest.GetMinSuffixComponents ());
46 written += AppendCloser (start);
47 }
48 if (interest.GetMaxSuffixComponents() >= 0)
49 {
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -070050 written += AppendBlockHeader (start, CcnbParser::CCN_DTAG_MaxSuffixComponents, CcnbParser::CCN_DTAG);
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070051 written += AppendNumber (start, interest.GetMaxSuffixComponents ());
52 written += AppendCloser (start);
53 }
Alexander Afanasyev85a3bca2011-08-31 16:51:03 -070054 if (interest.IsEnabledExclude() && interest.GetExclude().size() > 0)
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070055 {
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -070056 written += AppendBlockHeader (start, CcnbParser::CCN_DTAG_Exclude, CcnbParser::CCN_DTAG); // <Exclude>
Alexander Afanasyev2a5df202011-08-15 22:39:05 -070057 written += AppendNameComponents (start, interest.GetExclude()); // <Component>...</Component>...
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070058 written += AppendCloser (start); // </Exclude>
59 }
60 if (interest.IsEnabledChildSelector())
61 {
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -070062 written += AppendBlockHeader (start, CcnbParser::CCN_DTAG_ChildSelector, CcnbParser::CCN_DTAG);
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070063 written += AppendNumber (start, 1);
64 written += AppendCloser (start);
65 }
66 if (interest.IsEnabledAnswerOriginKind())
67 {
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -070068 written += AppendBlockHeader (start, CcnbParser::CCN_DTAG_AnswerOriginKind, CcnbParser::CCN_DTAG);
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070069 written += AppendNumber (start, 1);
70 written += AppendCloser (start);
71 }
72 if (interest.GetScope() >= 0)
73 {
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -070074 written += AppendBlockHeader (start, CcnbParser::CCN_DTAG_Scope, CcnbParser::CCN_DTAG);
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070075 written += AppendNumber (start, interest.GetScope ());
76 written += AppendCloser (start);
77 }
78 if (!interest.GetInterestLifetime().IsZero())
79 {
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -070080 written += AppendBlockHeader (start, CcnbParser::CCN_DTAG_InterestLifetime, CcnbParser::CCN_DTAG);
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070081 written += AppendTimestampBlob (start, interest.GetInterestLifetime());
82 written += AppendCloser (start);
83 }
84 if (interest.GetNonce()>0)
85 {
86 uint32_t nonce = interest.GetNonce();
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -070087 written += AppendTaggedBlob (start, CcnbParser::CCN_DTAG_Nonce,
Alexander Afanasyevc74a6022011-08-15 20:01:35 -070088 reinterpret_cast<const uint8_t*>(&nonce),
89 sizeof(nonce));
90 }
91 written += AppendCloser (start); // </Interest>
92
93 return written;
94}
95
96size_t
Alexander Afanasyev85a3bca2011-08-31 16:51:03 -070097CcnxEncodingHelper::GetSerializedSize (const CcnxInterestHeader &interest)
98{
99 size_t written = 0;
100 written += EstimateBlockHeader (CcnbParser::CCN_DTAG_Interest); // <Interest>
101
102 written += EstimateBlockHeader (CcnbParser::CCN_DTAG_Name); // <Name>
103 written += EstimateNameComponents (interest.GetName()); // <Component>...</Component>...
104 written += 1; // </Name>
105
106 if (interest.GetMinSuffixComponents() >= 0)
107 {
108 written += EstimateBlockHeader (CcnbParser::CCN_DTAG_MinSuffixComponents);
109 written += EstimateNumber (interest.GetMinSuffixComponents ());
110 written += 1;
111 }
112 if (interest.GetMaxSuffixComponents() >= 0)
113 {
114 written += EstimateBlockHeader (CcnbParser::CCN_DTAG_MaxSuffixComponents);
115 written += EstimateNumber (interest.GetMaxSuffixComponents ());
116 written += 1;
117 }
118 if (interest.IsEnabledExclude() && interest.GetExclude().size() > 0)
119 {
120 written += EstimateBlockHeader (CcnbParser::CCN_DTAG_Exclude);
121 written += EstimateNameComponents (interest.GetExclude()); // <Component>...</Component>...
122 written += 1; // </Exclude>
123 }
124 if (interest.IsEnabledChildSelector())
125 {
126 written += EstimateBlockHeader (CcnbParser::CCN_DTAG_ChildSelector);
127 written += EstimateNumber (1);
128 written += 1;
129 }
130 if (interest.IsEnabledAnswerOriginKind())
131 {
132 written += EstimateBlockHeader (CcnbParser::CCN_DTAG_AnswerOriginKind);
133 written += EstimateNumber (1);
134 written += 1;
135 }
136 if (interest.GetScope() >= 0)
137 {
138 written += EstimateBlockHeader (CcnbParser::CCN_DTAG_Scope);
139 written += EstimateNumber (interest.GetScope ());
140 written += 1;
141 }
142 if (!interest.GetInterestLifetime().IsZero())
143 {
144 written += EstimateBlockHeader (CcnbParser::CCN_DTAG_InterestLifetime);
145 written += EstimateTimestampBlob (interest.GetInterestLifetime());
146 written += 1;
147 }
148 if (interest.GetNonce()>0)
149 {
150 written += EstimateTaggedBlob (CcnbParser::CCN_DTAG_Nonce, sizeof(uint32_t));
151 }
Ilya Moiseenkoaa17c8e2011-10-28 13:04:30 -0700152 if (interest.IsNack () )
153 {
154 written += EstimateBlockHeader (CcnbParser::NDN_DTAG_Nack);
155 written += EstimateNumber (1);
156 written += 1;
157 }
158 if (interest.IsCongested () )
159 {
160 written += EstimateBlockHeader (CcnbParser::NDN_DTAG_Congested);
161 written += EstimateNumber (1);
162 written += 1;
163 }
164
Alexander Afanasyev85a3bca2011-08-31 16:51:03 -0700165 written += 1; // </Interest>
166
167 return written;
168}
169
170size_t
Alexander Afanasyev834f35c2011-08-16 17:13:50 -0700171CcnxEncodingHelper::Serialize (Buffer::Iterator start, const CcnxContentObjectHeader &contentObject)
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700172{
173 size_t written = 0;
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -0700174 written += AppendBlockHeader (start, CcnbParser::CCN_DTAG_ContentObject, CcnbParser::CCN_DTAG); // <ContentObject>
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700175
176 // fake signature
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -0700177 written += AppendBlockHeader (start, CcnbParser::CCN_DTAG_Signature, CcnbParser::CCN_DTAG); // <Signature>
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700178 // Signature ::= DigestAlgorithm?
179 // Witness?
180 // SignatureBits
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -0700181 written += AppendTaggedBlob (start, CcnbParser::CCN_DTAG_SignatureBits, 0, 0); // <SignatureBits />
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700182 written += AppendCloser (start); // </Signature>
183
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -0700184 written += AppendBlockHeader (start, CcnbParser::CCN_DTAG_Name, CcnbParser::CCN_DTAG); // <Name>
Alexander Afanasyev2a5df202011-08-15 22:39:05 -0700185 written += AppendNameComponents (start, contentObject.GetName()); // <Component>...</Component>...
186 written += AppendCloser (start); // </Name>
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700187
188 // fake signature
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -0700189 written += AppendBlockHeader (start, CcnbParser::CCN_DTAG_SignedInfo, CcnbParser::CCN_DTAG); // <SignedInfo>
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700190 // SignedInfo ::= PublisherPublicKeyDigest
191 // Timestamp
192 // Type?
193 // FreshnessSeconds?
194 // FinalBlockID?
195 // KeyLocator?
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -0700196 written += AppendTaggedBlob (start, CcnbParser::CCN_DTAG_PublisherPublicKeyDigest, 0, 0); // <PublisherPublicKeyDigest />
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700197 written += AppendCloser (start); // </SignedInfo>
198
Alexander Afanasyeve709f3d2011-08-21 17:55:45 -0700199 written += AppendBlockHeader (start, CcnbParser::CCN_DTAG_Content, CcnbParser::CCN_DTAG); // <Content>
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700200
Alexander Afanasyeve91ab752011-08-31 19:13:40 -0700201 // there are no closing tags !!!
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700202 return written;
203}
204
Alexander Afanasyev85a3bca2011-08-31 16:51:03 -0700205size_t
206CcnxEncodingHelper::GetSerializedSize (const CcnxContentObjectHeader &contentObject)
207{
208 size_t written = 0;
209 written += EstimateBlockHeader (CcnbParser::CCN_DTAG_ContentObject); // <ContentObject>
210
211 // fake signature
212 written += EstimateBlockHeader (CcnbParser::CCN_DTAG_Signature); // <Signature>
213 // Signature ::= DigestAlgorithm?
214 // Witness?
215 // SignatureBits
216 written += EstimateTaggedBlob (CcnbParser::CCN_DTAG_SignatureBits, 0); // <SignatureBits />
217 written += 1; // </Signature>
218
219 written += EstimateBlockHeader (CcnbParser::CCN_DTAG_Name); // <Name>
220 written += EstimateNameComponents (contentObject.GetName()); // <Component>...</Component>...
221 written += 1; // </Name>
222
223 // fake signature
224 written += EstimateBlockHeader (CcnbParser::CCN_DTAG_SignedInfo); // <SignedInfo>
225 // SignedInfo ::= PublisherPublicKeyDigest
226 // Timestamp
227 // Type?
228 // FreshnessSeconds?
229 // FinalBlockID?
230 // KeyLocator?
231 written += EstimateTaggedBlob (CcnbParser::CCN_DTAG_PublisherPublicKeyDigest, 0); // <PublisherPublicKeyDigest />
232 written += 1; // </SignedInfo>
233
234 written += EstimateBlockHeader (CcnbParser::CCN_DTAG_Content); // <Content>
235
Alexander Afanasyeve91ab752011-08-31 19:13:40 -0700236 // there are no closing tags !!!
Alexander Afanasyev85a3bca2011-08-31 16:51:03 -0700237 return written;
238}
239
240//////////////////////////////////////////////////////////////////////
241//////////////////////////////////////////////////////////////////////
242//////////////////////////////////////////////////////////////////////
243
244#define CCN_TT_BITS 3
245#define CCN_TT_MASK ((1 << CCN_TT_BITS) - 1)
246#define CCN_MAX_TINY ((1 << (7-CCN_TT_BITS)) - 1)
247#define CCN_TT_HBIT ((unsigned char)(1 << 7))
248
249size_t
250CcnxEncodingHelper::AppendBlockHeader (Buffer::Iterator &start, size_t val, CcnbParser::ccn_tt tt)
251{
252 unsigned char buf[1+8*((sizeof(val)+6)/7)];
253 unsigned char *p = &(buf[sizeof(buf)-1]);
254 size_t n = 1;
255 p[0] = (CCN_TT_HBIT & ~CcnbParser::CCN_CLOSE) |
256 ((val & CCN_MAX_TINY) << CCN_TT_BITS) |
257 (CCN_TT_MASK & tt);
258 val >>= (7-CCN_TT_BITS);
259 while (val != 0) {
260 (--p)[0] = (((unsigned char)val) & ~CCN_TT_HBIT) | CcnbParser::CCN_CLOSE;
261 n++;
262 val >>= 7;
263 }
264 start.Write (p,n);
265 return n;
266}
267
268size_t
269CcnxEncodingHelper::EstimateBlockHeader (size_t value)
270{
271 value >>= (7-CCN_TT_BITS);
272 size_t n = 1;
273 while (value>0)
274 {
275 value >>= 7;
276 n++;
277 }
278 return n;
279}
280
281size_t
282CcnxEncodingHelper::AppendNumber (Buffer::Iterator &start, uint32_t number)
283{
284 std::ostringstream os;
285 os << number;
286
287 size_t written = 0;
288 written += AppendBlockHeader (start, os.str().size(), CcnbParser::CCN_UDATA);
289 written += os.str().size();
290 start.Write (reinterpret_cast<const unsigned char*>(os.str().c_str()), os.str().size());
291
292 return written;
293}
294
295size_t
296CcnxEncodingHelper::EstimateNumber (uint32_t number)
297{
298 std::ostringstream os;
299 os << number;
300 return EstimateBlockHeader (os.str ().size ()) + os.str ().size ();
301}
302
303size_t
304CcnxEncodingHelper::AppendCloser (Buffer::Iterator &start)
305{
306 start.WriteU8 (CcnbParser::CCN_CLOSE);
307 return 1;
308}
309
310size_t
311CcnxEncodingHelper::AppendNameComponents (Buffer::Iterator &start, const CcnxNameComponents &name)
312{
313 size_t written = 0;
314 BOOST_FOREACH (const std::string &component, name.GetComponents())
315 {
316 written += AppendTaggedBlob (start, CcnbParser::CCN_DTAG_Component,
317 reinterpret_cast<const uint8_t*>(component.c_str()), component.size());
318 }
319 return written;
320}
321
322size_t
323CcnxEncodingHelper::EstimateNameComponents (const CcnxNameComponents &name)
324{
325 size_t written = 0;
326 BOOST_FOREACH (const std::string &component, name.GetComponents())
327 {
328 written += EstimateTaggedBlob (CcnbParser::CCN_DTAG_Component, component.size());
329 }
330 return written;
331}
332
333size_t
334CcnxEncodingHelper::AppendTimestampBlob (Buffer::Iterator &start, const Time &time)
335{
336 // the original function implements Markers... thought not sure what are these markers for...
337
338 // Determine miminal number of bytes required to store the timestamp
339 int required_bytes = 2; // 12 bits for fractions of a second, 4 bits left for seconds. Sometimes it is enough
340 intmax_t ts = time.ToInteger (Time::S) >> 4;
341 for (; required_bytes < 7 && ts != 0; ts >>= 8) // not more than 6 bytes?
342 required_bytes++;
343
344 size_t len = AppendBlockHeader(start, required_bytes, CcnbParser::CCN_BLOB);
345
346 // write part with seconds
347 ts = time.ToInteger (Time::S) >> 4;
348 for (int i = 0; i < required_bytes - 2; i++)
349 start.WriteU8 ( ts >> (8 * (required_bytes - 3 - i)) );
350
351 /* arithmetic contortions are to avoid overflowing 31 bits */
352 ts = ((time.ToInteger (Time::S) & 15) << 12) +
353 (((time.ToInteger (Time::NS) % 1000000000) / 5 * 8 + 195312) / 390625);
354 for (int i = required_bytes - 2; i < required_bytes; i++)
355 start.WriteU8 ( ts >> (8 * (required_bytes - 1 - i)) );
356
357 return len + required_bytes;
358}
359
360size_t
361CcnxEncodingHelper::EstimateTimestampBlob (const Time &time)
362{
363 int required_bytes = 2; // 12 bits for fractions of a second, 4 bits left for seconds. Sometimes it is enough
364 intmax_t ts = time.ToInteger (Time::S) >> 4;
365 for (; required_bytes < 7 && ts != 0; ts >>= 8) // not more than 6 bytes?
366 required_bytes++;
367
368 return EstimateBlockHeader (required_bytes) + required_bytes;
369}
370
371size_t
372CcnxEncodingHelper::AppendTaggedBlob (Buffer::Iterator &start, CcnbParser::ccn_dtag dtag,
373 const uint8_t *data, size_t size)
374{
375 size_t written = AppendBlockHeader (start, dtag, CcnbParser::CCN_DTAG);
376 /* 2 */
377 if (size>0)
378 {
379 written += AppendBlockHeader (start, size, CcnbParser::CCN_BLOB);
380 start.Write (data, size);
381 written += size;
382 /* size */
383 }
384 written += AppendCloser (start);
385 /* 1 */
386
387 return written;
388}
389
390size_t
391CcnxEncodingHelper::EstimateTaggedBlob (CcnbParser::ccn_dtag dtag, size_t size)
392{
Alexander Afanasyeve91ab752011-08-31 19:13:40 -0700393 if (size>0)
394 return EstimateBlockHeader (dtag) + EstimateBlockHeader (size) + size + 1;
395 else
396 return EstimateBlockHeader (dtag) + 1;
Alexander Afanasyev85a3bca2011-08-31 16:51:03 -0700397}
398
399
400
Alexander Afanasyevc74a6022011-08-15 20:01:35 -0700401} // namespace ns3