22 #include "ns3/assert.h"
23 #include "ns3/fatal-error.h"
25 #include "packet-metadata.h"
34 bool PacketMetadata::m_enable =
false;
35 bool PacketMetadata::m_enableChecking =
false;
36 bool PacketMetadata::m_metadataSkipped =
false;
37 uint32_t PacketMetadata::m_maxSize = 0;
38 uint16_t PacketMetadata::m_chunkUid = 0;
39 PacketMetadata::DataFreeList PacketMetadata::m_freeList;
41 PacketMetadata::DataFreeList::~DataFreeList ()
44 for (iterator i = begin (); i != end (); i++)
46 PacketMetadata::Deallocate (*i);
48 PacketMetadata::m_enable =
false;
52 PacketMetadata::Enable (
void)
56 "Error: attempting to enable the packet metadata "
57 "subsystem too late in the simulation, which is not allowed.\n"
58 "A common cause for this problem is to enable ASCII tracing "
59 "after sending any packets. One way to fix this problem is "
60 "to call ns3::PacketMetadata::Enable () near the beginning of"
61 " the program, before any packets are sent.");
66 PacketMetadata::EnableChecking (
void)
70 m_enableChecking =
true;
74 PacketMetadata::ReserveCopy (uint32_t size)
77 struct PacketMetadata::Data *newData = PacketMetadata::Create (m_used + size);
78 memcpy (newData->m_data, m_data->m_data, m_used);
79 newData->m_dirtyEnd = m_used;
81 if (m_data->m_count == 0)
83 PacketMetadata::Recycle (m_data);
91 start = &m_data->m_data[m_tail];
92 Append16 (0xffff, start);
94 start = &m_data->m_data[
m_head] + 2;
95 Append16 (0xffff, start);
99 PacketMetadata::Reserve (uint32_t size)
103 if (m_data->m_size >= m_used + size &&
105 m_data->m_count == 1 ||
106 m_data->m_dirtyEnd == m_used))
118 PacketMetadata::IsSharedPointerOk (uint16_t pointer)
const
121 bool ok = pointer == 0xffff || pointer <= m_data->m_size;
125 PacketMetadata::IsPointerOk (uint16_t pointer)
const
128 bool ok = pointer == 0xffff || pointer <= m_used;
133 PacketMetadata::IsStateOk (
void)
const
136 bool ok = m_used <= m_data->m_size;
137 ok &= IsPointerOk (
m_head);
138 ok &= IsPointerOk (m_tail);
139 uint16_t current =
m_head;
140 while (ok && current != 0xffff)
142 struct PacketMetadata::SmallItem item;
143 PacketMetadata::ExtraItem extraItem;
145 ok &= IsSharedPointerOk (item.next);
146 ok &= IsSharedPointerOk (item.prev);
149 ok &= IsPointerOk (item.prev);
151 if (current != m_tail)
153 ok &= IsPointerOk (item.next);
155 if (current == m_tail)
165 PacketMetadata::GetUleb128Size (uint32_t value)
const
176 if (value < 0x200000)
180 if (value < 0x10000000)
187 PacketMetadata::ReadUleb128 (
const uint8_t **pBuffer)
const
190 const uint8_t *buffer = *pBuffer;
195 result = (byte & (~0x80));
198 *pBuffer = buffer + 1;
202 result |= (byte & (~0x80)) << 7;
205 *pBuffer = buffer + 2;
209 result |= (byte & (~0x80)) << 14;
212 *pBuffer = buffer + 3;
216 result |= (byte & (~0x80)) << 21;
219 *pBuffer = buffer + 4;
223 result |= (byte & (~0x80)) << 28;
226 *pBuffer = buffer + 5;
237 PacketMetadata::Append16 (uint16_t value, uint8_t *buffer)
240 buffer[0] = value & 0xff;
245 PacketMetadata::Append32 (uint32_t value, uint8_t *buffer)
248 buffer[0] = value & 0xff;
249 buffer[1] = (value >> 8) & 0xff;
250 buffer[2] = (value >> 16) & 0xff;
251 buffer[3] = (value >> 24) & 0xff;
255 PacketMetadata::AppendValueExtra (uint32_t value, uint8_t *buffer)
258 if (value < 0x200000)
260 uint8_t byte = value & (~0x80);
261 buffer[0] = 0x80 | byte;
263 byte = value & (~0x80);
264 buffer[1] = 0x80 | byte;
266 byte = value & (~0x80);
270 if (value < 0x10000000)
272 uint8_t byte = value & (~0x80);
273 buffer[0] = 0x80 | byte;
275 byte = value & (~0x80);
276 buffer[1] = 0x80 | byte;
278 byte = value & (~0x80);
279 buffer[2] = 0x80 | byte;
285 uint8_t byte = value & (~0x80);
286 buffer[0] = 0x80 | byte;
288 byte = value & (~0x80);
289 buffer[1] = 0x80 | byte;
291 byte = value & (~0x80);
292 buffer[2] = 0x80 | byte;
294 byte = value & (~0x80);
295 buffer[3] = 0x80 | byte;
302 PacketMetadata::AppendValue (uint32_t value, uint8_t *buffer)
312 uint8_t byte = value & (~0x80);
313 buffer[0] = 0x80 | byte;
318 AppendValueExtra (value, buffer);
322 PacketMetadata::UpdateTail (uint16_t written)
335 uint8_t *previousTail = &m_data->m_data[m_tail];
336 Append16 (m_used, previousTail);
344 m_data->m_dirtyEnd = m_used;
349 PacketMetadata::UpdateHead (uint16_t written)
362 uint8_t *previousHead = &m_data->m_data[
m_head + 2];
363 Append16 (m_used, previousHead);
371 m_data->m_dirtyEnd = m_used;
375 PacketMetadata::AddSmall (
const struct PacketMetadata::SmallItem *item)
377 NS_LOG_FUNCTION (
this << item->next << item->prev << item->typeUid << item->size << item->chunkUid);
379 NS_ASSERT (m_used != item->prev && m_used != item->next);
380 uint32_t typeUidSize = GetUleb128Size (item->typeUid);
381 uint32_t sizeSize = GetUleb128Size (item->size);
382 uint32_t n = 2 + 2 + typeUidSize + sizeSize + 2;
383 if (m_used + n > m_data->m_size ||
385 m_data->m_count != 1 &&
386 m_used != m_data->m_dirtyEnd))
390 uint8_t *buffer = &m_data->m_data[m_used];
391 Append16 (item->next, buffer);
393 Append16 (item->prev, buffer);
395 AppendValue (item->typeUid, buffer);
396 buffer += typeUidSize;
397 AppendValue (item->size, buffer);
399 Append16 (item->chunkUid, buffer);
404 PacketMetadata::AddBig (uint32_t next, uint32_t prev,
405 const PacketMetadata::SmallItem *item,
406 const PacketMetadata::ExtraItem *extraItem)
409 item->next << item->prev << item->typeUid << item->size << item->chunkUid <<
410 extraItem->fragmentStart << extraItem->fragmentEnd << extraItem->packetUid);
412 uint32_t typeUid = ((item->typeUid & 0x1) == 0x1) ? item->typeUid : item->typeUid+1;
413 NS_ASSERT (m_used != prev && m_used != next);
415 uint32_t typeUidSize = GetUleb128Size (typeUid);
416 uint32_t sizeSize = GetUleb128Size (item->size);
417 uint32_t fragStartSize = GetUleb128Size (extraItem->fragmentStart);
418 uint32_t fragEndSize = GetUleb128Size (extraItem->fragmentEnd);
419 uint32_t n = 2 + 2 + typeUidSize + sizeSize + 2 + fragStartSize + fragEndSize + 4;
421 if (m_used + n > m_data->m_size ||
423 m_data->m_count != 1 &&
424 m_used != m_data->m_dirtyEnd))
429 uint8_t *buffer = &m_data->m_data[m_used];
431 Append16 (next, buffer);
433 Append16 (prev, buffer);
435 AppendValue (typeUid, buffer);
436 buffer += typeUidSize;
437 AppendValue (item->size, buffer);
439 Append16 (item->chunkUid, buffer);
441 AppendValue (extraItem->fragmentStart, buffer);
442 buffer += fragStartSize;
443 AppendValue (extraItem->fragmentEnd, buffer);
444 buffer += fragEndSize;
445 Append32 (extraItem->packetUid, buffer);
462 item->next << item->prev << item->typeUid << item->size << item->chunkUid <<
463 extraItem->fragmentStart << extraItem->fragmentEnd << extraItem->packetUid <<
472 if (m_tail + available == m_used &&
473 m_used == m_data->m_dirtyEnd)
475 available = m_data->m_size - m_tail;
478 uint32_t typeUid = ((item->typeUid & 0x1) == 0x1) ? item->typeUid : item->typeUid+1;
479 uint32_t typeUidSize = GetUleb128Size (typeUid);
480 uint32_t sizeSize = GetUleb128Size (item->size);
481 uint32_t fragStartSize = GetUleb128Size (extraItem->fragmentStart);
482 uint32_t fragEndSize = GetUleb128Size (extraItem->fragmentEnd);
483 uint32_t n = 2 + 2 + typeUidSize + sizeSize + 2 + fragStartSize + fragEndSize + 4;
485 if (available >= n &&
486 m_data->m_count == 1)
488 uint8_t *buffer = &m_data->m_data[m_tail];
489 Append16 (item->next, buffer);
491 Append16 (item->prev, buffer);
493 AppendValue (typeUid, buffer);
494 buffer += typeUidSize;
495 AppendValue (item->size, buffer);
497 Append16 (item->chunkUid, buffer);
499 AppendValue (extraItem->fragmentStart, buffer);
500 buffer += fragStartSize;
501 AppendValue (extraItem->fragmentEnd, buffer);
502 buffer += fragEndSize;
503 Append32 (extraItem->packetUid, buffer);
504 m_used = std::max (m_used, (uint16_t)(buffer - &m_data->m_data[0]));
505 m_data->m_dirtyEnd = m_used;
515 uint16_t current =
m_head;
516 while (current != 0xffff && current != m_tail)
520 ReadItems (current, &tmpItem, &tmpExtraItem);
521 uint16_t written = h.AddBig (0xffff, h.m_tail,
522 &tmpItem, &tmpExtraItem);
523 h.UpdateTail (written);
524 current = tmpItem.next;
527 uint16_t written = h.AddBig (0xffff, h.m_tail, item, extraItem);
528 h.UpdateTail (written);
544 NS_LOG_FUNCTION (
this << current << item->chunkUid << item->prev << item->next << item->size <<
545 item->typeUid << extraItem->fragmentEnd << extraItem->fragmentStart <<
546 extraItem->packetUid);
548 const uint8_t *buffer = &m_data->m_data[current];
549 item->next = buffer[0];
550 item->next |= (buffer[1]) << 8;
551 item->prev = buffer[2];
552 item->prev |= (buffer[3]) << 8;
554 item->typeUid = ReadUleb128 (&buffer);
555 item->size = ReadUleb128 (&buffer);
556 item->chunkUid = buffer[0];
557 item->chunkUid |= (buffer[1]) << 8;
560 bool isExtra = (item->typeUid & 0x1) == 0x1;
563 extraItem->fragmentStart = ReadUleb128 (&buffer);
564 extraItem->fragmentEnd = ReadUleb128 (&buffer);
565 extraItem->packetUid = buffer[0];
566 extraItem->packetUid |= buffer[1] << 8;
567 extraItem->packetUid |= buffer[2] << 16;
568 extraItem->packetUid |= buffer[3] << 24;
573 extraItem->fragmentStart = 0;
574 extraItem->fragmentEnd = item->size;
575 extraItem->packetUid = m_packetUid;
577 NS_ASSERT (buffer <= &m_data->m_data[m_data->m_size]);
578 return buffer - &m_data->m_data[current];
582 PacketMetadata::Create (uint32_t size)
585 NS_LOG_LOGIC (
"create size="<<size<<
", max="<<m_maxSize);
586 if (size > m_maxSize)
590 while (!m_freeList.empty ())
592 struct PacketMetadata::Data *data = m_freeList.back ();
593 m_freeList.pop_back ();
594 if (data->m_size >= size)
600 PacketMetadata::Deallocate (data);
604 return PacketMetadata::Allocate (m_maxSize);
608 PacketMetadata::Recycle (
struct PacketMetadata::Data *data)
613 PacketMetadata::Deallocate (data);
616 NS_LOG_LOGIC (
"recycle size="<<data->m_size<<
", list="<<m_freeList.size ());
618 if (m_freeList.size () > 1000 ||
619 data->m_size < m_maxSize)
621 PacketMetadata::Deallocate (data);
625 m_freeList.push_back (data);
629 struct PacketMetadata::Data *
630 PacketMetadata::Allocate (uint32_t n)
633 uint32_t size =
sizeof (
struct Data);
634 if (n <= PACKET_METADATA_DATA_M_DATA_SIZE)
636 n = PACKET_METADATA_DATA_M_DATA_SIZE;
638 size += n - PACKET_METADATA_DATA_M_DATA_SIZE;
639 uint8_t *buf =
new uint8_t [size];
640 struct PacketMetadata::Data *data = (
struct PacketMetadata::Data *)buf;
643 data->m_dirtyEnd = 0;
647 PacketMetadata::Deallocate (
struct PacketMetadata::Data *data)
650 uint8_t *buf = (uint8_t *)data;
660 fragment.RemoveAtStart (start);
661 fragment.RemoveAtEnd (end);
666 PacketMetadata::AddHeader (
const Header &header, uint32_t size)
671 DoAddHeader (uid, size);
675 PacketMetadata::DoAddHeader (uint32_t uid, uint32_t size)
680 m_metadataSkipped =
true;
684 struct PacketMetadata::SmallItem item;
689 item.chunkUid = m_chunkUid;
691 uint16_t written = AddSmall (&item);
692 UpdateHead (written);
695 PacketMetadata::RemoveHeader (
const Header &header, uint32_t size)
697 uint32_t uid = header.GetInstanceTypeId ().GetUid () << 1;
702 m_metadataSkipped =
true;
705 struct PacketMetadata::SmallItem item;
706 struct PacketMetadata::ExtraItem extraItem;
708 if ((item.typeUid & 0xfffffffe) != uid ||
711 if (m_enableChecking)
717 else if (item.typeUid != uid &&
718 (extraItem.fragmentStart != 0 ||
719 extraItem.fragmentEnd != size))
721 if (m_enableChecking)
727 if (
m_head + read == m_used)
743 PacketMetadata::AddTrailer (
const Trailer &trailer, uint32_t size)
745 uint32_t uid = trailer.GetInstanceTypeId ().GetUid () << 1;
750 m_metadataSkipped =
true;
753 struct PacketMetadata::SmallItem item;
758 item.chunkUid = m_chunkUid;
760 uint16_t written = AddSmall (&item);
761 UpdateTail (written);
765 PacketMetadata::RemoveTrailer (
const Trailer &trailer, uint32_t size)
767 uint32_t uid = trailer.GetInstanceTypeId ().GetUid () << 1;
772 m_metadataSkipped =
true;
775 struct PacketMetadata::SmallItem item;
776 struct PacketMetadata::ExtraItem extraItem;
777 uint32_t read =
ReadItems (m_tail, &item, &extraItem);
778 if ((item.typeUid & 0xfffffffe) != uid ||
781 if (m_enableChecking)
787 else if (item.typeUid != uid &&
788 (extraItem.fragmentStart != 0 ||
789 extraItem.fragmentEnd != size))
791 if (m_enableChecking)
797 if (m_tail + read == m_used)
813 PacketMetadata::AddAtEnd (PacketMetadata
const&o)
819 m_metadataSkipped =
true;
822 if (m_tail == 0xffff)
830 if (o.m_head == 0xffff)
840 struct PacketMetadata::SmallItem tailItem;
841 PacketMetadata::ExtraItem tailExtraItem;
842 uint32_t tailSize =
ReadItems (m_tail, &tailItem, &tailExtraItem);
845 struct PacketMetadata::SmallItem item;
846 PacketMetadata::ExtraItem extraItem;
847 o.ReadItems (o.m_head, &item, &extraItem);
848 if (extraItem.packetUid == tailExtraItem.packetUid &&
849 item.typeUid == tailItem.typeUid &&
850 item.chunkUid == tailItem.chunkUid &&
851 item.size == tailItem.size &&
852 extraItem.fragmentStart == tailExtraItem.fragmentEnd)
859 tailExtraItem.fragmentEnd = extraItem.fragmentEnd;
861 if (o.m_head == o.m_tail)
877 while (current != 0xffff)
879 o.ReadItems (current, &item, &extraItem);
880 uint16_t written = AddBig (0xffff, m_tail, &item, &extraItem);
881 UpdateTail (written);
882 if (current == o.m_tail)
891 PacketMetadata::AddPaddingAtEnd (uint32_t end)
896 m_metadataSkipped =
true;
901 PacketMetadata::RemoveAtStart (uint32_t start)
907 m_metadataSkipped =
true;
911 uint32_t leftToRemove = start;
912 uint16_t current =
m_head;
913 while (current != 0xffff && leftToRemove > 0)
915 struct PacketMetadata::SmallItem item;
916 PacketMetadata::ExtraItem extraItem;
918 uint32_t itemRealSize = extraItem.fragmentEnd - extraItem.fragmentStart;
919 if (itemRealSize <= leftToRemove)
931 leftToRemove -= itemRealSize;
936 PacketMetadata fragment (m_packetUid, 0);
937 extraItem.fragmentStart += leftToRemove;
939 uint16_t written = fragment.AddBig (0xffff, fragment.m_tail,
941 fragment.UpdateTail (written);
942 while (current != 0xffff && current != m_tail)
946 written = fragment.AddBig (0xffff, fragment.m_tail,
948 fragment.UpdateTail (written);
952 NS_ASSERT (item.size >= extraItem.fragmentEnd - extraItem.fragmentStart &&
953 extraItem.fragmentStart <= extraItem.fragmentEnd);
954 if (current == m_tail)
964 PacketMetadata::RemoveAtEnd (uint32_t end)
970 m_metadataSkipped =
true;
975 uint32_t leftToRemove = end;
976 uint16_t current = m_tail;
977 while (current != 0xffff && leftToRemove > 0)
979 struct PacketMetadata::SmallItem item;
980 PacketMetadata::ExtraItem extraItem;
982 uint32_t itemRealSize = extraItem.fragmentEnd - extraItem.fragmentStart;
983 if (itemRealSize <= leftToRemove)
995 leftToRemove -= itemRealSize;
1000 PacketMetadata fragment (m_packetUid, 0);
1001 NS_ASSERT (extraItem.fragmentEnd > leftToRemove);
1002 extraItem.fragmentEnd -= leftToRemove;
1004 uint16_t written = fragment.AddBig (fragment.m_head, 0xffff,
1006 fragment.UpdateHead (written);
1007 while (current != 0xffff && current !=
m_head)
1009 current = item.prev;
1011 written = fragment.AddBig (fragment.m_head, 0xffff,
1013 fragment.UpdateHead (written);
1017 NS_ASSERT (item.size >= extraItem.fragmentEnd - extraItem.fragmentStart &&
1018 extraItem.fragmentStart <= extraItem.fragmentEnd);
1023 current = item.prev;
1029 PacketMetadata::GetTotalSize (
void)
const
1032 uint32_t totalSize = 0;
1033 uint16_t current =
m_head;
1034 uint16_t tail = m_tail;
1035 while (current != 0xffff)
1037 struct PacketMetadata::SmallItem item;
1038 PacketMetadata::ExtraItem extraItem;
1040 totalSize += extraItem.fragmentEnd - extraItem.fragmentStart;
1041 if (current == tail)
1046 current = item.next;
1052 PacketMetadata::GetUid (
void)
const
1057 PacketMetadata::ItemIterator
1058 PacketMetadata::BeginItem (Buffer buffer)
const
1061 return ItemIterator (
this, buffer);
1063 PacketMetadata::ItemIterator::ItemIterator (
const PacketMetadata *metadata, Buffer buffer)
1064 : m_metadata (metadata),
1066 m_current (metadata->
m_head),
1068 m_hasReadTail (false)
1073 PacketMetadata::ItemIterator::HasNext (
void)
const
1076 if (m_current == 0xffff)
1086 PacketMetadata::Item
1087 PacketMetadata::ItemIterator::Next (
void)
1090 struct PacketMetadata::Item item;
1091 struct PacketMetadata::SmallItem smallItem;
1092 struct PacketMetadata::ExtraItem extraItem;
1093 m_metadata->ReadItems (m_current, &smallItem, &extraItem);
1094 if (m_current == m_metadata->m_tail)
1096 m_hasReadTail =
true;
1098 m_current = smallItem.next;
1099 uint32_t uid = (smallItem.typeUid & 0xfffffffe) >> 1;
1100 item.tid.SetUid (uid);
1101 item.currentTrimedFromStart = extraItem.fragmentStart;
1102 item.currentTrimedFromEnd = extraItem.fragmentEnd - smallItem.size;
1103 item.currentSize = extraItem.fragmentEnd - extraItem.fragmentStart;
1104 if (extraItem.fragmentStart != 0 || extraItem.fragmentEnd != smallItem.size)
1106 item.isFragment =
true;
1110 item.isFragment =
false;
1116 item.type = PacketMetadata::Item::PAYLOAD;
1118 else if (tid.IsChildOf (Header::GetTypeId ()))
1120 item.type = PacketMetadata::Item::HEADER;
1121 if (!item.isFragment)
1126 item.current = tmp.
Begin ();
1129 else if (tid.IsChildOf (Trailer::GetTypeId ()))
1131 item.type = PacketMetadata::Item::TRAILER;
1132 if (!item.isFragment)
1137 item.current = tmp.
End ();
1144 m_offset += extraItem.fragmentEnd - extraItem.fragmentStart;
1149 PacketMetadata::GetSerializedSize (
void)
const
1152 uint32_t totalSize = 0;
1165 struct PacketMetadata::SmallItem item;
1166 struct PacketMetadata::ExtraItem extraItem;
1167 uint32_t current =
m_head;
1168 while (current != 0xffff)
1171 uint32_t uid = (item.typeUid & 0xfffffffe) >> 1;
1180 totalSize += 4 + tid.GetName ().size ();
1182 totalSize += 1 + 4 + 2 + 4 + 4 + 8;
1183 if (current == m_tail)
1188 current = item.next;
1194 PacketMetadata::Serialize (uint8_t* buffer, uint32_t maxSize)
const
1197 uint8_t* start = buffer;
1199 buffer = AddToRawU64 (m_packetUid, start, buffer, maxSize);
1205 struct PacketMetadata::SmallItem item;
1206 struct PacketMetadata::ExtraItem extraItem;
1207 uint32_t current =
m_head;
1208 while (current != 0xffff)
1211 NS_LOG_LOGIC (
"bytesWritten=" << static_cast<uint32_t> (buffer - start) <<
", typeUid="<<
1212 item.typeUid <<
", size="<<item.size<<
", chunkUid="<<item.chunkUid<<
1213 ", fragmentStart="<<extraItem.fragmentStart<<
", fragmentEnd="<<
1214 extraItem.fragmentEnd<<
", packetUid="<<extraItem.packetUid);
1216 uint32_t uid = (item.typeUid & 0xfffffffe) >> 1;
1221 std::string uidString = tid.GetName ();
1222 uint32_t uidStringSize = uidString.size ();
1223 buffer = AddToRawU32 (uidStringSize, start, buffer, maxSize);
1228 buffer = AddToRaw (reinterpret_cast<const uint8_t *> (uidString.c_str ()),
1229 uidStringSize, start, buffer, maxSize);
1237 buffer = AddToRawU32 (0, start, buffer, maxSize);
1244 uint8_t isBig = item.typeUid & 0x1;
1245 buffer = AddToRawU8 (isBig, start, buffer, maxSize);
1251 buffer = AddToRawU32 (item.size, start, buffer, maxSize);
1257 buffer = AddToRawU16 (item.chunkUid, start, buffer, maxSize);
1263 buffer = AddToRawU32 (extraItem.fragmentStart, start, buffer, maxSize);
1269 buffer = AddToRawU32 (extraItem.fragmentEnd, start, buffer, maxSize);
1275 buffer = AddToRawU64 (extraItem.packetUid, start, buffer, maxSize);
1281 if (current == m_tail)
1287 current = item.next;
1290 NS_ASSERT (static_cast<uint32_t> (buffer - start) == maxSize);
1295 PacketMetadata::Deserialize (
const uint8_t* buffer, uint32_t size)
1298 const uint8_t* start = buffer;
1299 uint32_t desSize = size - 4;
1301 buffer = ReadFromRawU64 (m_packetUid, start, buffer, size);
1304 struct PacketMetadata::SmallItem item;
1305 struct PacketMetadata::ExtraItem extraItem;
1308 uint32_t uidStringSize = 0;
1309 buffer = ReadFromRawU32 (uidStringSize, start, buffer, size);
1312 if (uidStringSize == 0)
1319 std::string uidString;
1320 for (uint32_t j = 0; j < uidStringSize; j++)
1323 buffer = ReadFromRawU8 (ch, start, buffer, size);
1324 uidString.push_back (ch);
1328 uid = tid.GetUid ();
1331 buffer = ReadFromRawU8 (isBig, start, buffer, size);
1333 item.typeUid = (uid << 1) | isBig;
1334 buffer = ReadFromRawU32 (item.size, start, buffer, size);
1336 buffer = ReadFromRawU16 (item.chunkUid, start, buffer, size);
1338 buffer = ReadFromRawU32 (extraItem.fragmentStart, start, buffer, size);
1340 buffer = ReadFromRawU32 (extraItem.fragmentEnd, start, buffer, size);
1342 buffer = ReadFromRawU64 (extraItem.packetUid, start, buffer, size);
1344 NS_LOG_LOGIC (
"size=" << size <<
", typeUid="<<item.typeUid <<
1345 ", size="<<item.size<<
", chunkUid="<<item.chunkUid<<
1346 ", fragmentStart="<<extraItem.fragmentStart<<
", fragmentEnd="<<
1347 extraItem.fragmentEnd<<
", packetUid="<<extraItem.packetUid);
1348 uint32_t tmp = AddBig (0xffff, m_tail, &item, &extraItem);
1352 return (desSize !=0) ? 0 : 1;
1356 PacketMetadata::AddToRawU8 (
const uint8_t& data,
1361 NS_LOG_FUNCTION (static_cast<uint32_t> (data) << &start << ¤t << maxSize);
1363 if (static_cast<uint32_t> ((current +
sizeof (uint8_t) - start)) > maxSize)
1367 memcpy (current, &data,
sizeof (uint8_t));
1368 return current +
sizeof (uint8_t);
1372 PacketMetadata::AddToRawU16 (
const uint16_t& data,
1379 if (static_cast<uint32_t> ((current +
sizeof (uint16_t) - start)) > maxSize)
1383 memcpy (current, &data,
sizeof (uint16_t));
1384 return current +
sizeof (uint16_t);
1388 PacketMetadata::AddToRawU32 (
const uint32_t& data,
1395 if (static_cast<uint32_t> ((current +
sizeof (uint32_t) - start)) > maxSize)
1399 memcpy (current, &data,
sizeof (uint32_t));
1400 return current +
sizeof (uint32_t);
1404 PacketMetadata::AddToRawU64 (
const uint64_t& data,
1411 if (static_cast<uint32_t> ((current +
sizeof (uint64_t) - start)) > maxSize)
1415 memcpy (current, &data,
sizeof (uint64_t));
1416 return current +
sizeof (uint64_t);
1420 PacketMetadata::AddToRaw (
const uint8_t* data,
1428 if (static_cast<uint32_t> ((current + dataSize - start)) > maxSize)
1432 memcpy (current, data, dataSize);
1433 return current + dataSize;
1437 PacketMetadata::ReadFromRawU8 (uint8_t& data,
1438 const uint8_t* start,
1439 const uint8_t* current,
1442 NS_LOG_FUNCTION (static_cast<uint32_t> (data) << &start << ¤t << maxSize);
1444 if (static_cast<uint32_t> ((current +
sizeof (uint8_t) - start)) > maxSize)
1448 memcpy (&data, current,
sizeof (uint8_t));
1449 return const_cast<uint8_t *
> (current) +
sizeof (uint8_t);
1453 PacketMetadata::ReadFromRawU16 (uint16_t& data,
1454 const uint8_t* start,
1455 const uint8_t* current,
1460 if (static_cast<uint32_t> ((current +
sizeof (uint16_t) - start)) > maxSize)
1464 memcpy (&data, current,
sizeof (uint16_t));
1465 return const_cast<uint8_t *
> (current) +
sizeof (uint16_t);
1469 PacketMetadata::ReadFromRawU32 (uint32_t& data,
1470 const uint8_t* start,
1471 const uint8_t* current,
1476 if (static_cast<uint32_t> ((current +
sizeof (uint32_t) - start)) > maxSize)
1480 memcpy (&data, current,
sizeof (uint32_t));
1481 return const_cast<uint8_t *
> (current) +
sizeof (uint32_t);
1485 PacketMetadata::ReadFromRawU64 (uint64_t& data,
1486 const uint8_t* start,
1487 const uint8_t* current,
1492 if ((uint32_t)((current +
sizeof (uint64_t) - start)) > maxSize)
1496 memcpy (&data, current,
sizeof (uint64_t));
1497 return const_cast<uint8_t *
> (current) +
sizeof (uint64_t);
#define NS_LOG_FUNCTION(parameters)
void RemoveAtEnd(uint32_t end)
void RemoveAtStart(uint32_t start)
automatically resized byte buffer
#define NS_ASSERT(condition)
#define NS_LOG_COMPONENT_DEFINE(name)
#define NS_LOG_FUNCTION_NOARGS()
#define NS_FATAL_ERROR(msg)
fatal error handling
Buffer::Iterator End(void) const
#define NS_LOG_LOGIC(msg)
Buffer::Iterator Begin(void) const
uint16_t GetUid(void) const
uint32_t GetSize(void) const
#define NS_ASSERT_MSG(condition, message)
virtual TypeId GetInstanceTypeId(void) const =0
static TypeId LookupByName(std::string name)