Bug Summary

File:/tmp/asd-nat/home/nat/Work/ns-3-dev-git/build/../src/network/model/packet-metadata.cc
Location:line 193, column 3
Description:Value stored to 'result' is never read

Annotated Source Code

1/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2/*
3 * Copyright (c) 2006,2007 INRIA
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: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
19 */
20#include <utility>
21#include <list>
22#include "ns3/assert.h"
23#include "ns3/fatal-error.h"
24#include "ns3/log.h"
25#include "packet-metadata.h"
26#include "buffer.h"
27#include "header.h"
28#include "trailer.h"
29
30namespace ns3 {
31
32NS_LOG_COMPONENT_DEFINE ("PacketMetadata")static ns3::LogComponent g_log = ns3::LogComponent ("PacketMetadata"
, "../src/network/model/packet-metadata.cc");
33
34bool PacketMetadata::m_enable = false;
35bool PacketMetadata::m_enableChecking = false;
36bool PacketMetadata::m_metadataSkipped = false;
37uint32_t PacketMetadata::m_maxSize = 0;
38uint16_t PacketMetadata::m_chunkUid = 0;
39PacketMetadata::DataFreeList PacketMetadata::m_freeList;
40
41PacketMetadata::DataFreeList::~DataFreeList ()
42{
43 NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this; std::clog << ")" << std::endl; } } while (
false);
44 for (iterator i = begin (); i != end (); i++)
45 {
46 PacketMetadata::Deallocate (*i);
47 }
48 PacketMetadata::m_enable = false;
49}
50
51void
52PacketMetadata::Enable (void)
53{
54 NS_LOG_FUNCTION_NOARGS ()do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "()" << std::endl; } } while (false
);
55 NS_ASSERT_MSG (!m_metadataSkipped,do { if (!(!m_metadataSkipped)) { std::cerr << "assert failed. cond=\""
<< "!m_metadataSkipped" << "\", "; do { std::cerr
<< "msg=\"" << "Error: attempting to enable the packet metadata "
"subsystem too late in the simulation, which is not allowed.\n"
"A common cause for this problem is to enable ASCII tracing "
"after sending any packets. One way to fix this problem is "
"to call ns3::PacketMetadata::Enable () near the beginning of"
" the program, before any packets are sent." << "\", "
; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 61 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } while (false); } } while (false)
56 "Error: attempting to enable the packet metadata "do { if (!(!m_metadataSkipped)) { std::cerr << "assert failed. cond=\""
<< "!m_metadataSkipped" << "\", "; do { std::cerr
<< "msg=\"" << "Error: attempting to enable the packet metadata "
"subsystem too late in the simulation, which is not allowed.\n"
"A common cause for this problem is to enable ASCII tracing "
"after sending any packets. One way to fix this problem is "
"to call ns3::PacketMetadata::Enable () near the beginning of"
" the program, before any packets are sent." << "\", "
; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 61 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } while (false); } } while (false)
57 "subsystem too late in the simulation, which is not allowed.\n"do { if (!(!m_metadataSkipped)) { std::cerr << "assert failed. cond=\""
<< "!m_metadataSkipped" << "\", "; do { std::cerr
<< "msg=\"" << "Error: attempting to enable the packet metadata "
"subsystem too late in the simulation, which is not allowed.\n"
"A common cause for this problem is to enable ASCII tracing "
"after sending any packets. One way to fix this problem is "
"to call ns3::PacketMetadata::Enable () near the beginning of"
" the program, before any packets are sent." << "\", "
; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 61 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } while (false); } } while (false)
58 "A common cause for this problem is to enable ASCII tracing "do { if (!(!m_metadataSkipped)) { std::cerr << "assert failed. cond=\""
<< "!m_metadataSkipped" << "\", "; do { std::cerr
<< "msg=\"" << "Error: attempting to enable the packet metadata "
"subsystem too late in the simulation, which is not allowed.\n"
"A common cause for this problem is to enable ASCII tracing "
"after sending any packets. One way to fix this problem is "
"to call ns3::PacketMetadata::Enable () near the beginning of"
" the program, before any packets are sent." << "\", "
; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 61 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } while (false); } } while (false)
59 "after sending any packets. One way to fix this problem is "do { if (!(!m_metadataSkipped)) { std::cerr << "assert failed. cond=\""
<< "!m_metadataSkipped" << "\", "; do { std::cerr
<< "msg=\"" << "Error: attempting to enable the packet metadata "
"subsystem too late in the simulation, which is not allowed.\n"
"A common cause for this problem is to enable ASCII tracing "
"after sending any packets. One way to fix this problem is "
"to call ns3::PacketMetadata::Enable () near the beginning of"
" the program, before any packets are sent." << "\", "
; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 61 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } while (false); } } while (false)
60 "to call ns3::PacketMetadata::Enable () near the beginning of"do { if (!(!m_metadataSkipped)) { std::cerr << "assert failed. cond=\""
<< "!m_metadataSkipped" << "\", "; do { std::cerr
<< "msg=\"" << "Error: attempting to enable the packet metadata "
"subsystem too late in the simulation, which is not allowed.\n"
"A common cause for this problem is to enable ASCII tracing "
"after sending any packets. One way to fix this problem is "
"to call ns3::PacketMetadata::Enable () near the beginning of"
" the program, before any packets are sent." << "\", "
; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 61 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } while (false); } } while (false)
61 " the program, before any packets are sent.")do { if (!(!m_metadataSkipped)) { std::cerr << "assert failed. cond=\""
<< "!m_metadataSkipped" << "\", "; do { std::cerr
<< "msg=\"" << "Error: attempting to enable the packet metadata "
"subsystem too late in the simulation, which is not allowed.\n"
"A common cause for this problem is to enable ASCII tracing "
"after sending any packets. One way to fix this problem is "
"to call ns3::PacketMetadata::Enable () near the beginning of"
" the program, before any packets are sent." << "\", "
; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 61 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } while (false); } } while (false);
62 m_enable = true;
63}
64
65void
66PacketMetadata::EnableChecking (void)
67{
68 NS_LOG_FUNCTION_NOARGS ()do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "()" << std::endl; } } while (false
);
69 Enable ();
70 m_enableChecking = true;
71}
72
73void
74PacketMetadata::ReserveCopy (uint32_t size)
75{
76 NS_LOG_FUNCTION (this << size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << size; std::clog << ")" << std::endl
; } } while (false);
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;
80 m_data->m_count--;
81 if (m_data->m_count == 0)
82 {
83 PacketMetadata::Recycle (m_data);
84 }
85 m_data = newData;
86 if (m_head != 0xffff)
87 {
88 uint8_t *start;
89 NS_ASSERT (m_tail != 0xffff)do { if (!(m_tail != 0xffff)) { std::cerr << "assert failed. cond=\""
<< "m_tail != 0xffff" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 89 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
90 // clear the next field of the tail
91 start = &m_data->m_data[m_tail];
92 Append16 (0xffff, start);
93 // clear the prev field of the head
94 start = &m_data->m_data[m_head] + 2;
95 Append16 (0xffff, start);
96 }
97}
98void
99PacketMetadata::Reserve (uint32_t size)
100{
101 NS_LOG_FUNCTION (this << size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << size; std::clog << ")" << std::endl
; } } while (false);
102 NS_ASSERT (m_data != 0)do { if (!(m_data != 0)) { std::cerr << "assert failed. cond=\""
<< "m_data != 0" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 102 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
103 if (m_data->m_size >= m_used + size &&
104 (m_head == 0xffff ||
105 m_data->m_count == 1 ||
106 m_data->m_dirtyEnd == m_used))
107 {
108 /* enough room, not dirty. */
109 }
110 else
111 {
112 /* (enough room and dirty) or (not enough room) */
113 ReserveCopy (size);
114 }
115}
116
117bool
118PacketMetadata::IsSharedPointerOk (uint16_t pointer) const
119{
120 NS_LOG_FUNCTION (this << pointer)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << pointer; std::clog << ")" << std::
endl; } } while (false);
121 bool ok = pointer == 0xffff || pointer <= m_data->m_size;
122 return ok;
123}
124bool
125PacketMetadata::IsPointerOk (uint16_t pointer) const
126{
127 NS_LOG_FUNCTION (this << pointer)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << pointer; std::clog << ")" << std::
endl; } } while (false);
128 bool ok = pointer == 0xffff || pointer <= m_used;
129 return ok;
130}
131
132bool
133PacketMetadata::IsStateOk (void) const
134{
135 NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this; std::clog << ")" << std::endl; } } while (
false);
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)
141 {
142 struct PacketMetadata::SmallItem item;
143 PacketMetadata::ExtraItem extraItem;
144 ReadItems (current, &item, &extraItem);
145 ok &= IsSharedPointerOk (item.next);
146 ok &= IsSharedPointerOk (item.prev);
147 if (current != m_head)
148 {
149 ok &= IsPointerOk (item.prev);
150 }
151 if (current != m_tail)
152 {
153 ok &= IsPointerOk (item.next);
154 }
155 if (current == m_tail)
156 {
157 break;
158 }
159 current = item.next;
160 }
161 return ok;
162}
163
164uint32_t
165PacketMetadata::GetUleb128Size (uint32_t value) const
166{
167 NS_LOG_FUNCTION (this << value)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << value; std::clog << ")" << std::endl
; } } while (false);
168 if (value < 0x80)
169 {
170 return 1;
171 }
172 if (value < 0x4000)
173 {
174 return 2;
175 }
176 if (value < 0x200000)
177 {
178 return 3;
179 }
180 if (value < 0x10000000)
181 {
182 return 4;
183 }
184 return 5;
185}
186uint32_t
187PacketMetadata::ReadUleb128 (const uint8_t **pBuffer) const
188{
189 NS_LOG_FUNCTION (this << &pBuffer)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << &pBuffer; std::clog << ")" << std
::endl; } } while (false);
190 const uint8_t *buffer = *pBuffer;
191 uint32_t result = 0;
192 uint8_t byte;
193 result = 0;
Value stored to 'result' is never read
194 byte = buffer[0];
195 result = (byte & (~0x80));
196 if (!(byte & 0x80))
197 {
198 *pBuffer = buffer + 1;
199 return result;
200 }
201 byte = buffer[1];
202 result |= (byte & (~0x80)) << 7;
203 if (!(byte & 0x80))
204 {
205 *pBuffer = buffer + 2;
206 return result;
207 }
208 byte = buffer[2];
209 result |= (byte & (~0x80)) << 14;
210 if (!(byte & 0x80))
211 {
212 *pBuffer = buffer + 3;
213 return result;
214 }
215 byte = buffer[3];
216 result |= (byte & (~0x80)) << 21;
217 if (!(byte & 0x80))
218 {
219 *pBuffer = buffer + 4;
220 return result;
221 }
222 byte = buffer[4];
223 result |= (byte & (~0x80)) << 28;
224 if (!(byte & 0x80))
225 {
226 *pBuffer = buffer + 5;
227 return result;
228 }
229 /* This means that the LEB128 number was not valid.
230 * ie: the last (5th) byte did not have the high-order bit zeroed.
231 */
232 NS_ASSERT (false)do { if (!(false)) { std::cerr << "assert failed. cond=\""
<< "false" << "\", "; do { std::cerr << "file="
<< "../src/network/model/packet-metadata.cc" << ", line="
<< 232 << std::endl; ::ns3::FatalImpl::FlushStreams
(); if (true) std::terminate (); } while (false); } } while (
false);
233 return 0;
234}
235
236void
237PacketMetadata::Append16 (uint16_t value, uint8_t *buffer)
238{
239 NS_LOG_FUNCTION (this << value << &buffer)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << value << &buffer; std::clog <<
")" << std::endl; } } while (false);
240 buffer[0] = value & 0xff;
241 value >>= 8;
242 buffer[1] = value;
243}
244void
245PacketMetadata::Append32 (uint32_t value, uint8_t *buffer)
246{
247 NS_LOG_FUNCTION (this << value << &buffer)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << value << &buffer; std::clog <<
")" << std::endl; } } while (false);
248 buffer[0] = value & 0xff;
249 buffer[1] = (value >> 8) & 0xff;
250 buffer[2] = (value >> 16) & 0xff;
251 buffer[3] = (value >> 24) & 0xff;
252}
253
254void
255PacketMetadata::AppendValueExtra (uint32_t value, uint8_t *buffer)
256{
257 NS_LOG_FUNCTION (this << value << &buffer)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << value << &buffer; std::clog <<
")" << std::endl; } } while (false);
258 if (value < 0x200000)
259 {
260 uint8_t byte = value & (~0x80);
261 buffer[0] = 0x80 | byte;
262 value >>= 7;
263 byte = value & (~0x80);
264 buffer[1] = 0x80 | byte;
265 value >>= 7;
266 byte = value & (~0x80);
267 buffer[2] = value;
268 return;
269 }
270 if (value < 0x10000000)
271 {
272 uint8_t byte = value & (~0x80);
273 buffer[0] = 0x80 | byte;
274 value >>= 7;
275 byte = value & (~0x80);
276 buffer[1] = 0x80 | byte;
277 value >>= 7;
278 byte = value & (~0x80);
279 buffer[2] = 0x80 | byte;
280 value >>= 7;
281 buffer[3] = value;
282 return;
283 }
284 {
285 uint8_t byte = value & (~0x80);
286 buffer[0] = 0x80 | byte;
287 value >>= 7;
288 byte = value & (~0x80);
289 buffer[1] = 0x80 | byte;
290 value >>= 7;
291 byte = value & (~0x80);
292 buffer[2] = 0x80 | byte;
293 value >>= 7;
294 byte = value & (~0x80);
295 buffer[3] = 0x80 | byte;
296 value >>= 7;
297 buffer[4] = value;
298 }
299}
300
301void
302PacketMetadata::AppendValue (uint32_t value, uint8_t *buffer)
303{
304 NS_LOG_FUNCTION (this << value << &buffer)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << value << &buffer; std::clog <<
")" << std::endl; } } while (false);
305 if (value < 0x80)
306 {
307 buffer[0] = value;
308 return;
309 }
310 if (value < 0x4000)
311 {
312 uint8_t byte = value & (~0x80);
313 buffer[0] = 0x80 | byte;
314 value >>= 7;
315 buffer[1] = value;
316 return;
317 }
318 AppendValueExtra (value, buffer);
319}
320
321void
322PacketMetadata::UpdateTail (uint16_t written)
323{
324 NS_LOG_FUNCTION (this << written)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << written; std::clog << ")" << std::
endl; } } while (false);
325 if (m_head == 0xffff)
326 {
327 NS_ASSERT (m_tail == 0xffff)do { if (!(m_tail == 0xffff)) { std::cerr << "assert failed. cond=\""
<< "m_tail == 0xffff" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 327 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
328 m_head = m_used;
329 m_tail = m_used;
330 }
331 else
332 {
333 NS_ASSERT (m_tail != 0xffff)do { if (!(m_tail != 0xffff)) { std::cerr << "assert failed. cond=\""
<< "m_tail != 0xffff" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 333 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
334 // overwrite the next field of the previous tail of the list.
335 uint8_t *previousTail = &m_data->m_data[m_tail];
336 Append16 (m_used, previousTail);
337 // update the tail of the list to the new node.
338 m_tail = m_used;
339 }
340 NS_ASSERT (m_tail != 0xffff)do { if (!(m_tail != 0xffff)) { std::cerr << "assert failed. cond=\""
<< "m_tail != 0xffff" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 340 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
341 NS_ASSERT (m_head != 0xffff)do { if (!(m_head != 0xffff)) { std::cerr << "assert failed. cond=\""
<< "m_head != 0xffff" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 341 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
342 NS_ASSERT (written >= 8)do { if (!(written >= 8)) { std::cerr << "assert failed. cond=\""
<< "written >= 8" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 342 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
343 m_used += written;
344 m_data->m_dirtyEnd = m_used;
345}
346
347
348void
349PacketMetadata::UpdateHead (uint16_t written)
350{
351 NS_LOG_FUNCTION (this << written)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << written; std::clog << ")" << std::
endl; } } while (false);
352 if (m_head == 0xffff)
353 {
354 NS_ASSERT (m_tail == 0xffff)do { if (!(m_tail == 0xffff)) { std::cerr << "assert failed. cond=\""
<< "m_tail == 0xffff" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 354 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
355 m_head = m_used;
356 m_tail = m_used;
357 }
358 else
359 {
360 NS_ASSERT (m_head != 0xffff)do { if (!(m_head != 0xffff)) { std::cerr << "assert failed. cond=\""
<< "m_head != 0xffff" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 360 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
361 // overwrite the prev field of the previous head of the list.
362 uint8_t *previousHead = &m_data->m_data[m_head + 2];
363 Append16 (m_used, previousHead);
364 // update the head of list to the new node.
365 m_head = m_used;
366 }
367 NS_ASSERT (m_tail != 0xffff)do { if (!(m_tail != 0xffff)) { std::cerr << "assert failed. cond=\""
<< "m_tail != 0xffff" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 367 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
368 NS_ASSERT (m_head != 0xffff)do { if (!(m_head != 0xffff)) { std::cerr << "assert failed. cond=\""
<< "m_head != 0xffff" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 368 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
369 NS_ASSERT (written >= 8)do { if (!(written >= 8)) { std::cerr << "assert failed. cond=\""
<< "written >= 8" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 369 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
370 m_used += written;
371 m_data->m_dirtyEnd = m_used;
372}
373
374uint16_t
375PacketMetadata::AddSmall (const struct PacketMetadata::SmallItem *item)
376{
377 NS_LOG_FUNCTION (this << item->next << item->prev << item->typeUid << item->size << item->chunkUid)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << item->next << item->prev << item
->typeUid << item->size << item->chunkUid
; std::clog << ")" << std::endl; } } while (false
);
378 NS_ASSERT (m_data != 0)do { if (!(m_data != 0)) { std::cerr << "assert failed. cond=\""
<< "m_data != 0" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 378 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
379 NS_ASSERT (m_used != item->prev && m_used != item->next)do { if (!(m_used != item->prev && m_used != item->
next)) { std::cerr << "assert failed. cond=\"" <<
"m_used != item->prev && m_used != item->next"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 379 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
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 ||
384 (m_head != 0xffff &&
385 m_data->m_count != 1 &&
386 m_used != m_data->m_dirtyEnd))
387 {
388 ReserveCopy (n);
389 }
390 uint8_t *buffer = &m_data->m_data[m_used];
391 Append16 (item->next, buffer);
392 buffer += 2;
393 Append16 (item->prev, buffer);
394 buffer += 2;
395 AppendValue (item->typeUid, buffer);
396 buffer += typeUidSize;
397 AppendValue (item->size, buffer);
398 buffer += sizeSize;
399 Append16 (item->chunkUid, buffer);
400 return n;
401}
402
403uint16_t
404PacketMetadata::AddBig (uint32_t next, uint32_t prev,
405 const PacketMetadata::SmallItem *item,
406 const PacketMetadata::ExtraItem *extraItem)
407{
408 NS_LOG_FUNCTION (this << next << prev <<do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << next << prev << item->next <<
item->prev << item->typeUid << item->size
<< item->chunkUid << extraItem->fragmentStart
<< extraItem->fragmentEnd << extraItem->packetUid
; std::clog << ")" << std::endl; } } while (false
)
409 item->next << item->prev << item->typeUid << item->size << item->chunkUid <<do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << next << prev << item->next <<
item->prev << item->typeUid << item->size
<< item->chunkUid << extraItem->fragmentStart
<< extraItem->fragmentEnd << extraItem->packetUid
; std::clog << ")" << std::endl; } } while (false
)
410 extraItem->fragmentStart << extraItem->fragmentEnd << extraItem->packetUid)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << next << prev << item->next <<
item->prev << item->typeUid << item->size
<< item->chunkUid << extraItem->fragmentStart
<< extraItem->fragmentEnd << extraItem->packetUid
; std::clog << ")" << std::endl; } } while (false
);
411 NS_ASSERT (m_data != 0)do { if (!(m_data != 0)) { std::cerr << "assert failed. cond=\""
<< "m_data != 0" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 411 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
412 uint32_t typeUid = ((item->typeUid & 0x1) == 0x1) ? item->typeUid : item->typeUid+1;
413 NS_ASSERT (m_used != prev && m_used != next)do { if (!(m_used != prev && m_used != next)) { std::
cerr << "assert failed. cond=\"" << "m_used != prev && m_used != next"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 413 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
414
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;
420
421 if (m_used + n > m_data->m_size ||
422 (m_head != 0xffff &&
423 m_data->m_count != 1 &&
424 m_used != m_data->m_dirtyEnd))
425 {
426 ReserveCopy (n);
427 }
428
429 uint8_t *buffer = &m_data->m_data[m_used];
430
431 Append16 (next, buffer);
432 buffer += 2;
433 Append16 (prev, buffer);
434 buffer += 2;
435 AppendValue (typeUid, buffer);
436 buffer += typeUidSize;
437 AppendValue (item->size, buffer);
438 buffer += sizeSize;
439 Append16 (item->chunkUid, buffer);
440 buffer += 2;
441 AppendValue (extraItem->fragmentStart, buffer);
442 buffer += fragStartSize;
443 AppendValue (extraItem->fragmentEnd, buffer);
444 buffer += fragEndSize;
445 Append32 (extraItem->packetUid, buffer);
446
447 return n;
448}
449
450void
451PacketMetadata::ReplaceTail (PacketMetadata::SmallItem *item,
452 PacketMetadata::ExtraItem *extraItem,
453 uint32_t available)
454{
455 NS_LOG_FUNCTION (this <<do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << item->next << item->prev << item
->typeUid << item->size << item->chunkUid
<< extraItem->fragmentStart << extraItem->
fragmentEnd << extraItem->packetUid << available
; std::clog << ")" << std::endl; } } while (false
)
456 item->next << item->prev << item->typeUid << item->size << item->chunkUid <<do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << item->next << item->prev << item
->typeUid << item->size << item->chunkUid
<< extraItem->fragmentStart << extraItem->
fragmentEnd << extraItem->packetUid << available
; std::clog << ")" << std::endl; } } while (false
)
457 extraItem->fragmentStart << extraItem->fragmentEnd << extraItem->packetUid <<do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << item->next << item->prev << item
->typeUid << item->size << item->chunkUid
<< extraItem->fragmentStart << extraItem->
fragmentEnd << extraItem->packetUid << available
; std::clog << ")" << std::endl; } } while (false
)
458 available)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << item->next << item->prev << item
->typeUid << item->size << item->chunkUid
<< extraItem->fragmentStart << extraItem->
fragmentEnd << extraItem->packetUid << available
; std::clog << ")" << std::endl; } } while (false
);
459
460 NS_ASSERT (m_data != 0)do { if (!(m_data != 0)) { std::cerr << "assert failed. cond=\""
<< "m_data != 0" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 460 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
461 /* If the tail we want to replace is located at the end of the data array,
462 * and if there is extra room at the end of this array, then,
463 * we can try to use that extra space to avoid falling in the slow
464 * path below.
465 */
466 if (m_tail + available == m_used &&
467 m_used == m_data->m_dirtyEnd)
468 {
469 available = m_data->m_size - m_tail;
470 }
471
472 uint32_t typeUid = ((item->typeUid & 0x1) == 0x1) ? item->typeUid : item->typeUid+1;
473 uint32_t typeUidSize = GetUleb128Size (typeUid);
474 uint32_t sizeSize = GetUleb128Size (item->size);
475 uint32_t fragStartSize = GetUleb128Size (extraItem->fragmentStart);
476 uint32_t fragEndSize = GetUleb128Size (extraItem->fragmentEnd);
477 uint32_t n = 2 + 2 + typeUidSize + sizeSize + 2 + fragStartSize + fragEndSize + 4;
478
479 if (available >= n &&
480 m_data->m_count == 1)
481 {
482 uint8_t *buffer = &m_data->m_data[m_tail];
483 Append16 (item->next, buffer);
484 buffer += 2;
485 Append16 (item->prev, buffer);
486 buffer += 2;
487 AppendValue (typeUid, buffer);
488 buffer += typeUidSize;
489 AppendValue (item->size, buffer);
490 buffer += sizeSize;
491 Append16 (item->chunkUid, buffer);
492 buffer += 2;
493 AppendValue (extraItem->fragmentStart, buffer);
494 buffer += fragStartSize;
495 AppendValue (extraItem->fragmentEnd, buffer);
496 buffer += fragEndSize;
497 Append32 (extraItem->packetUid, buffer);
498 m_used = std::max (m_used, (uint16_t)(buffer - &m_data->m_data[0]));
499 m_data->m_dirtyEnd = m_used;
500 return;
501 }
502
503 /* Below is the slow path which is hit if the new tail we want
504 * to append is bigger than the previous tail.
505 */
506
507 // create a copy of the packet without its tail.
508 PacketMetadata h (m_packetUid, 0);
509 uint16_t current = m_head;
510 while (current != 0xffff && current != m_tail)
511 {
512 struct PacketMetadata::SmallItem tmpItem;
513 PacketMetadata::ExtraItem tmpExtraItem;
514 ReadItems (current, &tmpItem, &tmpExtraItem);
515 uint16_t written = h.AddBig (0xffff, h.m_tail,
516 &tmpItem, &tmpExtraItem);
517 h.UpdateTail (written);
518 current = tmpItem.next;
519 }
520 // append new tail.
521 uint16_t written = h.AddBig (0xffff, h.m_tail, item, extraItem);
522 h.UpdateTail (written);
523
524 *this = h;
525}
526
527
528uint32_t
529PacketMetadata::ReadItems (uint16_t current,
530 struct PacketMetadata::SmallItem *item,
531 struct PacketMetadata::ExtraItem *extraItem) const
532{
533 NS_LOG_FUNCTION (this << current << item->chunkUid << item->prev << item->next << item->size <<do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << current << item->chunkUid << item
->prev << item->next << item->size <<
item->typeUid << extraItem->fragmentEnd <<
extraItem->fragmentStart << extraItem->packetUid
; std::clog << ")" << std::endl; } } while (false
)
534 item->typeUid << extraItem->fragmentEnd << extraItem->fragmentStart <<do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << current << item->chunkUid << item
->prev << item->next << item->size <<
item->typeUid << extraItem->fragmentEnd <<
extraItem->fragmentStart << extraItem->packetUid
; std::clog << ")" << std::endl; } } while (false
)
535 extraItem->packetUid)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << current << item->chunkUid << item
->prev << item->next << item->size <<
item->typeUid << extraItem->fragmentEnd <<
extraItem->fragmentStart << extraItem->packetUid
; std::clog << ")" << std::endl; } } while (false
);
536 NS_ASSERT (current <= m_data->m_size)do { if (!(current <= m_data->m_size)) { std::cerr <<
"assert failed. cond=\"" << "current <= m_data->m_size"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 536 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
537 const uint8_t *buffer = &m_data->m_data[current];
538 item->next = buffer[0];
539 item->next |= (buffer[1]) << 8;
540 item->prev = buffer[2];
541 item->prev |= (buffer[3]) << 8;
542 buffer += 4;
543 item->typeUid = ReadUleb128 (&buffer);
544 item->size = ReadUleb128 (&buffer);
545 item->chunkUid = buffer[0];
546 item->chunkUid |= (buffer[1]) << 8;
547 buffer += 2;
548
549 bool isExtra = (item->typeUid & 0x1) == 0x1;
550 if (isExtra)
551 {
552 extraItem->fragmentStart = ReadUleb128 (&buffer);
553 extraItem->fragmentEnd = ReadUleb128 (&buffer);
554 extraItem->packetUid = buffer[0];
555 extraItem->packetUid |= buffer[1] << 8;
556 extraItem->packetUid |= buffer[2] << 16;
557 extraItem->packetUid |= buffer[3] << 24;
558 buffer += 4;
559 }
560 else
561 {
562 extraItem->fragmentStart = 0;
563 extraItem->fragmentEnd = item->size;
564 extraItem->packetUid = m_packetUid;
565 }
566 NS_ASSERT (buffer <= &m_data->m_data[m_data->m_size])do { if (!(buffer <= &m_data->m_data[m_data->m_size
])) { std::cerr << "assert failed. cond=\"" << "buffer <= &m_data->m_data[m_data->m_size]"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 566 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
567 return buffer - &m_data->m_data[current];
568}
569
570struct PacketMetadata::Data *
571PacketMetadata::Create (uint32_t size)
572{
573 NS_LOG_FUNCTION (size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
size; std::clog << ")" << std::endl; } } while (
false);
574 NS_LOG_LOGIC ("create size="<<size<<", max="<<m_maxSize)do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std
::clog << g_log.Name () << ":" << __FUNCTION__
<< "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL
)) { std::clog << "[" << g_log.GetLevelLabel (ns3
::LOG_LOGIC) << "] "; }; std::clog << "create size="
<<size<<", max="<<m_maxSize << std::endl
; } } while (false);
575 if (size > m_maxSize)
576 {
577 m_maxSize = size;
578 }
579 while (!m_freeList.empty ())
580 {
581 struct PacketMetadata::Data *data = m_freeList.back ();
582 m_freeList.pop_back ();
583 if (data->m_size >= size)
584 {
585 NS_LOG_LOGIC ("create found size="<<data->m_size)do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std
::clog << g_log.Name () << ":" << __FUNCTION__
<< "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL
)) { std::clog << "[" << g_log.GetLevelLabel (ns3
::LOG_LOGIC) << "] "; }; std::clog << "create found size="
<<data->m_size << std::endl; } } while (false);
586 data->m_count = 1;
587 return data;
588 }
589 PacketMetadata::Deallocate (data);
590 NS_LOG_LOGIC ("create dealloc size="<<data->m_size)do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std
::clog << g_log.Name () << ":" << __FUNCTION__
<< "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL
)) { std::clog << "[" << g_log.GetLevelLabel (ns3
::LOG_LOGIC) << "] "; }; std::clog << "create dealloc size="
<<data->m_size << std::endl; } } while (false);
591 }
592 NS_LOG_LOGIC ("create alloc size="<<m_maxSize)do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std
::clog << g_log.Name () << ":" << __FUNCTION__
<< "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL
)) { std::clog << "[" << g_log.GetLevelLabel (ns3
::LOG_LOGIC) << "] "; }; std::clog << "create alloc size="
<<m_maxSize << std::endl; } } while (false);
593 return PacketMetadata::Allocate (m_maxSize);
594}
595
596void
597PacketMetadata::Recycle (struct PacketMetadata::Data *data)
598{
599 NS_LOG_FUNCTION (data)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
data; std::clog << ")" << std::endl; } } while (
false);
600 if (!m_enable)
601 {
602 PacketMetadata::Deallocate (data);
603 return;
604 }
605 NS_LOG_LOGIC ("recycle size="<<data->m_size<<", list="<<m_freeList.size ())do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std
::clog << g_log.Name () << ":" << __FUNCTION__
<< "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL
)) { std::clog << "[" << g_log.GetLevelLabel (ns3
::LOG_LOGIC) << "] "; }; std::clog << "recycle size="
<<data->m_size<<", list="<<m_freeList.size
() << std::endl; } } while (false);
606 NS_ASSERT (data->m_count == 0)do { if (!(data->m_count == 0)) { std::cerr << "assert failed. cond=\""
<< "data->m_count == 0" << "\", "; do { std::
cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 606 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
607 if (m_freeList.size () > 1000 ||
608 data->m_size < m_maxSize)
609 {
610 PacketMetadata::Deallocate (data);
611 }
612 else
613 {
614 m_freeList.push_back (data);
615 }
616}
617
618struct PacketMetadata::Data *
619PacketMetadata::Allocate (uint32_t n)
620{
621 NS_LOG_FUNCTION (n)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
n; std::clog << ")" << std::endl; } } while (false
);
622 uint32_t size = sizeof (struct Data);
623 if (n <= PACKET_METADATA_DATA_M_DATA_SIZE8)
624 {
625 n = PACKET_METADATA_DATA_M_DATA_SIZE8;
626 }
627 size += n - PACKET_METADATA_DATA_M_DATA_SIZE8;
628 uint8_t *buf = new uint8_t [size];
629 struct PacketMetadata::Data *data = (struct PacketMetadata::Data *)buf;
630 data->m_size = n;
631 data->m_count = 1;
632 data->m_dirtyEnd = 0;
633 return data;
634}
635void
636PacketMetadata::Deallocate (struct PacketMetadata::Data *data)
637{
638 NS_LOG_FUNCTION (data)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
data; std::clog << ")" << std::endl; } } while (
false);
639 uint8_t *buf = (uint8_t *)data;
640 delete [] buf;
641}
642
643
644PacketMetadata
645PacketMetadata::CreateFragment (uint32_t start, uint32_t end) const
646{
647 NS_LOG_FUNCTION (this << start << end)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << start << end; std::clog << ")" <<
std::endl; } } while (false);
648 PacketMetadata fragment = *this;
649 fragment.RemoveAtStart (start);
650 fragment.RemoveAtEnd (end);
651 return fragment;
652}
653
654void
655PacketMetadata::AddHeader (const Header &header, uint32_t size)
656{
657 NS_LOG_FUNCTION (this << &header << size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << &header << size; std::clog << ")"
<< std::endl; } } while (false);
658 NS_ASSERT (IsStateOk ())do { if (!(IsStateOk ())) { std::cerr << "assert failed. cond=\""
<< "IsStateOk ()" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 658 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
659 uint32_t uid = header.GetInstanceTypeId ().GetUid () << 1;
660 DoAddHeader (uid, size);
661 NS_ASSERT (IsStateOk ())do { if (!(IsStateOk ())) { std::cerr << "assert failed. cond=\""
<< "IsStateOk ()" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 661 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
662}
663void
664PacketMetadata::DoAddHeader (uint32_t uid, uint32_t size)
665{
666 NS_LOG_FUNCTION (this << uid << size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << uid << size; std::clog << ")" <<
std::endl; } } while (false);
667 if (!m_enable)
668 {
669 m_metadataSkipped = true;
670 return;
671 }
672
673 struct PacketMetadata::SmallItem item;
674 item.next = m_head;
675 item.prev = 0xffff;
676 item.typeUid = uid;
677 item.size = size;
678 item.chunkUid = m_chunkUid;
679 m_chunkUid++;
680 uint16_t written = AddSmall (&item);
681 UpdateHead (written);
682}
683void
684PacketMetadata::RemoveHeader (const Header &header, uint32_t size)
685{
686 uint32_t uid = header.GetInstanceTypeId ().GetUid () << 1;
687 NS_LOG_FUNCTION (this << &header << size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << &header << size; std::clog << ")"
<< std::endl; } } while (false);
688 NS_ASSERT (IsStateOk ())do { if (!(IsStateOk ())) { std::cerr << "assert failed. cond=\""
<< "IsStateOk ()" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 688 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
689 if (!m_enable)
690 {
691 m_metadataSkipped = true;
692 return;
693 }
694 struct PacketMetadata::SmallItem item;
695 struct PacketMetadata::ExtraItem extraItem;
696 uint32_t read = ReadItems (m_head, &item, &extraItem);
697 if ((item.typeUid & 0xfffffffe) != uid ||
698 item.size != size)
699 {
700 if (m_enableChecking)
701 {
702 NS_FATAL_ERROR ("Removing unexpected header.")do { std::cerr << "msg=\"" << "Removing unexpected header."
<< "\", "; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 702 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } while (false);
703 }
704 return;
705 }
706 else if (item.typeUid != uid &&
707 (extraItem.fragmentStart != 0 ||
708 extraItem.fragmentEnd != size))
709 {
710 if (m_enableChecking)
711 {
712 NS_FATAL_ERROR ("Removing incomplete header.")do { std::cerr << "msg=\"" << "Removing incomplete header."
<< "\", "; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 712 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } while (false);
713 }
714 return;
715 }
716 if (m_head + read == m_used)
717 {
718 m_used = m_head;
719 }
720 if (m_head == m_tail)
721 {
722 m_head = 0xffff;
723 m_tail = 0xffff;
724 }
725 else
726 {
727 m_head = item.next;
728 }
729 NS_ASSERT (IsStateOk ())do { if (!(IsStateOk ())) { std::cerr << "assert failed. cond=\""
<< "IsStateOk ()" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 729 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
730}
731void
732PacketMetadata::AddTrailer (const Trailer &trailer, uint32_t size)
733{
734 uint32_t uid = trailer.GetInstanceTypeId ().GetUid () << 1;
735 NS_LOG_FUNCTION (this << &trailer << size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << &trailer << size; std::clog <<
")" << std::endl; } } while (false);
736 NS_ASSERT (IsStateOk ())do { if (!(IsStateOk ())) { std::cerr << "assert failed. cond=\""
<< "IsStateOk ()" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 736 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
737 if (!m_enable)
738 {
739 m_metadataSkipped = true;
740 return;
741 }
742 struct PacketMetadata::SmallItem item;
743 item.next = 0xffff;
744 item.prev = m_tail;
745 item.typeUid = uid;
746 item.size = size;
747 item.chunkUid = m_chunkUid;
748 m_chunkUid++;
749 uint16_t written = AddSmall (&item);
750 UpdateTail (written);
751 NS_ASSERT (IsStateOk ())do { if (!(IsStateOk ())) { std::cerr << "assert failed. cond=\""
<< "IsStateOk ()" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 751 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
752}
753void
754PacketMetadata::RemoveTrailer (const Trailer &trailer, uint32_t size)
755{
756 uint32_t uid = trailer.GetInstanceTypeId ().GetUid () << 1;
757 NS_LOG_FUNCTION (this << &trailer << size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << &trailer << size; std::clog <<
")" << std::endl; } } while (false);
758 NS_ASSERT (IsStateOk ())do { if (!(IsStateOk ())) { std::cerr << "assert failed. cond=\""
<< "IsStateOk ()" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 758 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
759 if (!m_enable)
760 {
761 m_metadataSkipped = true;
762 return;
763 }
764 struct PacketMetadata::SmallItem item;
765 struct PacketMetadata::ExtraItem extraItem;
766 uint32_t read = ReadItems (m_tail, &item, &extraItem);
767 if ((item.typeUid & 0xfffffffe) != uid ||
768 item.size != size)
769 {
770 if (m_enableChecking)
771 {
772 NS_FATAL_ERROR ("Removing unexpected trailer.")do { std::cerr << "msg=\"" << "Removing unexpected trailer."
<< "\", "; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 772 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } while (false);
773 }
774 return;
775 }
776 else if (item.typeUid != uid &&
777 (extraItem.fragmentStart != 0 ||
778 extraItem.fragmentEnd != size))
779 {
780 if (m_enableChecking)
781 {
782 NS_FATAL_ERROR ("Removing incomplete trailer.")do { std::cerr << "msg=\"" << "Removing incomplete trailer."
<< "\", "; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 782 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } while (false);
783 }
784 return;
785 }
786 if (m_tail + read == m_used)
787 {
788 m_used = m_tail;
789 }
790 if (m_head == m_tail)
791 {
792 m_head = 0xffff;
793 m_tail = 0xffff;
794 }
795 else
796 {
797 m_tail = item.prev;
798 }
799 NS_ASSERT (IsStateOk ())do { if (!(IsStateOk ())) { std::cerr << "assert failed. cond=\""
<< "IsStateOk ()" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 799 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
800}
801void
802PacketMetadata::AddAtEnd (PacketMetadata const&o)
803{
804 NS_LOG_FUNCTION (this << &o)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << &o; std::clog << ")" << std::endl
; } } while (false);
805 NS_ASSERT (IsStateOk ())do { if (!(IsStateOk ())) { std::cerr << "assert failed. cond=\""
<< "IsStateOk ()" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 805 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
806 if (!m_enable)
807 {
808 m_metadataSkipped = true;
809 return;
810 }
811 if (m_tail == 0xffff)
812 {
813 // We have no items so 'AddAtEnd' is
814 // equivalent to self-assignment.
815 *this = o;
816 NS_ASSERT (IsStateOk ())do { if (!(IsStateOk ())) { std::cerr << "assert failed. cond=\""
<< "IsStateOk ()" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 816 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
817 return;
818 }
819 if (o.m_head == 0xffff)
820 {
821 NS_ASSERT (o.m_tail == 0xffff)do { if (!(o.m_tail == 0xffff)) { std::cerr << "assert failed. cond=\""
<< "o.m_tail == 0xffff" << "\", "; do { std::cerr
<< "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 821 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
822 // we have nothing to append.
823 return;
824 }
825 NS_ASSERT (m_head != 0xffff && m_tail != 0xffff)do { if (!(m_head != 0xffff && m_tail != 0xffff)) { std
::cerr << "assert failed. cond=\"" << "m_head != 0xffff && m_tail != 0xffff"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 825 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
826
827 // We read the current tail because we are going to append
828 // after this item.
829 struct PacketMetadata::SmallItem tailItem;
830 PacketMetadata::ExtraItem tailExtraItem;
831 uint32_t tailSize = ReadItems (m_tail, &tailItem, &tailExtraItem);
832
833 uint16_t current;
834 struct PacketMetadata::SmallItem item;
835 PacketMetadata::ExtraItem extraItem;
836 o.ReadItems (o.m_head, &item, &extraItem);
837 if (extraItem.packetUid == tailExtraItem.packetUid &&
838 item.typeUid == tailItem.typeUid &&
839 item.chunkUid == tailItem.chunkUid &&
840 item.size == tailItem.size &&
841 extraItem.fragmentStart == tailExtraItem.fragmentEnd)
842 {
843 /* If the previous tail came from the same header as
844 * the next item we want to append to our array, then,
845 * we merge them and attempt to reuse the previous tail's
846 * location.
847 */
848 tailExtraItem.fragmentEnd = extraItem.fragmentEnd;
849 ReplaceTail (&tailItem, &tailExtraItem, tailSize);
850 if (o.m_head == o.m_tail)
851 {
852 // there is only one item to append to self from other.
853 return;
854 }
855 current = item.next;
856 }
857 else
858 {
859 current = o.m_head;
860 }
861
862 /* Now that we have merged our current tail with the head of the
863 * next packet, we just append all items from the next packet
864 * to the current packet.
865 */
866 while (current != 0xffff)
867 {
868 o.ReadItems (current, &item, &extraItem);
869 uint16_t written = AddBig (0xffff, m_tail, &item, &extraItem);
870 UpdateTail (written);
871 if (current == o.m_tail)
872 {
873 break;
874 }
875 current = item.next;
876 }
877 NS_ASSERT (IsStateOk ())do { if (!(IsStateOk ())) { std::cerr << "assert failed. cond=\""
<< "IsStateOk ()" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 877 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
878}
879void
880PacketMetadata::AddPaddingAtEnd (uint32_t end)
881{
882 NS_LOG_FUNCTION (this << end)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << end; std::clog << ")" << std::endl
; } } while (false);
883 if (!m_enable)
884 {
885 m_metadataSkipped = true;
886 return;
887 }
888}
889void
890PacketMetadata::RemoveAtStart (uint32_t start)
891{
892 NS_LOG_FUNCTION (this << start)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << start; std::clog << ")" << std::endl
; } } while (false);
893 NS_ASSERT (IsStateOk ())do { if (!(IsStateOk ())) { std::cerr << "assert failed. cond=\""
<< "IsStateOk ()" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 893 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
894 if (!m_enable)
895 {
896 m_metadataSkipped = true;
897 return;
898 }
899 NS_ASSERT (m_data != 0)do { if (!(m_data != 0)) { std::cerr << "assert failed. cond=\""
<< "m_data != 0" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 899 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
900 uint32_t leftToRemove = start;
901 uint16_t current = m_head;
902 while (current != 0xffff && leftToRemove > 0)
903 {
904 struct PacketMetadata::SmallItem item;
905 PacketMetadata::ExtraItem extraItem;
906 ReadItems (current, &item, &extraItem);
907 uint32_t itemRealSize = extraItem.fragmentEnd - extraItem.fragmentStart;
908 if (itemRealSize <= leftToRemove)
909 {
910 // remove from list.
911 if (m_head == m_tail)
912 {
913 m_head = 0xffff;
914 m_tail = 0xffff;
915 }
916 else
917 {
918 m_head = item.next;
919 }
920 leftToRemove -= itemRealSize;
921 }
922 else
923 {
924 // fragment the list item.
925 PacketMetadata fragment (m_packetUid, 0);
926 extraItem.fragmentStart += leftToRemove;
927 leftToRemove = 0;
928 uint16_t written = fragment.AddBig (0xffff, fragment.m_tail,
929 &item, &extraItem);
930 fragment.UpdateTail (written);
931 while (current != 0xffff && current != m_tail)
932 {
933 current = item.next;
934 ReadItems (current, &item, &extraItem);
935 written = fragment.AddBig (0xffff, fragment.m_tail,
936 &item, &extraItem);
937 fragment.UpdateTail (written);
938 }
939 *this = fragment;
940 }
941 NS_ASSERT (item.size >= extraItem.fragmentEnd - extraItem.fragmentStart &&do { if (!(item.size >= extraItem.fragmentEnd - extraItem.
fragmentStart && extraItem.fragmentStart <= extraItem
.fragmentEnd)) { std::cerr << "assert failed. cond=\"" <<
"item.size >= extraItem.fragmentEnd - extraItem.fragmentStart && extraItem.fragmentStart <= extraItem.fragmentEnd"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 942 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false)
942 extraItem.fragmentStart <= extraItem.fragmentEnd)do { if (!(item.size >= extraItem.fragmentEnd - extraItem.
fragmentStart && extraItem.fragmentStart <= extraItem
.fragmentEnd)) { std::cerr << "assert failed. cond=\"" <<
"item.size >= extraItem.fragmentEnd - extraItem.fragmentStart && extraItem.fragmentStart <= extraItem.fragmentEnd"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 942 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
943 if (current == m_tail)
944 {
945 break;
946 }
947 current = item.next;
948 }
949 NS_ASSERT (leftToRemove == 0)do { if (!(leftToRemove == 0)) { std::cerr << "assert failed. cond=\""
<< "leftToRemove == 0" << "\", "; do { std::cerr
<< "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 949 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
950 NS_ASSERT (IsStateOk ())do { if (!(IsStateOk ())) { std::cerr << "assert failed. cond=\""
<< "IsStateOk ()" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 950 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
951}
952void
953PacketMetadata::RemoveAtEnd (uint32_t end)
954{
955 NS_LOG_FUNCTION (this << end)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << end; std::clog << ")" << std::endl
; } } while (false);
956 NS_ASSERT (IsStateOk ())do { if (!(IsStateOk ())) { std::cerr << "assert failed. cond=\""
<< "IsStateOk ()" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 956 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
957 if (!m_enable)
958 {
959 m_metadataSkipped = true;
960 return;
961 }
962 NS_ASSERT (m_data != 0)do { if (!(m_data != 0)) { std::cerr << "assert failed. cond=\""
<< "m_data != 0" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 962 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
963
964 uint32_t leftToRemove = end;
965 uint16_t current = m_tail;
966 while (current != 0xffff && leftToRemove > 0)
967 {
968 struct PacketMetadata::SmallItem item;
969 PacketMetadata::ExtraItem extraItem;
970 ReadItems (current, &item, &extraItem);
971 uint32_t itemRealSize = extraItem.fragmentEnd - extraItem.fragmentStart;
972 if (itemRealSize <= leftToRemove)
973 {
974 // remove from list.
975 if (m_head == m_tail)
976 {
977 m_head = 0xffff;
978 m_tail = 0xffff;
979 }
980 else
981 {
982 m_tail = item.prev;
983 }
984 leftToRemove -= itemRealSize;
985 }
986 else
987 {
988 // fragment the list item.
989 PacketMetadata fragment (m_packetUid, 0);
990 NS_ASSERT (extraItem.fragmentEnd > leftToRemove)do { if (!(extraItem.fragmentEnd > leftToRemove)) { std::cerr
<< "assert failed. cond=\"" << "extraItem.fragmentEnd > leftToRemove"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 990 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
991 extraItem.fragmentEnd -= leftToRemove;
992 leftToRemove = 0;
993 uint16_t written = fragment.AddBig (fragment.m_head, 0xffff,
994 &item, &extraItem);
995 fragment.UpdateHead (written);
996 while (current != 0xffff && current != m_head)
997 {
998 current = item.prev;
999 ReadItems (current, &item, &extraItem);
1000 written = fragment.AddBig (fragment.m_head, 0xffff,
1001 &item, &extraItem);
1002 fragment.UpdateHead (written);
1003 }
1004 *this = fragment;
1005 }
1006 NS_ASSERT (item.size >= extraItem.fragmentEnd - extraItem.fragmentStart &&do { if (!(item.size >= extraItem.fragmentEnd - extraItem.
fragmentStart && extraItem.fragmentStart <= extraItem
.fragmentEnd)) { std::cerr << "assert failed. cond=\"" <<
"item.size >= extraItem.fragmentEnd - extraItem.fragmentStart && extraItem.fragmentStart <= extraItem.fragmentEnd"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 1007 << std::endl; ::ns3::
FatalImpl::FlushStreams (); if (true) std::terminate (); } while
(false); } } while (false)
1007 extraItem.fragmentStart <= extraItem.fragmentEnd)do { if (!(item.size >= extraItem.fragmentEnd - extraItem.
fragmentStart && extraItem.fragmentStart <= extraItem
.fragmentEnd)) { std::cerr << "assert failed. cond=\"" <<
"item.size >= extraItem.fragmentEnd - extraItem.fragmentStart && extraItem.fragmentStart <= extraItem.fragmentEnd"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 1007 << std::endl; ::ns3::
FatalImpl::FlushStreams (); if (true) std::terminate (); } while
(false); } } while (false);
1008 if (current == m_head)
1009 {
1010 break;
1011 }
1012 current = item.prev;
1013 }
1014 NS_ASSERT (leftToRemove == 0)do { if (!(leftToRemove == 0)) { std::cerr << "assert failed. cond=\""
<< "leftToRemove == 0" << "\", "; do { std::cerr
<< "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 1014 << std::endl; ::ns3::
FatalImpl::FlushStreams (); if (true) std::terminate (); } while
(false); } } while (false);
1015 NS_ASSERT (IsStateOk ())do { if (!(IsStateOk ())) { std::cerr << "assert failed. cond=\""
<< "IsStateOk ()" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 1015 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
1016}
1017uint32_t
1018PacketMetadata::GetTotalSize (void) const
1019{
1020 NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this; std::clog << ")" << std::endl; } } while (
false);
1021 uint32_t totalSize = 0;
1022 uint16_t current = m_head;
1023 uint16_t tail = m_tail;
1024 while (current != 0xffff)
1025 {
1026 struct PacketMetadata::SmallItem item;
1027 PacketMetadata::ExtraItem extraItem;
1028 ReadItems (current, &item, &extraItem);
1029 totalSize += extraItem.fragmentEnd - extraItem.fragmentStart;
1030 if (current == tail)
1031 {
1032 break;
1033 }
1034 NS_ASSERT (current != item.next)do { if (!(current != item.next)) { std::cerr << "assert failed. cond=\""
<< "current != item.next" << "\", "; do { std::cerr
<< "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 1034 << std::endl; ::ns3::
FatalImpl::FlushStreams (); if (true) std::terminate (); } while
(false); } } while (false);
1035 current = item.next;
1036 }
1037 return totalSize;
1038}
1039
1040uint64_t
1041PacketMetadata::GetUid (void) const
1042{
1043 NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this; std::clog << ")" << std::endl; } } while (
false);
1044 return m_packetUid;
1045}
1046PacketMetadata::ItemIterator
1047PacketMetadata::BeginItem (Buffer buffer) const
1048{
1049 NS_LOG_FUNCTION (this << &buffer)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << &buffer; std::clog << ")" << std
::endl; } } while (false);
1050 return ItemIterator (this, buffer);
1051}
1052PacketMetadata::ItemIterator::ItemIterator (const PacketMetadata *metadata, Buffer buffer)
1053 : m_metadata (metadata),
1054 m_buffer (buffer),
1055 m_current (metadata->m_head),
1056 m_offset (0),
1057 m_hasReadTail (false)
1058{
1059 NS_LOG_FUNCTION (this << metadata << &buffer)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << metadata << &buffer; std::clog <<
")" << std::endl; } } while (false);
1060}
1061bool
1062PacketMetadata::ItemIterator::HasNext (void) const
1063{
1064 NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this; std::clog << ")" << std::endl; } } while (
false);
1065 if (m_current == 0xffff)
1066 {
1067 return false;
1068 }
1069 if (m_hasReadTail)
1070 {
1071 return false;
1072 }
1073 return true;
1074}
1075PacketMetadata::Item
1076PacketMetadata::ItemIterator::Next (void)
1077{
1078 NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this; std::clog << ")" << std::endl; } } while (
false);
1079 struct PacketMetadata::Item item;
1080 struct PacketMetadata::SmallItem smallItem;
1081 struct PacketMetadata::ExtraItem extraItem;
1082 m_metadata->ReadItems (m_current, &smallItem, &extraItem);
1083 if (m_current == m_metadata->m_tail)
1084 {
1085 m_hasReadTail = true;
1086 }
1087 m_current = smallItem.next;
1088 uint32_t uid = (smallItem.typeUid & 0xfffffffe) >> 1;
1089 item.tid.SetUid (uid);
1090 item.currentTrimedFromStart = extraItem.fragmentStart;
1091 item.currentTrimedFromEnd = extraItem.fragmentEnd - smallItem.size;
1092 item.currentSize = extraItem.fragmentEnd - extraItem.fragmentStart;
1093 if (extraItem.fragmentStart != 0 || extraItem.fragmentEnd != smallItem.size)
1094 {
1095 item.isFragment = true;
1096 }
1097 else
1098 {
1099 item.isFragment = false;
1100 }
1101 TypeId tid;
1102 tid.SetUid (uid);
1103 if (uid == 0)
1104 {
1105 item.type = PacketMetadata::Item::PAYLOAD;
1106 }
1107 else if (tid.IsChildOf (Header::GetTypeId ()))
1108 {
1109 item.type = PacketMetadata::Item::HEADER;
1110 if (!item.isFragment)
1111 {
1112 item.current = m_buffer.Begin ();
1113 item.current.Next (m_offset);
1114 }
1115 }
1116 else if (tid.IsChildOf (Trailer::GetTypeId ()))
1117 {
1118 item.type = PacketMetadata::Item::TRAILER;
1119 if (!item.isFragment)
1120 {
1121 item.current = m_buffer.End ();
1122 item.current.Prev (m_buffer.GetSize () - (m_offset + smallItem.size));
1123 }
1124 }
1125 else
1126 {
1127 NS_ASSERT (false)do { if (!(false)) { std::cerr << "assert failed. cond=\""
<< "false" << "\", "; do { std::cerr << "file="
<< "../src/network/model/packet-metadata.cc" << ", line="
<< 1127 << std::endl; ::ns3::FatalImpl::FlushStreams
(); if (true) std::terminate (); } while (false); } } while (
false);
1128 }
1129 m_offset += extraItem.fragmentEnd - extraItem.fragmentStart;
1130 return item;
1131}
1132
1133uint32_t
1134PacketMetadata::GetSerializedSize (void) const
1135{
1136 NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this; std::clog << ")" << std::endl; } } while (
false);
1137 uint32_t totalSize = 0;
1138
1139 // add 8 bytes for the packet uid
1140 totalSize += 8;
1141
1142 // if packet-metadata not enabled, total size
1143 // is simply 4-bytes for itself plus 8-bytes
1144 // for packet uid
1145 if (!m_enable)
1146 {
1147 return totalSize;
1148 }
1149
1150 struct PacketMetadata::SmallItem item;
1151 struct PacketMetadata::ExtraItem extraItem;
1152 uint32_t current = m_head;
1153 while (current != 0xffff)
1154 {
1155 ReadItems (current, &item, &extraItem);
1156 uint32_t uid = (item.typeUid & 0xfffffffe) >> 1;
1157 if (uid == 0)
1158 {
1159 totalSize += 4;
1160 }
1161 else
1162 {
1163 TypeId tid;
1164 tid.SetUid (uid);
1165 totalSize += 4 + tid.GetName ().size ();
1166 }
1167 totalSize += 1 + 4 + 2 + 4 + 4 + 8;
1168 if (current == m_tail)
1169 {
1170 break;
1171 }
1172 NS_ASSERT (current != item.next)do { if (!(current != item.next)) { std::cerr << "assert failed. cond=\""
<< "current != item.next" << "\", "; do { std::cerr
<< "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 1172 << std::endl; ::ns3::
FatalImpl::FlushStreams (); if (true) std::terminate (); } while
(false); } } while (false);
1173 current = item.next;
1174 }
1175 return totalSize;
1176}
1177
1178uint32_t
1179PacketMetadata::Serialize (uint8_t* buffer, uint32_t maxSize) const
1180{
1181 NS_LOG_FUNCTION (this << &buffer << maxSize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << &buffer << maxSize; std::clog <<
")" << std::endl; } } while (false);
1182 uint8_t* start = buffer;
1183
1184 buffer = AddToRawU64 (m_packetUid, start, buffer, maxSize);
1185 if (buffer == 0)
1186 {
1187 return 0;
1188 }
1189
1190 struct PacketMetadata::SmallItem item;
1191 struct PacketMetadata::ExtraItem extraItem;
1192 uint32_t current = m_head;
1193 while (current != 0xffff)
1194 {
1195 ReadItems (current, &item, &extraItem);
1196 NS_LOG_LOGIC ("bytesWritten=" << static_cast<uint32_t> (buffer - start) << ", typeUid="<<do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std
::clog << g_log.Name () << ":" << __FUNCTION__
<< "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL
)) { std::clog << "[" << g_log.GetLevelLabel (ns3
::LOG_LOGIC) << "] "; }; std::clog << "bytesWritten="
<< static_cast<uint32_t> (buffer - start) <<
", typeUid="<< item.typeUid << ", size="<<
item.size<<", chunkUid="<<item.chunkUid<< ", fragmentStart="
<<extraItem.fragmentStart<<", fragmentEnd="<<
extraItem.fragmentEnd<< ", packetUid="<<extraItem
.packetUid << std::endl; } } while (false)
1197 item.typeUid << ", size="<<item.size<<", chunkUid="<<item.chunkUid<<do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std
::clog << g_log.Name () << ":" << __FUNCTION__
<< "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL
)) { std::clog << "[" << g_log.GetLevelLabel (ns3
::LOG_LOGIC) << "] "; }; std::clog << "bytesWritten="
<< static_cast<uint32_t> (buffer - start) <<
", typeUid="<< item.typeUid << ", size="<<
item.size<<", chunkUid="<<item.chunkUid<< ", fragmentStart="
<<extraItem.fragmentStart<<", fragmentEnd="<<
extraItem.fragmentEnd<< ", packetUid="<<extraItem
.packetUid << std::endl; } } while (false)
1198 ", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="<<do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std
::clog << g_log.Name () << ":" << __FUNCTION__
<< "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL
)) { std::clog << "[" << g_log.GetLevelLabel (ns3
::LOG_LOGIC) << "] "; }; std::clog << "bytesWritten="
<< static_cast<uint32_t> (buffer - start) <<
", typeUid="<< item.typeUid << ", size="<<
item.size<<", chunkUid="<<item.chunkUid<< ", fragmentStart="
<<extraItem.fragmentStart<<", fragmentEnd="<<
extraItem.fragmentEnd<< ", packetUid="<<extraItem
.packetUid << std::endl; } } while (false)
1199 extraItem.fragmentEnd<< ", packetUid="<<extraItem.packetUid)do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std
::clog << g_log.Name () << ":" << __FUNCTION__
<< "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL
)) { std::clog << "[" << g_log.GetLevelLabel (ns3
::LOG_LOGIC) << "] "; }; std::clog << "bytesWritten="
<< static_cast<uint32_t> (buffer - start) <<
", typeUid="<< item.typeUid << ", size="<<
item.size<<", chunkUid="<<item.chunkUid<< ", fragmentStart="
<<extraItem.fragmentStart<<", fragmentEnd="<<
extraItem.fragmentEnd<< ", packetUid="<<extraItem
.packetUid << std::endl; } } while (false);
1200
1201 uint32_t uid = (item.typeUid & 0xfffffffe) >> 1;
1202 if (uid != 0)
1203 {
1204 TypeId tid;
1205 tid.SetUid (uid);
1206 std::string uidString = tid.GetName ();
1207 uint32_t uidStringSize = uidString.size ();
1208 buffer = AddToRawU32 (uidStringSize, start, buffer, maxSize);
1209 if (buffer == 0)
1210 {
1211 return 0;
1212 }
1213 buffer = AddToRaw (reinterpret_cast<const uint8_t *> (uidString.c_str ()),
1214 uidStringSize, start, buffer, maxSize);
1215 if (buffer == 0)
1216 {
1217 return 0;
1218 }
1219 }
1220 else
1221 {
1222 buffer = AddToRawU32 (0, start, buffer, maxSize);
1223 if (buffer == 0)
1224 {
1225 return 0;
1226 }
1227 }
1228
1229 uint8_t isBig = item.typeUid & 0x1;
1230 buffer = AddToRawU8 (isBig, start, buffer, maxSize);
1231 if (buffer == 0)
1232 {
1233 return 0;
1234 }
1235
1236 buffer = AddToRawU32 (item.size, start, buffer, maxSize);
1237 if (buffer == 0)
1238 {
1239 return 0;
1240 }
1241
1242 buffer = AddToRawU16 (item.chunkUid, start, buffer, maxSize);
1243 if (buffer == 0)
1244 {
1245 return 0;
1246 }
1247
1248 buffer = AddToRawU32 (extraItem.fragmentStart, start, buffer, maxSize);
1249 if (buffer == 0)
1250 {
1251 return 0;
1252 }
1253
1254 buffer = AddToRawU32 (extraItem.fragmentEnd, start, buffer, maxSize);
1255 if (buffer == 0)
1256 {
1257 return 0;
1258 }
1259
1260 buffer = AddToRawU64 (extraItem.packetUid, start, buffer, maxSize);
1261 if (buffer == 0)
1262 {
1263 return 0;
1264 }
1265
1266 if (current == m_tail)
1267 {
1268 break;
1269 }
1270
1271 NS_ASSERT (current != item.next)do { if (!(current != item.next)) { std::cerr << "assert failed. cond=\""
<< "current != item.next" << "\", "; do { std::cerr
<< "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 1271 << std::endl; ::ns3::
FatalImpl::FlushStreams (); if (true) std::terminate (); } while
(false); } } while (false);
1272 current = item.next;
1273 }
1274
1275 NS_ASSERT (static_cast<uint32_t> (buffer - start) == maxSize)do { if (!(static_cast<uint32_t> (buffer - start) == maxSize
)) { std::cerr << "assert failed. cond=\"" << "static_cast<uint32_t> (buffer - start) == maxSize"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/packet-metadata.cc"
<< ", line=" << 1275 << std::endl; ::ns3::
FatalImpl::FlushStreams (); if (true) std::terminate (); } while
(false); } } while (false);
1276 return 1;
1277}
1278
1279uint32_t
1280PacketMetadata::Deserialize (const uint8_t* buffer, uint32_t size)
1281{
1282 NS_LOG_FUNCTION (this << &buffer << size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
this << &buffer << size; std::clog << ")"
<< std::endl; } } while (false);
1283 const uint8_t* start = buffer;
1284 uint32_t desSize = size - 4;
1285
1286 buffer = ReadFromRawU64 (m_packetUid, start, buffer, size);
1287 desSize -= 8;
1288
1289 struct PacketMetadata::SmallItem item = {0};
1290 struct PacketMetadata::ExtraItem extraItem = {0};
1291 while (desSize > 0)
1292 {
1293 uint32_t uidStringSize = 0;
1294 buffer = ReadFromRawU32 (uidStringSize, start, buffer, size);
1295 desSize -= 4;
1296 uint32_t uid;
1297 if (uidStringSize == 0)
1298 {
1299 // uid zero for payload.
1300 uid = 0;
1301 }
1302 else
1303 {
1304 std::string uidString;
1305 for (uint32_t j = 0; j < uidStringSize; j++)
1306 {
1307 uint8_t ch = 0;
1308 buffer = ReadFromRawU8 (ch, start, buffer, size);
1309 uidString.push_back (ch);
1310 desSize--;
1311 }
1312 TypeId tid = TypeId::LookupByName (uidString);
1313 uid = tid.GetUid ();
1314 }
1315 uint8_t isBig = 0;
1316 buffer = ReadFromRawU8 (isBig, start, buffer, size);
1317 desSize--;
1318 item.typeUid = (uid << 1) | isBig;
1319 buffer = ReadFromRawU32 (item.size, start, buffer, size);
1320 desSize -= 4;
1321 buffer = ReadFromRawU16 (item.chunkUid, start, buffer, size);
1322 desSize -= 2;
1323 buffer = ReadFromRawU32 (extraItem.fragmentStart, start, buffer, size);
1324 desSize -= 4;
1325 buffer = ReadFromRawU32 (extraItem.fragmentEnd, start, buffer, size);
1326 desSize -= 4;
1327 buffer = ReadFromRawU64 (extraItem.packetUid, start, buffer, size);
1328 desSize -= 8;
1329 NS_LOG_LOGIC ("size=" << size << ", typeUid="<<item.typeUid <<do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std
::clog << g_log.Name () << ":" << __FUNCTION__
<< "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL
)) { std::clog << "[" << g_log.GetLevelLabel (ns3
::LOG_LOGIC) << "] "; }; std::clog << "size=" <<
size << ", typeUid="<<item.typeUid << ", size="
<<item.size<<", chunkUid="<<item.chunkUid<<
", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="
<< extraItem.fragmentEnd<< ", packetUid="<<
extraItem.packetUid << std::endl; } } while (false)
1330 ", size="<<item.size<<", chunkUid="<<item.chunkUid<<do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std
::clog << g_log.Name () << ":" << __FUNCTION__
<< "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL
)) { std::clog << "[" << g_log.GetLevelLabel (ns3
::LOG_LOGIC) << "] "; }; std::clog << "size=" <<
size << ", typeUid="<<item.typeUid << ", size="
<<item.size<<", chunkUid="<<item.chunkUid<<
", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="
<< extraItem.fragmentEnd<< ", packetUid="<<
extraItem.packetUid << std::endl; } } while (false)
1331 ", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="<<do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std
::clog << g_log.Name () << ":" << __FUNCTION__
<< "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL
)) { std::clog << "[" << g_log.GetLevelLabel (ns3
::LOG_LOGIC) << "] "; }; std::clog << "size=" <<
size << ", typeUid="<<item.typeUid << ", size="
<<item.size<<", chunkUid="<<item.chunkUid<<
", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="
<< extraItem.fragmentEnd<< ", packetUid="<<
extraItem.packetUid << std::endl; } } while (false)
1332 extraItem.fragmentEnd<< ", packetUid="<<extraItem.packetUid)do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std
::clog << g_log.Name () << ":" << __FUNCTION__
<< "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL
)) { std::clog << "[" << g_log.GetLevelLabel (ns3
::LOG_LOGIC) << "] "; }; std::clog << "size=" <<
size << ", typeUid="<<item.typeUid << ", size="
<<item.size<<", chunkUid="<<item.chunkUid<<
", fragmentStart="<<extraItem.fragmentStart<<", fragmentEnd="
<< extraItem.fragmentEnd<< ", packetUid="<<
extraItem.packetUid << std::endl; } } while (false);
1333 uint32_t tmp = AddBig (0xffff, m_tail, &item, &extraItem);
1334 UpdateTail (tmp);
1335 }
1336 NS_ASSERT (desSize == 0)do { if (!(desSize == 0)) { std::cerr << "assert failed. cond=\""
<< "desSize == 0" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/packet-metadata.cc" <<
", line=" << 1336 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
1337 return (desSize !=0) ? 0 : 1;
1338}
1339
1340uint8_t*
1341PacketMetadata::AddToRawU8 (const uint8_t& data,
1342 uint8_t* start,
1343 uint8_t* current,
1344 uint32_t maxSize)
1345{
1346 NS_LOG_FUNCTION (static_cast<uint32_t> (data) << &start << &current << maxSize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
static_cast<uint32_t> (data) << &start <<
&current << maxSize; std::clog << ")" <<
std::endl; } } while (false);
1347 // First check buffer overflow
1348 if (static_cast<uint32_t> ((current + sizeof (uint8_t) - start)) > maxSize)
1349 {
1350 return 0;
1351 }
1352 memcpy (current, &data, sizeof (uint8_t));
1353 return current + sizeof (uint8_t);
1354}
1355
1356uint8_t*
1357PacketMetadata::AddToRawU16 (const uint16_t& data,
1358 uint8_t* start,
1359 uint8_t* current,
1360 uint32_t maxSize)
1361{
1362 NS_LOG_FUNCTION (data << &start << &current << maxSize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
data << &start << &current << maxSize
; std::clog << ")" << std::endl; } } while (false
);
1363 // First check buffer overflow
1364 if (static_cast<uint32_t> ((current + sizeof (uint16_t) - start)) > maxSize)
1365 {
1366 return 0;
1367 }
1368 memcpy (current, &data, sizeof (uint16_t));
1369 return current + sizeof (uint16_t);
1370}
1371
1372uint8_t*
1373PacketMetadata::AddToRawU32 (const uint32_t& data,
1374 uint8_t* start,
1375 uint8_t* current,
1376 uint32_t maxSize)
1377{
1378 NS_LOG_FUNCTION (data << &start << &current << maxSize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
data << &start << &current << maxSize
; std::clog << ")" << std::endl; } } while (false
);
1379 // First check buffer overflow
1380 if (static_cast<uint32_t> ((current + sizeof (uint32_t) - start)) > maxSize)
1381 {
1382 return 0;
1383 }
1384 memcpy (current, &data, sizeof (uint32_t));
1385 return current + sizeof (uint32_t);
1386}
1387
1388uint8_t*
1389PacketMetadata::AddToRawU64 (const uint64_t& data,
1390 uint8_t* start,
1391 uint8_t* current,
1392 uint32_t maxSize)
1393{
1394 NS_LOG_FUNCTION (data << &start << &current << maxSize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
data << &start << &current << maxSize
; std::clog << ")" << std::endl; } } while (false
);
1395 // First check buffer overflow
1396 if (static_cast<uint32_t> ((current + sizeof (uint64_t) - start)) > maxSize)
1397 {
1398 return 0;
1399 }
1400 memcpy (current, &data, sizeof (uint64_t));
1401 return current + sizeof (uint64_t);
1402}
1403
1404uint8_t*
1405PacketMetadata::AddToRaw (const uint8_t* data,
1406 uint32_t dataSize,
1407 uint8_t* start,
1408 uint8_t* current,
1409 uint32_t maxSize)
1410{
1411 NS_LOG_FUNCTION (&data << dataSize << &start << &current << maxSize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
&data << dataSize << &start << &
current << maxSize; std::clog << ")" << std
::endl; } } while (false);
1412 // First check buffer overflow
1413 if (static_cast<uint32_t> ((current + dataSize - start)) > maxSize)
1414 {
1415 return 0;
1416 }
1417 memcpy (current, data, dataSize);
1418 return current + dataSize;
1419}
1420
1421uint8_t*
1422PacketMetadata::ReadFromRawU8 (uint8_t& data,
1423 const uint8_t* start,
1424 const uint8_t* current,
1425 uint32_t maxSize)
1426{
1427 NS_LOG_FUNCTION (static_cast<uint32_t> (data) << &start << &current << maxSize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
static_cast<uint32_t> (data) << &start <<
&current << maxSize; std::clog << ")" <<
std::endl; } } while (false);
1428 // First check buffer underflow
1429 if (static_cast<uint32_t> ((current + sizeof (uint8_t) - start)) > maxSize)
1430 {
1431 return 0;
1432 }
1433 memcpy (&data, current, sizeof (uint8_t));
1434 return const_cast<uint8_t *> (current) + sizeof (uint8_t);
1435}
1436
1437uint8_t*
1438PacketMetadata::ReadFromRawU16 (uint16_t& data,
1439 const uint8_t* start,
1440 const uint8_t* current,
1441 uint32_t maxSize)
1442{
1443 NS_LOG_FUNCTION (data << &start << &current << maxSize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
data << &start << &current << maxSize
; std::clog << ")" << std::endl; } } while (false
);
1444 // First check buffer underflow
1445 if (static_cast<uint32_t> ((current + sizeof (uint16_t) - start)) > maxSize)
1446 {
1447 return 0;
1448 }
1449 memcpy (&data, current, sizeof (uint16_t));
1450 return const_cast<uint8_t *> (current) + sizeof (uint16_t);
1451}
1452
1453uint8_t*
1454PacketMetadata::ReadFromRawU32 (uint32_t& data,
1455 const uint8_t* start,
1456 const uint8_t* current,
1457 uint32_t maxSize)
1458{
1459 NS_LOG_FUNCTION (data << &start << &current << maxSize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
data << &start << &current << maxSize
; std::clog << ")" << std::endl; } } while (false
);
1460 // First check buffer underflow
1461 if (static_cast<uint32_t> ((current + sizeof (uint32_t) - start)) > maxSize)
1462 {
1463 return 0;
1464 }
1465 memcpy (&data, current, sizeof (uint32_t));
1466 return const_cast<uint8_t *> (current) + sizeof (uint32_t);
1467}
1468
1469uint8_t*
1470PacketMetadata::ReadFromRawU64 (uint64_t& data,
1471 const uint8_t* start,
1472 const uint8_t* current,
1473 uint32_t maxSize)
1474{
1475 NS_LOG_FUNCTION (data << &start << &current << maxSize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled
(ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3::
LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog
); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE
)) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter ();
if (printer != 0) { (*printer)(std::clog); std::clog <<
" "; } }; ; std::clog << g_log.Name () << ":" <<
__FUNCTION__ << "("; ns3::ParameterLogger (std::clog) <<
data << &start << &current << maxSize
; std::clog << ")" << std::endl; } } while (false
);
1476 // First check buffer underflow
1477 if ((uint32_t)((current + sizeof (uint64_t) - start)) > maxSize)
1478 {
1479 return 0;
1480 }
1481 memcpy (&data, current, sizeof (uint64_t));
1482 return const_cast<uint8_t *> (current) + sizeof (uint64_t);
1483}
1484
1485
1486} // namespace ns3
1487