22 #include "ns3/assert.h"
23 #include "ns3/fatal-error.h"
43 for (iterator i = begin (); i != end (); i++)
54 "Error: attempting to enable the packet metadata "
55 "subsystem too late in the simulation, which is not allowed.\n"
56 "A common cause for this problem is to enable ASCII tracing "
57 "after sending any packets. One way to fix this problem is "
58 "to call ns3::PacketMetadata::Enable () near the beginning of"
59 " the program, before any packets are sent.");
115 bool ok = pointer == 0xffff || pointer <=
m_data->
m_size;
121 bool ok = pointer == 0xffff || pointer <=
m_used;
131 uint16_t current =
m_head;
132 while (ok && current != 0xffff)
167 if (value < 0x200000)
171 if (value < 0x10000000)
180 const uint8_t *buffer = *pBuffer;
185 result = (byte & (~0x80));
188 *pBuffer = buffer + 1;
192 result |= (byte & (~0x80)) << 7;
195 *pBuffer = buffer + 2;
199 result |= (byte & (~0x80)) << 14;
202 *pBuffer = buffer + 3;
206 result |= (byte & (~0x80)) << 21;
209 *pBuffer = buffer + 4;
213 result |= (byte & (~0x80)) << 28;
216 *pBuffer = buffer + 5;
229 buffer[0] = value & 0xff;
236 buffer[0] = value & 0xff;
237 buffer[1] = (value >> 8) & 0xff;
238 buffer[2] = (value >> 16) & 0xff;
239 buffer[3] = (value >> 24) & 0xff;
245 if (value < 0x200000)
247 uint8_t byte = value & (~0x80);
248 buffer[0] = 0x80 | byte;
250 byte = value & (~0x80);
251 buffer[1] = 0x80 | byte;
253 byte = value & (~0x80);
257 if (value < 0x10000000)
259 uint8_t byte = value & (~0x80);
260 buffer[0] = 0x80 | byte;
262 byte = value & (~0x80);
263 buffer[1] = 0x80 | byte;
265 byte = value & (~0x80);
266 buffer[2] = 0x80 | byte;
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;
281 byte = value & (~0x80);
282 buffer[3] = 0x80 | byte;
298 uint8_t byte = value & (~0x80);
299 buffer[0] = 0x80 | byte;
368 uint32_t n = 2 + 2 + typeUidSize + sizeSize + 2;
382 buffer += typeUidSize;
405 uint32_t n = 2 + 2 + typeUidSize + sizeSize + 2 + fragStartSize + fragEndSize + 4;
422 buffer += typeUidSize;
428 buffer += fragStartSize;
430 buffer += fragEndSize;
469 uint32_t n = 2 + 2 + typeUidSize + sizeSize + 2 + fragStartSize + fragEndSize + 4;
471 if (available >= n &&
480 buffer += typeUidSize;
486 buffer += fragStartSize;
488 buffer += fragEndSize;
501 uint16_t current =
m_head;
502 while (current != 0xffff && current !=
m_tail)
506 ReadItems (current, &tmpItem, &tmpExtraItem);
508 &tmpItem, &tmpExtraItem);
510 current = tmpItem.
next;
513 uint16_t written = h.
AddBig (0xffff, h.
m_tail, item, extraItem);
533 item->
next = buffer[0];
534 item->
next |= (buffer[1]) << 8;
535 item->
prev = buffer[2];
536 item->
prev |= (buffer[3]) << 8;
544 bool isExtra = (item->
typeUid & 0x1) == 0x1;
562 return buffer - &m_data->m_data[current];
614 uint32_t size =
sizeof (
struct Data);
620 uint8_t *buf =
new uint8_t [size];
630 uint8_t *buf = (uint8_t *)data;
669 uint16_t written =
AddSmall (&item);
686 if ((item.
typeUid & 0xfffffffe) != uid ||
695 else if (item.
typeUid != uid &&
738 uint16_t written =
AddSmall (&item);
756 if ((item.
typeUid & 0xfffffffe) != uid ||
765 else if (item.
typeUid != uid &&
826 if (extraItem.packetUid == tailExtraItem.packetUid &&
830 extraItem.fragmentStart == tailExtraItem.fragmentEnd)
837 tailExtraItem.fragmentEnd = extraItem.fragmentEnd;
855 while (current != 0xffff)
857 o.
ReadItems (current, &item, &extraItem);
858 uint16_t written =
AddBig (0xffff,
m_tail, &item, &extraItem);
888 uint32_t leftToRemove =
start;
889 uint16_t current =
m_head;
890 while (current != 0xffff && leftToRemove > 0)
895 uint32_t itemRealSize = extraItem.fragmentEnd - extraItem.fragmentStart;
896 if (itemRealSize <= leftToRemove)
908 leftToRemove -= itemRealSize;
914 extraItem.fragmentStart += leftToRemove;
916 uint16_t written = fragment.
AddBig (0xffff, fragment.
m_tail,
919 while (current != 0xffff && current !=
m_tail)
929 NS_ASSERT (item.
size >= extraItem.fragmentEnd - extraItem.fragmentStart &&
930 extraItem.fragmentStart <= extraItem.fragmentEnd);
952 uint32_t leftToRemove = end;
953 uint16_t current =
m_tail;
954 while (current != 0xffff && leftToRemove > 0)
959 uint32_t itemRealSize = extraItem.fragmentEnd - extraItem.fragmentStart;
960 if (itemRealSize <= leftToRemove)
972 leftToRemove -= itemRealSize;
978 NS_ASSERT (extraItem.fragmentEnd > leftToRemove);
979 extraItem.fragmentEnd -= leftToRemove;
981 uint16_t written = fragment.
AddBig (fragment.
m_head, 0xffff,
984 while (current != 0xffff && current !=
m_head)
994 NS_ASSERT (item.
size >= extraItem.fragmentEnd - extraItem.fragmentStart &&
995 extraItem.fragmentStart <= extraItem.fragmentEnd);
1000 current = item.
prev;
1008 uint32_t totalSize = 0;
1009 uint16_t current =
m_head;
1011 while (current != 0xffff)
1016 totalSize += extraItem.fragmentEnd - extraItem.fragmentStart;
1017 if (current == tail)
1022 current = item.
next;
1038 : m_metadata (metadata),
1040 m_current (metadata->
m_head),
1042 m_hasReadTail (false)
1048 if (m_current == 0xffff)
1064 m_metadata->ReadItems (m_current, &smallItem, &extraItem);
1065 if (m_current == m_metadata->m_tail)
1067 m_hasReadTail =
true;
1069 m_current = smallItem.
next;
1070 uint32_t uid = (smallItem.
typeUid & 0xfffffffe) >> 1;
1123 uint32_t totalSize = 0;
1138 uint32_t current =
m_head;
1139 while (current != 0xffff)
1142 uint32_t uid = (item.
typeUid & 0xfffffffe) >> 1;
1151 totalSize += 4 + tid.
GetName ().size ();
1153 totalSize += 1 + 4 + 2 + 4 + 4 + 8;
1159 current = item.
next;
1168 uint8_t*
start = buffer;
1178 uint32_t current =
m_head;
1179 while (current != 0xffff)
1182 NS_LOG_LOGIC (
"bytesWritten=" << static_cast<uint32_t> (buffer - start) <<
", typeUid="<<
1184 ", fragmentStart="<<extraItem.
fragmentStart<<
", fragmentEnd="<<
1187 uint32_t uid = (item.
typeUid & 0xfffffffe) >> 1;
1192 std::string uidString = tid.
GetName ();
1193 uint32_t uidStringSize = uidString.size ();
1194 buffer =
AddToRawU32 (uidStringSize, start, buffer, maxSize);
1199 buffer =
AddToRaw (reinterpret_cast<const uint8_t *> (uidString.c_str ()),
1200 uidStringSize, start, buffer, maxSize);
1215 uint8_t isBig = item.
typeUid & 0x1;
1216 buffer =
AddToRawU8 (isBig, start, buffer, maxSize);
1258 current = item.
next;
1261 NS_ASSERT (static_cast<uint32_t> (buffer - start) == maxSize);
1269 const uint8_t*
start = buffer;
1270 uint32_t desSize = size - 4;
1279 uint32_t uidStringSize = 0;
1283 if (uidStringSize == 0)
1290 std::string uidString;
1291 for (uint32_t j = 0; j < uidStringSize; j++)
1295 uidString.push_back (ch);
1304 item.
typeUid = (uid << 1) | isBig;
1317 ", fragmentStart="<<extraItem.
fragmentStart<<
", fragmentEnd="<<
1319 uint32_t tmp =
AddBig (0xffff,
m_tail, &item, &extraItem);
1323 return (desSize !=0) ? 0 : 1;
1333 if (static_cast<uint32_t> ((current +
sizeof (uint8_t) - start)) > maxSize)
1337 memcpy (current, &data,
sizeof (uint8_t));
1338 return current +
sizeof (uint8_t);
1348 if (static_cast<uint32_t> ((current +
sizeof (uint16_t) - start)) > maxSize)
1352 memcpy (current, &data,
sizeof (uint16_t));
1353 return current +
sizeof (uint16_t);
1363 if (static_cast<uint32_t> ((current +
sizeof (uint32_t) - start)) > maxSize)
1367 memcpy (current, &data,
sizeof (uint32_t));
1368 return current +
sizeof (uint32_t);
1378 if (static_cast<uint32_t> ((current +
sizeof (uint64_t) - start)) > maxSize)
1382 memcpy (current, &data,
sizeof (uint64_t));
1383 return current +
sizeof (uint64_t);
1394 if (static_cast<uint32_t> ((current + dataSize - start)) > maxSize)
1398 memcpy (current, data, dataSize);
1399 return current + dataSize;
1404 const uint8_t*
start,
1405 const uint8_t* current,
1409 if (static_cast<uint32_t> ((current +
sizeof (uint8_t) - start)) > maxSize)
1413 memcpy (&data, current,
sizeof (uint8_t));
1414 return const_cast<uint8_t *
> (current) +
sizeof (uint8_t);
1419 const uint8_t*
start,
1420 const uint8_t* current,
1424 if (static_cast<uint32_t> ((current +
sizeof (uint16_t) - start)) > maxSize)
1428 memcpy (&data, current,
sizeof (uint16_t));
1429 return const_cast<uint8_t *
> (current) +
sizeof (uint16_t);
1434 const uint8_t*
start,
1435 const uint8_t* current,
1439 if (static_cast<uint32_t> ((current +
sizeof (uint32_t) - start)) > maxSize)
1443 memcpy (&data, current,
sizeof (uint32_t));
1444 return const_cast<uint8_t *
> (current) +
sizeof (uint32_t);
1449 const uint8_t*
start,
1450 const uint8_t* current,
1454 if ((uint32_t)((current +
sizeof (uint64_t) - start)) > maxSize)
1458 memcpy (&data, current,
sizeof (uint64_t));
1459 return const_cast<uint8_t *
> (current) +
sizeof (uint64_t);