10#include "ns3/assert.h"
13#define LOG_INTERNAL_STATE(y) \
14 NS_LOG_LOGIC(y << "start=" << m_start << ", end=" << m_end \
15 << ", zero start=" << m_zeroAreaStart << ", zero end=" << m_zeroAreaEnd \
16 << ", count=" << m_data->m_count << ", size=" << m_data->m_size \
17 << ", dirty start=" << m_data->m_dirtyStart \
18 << ", dirty end=" << m_data->m_dirtyEnd)
47#ifdef BUFFER_FREE_LIST
65#define MAGIC_DESTROYED (~(long)0)
66#define IS_UNINITIALIZED(x) (x == (Buffer::FreeList*)0)
67#define IS_DESTROYED(x) (x == (Buffer::FreeList*)MAGIC_DESTROYED)
68#define IS_INITIALIZED(x) (!IS_UNINITIALIZED(x) && !IS_DESTROYED(x))
69#define DESTROYED ((Buffer::FreeList*)MAGIC_DESTROYED)
70#define UNINITIALIZED ((Buffer::FreeList*)0)
123 if (
data->m_size >= dataSize)
165 auto b =
new uint8_t[size];
167 data->m_size = reqSize;
177 auto buf =
reinterpret_cast<uint8_t*
>(
data);
222 bool ok =
m_data->m_count > 0 && offsetsOk && dirtyOk && internalSizeOk;
226 ", " << (offsetsOk ?
"true" :
"false") <<
227 ", " << (dirtyOk ?
"true" :
"false") <<
228 ", " << (internalSizeOk ?
"true" :
"false") <<
" ");
308 if (
m_start >= start && !isDirty)
456 else if (newStart <=
m_end)
574 auto p =
reinterpret_cast<uint32_t*
>(buffer);
596 *p++ = dataStartLength;
599 size += (dataStartLength + 3) & (~3);
607 p += (((dataStartLength + 3) & (~3)) / 4);
618 *p++ = dataEndLength;
621 size += (dataEndLength + 3) & (~3);
640 auto p =
reinterpret_cast<const uint32_t*
>(buffer);
658 p += (((dataStartLength + 3) & (~3)) / 4);
659 sizeCheck -= ((dataStartLength + 3) & (~3));
669 tmp.
Prev(dataEndLength);
670 tmp.
Write(
reinterpret_cast<uint8_t*
>(
const_cast<uint32_t*
>(p)), dataEndLength);
673 sizeCheck -= ((dataEndLength + 3) & (~3));
678 return (sizeCheck != 0) ? 0 : 1;
687 *
const_cast<Buffer*
>(
this) = tmp;
717 os->write(g_zeroes.
buffer, toWrite);
738 memcpy(buffer, (
const char*)(
m_data->m_data +
m_start), tmpsize);
748 memcpy(buffer, g_zeroes.
buffer, toWrite);
761 return originalSize - size;
802 return !(start < m_dataStart || end >
m_dataEnd ||
824 if (start.m_current <= start.m_zeroStart)
826 uint32_t toCopy = std::min(size, start.m_zeroStart - start.m_current);
828 start.m_current += toCopy;
832 if (start.m_current <= start.m_zeroEnd)
834 uint32_t toCopy = std::min(size, start.m_zeroEnd - start.m_current);
836 start.m_current += toCopy;
840 uint32_t toCopy = std::min(size, start.m_dataEnd - start.m_current);
841 uint8_t* from = &start.m_data[start.m_current - (start.m_zeroEnd - start.m_zeroStart)];
843 memcpy(to, from, toCopy);
950 memcpy(to, buffer, size);
984 uint64_t
data = byte7;
1007 uint16_t retval = 0;
1033 uint64_t retval = 0;
1056 uint8_t byte0 =
ReadU8();
1057 uint8_t byte1 =
ReadU8();
1058 uint16_t
data = byte1;
1068 uint8_t byte0 =
ReadU8();
1069 uint8_t byte1 =
ReadU8();
1070 uint8_t byte2 =
ReadU8();
1071 uint8_t byte3 =
ReadU8();
1086 uint8_t byte0 =
ReadU8();
1087 uint8_t byte1 =
ReadU8();
1088 uint8_t byte2 =
ReadU8();
1089 uint8_t byte3 =
ReadU8();
1090 uint8_t byte4 =
ReadU8();
1091 uint8_t byte5 =
ReadU8();
1092 uint8_t byte6 =
ReadU8();
1093 uint8_t byte7 =
ReadU8();
1094 uint64_t
data = byte7;
1117 for (
uint32_t i = 0; i < size; i++)
1137 for (
int j = 0; j < size / 2; j++)
1149 sum = (sum & 0xffff) + (sum >> 16);
1172 std::string str =
"You have attempted to read beyond the bounds of the "
1173 "available buffer space. This usually indicates that a "
1174 "Header::Deserialize or Trailer::Deserialize method "
1175 "is trying to read data which was not written by "
1176 "a Header::Serialize or Trailer::Serialize method. "
1177 "In short: check the code of your Serialize and Deserialize "
1189 str =
"You have attempted to write before the start of the available "
1190 "buffer space. This usually indicates that Trailer::GetSerializedSize "
1191 "returned a size which is too small compared to what Trailer::Serialize "
1192 "is actually using.";
1196 str =
"You have attempted to write after the end of the available "
1197 "buffer space. This usually indicates that Header::GetSerializedSize "
1198 "returned a size which is too small compared to what Header::Serialize "
1199 "is actually using.";
1204 str =
"You have attempted to write inside the payload area of the "
1205 "buffer. This usually indicates that your Serialize method uses more "
1206 "buffer space than what your GetSerialized method returned.";
#define LOG_INTERNAL_STATE(y)
#define IS_UNINITIALIZED(x)
#define IS_INITIALIZED(x)
iterator in a Buffer instance
void WriteU64(uint64_t data)
uint32_t GetRemainingSize() const
void WriteU32(uint32_t data)
uint32_t m_dataEnd
offset in virtual bytes from the start of the data buffer to the end of the data which can be read by...
void WriteHtonU64(uint64_t data)
void WriteHtolsbU16(uint16_t data)
uint32_t m_dataStart
offset in virtual bytes from the start of the data buffer to the start of the data which can be read ...
std::string GetReadErrorMessage() const
Returns an appropriate message indicating a read error.
uint16_t CalculateIpChecksum(uint16_t size)
Calculate the checksum.
void WriteU8(uint8_t data)
uint16_t SlowReadNtohU16()
uint8_t * m_data
a pointer to the underlying byte buffer.
void WriteHtolsbU32(uint32_t data)
void Write(const uint8_t *buffer, uint32_t size)
uint32_t m_zeroEnd
offset in virtual bytes from the start of the data buffer to the end of the "virtual zero area".
bool Check(uint32_t i) const
Checks that the buffer position is not in the "virtual zero area".
void WriteU16(uint16_t data)
uint32_t m_current
offset in virtual bytes from the start of the data buffer to the current position represented by this...
uint32_t SlowReadNtohU32()
void Read(uint8_t *buffer, uint32_t size)
void WriteHtolsbU64(uint64_t data)
uint32_t m_zeroStart
offset in virtual bytes from the start of the data buffer to the start of the "virtual zero area".
bool CheckNoZero(uint32_t start, uint32_t end) const
Checks that the [start, end) is not in the "virtual zero area".
uint32_t GetDistanceFrom(const Iterator &o) const
void Prev()
go backward by one byte
std::string GetWriteErrorMessage() const
Returns an appropriate message indicating a write error.
automatically resized byte buffer
uint32_t GetSerializedSize() const
Return the number of bytes required for serialization.
std::vector< Buffer::Data * > FreeList
Container for buffer data.
uint32_t GetInternalEnd() const
Get the buffer end position.
uint32_t m_end
offset to the end of the data referenced by this Buffer instance from the start of m_data->m_data
static Buffer::Data * Allocate(uint32_t reqSize)
Allocate a buffer data storage.
Buffer CreateFragment(uint32_t start, uint32_t length) const
static FreeList * g_freeList
Buffer data container.
Data * m_data
the buffer data storage
static Buffer::Data * Create(uint32_t size)
Create a buffer data storage.
static uint32_t g_maxSize
Max observed data size.
static LocalStaticDestructor g_localStaticDestructor
Local static destructor.
uint32_t m_zeroAreaEnd
offset to the end of the virtual zero area from the start of m_data->m_data
uint32_t m_maxZeroAreaStart
keep track of the maximum value of m_zeroAreaStart across the lifetime of a Buffer instance.
static uint32_t g_recommendedStart
location in a newly-allocated buffer where you should start writing data.
static void Deallocate(Buffer::Data *data)
Deallocate the buffer memory.
void CopyData(std::ostream *os, uint32_t size) const
Copy the specified amount of data from the buffer to the given output stream.
void RemoveAtEnd(uint32_t end)
void TransformIntoRealBuffer() const
Transform a "Virtual byte buffer" into a "Real byte buffer".
void AddAtStart(uint32_t start)
uint32_t GetInternalSize() const
Get the buffer real size.
Buffer::Iterator Begin() const
void AddAtEnd(uint32_t end)
Buffer::Iterator End() const
Buffer & operator=(const Buffer &o)
Assignment operator.
Buffer(const Buffer &o)
Copy constructor.
Buffer CreateFullCopy() const
Create a full copy of the buffer, including all the internal structures.
static void Recycle(Buffer::Data *data)
Recycle the buffer memory.
bool CheckInternalState() const
Checks the internal buffer structures consistency.
void Initialize(uint32_t zeroSize)
Initializes the buffer with a number of zeroes.
uint32_t Deserialize(const uint8_t *buffer, uint32_t size)
void RemoveAtStart(uint32_t start)
uint32_t m_zeroAreaStart
offset to the start of the virtual zero area from the start of m_data->m_data
uint32_t Serialize(uint8_t *buffer, uint32_t maxSize) const
const uint8_t * PeekData() const
uint32_t m_start
offset to the start of the data referenced by this Buffer instance from the start of m_data->m_data
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
struct anonymous_namespace{buffer.cc}::Zeroes g_zeroes
Zero-filled buffer.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
constexpr uint32_t ALLOC_OVER_PROVISION
Additional bytes to over-provision.
char buffer[1000]
buffer containing zero values
const uint32_t size
buffer size
This data structure is variable-sized through its last member whose size is determined at allocation ...
uint8_t m_data[1]
The real data buffer holds at least one byte.