A Discrete-Event Network Simulator
API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
lte-asn1-header.cc
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2012 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
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: Lluis Parcerisa <lparcerisa@cttc.cat>
19  */
20 
21 #include "ns3/log.h"
22 #include "ns3/lte-asn1-header.h"
23 
24 #include <stdio.h>
25 #include <sstream>
26 #include <cmath>
27 
28 NS_LOG_COMPONENT_DEFINE ("Asn1Header");
29 
30 namespace ns3 {
31 
32 NS_OBJECT_ENSURE_REGISTERED (Asn1Header);
33 
34 TypeId
36 {
37  static TypeId tid = TypeId ("ns3::Asn1Header")
38  .SetParent<Header> ()
39  ;
40  return tid;
41 }
42 
43 TypeId
45 {
46  return GetTypeId ();
47 }
48 
50 {
53  m_isDataSerialized = false;
54 }
55 
57 {
58 }
59 
60 uint32_t
62 {
63  if (!m_isDataSerialized)
64  {
65  PreSerialize ();
66  }
68 }
69 
71 {
72  if (!m_isDataSerialized)
73  {
74  PreSerialize ();
75  }
77 }
78 
79 void Asn1Header::WriteOctet (uint8_t octet) const
80 {
83  bIterator.Prev ();
84  bIterator.WriteU8 (octet);
85 }
86 
87 template <int N>
88 void Asn1Header::SerializeBitset (std::bitset<N> data) const
89 {
90 
91  size_t dataSize = data.size ();
92  uint8_t pendingBits = dataSize;
93  uint8_t mask = 1;
94  int j;
95 
96  // No extension marker (Clause 16.7 ITU-T X.691),
97  // as 3GPP TS 36.331 does not use it in its IE's.
98 
99  // Clause 16.8 ITU-T X.691
100  if (dataSize == 0)
101  {
102  return;
103  }
104 
105  // Clause 16.9 ITU-T X.691
106  // Clause 16.10 ITU-T X.691
107  if (dataSize <= 65536)
108  {
109  // If there are bits pending to be processed,
110  // append first bits in data to complete an octet.
112  {
113  mask = 0x80 >> m_numSerializationPendingBits;
114  while (pendingBits > 0 && m_numSerializationPendingBits < 8)
115  {
116  m_serializationPendingBits |= (data[pendingBits - 1]) ? mask : 0;
117  pendingBits--;
119  mask = (mask >> 1) & (~mask);
120  }
121 
123  {
127  }
128  }
129 
130  while (pendingBits > 0)
131  {
132  mask = 1;
133  j = 8;
134 
135  // If there are less than 8 remaining bits,
136  // store it to m_serializationPendingBits.
137  if (pendingBits < 8)
138  {
139  mask = 0x80;
140  m_numSerializationPendingBits = pendingBits;
141  while (pendingBits > 0)
142  {
143  m_serializationPendingBits |= (data[pendingBits - 1]) ? mask : 0;
144  mask = (mask >> 1) & (~mask);
145  pendingBits--;
146  }
147  }
148 
149  // Write the data to buffer
150  else
151  {
152  uint8_t octetToWrite = 0;
153  for (; j > 0; j--)
154  {
155  octetToWrite |= (data[pendingBits - j]) ? mask : 0;
156  mask = (mask << 1) & (~mask);
157  }
158  WriteOctet (octetToWrite);
159  pendingBits -= 8;
160  }
161  }
162  }
163 
164  // Clause 16.11 ITU-T X.691
165  else
166  {
167  printf ("FRAGMENTATION NEEDED!\n");
168  }
169 }
170 
171 template <int N>
172 void Asn1Header::SerializeBitstring (std::bitset<N> data) const
173 {
174  SerializeBitset<N> (data);
175 }
176 
177 
178 void Asn1Header::SerializeBitstring (std::bitset<1> data) const
179 {
180  SerializeBitstring<1> (data);
181 }
182 
183 void Asn1Header::SerializeBitstring (std::bitset<2> data) const
184 {
185  SerializeBitstring<2> (data);
186 }
187 
188 void Asn1Header::SerializeBitstring (std::bitset<8> data) const
189 {
190  SerializeBitstring<8> (data);
191 }
192 
193 void Asn1Header::SerializeBitstring (std::bitset<10> data) const
194 {
195  SerializeBitstring<10> (data);
196 }
197 
198 void Asn1Header::SerializeBitstring (std::bitset<16> data) const
199 {
200  SerializeBitstring<16> (data);
201 }
202 
203 void Asn1Header::SerializeBitstring (std::bitset<27> data) const
204 {
205  SerializeBitstring<27> (data);
206 }
207 
208 void Asn1Header::SerializeBitstring (std::bitset<28> data) const
209 {
210  SerializeBitstring<28> (data);
211 }
212 
213 void Asn1Header::SerializeBitstring (std::bitset<32> data) const
214 {
215  SerializeBitstring<32> (data);
216 }
217 
218 void Asn1Header::SerializeBoolean (bool value) const
219 {
220  // Clause 12 ITU-T X.691
221  std::bitset<1> val;
222  (value) ? val.set () : val.reset ();
223  SerializeBitset<1> (val);
224 }
225 
226 template <int N>
227 void Asn1Header::SerializeSequence (std::bitset<N> optionalOrDefaultMask, bool isExtensionMarkerPresent) const
228 {
229  if (isExtensionMarkerPresent)
230  {
231  // Extension marker present, but no extension
232  SerializeBoolean (false);
233  }
234  SerializeBitstring<N> (optionalOrDefaultMask);
235 }
236 
237 void Asn1Header::SerializeSequence (std::bitset<0> optionalOrDefaultMask, bool isExtensionMarkerPresent) const
238 {
239  SerializeSequence<0> (optionalOrDefaultMask,isExtensionMarkerPresent);
240 }
241 
242 void Asn1Header::SerializeSequence (std::bitset<1> optionalOrDefaultMask, bool isExtensionMarkerPresent) const
243 {
244  SerializeSequence<1> (optionalOrDefaultMask,isExtensionMarkerPresent);
245 }
246 
247 void Asn1Header::SerializeSequence (std::bitset<2> optionalOrDefaultMask, bool isExtensionMarkerPresent) const
248 {
249  SerializeSequence<2> (optionalOrDefaultMask,isExtensionMarkerPresent);
250 }
251 
252 void Asn1Header::SerializeSequence (std::bitset<3> optionalOrDefaultMask, bool isExtensionMarkerPresent) const
253 {
254  SerializeSequence<3> (optionalOrDefaultMask,isExtensionMarkerPresent);
255 }
256 
257 void Asn1Header::SerializeSequence (std::bitset<4> optionalOrDefaultMask, bool isExtensionMarkerPresent) const
258 {
259  SerializeSequence<4> (optionalOrDefaultMask,isExtensionMarkerPresent);
260 }
261 
262 void Asn1Header::SerializeSequence (std::bitset<5> optionalOrDefaultMask, bool isExtensionMarkerPresent) const
263 {
264  SerializeSequence<5> (optionalOrDefaultMask,isExtensionMarkerPresent);
265 }
266 
267 void Asn1Header::SerializeSequence (std::bitset<6> optionalOrDefaultMask, bool isExtensionMarkerPresent) const
268 {
269  SerializeSequence<6> (optionalOrDefaultMask,isExtensionMarkerPresent);
270 }
271 
272 void Asn1Header::SerializeSequence (std::bitset<9> optionalOrDefaultMask, bool isExtensionMarkerPresent) const
273 {
274  SerializeSequence<9> (optionalOrDefaultMask,isExtensionMarkerPresent);
275 }
276 
277 void Asn1Header::SerializeSequence (std::bitset<10> optionalOrDefaultMask, bool isExtensionMarkerPresent) const
278 {
279  SerializeSequence<10> (optionalOrDefaultMask,isExtensionMarkerPresent);
280 }
281 
282 void Asn1Header::SerializeSequence (std::bitset<11> optionalOrDefaultMask, bool isExtensionMarkerPresent) const
283 {
284  SerializeSequence<11> (optionalOrDefaultMask,isExtensionMarkerPresent);
285 }
286 
287 void Asn1Header::SerializeSequenceOf (int numElems, int nMax, int nMin) const
288 {
289  // Clause 20.6 ITU-T X.691
290  SerializeInteger (numElems, nMin, nMax);
291 }
292 
293 void Asn1Header::SerializeEnum (int numElems, int selectedElem) const
294 {
295  // Clause 14 ITU-T X.691
296  SerializeInteger (selectedElem, 0, numElems - 1);
297 }
298 
299 void Asn1Header::SerializeChoice (int numOptions, int selectedOption, bool isExtensionMarkerPresent) const
300 {
301  if(isExtensionMarkerPresent)
302  {
303  // Never extended attributes
304  SerializeBoolean(false);
305  }
306 
307  // Clause 23.4 ITU-T X.691
308  if (numOptions < 2)
309  {
310  return;
311  }
312 
313  SerializeInteger (selectedOption,0,numOptions - 1);
314 }
315 
316 void Asn1Header::SerializeInteger (int n, int nmin, int nmax) const
317 {
318  // Misusage check: Ensure nmax>nmin ...
319  if (nmin > nmax)
320  {
321  int aux = nmin;
322  nmin = nmax;
323  nmax = aux;
324  }
325 
326  // Clause 11.5.3 ITU-T X.691
327  int range = nmax - nmin + 1;
328  // Substract nmin to n
329  n -= nmin;
330 
331  // Clause 11.5.4 ITU-T X.691
332  if (range <= 1)
333  {
334  return;
335  }
336 
337  // Clause 11.5.6 ITU-T X.691
338  int requiredBits = std::ceil (std::log (range) / std::log (2.0));
339 
340  switch (requiredBits)
341  {
342  case 1:
343  SerializeBitset<1> (std::bitset<1> (n));
344  break;
345  case 2:
346  SerializeBitset<2> (std::bitset<2> (n));
347  break;
348  case 3:
349  SerializeBitset<3> (std::bitset<3> (n));
350  break;
351  case 4:
352  SerializeBitset<4> (std::bitset<4> (n));
353  break;
354  case 5:
355  SerializeBitset<5> (std::bitset<5> (n));
356  break;
357  case 6:
358  SerializeBitset<6> (std::bitset<6> (n));
359  break;
360  case 7:
361  SerializeBitset<7> (std::bitset<7> (n));
362  break;
363  case 8:
364  SerializeBitset<8> (std::bitset<8> (n));
365  break;
366  case 9:
367  SerializeBitset<9> (std::bitset<9> (n));
368  break;
369  case 10:
370  SerializeBitset<10> (std::bitset<10> (n));
371  break;
372  case 11:
373  SerializeBitset<11> (std::bitset<11> (n));
374  break;
375  case 12:
376  SerializeBitset<12> (std::bitset<12> (n));
377  break;
378  case 13:
379  SerializeBitset<13> (std::bitset<13> (n));
380  break;
381  case 14:
382  SerializeBitset<14> (std::bitset<14> (n));
383  break;
384  case 15:
385  SerializeBitset<15> (std::bitset<15> (n));
386  break;
387  case 16:
388  SerializeBitset<16> (std::bitset<16> (n));
389  break;
390  case 17:
391  SerializeBitset<17> (std::bitset<17> (n));
392  break;
393  case 18:
394  SerializeBitset<18> (std::bitset<18> (n));
395  break;
396  case 19:
397  SerializeBitset<19> (std::bitset<19> (n));
398  break;
399  case 20:
400  SerializeBitset<20> (std::bitset<20> (n));
401  break;
402  default:
403  {
404  std::cout << "SerializeInteger " << requiredBits << " Out of range!!" << std::endl;
405  exit (1);
406  }
407  }
408 }
409 
411 {
412  // Clause 18 ITU-T X.691
413  return;
414 }
415 
417 {
419  {
421  SerializeBitset<8> (std::bitset<8> (m_serializationPendingBits));
422  }
423  m_isDataSerialized = true;
424 }
425 
426 template <int N>
428 {
429 
430  int bitsToRead = N;
431  uint8_t mask;
432 
433  // Read bits from pending bits
435  {
436  while (bitsToRead > 0 && m_numSerializationPendingBits > 0)
437  {
438  data->set (bitsToRead - 1,(m_serializationPendingBits & 0x80) ? 1 : 0);
439  bitsToRead--;
442  }
443  }
444 
445  // Read bits from buffer
446  while (bitsToRead > 0)
447  {
448  uint8_t octet = bIterator.ReadU8 ();
449  // If 8 bits can be allocated to the bitset, set the bits
450  if (bitsToRead >= 8)
451  {
452  mask = 0x80;
453  for (int j = 0; j < 8; j++)
454  {
455  data->set (bitsToRead - 1,(octet & mask) ? 1 : 0);
456  bitsToRead--;
457  mask = mask >> 1;
458  }
459  }
460 
461  // Otherwise, we'll have to save the remaining bits
462  else
463  {
464  mask = 0x80;
465  m_numSerializationPendingBits = 8 - bitsToRead;
466  m_serializationPendingBits = octet << bitsToRead;
467  while (bitsToRead > 0)
468  {
469  data->set (bitsToRead - 1,(octet & mask) ? 1 : 0);
470  bitsToRead--;
471  mask = mask >> 1;
472  }
473  }
474  }
475 
476  return bIterator;
477 }
478 
479 template <int N>
481 {
482  return DeserializeBitset<N> (data,bIterator);
483 }
484 
486 {
487  return DeserializeBitstring<1> (data,bIterator);
488 }
489 
491 {
492  return DeserializeBitstring<2> (data,bIterator);
493 }
494 
496 {
497  return DeserializeBitstring<8> (data,bIterator);
498 }
499 
501 {
502  return DeserializeBitstring<10> (data,bIterator);
503 }
504 
506 {
507  return DeserializeBitstring<16> (data,bIterator);
508 }
509 
511 {
512  return DeserializeBitstring<27> (data,bIterator);
513 }
514 
516 {
517  return DeserializeBitstring<28> (data,bIterator);
518 }
519 
521 {
522  return DeserializeBitstring<32> (data,bIterator);
523 }
524 
526 {
527  std::bitset<1> readBit;
528  bIterator = DeserializeBitset<1> (&readBit,bIterator);
529  *value = (readBit[0] == 1) ? true : false;
530  return bIterator;
531 }
532 
533 Buffer::Iterator Asn1Header::DeserializeInteger (int *n, int nmin, int nmax, Buffer::Iterator bIterator)
534 {
535  // Misusage check: Ensure nmax>nmin ...
536  if (nmin > nmax)
537  {
538  int aux = nmin;
539  nmin = nmax;
540  nmax = aux;
541  }
542 
543  int range = nmax - nmin + 1;
544 
545  if (range == 1)
546  {
547  return bIterator;
548  }
549 
550  int requiredBits = std::ceil (std::log (range) / std::log (2.0));
551 
552  std::bitset<1> bitsRead1;
553  std::bitset<2> bitsRead2;
554  std::bitset<3> bitsRead3;
555  std::bitset<4> bitsRead4;
556  std::bitset<5> bitsRead5;
557  std::bitset<6> bitsRead6;
558  std::bitset<7> bitsRead7;
559  std::bitset<8> bitsRead8;
560  std::bitset<9> bitsRead9;
561  std::bitset<10> bitsRead10;
562  std::bitset<11> bitsRead11;
563  std::bitset<12> bitsRead12;
564  std::bitset<13> bitsRead13;
565  std::bitset<14> bitsRead14;
566  std::bitset<15> bitsRead15;
567  std::bitset<16> bitsRead16;
568  std::bitset<17> bitsRead17;
569  std::bitset<18> bitsRead18;
570  std::bitset<19> bitsRead19;
571  std::bitset<20> bitsRead20;
572 
573  switch (requiredBits)
574  {
575  case 1:
576  bIterator = DeserializeBitset<1> (&bitsRead1,bIterator);
577  *n = (int)bitsRead1.to_ulong ();
578  break;
579  case 2:
580  bIterator = DeserializeBitset<2> (&bitsRead2,bIterator);
581  *n = (int)bitsRead2.to_ulong ();
582  break;
583  case 3:
584  bIterator = DeserializeBitset<3> (&bitsRead3,bIterator);
585  *n = (int)bitsRead3.to_ulong ();
586  break;
587  case 4:
588  bIterator = DeserializeBitset<4> (&bitsRead4,bIterator);
589  *n = (int)bitsRead4.to_ulong ();
590  break;
591  case 5:
592  bIterator = DeserializeBitset<5> (&bitsRead5,bIterator);
593  *n = (int)bitsRead5.to_ulong ();
594  break;
595  case 6:
596  bIterator = DeserializeBitset<6> (&bitsRead6,bIterator);
597  *n = (int)bitsRead6.to_ulong ();
598  break;
599  case 7:
600  bIterator = DeserializeBitset<7> (&bitsRead7,bIterator);
601  *n = (int)bitsRead7.to_ulong ();
602  break;
603  case 8:
604  bIterator = DeserializeBitset<8> (&bitsRead8,bIterator);
605  *n = (int)bitsRead8.to_ulong ();
606  break;
607  case 9:
608  bIterator = DeserializeBitset<9> (&bitsRead9,bIterator);
609  *n = (int)bitsRead9.to_ulong ();
610  break;
611  case 10:
612  bIterator = DeserializeBitset<10> (&bitsRead10,bIterator);
613  *n = (int)bitsRead10.to_ulong ();
614  break;
615  case 11:
616  bIterator = DeserializeBitset<11> (&bitsRead11,bIterator);
617  *n = (int)bitsRead11.to_ulong ();
618  break;
619  case 12:
620  bIterator = DeserializeBitset<12> (&bitsRead12,bIterator);
621  *n = (int)bitsRead12.to_ulong ();
622  break;
623  case 13:
624  bIterator = DeserializeBitset<13> (&bitsRead13,bIterator);
625  *n = (int)bitsRead13.to_ulong ();
626  break;
627  case 14:
628  bIterator = DeserializeBitset<14> (&bitsRead14,bIterator);
629  *n = (int)bitsRead14.to_ulong ();
630  break;
631  case 15:
632  bIterator = DeserializeBitset<15> (&bitsRead15,bIterator);
633  *n = (int)bitsRead15.to_ulong ();
634  break;
635  case 16:
636  bIterator = DeserializeBitset<16> (&bitsRead16,bIterator);
637  *n = (int)bitsRead16.to_ulong ();
638  break;
639  case 17:
640  bIterator = DeserializeBitset<17> (&bitsRead17,bIterator);
641  *n = (int)bitsRead17.to_ulong ();
642  break;
643  case 18:
644  bIterator = DeserializeBitset<18> (&bitsRead18,bIterator);
645  *n = (int)bitsRead18.to_ulong ();
646  break;
647  case 19:
648  bIterator = DeserializeBitset<19> (&bitsRead19,bIterator);
649  *n = (int)bitsRead19.to_ulong ();
650  break;
651  case 20:
652  bIterator = DeserializeBitset<20> (&bitsRead20,bIterator);
653  *n = (int)bitsRead20.to_ulong ();
654  break;
655  default:
656  {
657  std::cout << "SerializeInteger Out of range!!" << std::endl;
658  exit (1);
659  }
660  }
661 
662  *n += nmin;
663 
664  return bIterator;
665 }
666 
667 Buffer::Iterator Asn1Header::DeserializeChoice (int numOptions, bool isExtensionMarkerPresent, int *selectedOption, Buffer::Iterator bIterator)
668 {
669  if (isExtensionMarkerPresent)
670  {
671  bool marker;
672  bIterator = DeserializeBoolean (&marker,bIterator);
673  }
674  return DeserializeInteger (selectedOption,0,numOptions - 1,bIterator);
675 }
676 
677 Buffer::Iterator Asn1Header::DeserializeEnum (int numElems, int *selectedElem, Buffer::Iterator bIterator)
678 {
679  return DeserializeInteger (selectedElem,0,numElems - 1,bIterator);
680 }
681 
682 template <int N>
683 Buffer::Iterator Asn1Header::DeserializeSequence (std::bitset<N> *optionalOrDefaultMask, bool isExtensionMarkerPresent, Buffer::Iterator bIterator)
684 {
685  if (isExtensionMarkerPresent)
686  {
687  bool dummy;
688  bIterator = DeserializeBoolean (&dummy,bIterator);
689  }
690  bIterator = DeserializeBitset<N> (optionalOrDefaultMask,bIterator);
691  return bIterator;
692 }
693 
694 Buffer::Iterator Asn1Header::DeserializeSequence (std::bitset<0> *optionalOrDefaultMask, bool isExtensionMarkerPresent, Buffer::Iterator bIterator)
695 {
696  return DeserializeSequence<0> (optionalOrDefaultMask,isExtensionMarkerPresent,bIterator);
697 }
698 
699 Buffer::Iterator Asn1Header::DeserializeSequence (std::bitset<1> *optionalOrDefaultMask, bool isExtensionMarkerPresent, Buffer::Iterator bIterator)
700 {
701  return DeserializeSequence<1> (optionalOrDefaultMask,isExtensionMarkerPresent,bIterator);
702 }
703 
704 Buffer::Iterator Asn1Header::DeserializeSequence (std::bitset<2> *optionalOrDefaultMask, bool isExtensionMarkerPresent, Buffer::Iterator bIterator)
705 {
706  return DeserializeSequence<2> (optionalOrDefaultMask,isExtensionMarkerPresent,bIterator);
707 }
708 
709 Buffer::Iterator Asn1Header::DeserializeSequence (std::bitset<3> *optionalOrDefaultMask, bool isExtensionMarkerPresent, Buffer::Iterator bIterator)
710 {
711  return DeserializeSequence<3> (optionalOrDefaultMask,isExtensionMarkerPresent,bIterator);
712 }
713 
714 Buffer::Iterator Asn1Header::DeserializeSequence (std::bitset<4> *optionalOrDefaultMask, bool isExtensionMarkerPresent, Buffer::Iterator bIterator)
715 {
716  return DeserializeSequence<4> (optionalOrDefaultMask,isExtensionMarkerPresent,bIterator);
717 }
718 
719 Buffer::Iterator Asn1Header::DeserializeSequence (std::bitset<5> *optionalOrDefaultMask, bool isExtensionMarkerPresent, Buffer::Iterator bIterator)
720 {
721  return DeserializeSequence<5> (optionalOrDefaultMask,isExtensionMarkerPresent,bIterator);
722 }
723 
724 Buffer::Iterator Asn1Header::DeserializeSequence (std::bitset<6> *optionalOrDefaultMask, bool isExtensionMarkerPresent, Buffer::Iterator bIterator)
725 {
726  return DeserializeSequence<6> (optionalOrDefaultMask,isExtensionMarkerPresent,bIterator);
727 }
728 
729 Buffer::Iterator Asn1Header::DeserializeSequence (std::bitset<9> *optionalOrDefaultMask, bool isExtensionMarkerPresent, Buffer::Iterator bIterator)
730 {
731  return DeserializeSequence<9> (optionalOrDefaultMask,isExtensionMarkerPresent,bIterator);
732 }
733 
734 Buffer::Iterator Asn1Header::DeserializeSequence (std::bitset<10> *optionalOrDefaultMask, bool isExtensionMarkerPresent, Buffer::Iterator bIterator)
735 {
736  return DeserializeSequence<10> (optionalOrDefaultMask,isExtensionMarkerPresent,bIterator);
737 }
738 
739 Buffer::Iterator Asn1Header::DeserializeSequence (std::bitset<11> *optionalOrDefaultMask, bool isExtensionMarkerPresent, Buffer::Iterator bIterator)
740 {
741  return DeserializeSequence<11> (optionalOrDefaultMask,isExtensionMarkerPresent,bIterator);
742 }
743 
745 {
746  return bIterator;
747 }
748 
749 Buffer::Iterator Asn1Header::DeserializeSequenceOf (int *numElems, int nMax, int nMin, Buffer::Iterator bIterator)
750 {
751  return DeserializeInteger (numElems,nMin,nMax,bIterator);
752 }
753 
754 } // namespace ns3
Protocol header serialization and deserialization.
Definition: header.h:42
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register the class in the ns-3 factory.
Definition: object-base.h:38
void SerializeSequenceOf(int numElems, int nMax, int nMin) const
Buffer::Iterator DeserializeChoice(int numOptions, bool isExtensionMarkerPresent, int *selectedOption, Buffer::Iterator bIterator)
Buffer::Iterator DeserializeNull(Buffer::Iterator bIterator)
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:170
uint8_t m_numSerializationPendingBits
void SerializeBoolean(bool value) const
void SerializeBitset(std::bitset< N > data) const
Buffer::Iterator DeserializeSequence(std::bitset< N > *optionalOrDefaultMask, bool isExtensionMarkerPresent, Buffer::Iterator bIterator)
iterator in a Buffer instance
Definition: buffer.h:98
void SerializeNull() const
Buffer::Iterator DeserializeBoolean(bool *value, Buffer::Iterator bIterator)
virtual ~Asn1Header()
void Prev(void)
go backward by one byte
Definition: buffer.h:858
uint8_t m_serializationPendingBits
uint32_t GetSerializedSize(void) const
Buffer::Iterator DeserializeEnum(int numElems, int *selectedElem, Buffer::Iterator bIterator)
Buffer::Iterator DeserializeInteger(int *n, int nmin, int nmax, Buffer::Iterator bIterator)
uint8_t data[writeSize]
Buffer::Iterator End(void) const
Definition: buffer.h:1082
Buffer m_serializationResult
virtual void PreSerialize(void) const =0
This function serializes class attributes to m_serializationResult local Buffer.
Buffer::Iterator Begin(void) const
Definition: buffer.h:1076
void SerializeInteger(int n, int nmin, int nmax) const
Buffer::Iterator DeserializeBitset(std::bitset< N > *data, Buffer::Iterator bIterator)
virtual TypeId GetInstanceTypeId(void) const
uint32_t GetSize(void) const
Definition: buffer.h:1070
void SerializeBitstring(std::bitset< N > bitstring) const
bool AddAtEnd(uint32_t end)
Definition: buffer.cc:360
void WriteOctet(uint8_t octet) const
void WriteU8(uint8_t data)
Definition: buffer.h:876
void SerializeSequence(std::bitset< N > optionalOrDefaultMask, bool isExtensionMarkerPresent) const
Buffer::Iterator DeserializeSequenceOf(int *numElems, int nMax, int nMin, Buffer::Iterator bIterator)
uint8_t ReadU8(void)
Definition: buffer.h:1028
void Write(uint8_t const *buffer, uint32_t size)
Definition: buffer.cc:982
void FinalizeSerialization() const
a unique identifier for an interface.
Definition: type-id.h:49
void Serialize(Buffer::Iterator bIterator) const
static TypeId GetTypeId(void)
TypeId SetParent(TypeId tid)
Definition: type-id.cc:610
void SerializeChoice(int numOptions, int selectedOption, bool isExtensionMarkerPresent) const
void SerializeEnum(int numElems, int selectedElem) const
Buffer::Iterator DeserializeBitstring(std::bitset< N > *bitstring, Buffer::Iterator bIterator)