Bug Summary

File:/tmp/asd-nat/home/nat/Work/ns-3-dev-git/build/../src/network/model/buffer.cc
Location:line 635, column 7
Description:Value stored to 'size' is never read

Annotated Source Code

1/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2/*
3 * Copyright (c) 2005,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 "buffer.h"
21#include "ns3/assert.h"
22#include "ns3/log.h"
23
24#define LOG_INTERNAL_STATE(y)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 << y << "start="
<<m_start<<", end="<<m_end<<", zero start="
<<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd
<<", count="<<m_data->m_count<<", size="
<<m_data->m_size<< ", dirty start="<<m_data
->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd
<< std::endl; } } while (false) \
25 NS_LOG_LOGIC (y << "start="<<m_start<<", end="<<m_end<<", zero start="<<m_zeroAreaStart<< \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 << y << "start="
<<m_start<<", end="<<m_end<<", zero start="
<<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd
<<", count="<<m_data->m_count<<", size="
<<m_data->m_size<< ", dirty start="<<m_data
->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd
<< std::endl; } } while (false)
26 ", zero end="<<m_zeroAreaEnd<<", count="<<m_data->m_count<<", size="<<m_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 << y << "start="
<<m_start<<", end="<<m_end<<", zero start="
<<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd
<<", count="<<m_data->m_count<<", size="
<<m_data->m_size<< ", dirty start="<<m_data
->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd
<< std::endl; } } while (false)
27 ", dirty start="<<m_data->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd)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 << y << "start="
<<m_start<<", end="<<m_end<<", zero start="
<<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd
<<", count="<<m_data->m_count<<", size="
<<m_data->m_size<< ", dirty start="<<m_data
->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd
<< std::endl; } } while (false)
28
29namespace {
30
31/**
32 * \ingroup packet
33 * \brief Zero-filled buffer.
34 */
35static struct Zeroes
36{
37 Zeroes ()
38 : size (1000)
39 {
40 memset (buffer, 0, size);
41 }
42 char buffer[1000]; //!< buffer containing zero values
43 const uint32_t size; //!< buffer size
44} g_zeroes; //!< Zero-filled buffer
45
46}
47
48namespace ns3 {
49
50NS_LOG_COMPONENT_DEFINE ("Buffer")static ns3::LogComponent g_log = ns3::LogComponent ("Buffer",
"../src/network/model/buffer.cc");
51
52
53uint32_t Buffer::g_recommendedStart = 0;
54#ifdef BUFFER_FREE_LIST1
55/* The following macros are pretty evil but they are needed to allow us to
56 * keep track of 3 possible states for the g_freeList variable:
57 * - uninitialized means that no one has created a buffer yet
58 * so no one has created the associated free list (it is created
59 * on-demand when the first buffer is created)
60 * - initialized means that the free list exists and is valid
61 * - destroyed means that the static destructors of this compilation unit
62 * have run so, the free list has been cleared from its content
63 * The key is that in destroyed state, we are careful not re-create it
64 * which is a typical weakness of lazy evaluation schemes which use
65 * '0' as a special value to indicate both un-initialized and destroyed.
66 * Note that it is important to use '0' as the marker for un-initialized state
67 * because the variable holding this state information is initialized to zero
68 * which the compiler assigns to zero-memory which is initialized to _zero_
69 * before the constructors run so this ensures perfect handling of crazy
70 * constructor orderings.
71 */
72#define MAGIC_DESTROYED(~(long) 0) (~(long) 0)
73#define IS_UNINITIALIZED(x)(x == (Buffer::FreeList*)0) (x == (Buffer::FreeList*)0)
74#define IS_DESTROYED(x)(x == (Buffer::FreeList*)(~(long) 0)) (x == (Buffer::FreeList*)MAGIC_DESTROYED(~(long) 0))
75#define IS_INITIALIZED(x)(!(x == (Buffer::FreeList*)0) && !(x == (Buffer::FreeList
*)(~(long) 0))) (!IS_UNINITIALIZED (x)(x == (Buffer::FreeList*)0) && !IS_DESTROYED (x)(x == (Buffer::FreeList*)(~(long) 0)))
76#define DESTROYED((Buffer::FreeList*)(~(long) 0)) ((Buffer::FreeList*)MAGIC_DESTROYED(~(long) 0))
77#define UNINITIALIZED((Buffer::FreeList*)0) ((Buffer::FreeList*)0)
78uint32_t Buffer::g_maxSize = 0;
79Buffer::FreeList *Buffer::g_freeList = 0;
80struct Buffer::LocalStaticDestructor Buffer::g_localStaticDestructor;
81
82Buffer::LocalStaticDestructor::~LocalStaticDestructor(void)
83{
84 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);
85 if (IS_INITIALIZED (g_freeList)(!(g_freeList == (Buffer::FreeList*)0) && !(g_freeList
== (Buffer::FreeList*)(~(long) 0))))
86 {
87 for (Buffer::FreeList::iterator i = g_freeList->begin ();
88 i != g_freeList->end (); i++)
89 {
90 Buffer::Deallocate (*i);
91 }
92 delete g_freeList;
93 g_freeList = DESTROYED((Buffer::FreeList*)(~(long) 0));
94 }
95}
96
97void
98Buffer::Recycle (struct Buffer::Data *data)
99{
100 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);
101 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/buffer.cc"
<< ", line=" << 101 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
102 NS_ASSERT (!IS_UNINITIALIZED (g_freeList))do { if (!(!(g_freeList == (Buffer::FreeList*)0))) { std::cerr
<< "assert failed. cond=\"" << "!IS_UNINITIALIZED (g_freeList)"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 102 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
103 g_maxSize = std::max (g_maxSize, data->m_size);
104 /* feed into free list */
105 if (data->m_size < g_maxSize ||
106 IS_DESTROYED (g_freeList)(g_freeList == (Buffer::FreeList*)(~(long) 0)) ||
107 g_freeList->size () > 1000)
108 {
109 Buffer::Deallocate (data);
110 }
111 else
112 {
113 NS_ASSERT (IS_INITIALIZED (g_freeList))do { if (!((!(g_freeList == (Buffer::FreeList*)0) && !
(g_freeList == (Buffer::FreeList*)(~(long) 0))))) { std::cerr
<< "assert failed. cond=\"" << "IS_INITIALIZED (g_freeList)"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 113 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
114 g_freeList->push_back (data);
115 }
116}
117
118Buffer::Data *
119Buffer::Create (uint32_t dataSize)
120{
121 NS_LOG_FUNCTION (dataSize)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) <<
dataSize; std::clog << ")" << std::endl; } } while
(false);
122 /* try to find a buffer correctly sized. */
123 if (IS_UNINITIALIZED (g_freeList)(g_freeList == (Buffer::FreeList*)0))
124 {
125 g_freeList = new Buffer::FreeList ();
126 }
127 else if (IS_INITIALIZED (g_freeList)(!(g_freeList == (Buffer::FreeList*)0) && !(g_freeList
== (Buffer::FreeList*)(~(long) 0))))
128 {
129 while (!g_freeList->empty ())
130 {
131 struct Buffer::Data *data = g_freeList->back ();
132 g_freeList->pop_back ();
133 if (data->m_size >= dataSize)
134 {
135 data->m_count = 1;
136 return data;
137 }
138 Buffer::Deallocate (data);
139 }
140 }
141 struct Buffer::Data *data = Buffer::Allocate (dataSize);
142 NS_ASSERT (data->m_count == 1)do { if (!(data->m_count == 1)) { std::cerr << "assert failed. cond=\""
<< "data->m_count == 1" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 142 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
143 return data;
144}
145#else /* BUFFER_FREE_LIST */
146void
147Buffer::Recycle (struct Buffer::Data *data)
148{
149 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);
150 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/buffer.cc"
<< ", line=" << 150 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
151 Deallocate (data);
152}
153
154Buffer::Data *
155Buffer::Create (uint32_t size)
156{
157 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);
158 return Allocate (size);
159}
160#endif /* BUFFER_FREE_LIST */
161
162struct Buffer::Data *
163Buffer::Allocate (uint32_t reqSize)
164{
165 NS_LOG_FUNCTION (reqSize)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) <<
reqSize; std::clog << ")" << std::endl; } } while
(false);
166 if (reqSize == 0)
167 {
168 reqSize = 1;
169 }
170 NS_ASSERT (reqSize >= 1)do { if (!(reqSize >= 1)) { std::cerr << "assert failed. cond=\""
<< "reqSize >= 1" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/buffer.cc" << ", line="
<< 170 << std::endl; ::ns3::FatalImpl::FlushStreams
(); if (true) std::terminate (); } while (false); } } while (
false);
171 uint32_t size = reqSize - 1 + sizeof (struct Buffer::Data);
172 uint8_t *b = new uint8_t [size];
173 struct Buffer::Data *data = reinterpret_cast<struct Buffer::Data*>(b);
174 data->m_size = reqSize;
175 data->m_count = 1;
176 return data;
177}
178
179void
180Buffer::Deallocate (struct Buffer::Data *data)
181{
182 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);
183 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/buffer.cc"
<< ", line=" << 183 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
184 uint8_t *buf = reinterpret_cast<uint8_t *> (data);
185 delete [] buf;
186}
187
188Buffer::Buffer ()
189{
190 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);
191 Initialize (0);
192}
193
194Buffer::Buffer (uint32_t dataSize)
195{
196 NS_LOG_FUNCTION (this << dataSize)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 << dataSize; std::clog << ")" << std::
endl; } } while (false);
197 Initialize (dataSize);
198}
199
200Buffer::Buffer (uint32_t dataSize, bool initialize)
201{
202 NS_LOG_FUNCTION (this << dataSize << initialize)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 << dataSize << initialize; std::clog <<
")" << std::endl; } } while (false);
203 if (initialize == true)
204 {
205 Initialize (dataSize);
206 }
207}
208
209bool
210Buffer::CheckInternalState (void) const
211{
212 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);
213#if 0
214 // If you want to modify any code in this file, enable this checking code.
215 // Otherwise, there is not much point is enabling it because the
216 // current implementation has been fairly seriously tested and the cost
217 // of this constant checking is pretty high, even for a debug build.
218 bool offsetsOk =
219 m_start <= m_zeroAreaStart &&
220 m_zeroAreaStart <= m_zeroAreaEnd &&
221 m_zeroAreaEnd <= m_end;
222 bool dirtyOk =
223 m_start >= m_data->m_dirtyStart &&
224 m_end <= m_data->m_dirtyEnd;
225 bool internalSizeOk = m_end - (m_zeroAreaEnd - m_zeroAreaStart) <= m_data->m_size &&
226 m_start <= m_data->m_size &&
227 m_zeroAreaStart <= m_data->m_size;
228
229 bool ok = m_data->m_count > 0 && offsetsOk && dirtyOk && internalSizeOk;
230 if (!ok)
231 {
232 LOG_INTERNAL_STATE ("check " << this <<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 << "check " <<
this << ", " << (offsetsOk ? "true" : "false") <<
", " << (dirtyOk ? "true" : "false") << ", " <<
(internalSizeOk ? "true" : "false") << " " << "start="
<<m_start<<", end="<<m_end<<", zero start="
<<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd
<<", count="<<m_data->m_count<<", size="
<<m_data->m_size<< ", dirty start="<<m_data
->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd
<< std::endl; } } while (false)
233 ", " << (offsetsOk ? "true" : "false") <<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 << "check " <<
this << ", " << (offsetsOk ? "true" : "false") <<
", " << (dirtyOk ? "true" : "false") << ", " <<
(internalSizeOk ? "true" : "false") << " " << "start="
<<m_start<<", end="<<m_end<<", zero start="
<<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd
<<", count="<<m_data->m_count<<", size="
<<m_data->m_size<< ", dirty start="<<m_data
->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd
<< std::endl; } } while (false)
234 ", " << (dirtyOk ? "true" : "false") <<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 << "check " <<
this << ", " << (offsetsOk ? "true" : "false") <<
", " << (dirtyOk ? "true" : "false") << ", " <<
(internalSizeOk ? "true" : "false") << " " << "start="
<<m_start<<", end="<<m_end<<", zero start="
<<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd
<<", count="<<m_data->m_count<<", size="
<<m_data->m_size<< ", dirty start="<<m_data
->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd
<< std::endl; } } while (false)
235 ", " << (internalSizeOk ? "true" : "false") << " ")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 << "check " <<
this << ", " << (offsetsOk ? "true" : "false") <<
", " << (dirtyOk ? "true" : "false") << ", " <<
(internalSizeOk ? "true" : "false") << " " << "start="
<<m_start<<", end="<<m_end<<", zero start="
<<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd
<<", count="<<m_data->m_count<<", size="
<<m_data->m_size<< ", dirty start="<<m_data
->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd
<< std::endl; } } while (false);
236 }
237 return ok;
238#else
239 return true;
240#endif
241}
242
243void
244Buffer::Initialize (uint32_t zeroSize)
245{
246 NS_LOG_FUNCTION (this << zeroSize)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 << zeroSize; std::clog << ")" << std::
endl; } } while (false);
247 m_data = Buffer::Create (0);
248 m_start = std::min (m_data->m_size, g_recommendedStart);
249 m_maxZeroAreaStart = m_start;
250 m_zeroAreaStart = m_start;
251 m_zeroAreaEnd = m_zeroAreaStart + zeroSize;
252 m_end = m_zeroAreaEnd;
253 m_data->m_dirtyStart = m_start;
254 m_data->m_dirtyEnd = m_end;
255 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 255 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
256}
257
258Buffer &
259Buffer::operator = (Buffer const&o)
260{
261 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 261 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
262 if (m_data != o.m_data)
263 {
264 // not assignment to self.
265 m_data->m_count--;
266 if (m_data->m_count == 0)
267 {
268 Recycle (m_data);
269 }
270 m_data = o.m_data;
271 m_data->m_count++;
272 }
273 g_recommendedStart = std::max (g_recommendedStart, m_maxZeroAreaStart);
274 m_maxZeroAreaStart = o.m_maxZeroAreaStart;
275 m_zeroAreaStart = o.m_zeroAreaStart;
276 m_zeroAreaEnd = o.m_zeroAreaEnd;
277 m_start = o.m_start;
278 m_end = o.m_end;
279 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 279 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
280 return *this;
281}
282
283Buffer::~Buffer ()
284{
285 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);
286 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 286 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
287 g_recommendedStart = std::max (g_recommendedStart, m_maxZeroAreaStart);
288 m_data->m_count--;
289 if (m_data->m_count == 0)
290 {
291 Recycle (m_data);
292 }
293}
294
295uint32_t
296Buffer::GetInternalSize (void) const
297{
298 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);
299 return m_zeroAreaStart - m_start + m_end - m_zeroAreaEnd;
300}
301uint32_t
302Buffer::GetInternalEnd (void) const
303{
304 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);
305 return m_end - (m_zeroAreaEnd - m_zeroAreaStart);
306}
307
308void
309Buffer::AddAtStart (uint32_t start)
310{
311 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);
312 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 312 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
313 bool isDirty = m_data->m_count > 1 && m_start > m_data->m_dirtyStart;
314 if (m_start >= start && !isDirty)
315 {
316 /* enough space in the buffer and not dirty.
317 * To add: |..|
318 * Before: |*****---------***|
319 * After: |***..---------***|
320 */
321 NS_ASSERT (m_data->m_count == 1 || m_start == m_data->m_dirtyStart)do { if (!(m_data->m_count == 1 || m_start == m_data->m_dirtyStart
)) { std::cerr << "assert failed. cond=\"" << "m_data->m_count == 1 || m_start == m_data->m_dirtyStart"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 321 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
322 m_start -= start;
323 // update dirty area
324 m_data->m_dirtyStart = m_start;
325 }
326 else
327 {
328 uint32_t newSize = GetInternalSize () + start;
329 struct Buffer::Data *newData = Buffer::Create (newSize);
330 memcpy (newData->m_data + start, m_data->m_data + m_start, GetInternalSize ());
331 m_data->m_count--;
332 if (m_data->m_count == 0)
333 {
334 Buffer::Recycle (m_data);
335 }
336 m_data = newData;
337
338 int32_t delta = start - m_start;
339 m_start += delta;
340 m_zeroAreaStart += delta;
341 m_zeroAreaEnd += delta;
342 m_end += delta;
343 m_start -= start;
344
345 // update dirty area
346 m_data->m_dirtyStart = m_start;
347 m_data->m_dirtyEnd = m_end;
348 }
349 m_maxZeroAreaStart = std::max (m_maxZeroAreaStart, m_zeroAreaStart);
350 LOG_INTERNAL_STATE ("add start=" << start << ", ")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 << "add start="
<< start << ", " << "start="<<m_start
<<", end="<<m_end<<", zero start="<<m_zeroAreaStart
<< ", zero end="<<m_zeroAreaEnd<<", count="
<<m_data->m_count<<", size="<<m_data->
m_size<< ", dirty start="<<m_data->m_dirtyStart
<<", dirty end="<<m_data->m_dirtyEnd << std
::endl; } } while (false);
351 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 351 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
352}
353void
354Buffer::AddAtEnd (uint32_t end)
355{
356 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);
357 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 357 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
358 bool isDirty = m_data->m_count > 1 && m_end < m_data->m_dirtyEnd;
359 if (GetInternalEnd () + end <= m_data->m_size && !isDirty)
360 {
361 /* enough space in buffer and not dirty
362 * Add: |...|
363 * Before: |**----*****|
364 * After: |**----...**|
365 */
366 NS_ASSERT (m_data->m_count == 1 || m_end == m_data->m_dirtyEnd)do { if (!(m_data->m_count == 1 || m_end == m_data->m_dirtyEnd
)) { std::cerr << "assert failed. cond=\"" << "m_data->m_count == 1 || m_end == m_data->m_dirtyEnd"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 366 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
367 m_end += end;
368 // update dirty area.
369 m_data->m_dirtyEnd = m_end;
370 }
371 else
372 {
373 uint32_t newSize = GetInternalSize () + end;
374 struct Buffer::Data *newData = Buffer::Create (newSize);
375 memcpy (newData->m_data, m_data->m_data + m_start, GetInternalSize ());
376 m_data->m_count--;
377 if (m_data->m_count == 0)
378 {
379 Buffer::Recycle (m_data);
380 }
381 m_data = newData;
382
383 int32_t delta = -m_start;
384 m_zeroAreaStart += delta;
385 m_zeroAreaEnd += delta;
386 m_end += delta;
387 m_start += delta;
388 m_end += end;
389
390 // update dirty area
391 m_data->m_dirtyStart = m_start;
392 m_data->m_dirtyEnd = m_end;
393 }
394 m_maxZeroAreaStart = std::max (m_maxZeroAreaStart, m_zeroAreaStart);
395 LOG_INTERNAL_STATE ("add end=" << end << ", ")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 << "add end=" <<
end << ", " << "start="<<m_start<<", end="
<<m_end<<", zero start="<<m_zeroAreaStart<<
", zero end="<<m_zeroAreaEnd<<", count="<<
m_data->m_count<<", size="<<m_data->m_size<<
", dirty start="<<m_data->m_dirtyStart<<", dirty end="
<<m_data->m_dirtyEnd << std::endl; } } while (
false);
396 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 396 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
397}
398
399void
400Buffer::AddAtEnd (const Buffer &o)
401{
402 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);
403 if (m_data->m_count == 1 &&
404 m_end == m_zeroAreaEnd &&
405 m_end == m_data->m_dirtyEnd &&
406 o.m_start == o.m_zeroAreaStart &&
407 o.m_zeroAreaEnd - o.m_zeroAreaStart > 0)
408 {
409 /**
410 * This is an optimization which kicks in when
411 * we attempt to aggregate two buffers which contain
412 * adjacent zero areas.
413 */
414 uint32_t zeroSize = o.m_zeroAreaEnd - o.m_zeroAreaStart;
415 m_zeroAreaEnd += zeroSize;
416 m_end = m_zeroAreaEnd;
417 m_data->m_dirtyEnd = m_zeroAreaEnd;
418 uint32_t endData = o.m_end - o.m_zeroAreaEnd;
419 AddAtEnd (endData);
420 Buffer::Iterator dst = End ();
421 dst.Prev (endData);
422 Buffer::Iterator src = o.End ();
423 src.Prev (endData);
424 dst.Write (src, o.End ());
425 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 425 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
426 return;
427 }
428
429 Buffer dst = CreateFullCopy ();
430 Buffer src = o.CreateFullCopy ();
431
432 dst.AddAtEnd (src.GetSize ());
433 Buffer::Iterator destStart = dst.End ();
434 destStart.Prev (src.GetSize ());
435 destStart.Write (src.Begin (), src.End ());
436 *this = dst;
437 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 437 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
438}
439
440void
441Buffer::RemoveAtStart (uint32_t start)
442{
443 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);
444 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 444 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
445 uint32_t newStart = m_start + start;
446 if (newStart <= m_zeroAreaStart)
447 {
448 /* only remove start of buffer
449 */
450 m_start = newStart;
451 }
452 else if (newStart <= m_zeroAreaEnd)
453 {
454 /* remove start of buffer _and_ start of zero area
455 */
456 uint32_t delta = newStart - m_zeroAreaStart;
457 m_start = m_zeroAreaStart;
458 m_zeroAreaEnd -= delta;
459 m_end -= delta;
460 }
461 else if (newStart <= m_end)
462 {
463 /* remove start of buffer, complete zero area, and part
464 * of end of buffer
465 */
466 NS_ASSERT (m_end >= start)do { if (!(m_end >= start)) { std::cerr << "assert failed. cond=\""
<< "m_end >= start" << "\", "; do { std::cerr
<< "file=" << "../src/network/model/buffer.cc" <<
", line=" << 466 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
467 uint32_t zeroSize = m_zeroAreaEnd - m_zeroAreaStart;
468 m_start = newStart - zeroSize;
469 m_end -= zeroSize;
470 m_zeroAreaStart = m_start;
471 m_zeroAreaEnd = m_start;
472 }
473 else
474 {
475 /* remove all buffer */
476 m_end -= m_zeroAreaEnd - m_zeroAreaStart;
477 m_start = m_end;
478 m_zeroAreaEnd = m_end;
479 m_zeroAreaStart = m_end;
480 }
481 m_maxZeroAreaStart = std::max (m_maxZeroAreaStart, m_zeroAreaStart);
482 LOG_INTERNAL_STATE ("rem start=" << start << ", ")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 << "rem start="
<< start << ", " << "start="<<m_start
<<", end="<<m_end<<", zero start="<<m_zeroAreaStart
<< ", zero end="<<m_zeroAreaEnd<<", count="
<<m_data->m_count<<", size="<<m_data->
m_size<< ", dirty start="<<m_data->m_dirtyStart
<<", dirty end="<<m_data->m_dirtyEnd << std
::endl; } } while (false);
483 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 483 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
484}
485void
486Buffer::RemoveAtEnd (uint32_t end)
487{
488 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);
489 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 489 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
490 uint32_t newEnd = m_end - std::min (end, m_end - m_start);
491 if (newEnd > m_zeroAreaEnd)
492 {
493 /* remove part of end of buffer */
494 m_end = newEnd;
495 }
496 else if (newEnd > m_zeroAreaStart)
497 {
498 /* remove end of buffer, part of zero area */
499 m_end = newEnd;
500 m_zeroAreaEnd = newEnd;
501 }
502 else if (newEnd > m_start)
503 {
504 /* remove end of buffer, zero area, part of start of buffer */
505 m_end = newEnd;
506 m_zeroAreaEnd = newEnd;
507 m_zeroAreaStart = newEnd;
508 }
509 else
510 {
511 /* remove all buffer */
512 m_end = m_start;
513 m_zeroAreaEnd = m_start;
514 m_zeroAreaStart = m_start;
515 }
516 m_maxZeroAreaStart = std::max (m_maxZeroAreaStart, m_zeroAreaStart);
517 LOG_INTERNAL_STATE ("rem end=" << end << ", ")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 << "rem end=" <<
end << ", " << "start="<<m_start<<", end="
<<m_end<<", zero start="<<m_zeroAreaStart<<
", zero end="<<m_zeroAreaEnd<<", count="<<
m_data->m_count<<", size="<<m_data->m_size<<
", dirty start="<<m_data->m_dirtyStart<<", dirty end="
<<m_data->m_dirtyEnd << std::endl; } } while (
false);
518 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 518 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
519}
520
521Buffer
522Buffer::CreateFragment (uint32_t start, uint32_t length) const
523{
524 NS_LOG_FUNCTION (this << start << length)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 << length; std::clog << ")" <<
std::endl; } } while (false);
525 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 525 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
526 Buffer tmp = *this;
527 tmp.RemoveAtStart (start);
528 tmp.RemoveAtEnd (GetSize () - (start + length));
529 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 529 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
530 return tmp;
531}
532
533Buffer
534Buffer::CreateFullCopy (void) const
535{
536 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);
537 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 537 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
538 if (m_zeroAreaEnd - m_zeroAreaStart != 0)
539 {
540 Buffer tmp;
541 tmp.AddAtStart (m_zeroAreaEnd - m_zeroAreaStart);
542 tmp.Begin ().WriteU8 (0, m_zeroAreaEnd - m_zeroAreaStart);
543 uint32_t dataStart = m_zeroAreaStart - m_start;
544 tmp.AddAtStart (dataStart);
545 tmp.Begin ().Write (m_data->m_data+m_start, dataStart);
546 uint32_t dataEnd = m_end - m_zeroAreaEnd;
547 tmp.AddAtEnd (dataEnd);
548 Buffer::Iterator i = tmp.End ();
549 i.Prev (dataEnd);
550 i.Write (m_data->m_data+m_zeroAreaStart,dataEnd);
551 NS_ASSERT (tmp.CheckInternalState ())do { if (!(tmp.CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "tmp.CheckInternalState ()" << "\", "; do { std
::cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 551 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
552 return tmp;
553 }
554 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 554 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
555 return *this;
556}
557
558uint32_t
559Buffer::GetSerializedSize (void) const
560{
561 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);
562 uint32_t dataStart = (m_zeroAreaStart - m_start + 3) & (~0x3);
563 uint32_t dataEnd = (m_end - m_zeroAreaEnd + 3) & (~0x3);
564
565 // total size 4-bytes for dataStart length
566 // + X number of bytes for dataStart
567 // + 4-bytes for dataEnd length
568 // + X number of bytes for dataEnd
569 uint32_t sz = sizeof (uint32_t)
570 + sizeof (uint32_t)
571 + dataStart
572 + sizeof (uint32_t)
573 + dataEnd;
574
575 return sz;
576}
577
578uint32_t
579Buffer::Serialize (uint8_t* buffer, uint32_t maxSize) const
580{
581 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);
582 uint32_t* p = reinterpret_cast<uint32_t *> (buffer);
583 uint32_t size = 0;
584
585 // Add the zero data length
586 if (size + 4 <= maxSize)
587 {
588 size += 4;
589 *p++ = m_zeroAreaEnd - m_zeroAreaStart;
590 }
591 else
592 {
593 return 0;
594 }
595
596 // Add the length of actual start data
597 uint32_t dataStartLength = m_zeroAreaStart - m_start;
598 if (size + 4 <= maxSize)
599 {
600 size += 4;
601 *p++ = dataStartLength;
602 }
603 else
604 {
605 return 0;
606 }
607
608 // Add the actual data
609 if (size + ((dataStartLength + 3) & (~3)) <= maxSize)
610 {
611 size += (dataStartLength + 3) & (~3);
612 memcpy (p, m_data->m_data + m_start, dataStartLength);
613 p += (((dataStartLength + 3) & (~3))/4); // Advance p, insuring 4 byte boundary
614 }
615 else
616 {
617 return 0;
618 }
619
620 // Add the length of the actual end data
621 uint32_t dataEndLength = m_end - m_zeroAreaEnd;
622 if (size + 4 <= maxSize)
623 {
624 size += 4;
625 *p++ = dataEndLength;
626 }
627 else
628 {
629 return 0;
630 }
631
632 // Add the actual data
633 if (size + ((dataEndLength + 3) & (~3)) <= maxSize)
634 {
635 size += (dataEndLength + 3) & (~3);
Value stored to 'size' is never read
636 memcpy (p, m_data->m_data+m_zeroAreaStart,dataEndLength);
637 p += (((dataEndLength + 3) & (~3))/4); // Advance p, insuring 4 byte boundary
638 }
639 else
640 {
641 return 0;
642 }
643
644 // Serialzed everything successfully
645 return 1;
646}
647
648uint32_t
649Buffer::Deserialize (const uint8_t *buffer, uint32_t size)
650{
651 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);
652 const uint32_t* p = reinterpret_cast<const uint32_t *> (buffer);
653 uint32_t sizeCheck = size-4;
654
655 NS_ASSERT (sizeCheck >= 4)do { if (!(sizeCheck >= 4)) { std::cerr << "assert failed. cond=\""
<< "sizeCheck >= 4" << "\", "; do { std::cerr
<< "file=" << "../src/network/model/buffer.cc" <<
", line=" << 655 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
656 uint32_t zeroDataLength = *p++;
657 sizeCheck -= 4;
658
659 // Create zero bytes
660 Initialize (zeroDataLength);
661
662 // Add start data
663 NS_ASSERT (sizeCheck >= 4)do { if (!(sizeCheck >= 4)) { std::cerr << "assert failed. cond=\""
<< "sizeCheck >= 4" << "\", "; do { std::cerr
<< "file=" << "../src/network/model/buffer.cc" <<
", line=" << 663 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
664 uint32_t dataStartLength = *p++;
665 sizeCheck -= 4;
666 AddAtStart (dataStartLength);
667
668 NS_ASSERT (sizeCheck >= dataStartLength)do { if (!(sizeCheck >= dataStartLength)) { std::cerr <<
"assert failed. cond=\"" << "sizeCheck >= dataStartLength"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 668 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
669 Begin ().Write (reinterpret_cast<uint8_t *> (const_cast<uint32_t *> (p)), dataStartLength);
670 p += (((dataStartLength+3)&(~3))/4); // Advance p, insuring 4 byte boundary
671 sizeCheck -= ((dataStartLength+3)&(~3));
672
673 // Add end data
674 NS_ASSERT (sizeCheck >= 4)do { if (!(sizeCheck >= 4)) { std::cerr << "assert failed. cond=\""
<< "sizeCheck >= 4" << "\", "; do { std::cerr
<< "file=" << "../src/network/model/buffer.cc" <<
", line=" << 674 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
675 uint32_t dataEndLength = *p++;
676 sizeCheck -= 4;
677 AddAtEnd (dataEndLength);
678
679 NS_ASSERT (sizeCheck >= dataEndLength)do { if (!(sizeCheck >= dataEndLength)) { std::cerr <<
"assert failed. cond=\"" << "sizeCheck >= dataEndLength"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 679 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
680 Buffer::Iterator tmp = End ();
681 tmp.Prev (dataEndLength);
682 tmp.Write (reinterpret_cast<uint8_t *> (const_cast<uint32_t *> (p)), dataEndLength);
683 p += (((dataEndLength+3)&(~3))/4); // Advance p, insuring 4 byte boundary
684 sizeCheck -= ((dataEndLength+3)&(~3));
685
686 NS_ASSERT (sizeCheck == 0)do { if (!(sizeCheck == 0)) { std::cerr << "assert failed. cond=\""
<< "sizeCheck == 0" << "\", "; do { std::cerr <<
"file=" << "../src/network/model/buffer.cc" << ", line="
<< 686 << std::endl; ::ns3::FatalImpl::FlushStreams
(); if (true) std::terminate (); } while (false); } } while (
false);
687 // return zero if buffer did not
688 // contain a complete message
689 return (sizeCheck != 0) ? 0 : 1;
690}
691
692
693void
694Buffer::TransformIntoRealBuffer (void) const
695{
696 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);
697 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 697 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
698 Buffer tmp = CreateFullCopy ();
699 *const_cast<Buffer *> (this) = tmp;
700 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 700 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
701}
702
703
704uint8_t const*
705Buffer::PeekData (void) const
706{
707 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);
708 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 708 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
709 TransformIntoRealBuffer ();
710 NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\""
<< "CheckInternalState ()" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 710 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
711 return m_data->m_data + m_start;
712}
713
714void
715Buffer::CopyData (std::ostream *os, uint32_t size) const
716{
717 NS_LOG_FUNCTION (this << &os << 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 << &os << size; std::clog << ")" <<
std::endl; } } while (false);
718 if (size > 0)
719 {
720 uint32_t tmpsize = std::min (m_zeroAreaStart-m_start, size);
721 os->write ((const char*)(m_data->m_data + m_start), tmpsize);
722 if (size > tmpsize)
723 {
724 size -= m_zeroAreaStart-m_start;
725 tmpsize = std::min (m_zeroAreaEnd - m_zeroAreaStart, size);
726 uint32_t left = tmpsize;
727 while (left > 0)
728 {
729 uint32_t toWrite = std::min (left, g_zeroes.size);
730 os->write (g_zeroes.buffer, toWrite);
731 left -= toWrite;
732 }
733 if (size > tmpsize)
734 {
735 size -= tmpsize;
736 tmpsize = std::min (m_end - m_zeroAreaEnd, size);
737 os->write ((const char*)(m_data->m_data + m_zeroAreaStart), tmpsize);
738 }
739 }
740 }
741}
742
743uint32_t
744Buffer::CopyData (uint8_t *buffer, uint32_t size) const
745{
746 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);
747 uint32_t originalSize = size;
748 if (size > 0)
749 {
750 uint32_t tmpsize = std::min (m_zeroAreaStart-m_start, size);
751 memcpy (buffer, (const char*)(m_data->m_data + m_start), tmpsize);
752 buffer += tmpsize;
753 size -= tmpsize;
754 if (size > 0)
755 {
756 tmpsize = std::min (m_zeroAreaEnd - m_zeroAreaStart, size);
757 uint32_t left = tmpsize;
758 while (left > 0)
759 {
760 uint32_t toWrite = std::min (left, g_zeroes.size);
761 memcpy (buffer, g_zeroes.buffer, toWrite);
762 left -= toWrite;
763 buffer += toWrite;
764 }
765 size -= tmpsize;
766 if (size > 0)
767 {
768 tmpsize = std::min (m_end - m_zeroAreaEnd, size);
769 memcpy (buffer, (const char*)(m_data->m_data + m_zeroAreaStart), tmpsize);
770 size -= tmpsize;
771 }
772 }
773 }
774 return originalSize - size;
775}
776
777/******************************************************
778 * The buffer iterator below.
779 ******************************************************/
780
781
782uint32_t
783Buffer::Iterator::GetDistanceFrom (Iterator const &o) const
784{
785 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);
786 NS_ASSERT (m_data == o.m_data)do { if (!(m_data == o.m_data)) { std::cerr << "assert failed. cond=\""
<< "m_data == o.m_data" << "\", "; do { std::cerr
<< "file=" << "../src/network/model/buffer.cc" <<
", line=" << 786 << std::endl; ::ns3::FatalImpl::
FlushStreams (); if (true) std::terminate (); } while (false)
; } } while (false);
787 int32_t diff = m_current - o.m_current;
788 if (diff < 0)
789 {
790 return -diff;
791 }
792 else
793 {
794 return diff;
795 }
796}
797
798bool
799Buffer::Iterator::IsEnd (void) const
800{
801 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);
802 return m_current == m_dataEnd;
803}
804bool
805Buffer::Iterator::IsStart (void) const
806{
807 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);
808 return m_current == m_dataStart;
809}
810
811bool
812Buffer::Iterator::CheckNoZero (uint32_t start, uint32_t end) const
813{
814 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);
815 for (uint32_t i = start; i < end; i++)
816 {
817 if (!Check (i))
818 {
819 return false;
820 }
821 }
822 return true;
823}
824bool
825Buffer::Iterator::Check (uint32_t i) const
826{
827 NS_LOG_FUNCTION (this << &i)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 << &i; std::clog << ")" << std::endl
; } } while (false);
828 return i >= m_dataStart &&
829 !(i >= m_zeroStart && i < m_zeroEnd) &&
830 i <= m_dataEnd;
831}
832
833
834void
835Buffer::Iterator::Write (Iterator start, Iterator end)
836{
837 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);
838 NS_ASSERT (start.m_data == end.m_data)do { if (!(start.m_data == end.m_data)) { std::cerr << "assert failed. cond=\""
<< "start.m_data == end.m_data" << "\", "; do { std
::cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 838 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
839 NS_ASSERT (start.m_current <= end.m_current)do { if (!(start.m_current <= end.m_current)) { std::cerr <<
"assert failed. cond=\"" << "start.m_current <= end.m_current"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 839 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
840 NS_ASSERT (start.m_zeroStart == end.m_zeroStart)do { if (!(start.m_zeroStart == end.m_zeroStart)) { std::cerr
<< "assert failed. cond=\"" << "start.m_zeroStart == end.m_zeroStart"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 840 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
841 NS_ASSERT (start.m_zeroEnd == end.m_zeroEnd)do { if (!(start.m_zeroEnd == end.m_zeroEnd)) { std::cerr <<
"assert failed. cond=\"" << "start.m_zeroEnd == end.m_zeroEnd"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 841 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
842 NS_ASSERT (m_data != start.m_data)do { if (!(m_data != start.m_data)) { std::cerr << "assert failed. cond=\""
<< "m_data != start.m_data" << "\", "; do { std::
cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 842 << std::endl; ::ns3::FatalImpl
::FlushStreams (); if (true) std::terminate (); } while (false
); } } while (false);
843 uint32_t size = end.m_current - start.m_current;
844 NS_ASSERT_MSG (CheckNoZero (m_current, m_current + size),do { if (!(CheckNoZero (m_current, m_current + size))) { std::
cerr << "assert failed. cond=\"" << "CheckNoZero (m_current, m_current + size)"
<< "\", "; do { std::cerr << "msg=\"" << GetWriteErrorMessage
() << "\", "; do { std::cerr << "file=" <<
"../src/network/model/buffer.cc" << ", line=" <<
845 << std::endl; ::ns3::FatalImpl::FlushStreams (); if
(true) std::terminate (); } while (false); } while (false); }
} while (false)
845 GetWriteErrorMessage ())do { if (!(CheckNoZero (m_current, m_current + size))) { std::
cerr << "assert failed. cond=\"" << "CheckNoZero (m_current, m_current + size)"
<< "\", "; do { std::cerr << "msg=\"" << GetWriteErrorMessage
() << "\", "; do { std::cerr << "file=" <<
"../src/network/model/buffer.cc" << ", line=" <<
845 << std::endl; ::ns3::FatalImpl::FlushStreams (); if
(true) std::terminate (); } while (false); } while (false); }
} while (false);
846 if (start.m_current <= start.m_zeroStart)
847 {
848 uint32_t toCopy = std::min (size, start.m_zeroStart - start.m_current);
849 memcpy (&m_data[m_current], &start.m_data[start.m_current], toCopy);
850 start.m_current += toCopy;
851 m_current += toCopy;
852 size -= toCopy;
853 }
854 if (start.m_current <= start.m_zeroEnd)
855 {
856 uint32_t toCopy = std::min (size, start.m_zeroEnd - start.m_current);
857 memset (&m_data[m_current], 0, toCopy);
858 start.m_current += toCopy;
859 m_current += toCopy;
860 size -= toCopy;
861 }
862 uint32_t toCopy = std::min (size, start.m_dataEnd - start.m_current);
863 uint8_t *from = &start.m_data[start.m_current - (start.m_zeroEnd-start.m_zeroStart)];
864 uint8_t *to = &m_data[m_current];
865 memcpy (to, from, toCopy);
866 m_current += toCopy;
867}
868
869void
870Buffer::Iterator::WriteU16 (uint16_t data)
871{
872 NS_LOG_FUNCTION (this << 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) <<
this << data; std::clog << ")" << std::endl
; } } while (false);
873 WriteU8 (data & 0xff);
874 data >>= 8;
875 WriteU8 (data & 0xff);
876}
877void
878Buffer::Iterator::WriteU32 (uint32_t data)
879{
880 NS_LOG_FUNCTION (this << 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) <<
this << data; std::clog << ")" << std::endl
; } } while (false);
881 WriteU8 (data & 0xff);
882 data >>= 8;
883 WriteU8 (data & 0xff);
884 data >>= 8;
885 WriteU8 (data & 0xff);
886 data >>= 8;
887 WriteU8 (data & 0xff);
888}
889void
890Buffer::Iterator::WriteU64 (uint64_t data)
891{
892 NS_LOG_FUNCTION (this << 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) <<
this << data; std::clog << ")" << std::endl
; } } while (false);
893 WriteU8 (data & 0xff);
894 data >>= 8;
895 WriteU8 (data & 0xff);
896 data >>= 8;
897 WriteU8 (data & 0xff);
898 data >>= 8;
899 WriteU8 (data & 0xff);
900 data >>= 8;
901 WriteU8 (data & 0xff);
902 data >>= 8;
903 WriteU8 (data & 0xff);
904 data >>= 8;
905 WriteU8 (data & 0xff);
906 data >>= 8;
907 WriteU8 (data & 0xff);
908}
909void
910Buffer::Iterator::WriteHtolsbU16 (uint16_t data)
911{
912 NS_LOG_FUNCTION (this << 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) <<
this << data; std::clog << ")" << std::endl
; } } while (false);
913 WriteU8 ((data >> 0) & 0xff);
914 WriteU8 ((data >> 8) & 0xff);
915}
916void
917Buffer::Iterator::WriteHtolsbU32 (uint32_t data)
918{
919 NS_LOG_FUNCTION (this << 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) <<
this << data; std::clog << ")" << std::endl
; } } while (false);
920 WriteU8 ((data >> 0) & 0xff);
921 WriteU8 ((data >> 8) & 0xff);
922 WriteU8 ((data >> 16) & 0xff);
923 WriteU8 ((data >> 24) & 0xff);
924}
925void
926Buffer::Iterator::WriteHtolsbU64 (uint64_t data)
927{
928 NS_LOG_FUNCTION (this << 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) <<
this << data; std::clog << ")" << std::endl
; } } while (false);
929 WriteU8 ((data >> 0) & 0xff);
930 WriteU8 ((data >> 8) & 0xff);
931 WriteU8 ((data >> 16) & 0xff);
932 WriteU8 ((data >> 24) & 0xff);
933 WriteU8 ((data >> 32) & 0xff);
934 WriteU8 ((data >> 40) & 0xff);
935 WriteU8 ((data >> 48) & 0xff);
936 WriteU8 ((data >> 56) & 0xff);
937}
938
939void
940Buffer::Iterator::WriteHtonU64 (uint64_t data)
941{
942 NS_LOG_FUNCTION (this << 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) <<
this << data; std::clog << ")" << std::endl
; } } while (false);
943 WriteU8 ((data >> 56) & 0xff);
944 WriteU8 ((data >> 48) & 0xff);
945 WriteU8 ((data >> 40) & 0xff);
946 WriteU8 ((data >> 32) & 0xff);
947 WriteU8 ((data >> 24) & 0xff);
948 WriteU8 ((data >> 16) & 0xff);
949 WriteU8 ((data >> 8) & 0xff);
950 WriteU8 ((data >> 0) & 0xff);
951}
952void
953Buffer::Iterator::Write (uint8_t const*buffer, uint32_t size)
954{
955 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);
956 NS_ASSERT_MSG (CheckNoZero (m_current, size),do { if (!(CheckNoZero (m_current, size))) { std::cerr <<
"assert failed. cond=\"" << "CheckNoZero (m_current, size)"
<< "\", "; do { std::cerr << "msg=\"" << GetWriteErrorMessage
() << "\", "; do { std::cerr << "file=" <<
"../src/network/model/buffer.cc" << ", line=" <<
957 << std::endl; ::ns3::FatalImpl::FlushStreams (); if
(true) std::terminate (); } while (false); } while (false); }
} while (false)
957 GetWriteErrorMessage ())do { if (!(CheckNoZero (m_current, size))) { std::cerr <<
"assert failed. cond=\"" << "CheckNoZero (m_current, size)"
<< "\", "; do { std::cerr << "msg=\"" << GetWriteErrorMessage
() << "\", "; do { std::cerr << "file=" <<
"../src/network/model/buffer.cc" << ", line=" <<
957 << std::endl; ::ns3::FatalImpl::FlushStreams (); if
(true) std::terminate (); } while (false); } while (false); }
} while (false);
958 uint8_t *to;
959 if (m_current <= m_zeroStart)
960 {
961 to = &m_data[m_current];
962 }
963 else
964 {
965 to = &m_data[m_current - (m_zeroEnd - m_zeroStart)];
966 }
967 memcpy (to, buffer, size);
968 m_current += size;
969}
970
971uint32_t
972Buffer::Iterator::ReadU32 (void)
973{
974 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);
975 uint8_t byte0 = ReadU8 ();
976 uint8_t byte1 = ReadU8 ();
977 uint8_t byte2 = ReadU8 ();
978 uint8_t byte3 = ReadU8 ();
979 uint32_t data = byte3;
980 data <<= 8;
981 data |= byte2;
982 data <<= 8;
983 data |= byte1;
984 data <<= 8;
985 data |= byte0;
986 return data;
987}
988uint64_t
989Buffer::Iterator::ReadU64 (void)
990{
991 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);
992 uint8_t byte0 = ReadU8 ();
993 uint8_t byte1 = ReadU8 ();
994 uint8_t byte2 = ReadU8 ();
995 uint8_t byte3 = ReadU8 ();
996 uint8_t byte4 = ReadU8 ();
997 uint8_t byte5 = ReadU8 ();
998 uint8_t byte6 = ReadU8 ();
999 uint8_t byte7 = ReadU8 ();
1000 uint64_t data = byte7;
1001 data <<= 8;
1002 data |= byte6;
1003 data <<= 8;
1004 data |= byte5;
1005 data <<= 8;
1006 data |= byte4;
1007 data <<= 8;
1008 data |= byte3;
1009 data <<= 8;
1010 data |= byte2;
1011 data <<= 8;
1012 data |= byte1;
1013 data <<= 8;
1014 data |= byte0;
1015
1016 return data;
1017}
1018uint16_t
1019Buffer::Iterator::SlowReadNtohU16 (void)
1020{
1021 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);
1022 uint16_t retval = 0;
1023 retval |= ReadU8 ();
1024 retval <<= 8;
1025 retval |= ReadU8 ();
1026 return retval;
1027}
1028uint32_t
1029Buffer::Iterator::SlowReadNtohU32 (void)
1030{
1031 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);
1032 uint32_t retval = 0;
1033 retval |= ReadU8 ();
1034 retval <<= 8;
1035 retval |= ReadU8 ();
1036 retval <<= 8;
1037 retval |= ReadU8 ();
1038 retval <<= 8;
1039 retval |= ReadU8 ();
1040 return retval;
1041}
1042uint64_t
1043Buffer::Iterator::ReadNtohU64 (void)
1044{
1045 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);
1046 uint64_t retval = 0;
1047 retval |= ReadU8 ();
1048 retval <<= 8;
1049 retval |= ReadU8 ();
1050 retval <<= 8;
1051 retval |= ReadU8 ();
1052 retval <<= 8;
1053 retval |= ReadU8 ();
1054 retval <<= 8;
1055 retval |= ReadU8 ();
1056 retval <<= 8;
1057 retval |= ReadU8 ();
1058 retval <<= 8;
1059 retval |= ReadU8 ();
1060 retval <<= 8;
1061 retval |= ReadU8 ();
1062 return retval;
1063}
1064uint16_t
1065Buffer::Iterator::ReadLsbtohU16 (void)
1066{
1067 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);
1068 uint8_t byte0 = ReadU8 ();
1069 uint8_t byte1 = ReadU8 ();
1070 uint16_t data = byte1;
1071 data <<= 8;
1072 data |= byte0;
1073 return data;
1074}
1075uint32_t
1076Buffer::Iterator::ReadLsbtohU32 (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 uint8_t byte0 = ReadU8 ();
1080 uint8_t byte1 = ReadU8 ();
1081 uint8_t byte2 = ReadU8 ();
1082 uint8_t byte3 = ReadU8 ();
1083 uint32_t data = byte3;
1084 data <<= 8;
1085 data |= byte2;
1086 data <<= 8;
1087 data |= byte1;
1088 data <<= 8;
1089 data |= byte0;
1090 return data;
1091}
1092uint64_t
1093Buffer::Iterator::ReadLsbtohU64 (void)
1094{
1095 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);
1096 uint8_t byte0 = ReadU8 ();
1097 uint8_t byte1 = ReadU8 ();
1098 uint8_t byte2 = ReadU8 ();
1099 uint8_t byte3 = ReadU8 ();
1100 uint8_t byte4 = ReadU8 ();
1101 uint8_t byte5 = ReadU8 ();
1102 uint8_t byte6 = ReadU8 ();
1103 uint8_t byte7 = ReadU8 ();
1104 uint64_t data = byte7;
1105 data <<= 8;
1106 data |= byte6;
1107 data <<= 8;
1108 data |= byte5;
1109 data <<= 8;
1110 data |= byte4;
1111 data <<= 8;
1112 data |= byte3;
1113 data <<= 8;
1114 data |= byte2;
1115 data <<= 8;
1116 data |= byte1;
1117 data <<= 8;
1118 data |= byte0;
1119
1120 return data;
1121}
1122void
1123Buffer::Iterator::Read (uint8_t *buffer, uint32_t size)
1124{
1125 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);
1126 for (uint32_t i = 0; i < size; i++)
1127 {
1128 buffer[i] = ReadU8 ();
1129 }
1130}
1131
1132uint16_t
1133Buffer::Iterator::CalculateIpChecksum (uint16_t size)
1134{
1135 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);
1136 return CalculateIpChecksum (size, 0);
1137}
1138
1139uint16_t
1140Buffer::Iterator::CalculateIpChecksum (uint16_t size, uint32_t initialChecksum)
1141{
1142 NS_LOG_FUNCTION (this << size << initialChecksum)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 << initialChecksum; std::clog <<
")" << std::endl; } } while (false);
1143 /* see RFC 1071 to understand this code. */
1144 uint32_t sum = initialChecksum;
1145
1146 for (int j = 0; j < size/2; j++)
1147 sum += ReadU16 ();
1148
1149 if (size & 1)
1150 sum += ReadU8 ();
1151
1152 while (sum >> 16)
1153 sum = (sum & 0xffff) + (sum >> 16);
1154 return ~sum;
1155}
1156
1157uint32_t
1158Buffer::Iterator::GetSize (void) const
1159{
1160 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);
1161 return m_dataEnd - m_dataStart;
1162}
1163
1164uint32_t
1165Buffer::Iterator::GetRemainingSize (void) const
1166{
1167 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);
1168 return m_dataEnd - m_current;
1169}
1170
1171
1172std::string
1173Buffer::Iterator::GetReadErrorMessage (void) const
1174{
1175 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);
1176 std::string str = "You have attempted to read beyond the bounds of the "
1177 "available buffer space. This usually indicates that a "
1178 "Header::Deserialize or Trailer::Deserialize method "
1179 "is trying to read data which was not written by "
1180 "a Header::Serialize or Trailer::Serialize method. "
1181 "In short: check the code of your Serialize and Deserialize "
1182 "methods.";
1183 return str;
1184}
1185std::string
1186Buffer::Iterator::GetWriteErrorMessage (void) const
1187{
1188 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);
1189 std::string str;
1190 if (m_current < m_dataStart)
1191 {
1192 str = "You have attempted to write before the start of the available "
1193 "buffer space. This usually indicates that Trailer::GetSerializedSize "
1194 "returned a size which is too small compared to what Trailer::Serialize "
1195 "is actually using.";
1196 }
1197 else if (m_current >= m_dataEnd)
1198 {
1199 str = "You have attempted to write after the end of the available "
1200 "buffer space. This usually indicates that Header::GetSerializedSize "
1201 "returned a size which is too small compared to what Header::Serialize "
1202 "is actually using.";
1203 }
1204 else
1205 {
1206 NS_ASSERT (m_current >= m_zeroStart && m_current < m_zeroEnd)do { if (!(m_current >= m_zeroStart && m_current <
m_zeroEnd)) { std::cerr << "assert failed. cond=\"" <<
"m_current >= m_zeroStart && m_current < m_zeroEnd"
<< "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc"
<< ", line=" << 1206 << std::endl; ::ns3::
FatalImpl::FlushStreams (); if (true) std::terminate (); } while
(false); } } while (false);
1207 str = "You have attempted to write inside the payload area of the "
1208 "buffer. This usually indicates that your Serialize method uses more "
1209 "buffer space than what your GetSerialized method returned.";
1210 }
1211 return str;
1212}
1213
1214
1215} // namespace ns3
1216
1217