1086 lines
32 KiB
C++
1086 lines
32 KiB
C++
/*
|
|
* Copyright (c) 2005,2006,2007 INRIA
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-only
|
|
*
|
|
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
|
|
*/
|
|
#ifndef BUFFER_H
|
|
#define BUFFER_H
|
|
|
|
#include "ns3/assert.h"
|
|
#include "ns3/atomic-counter.h"
|
|
|
|
#include <ostream>
|
|
#include <stdint.h>
|
|
#include <vector>
|
|
|
|
#ifndef NS3_MTP
|
|
#define BUFFER_FREE_LIST 1
|
|
#endif
|
|
|
|
namespace ns3
|
|
{
|
|
|
|
/**
|
|
* @ingroup packet
|
|
*
|
|
* @brief automatically resized byte buffer
|
|
*
|
|
* This represents a buffer of bytes. Its size is
|
|
* automatically adjusted to hold any data prepended
|
|
* or appended by the user. Its implementation is optimized
|
|
* to ensure that the number of buffer resizes is minimized,
|
|
* by creating new Buffers of the maximum size ever used.
|
|
* The correct maximum size is learned at runtime during use by
|
|
* recording the maximum size of each packet.
|
|
*
|
|
* @internal
|
|
* The implementation of the Buffer class uses a COW (Copy On Write)
|
|
* technique to ensure that the underlying data buffer which holds
|
|
* the data bytes is shared among a lot of Buffer instances despite
|
|
* data being added or removed from them.
|
|
*
|
|
* When multiple Buffer instances hold a reference to the same
|
|
* underlying BufferData object, they must be able to detect when
|
|
* the operation they want to perform should trigger a copy of the
|
|
* BufferData. If the BufferData::m_count field is one, it means that
|
|
* there exist only one instance of Buffer which references the
|
|
* BufferData instance so, it is safe to modify it. It is also
|
|
* safe to modify the content of a BufferData if the modification
|
|
* falls outside of the "dirty area" defined by the BufferData.
|
|
* In every other case, the BufferData must be copied before
|
|
* being modified.
|
|
*
|
|
* To understand the way the Buffer::Add and Buffer::Remove methods
|
|
* work, you first need to understand the "virtual offsets" used to
|
|
* keep track of the content of buffers. Each Buffer instance
|
|
* contains real data bytes in its BufferData instance but it also
|
|
* contains "virtual zero data" which typically is used to represent
|
|
* application-level payload. No memory is allocated to store the
|
|
* zero bytes of application-level payload unless the user fragments
|
|
* a Buffer: this application-level payload is kept track of with
|
|
* a pair of integers which describe where in the buffer content
|
|
* the "virtual zero area" starts and ends.
|
|
*
|
|
* @verbatim
|
|
* ***: unused bytes
|
|
* xxx: bytes "added" at the front of the zero area
|
|
* ...: bytes "added" at the back of the zero area
|
|
* 000: virtual zero bytes
|
|
*
|
|
* Real byte buffer: |********xxxxxxxxxxxx.........*****|
|
|
* |--------^ m_start
|
|
* |-------------------^ m_zeroAreaStart
|
|
* |-----------------------------^ m_end - (m_zeroAreaEnd - m_zeroAreaStart)
|
|
* Virtual byte buffer: |xxxxxxxxxxxx0000000000000.........|
|
|
* |--------^ m_start
|
|
* |--------------------^ m_zeroAreaStart
|
|
* |---------------------------------^ m_zeroAreaEnd
|
|
* |------------------------------------------^ m_end
|
|
* @endverbatim
|
|
*
|
|
* A simple state invariant is that m_start <= m_zeroStart <= m_zeroEnd <= m_end
|
|
*/
|
|
class Buffer
|
|
{
|
|
public:
|
|
/**
|
|
* @brief iterator in a Buffer instance
|
|
*/
|
|
class Iterator
|
|
{
|
|
public:
|
|
inline Iterator();
|
|
/**
|
|
* go forward by one byte
|
|
*/
|
|
inline void Next();
|
|
/**
|
|
* go backward by one byte
|
|
*/
|
|
inline void Prev();
|
|
/**
|
|
* @param delta number of bytes to go forward
|
|
*/
|
|
inline void Next(uint32_t delta);
|
|
/**
|
|
* @param delta number of bytes to go backward
|
|
*/
|
|
inline void Prev(uint32_t delta);
|
|
/**
|
|
* @param o the second iterator
|
|
* @return number of bytes included between the two iterators
|
|
*
|
|
* This method works only if the two iterators point
|
|
* to the same underlying buffer. Debug builds ensure
|
|
* this with an assert.
|
|
*/
|
|
uint32_t GetDistanceFrom(const Iterator& o) const;
|
|
|
|
/**
|
|
* @return true if this iterator points to the end of the byte array.
|
|
* false otherwise.
|
|
*/
|
|
bool IsEnd() const;
|
|
/**
|
|
* @return true if this iterator points to the start of the byte array.
|
|
* false otherwise.
|
|
*/
|
|
bool IsStart() const;
|
|
|
|
/**
|
|
* @param data data to write in buffer
|
|
*
|
|
* Write the data in buffer and advance the iterator position
|
|
* by one byte.
|
|
*/
|
|
inline void WriteU8(uint8_t data);
|
|
/**
|
|
* @param data data to write in buffer
|
|
* @param len number of times data must be written in buffer
|
|
*
|
|
* Write the data in buffer len times and advance the iterator position
|
|
* by len byte.
|
|
*/
|
|
inline void WriteU8(uint8_t data, uint32_t len);
|
|
/**
|
|
* @param data data to write in buffer
|
|
*
|
|
* Write the data in buffer and advance the iterator position
|
|
* by two bytes. The format of the data written in the byte
|
|
* buffer is non-portable. We only ensure that readU16 will
|
|
* return exactly what we wrote with writeU16 if the program
|
|
* is run on the same machine.
|
|
*/
|
|
void WriteU16(uint16_t data);
|
|
/**
|
|
* @param data data to write in buffer
|
|
*
|
|
* Write the data in buffer and advance the iterator position
|
|
* by four bytes. The format of the data written in the byte
|
|
* buffer is non-portable. We only ensure that readU32 will
|
|
* return exactly what we wrote with writeU32 if the program
|
|
* is run on the same machine.
|
|
*/
|
|
void WriteU32(uint32_t data);
|
|
/**
|
|
* @param data data to write in buffer
|
|
*
|
|
* Write the data in buffer and advance the iterator position
|
|
* by eight bytes. The format of the data written in the byte
|
|
* buffer is non-portable. We only ensure that readU64 will
|
|
* return exactly what we wrote with writeU64 if the program
|
|
* is run on the same machine.
|
|
*/
|
|
void WriteU64(uint64_t data);
|
|
/**
|
|
* @param data data to write in buffer
|
|
*
|
|
* Write the data in buffer and advance the iterator position
|
|
* by two bytes. The data is written in least significant byte order and the
|
|
* input data is expected to be in host order.
|
|
*/
|
|
void WriteHtolsbU16(uint16_t data);
|
|
/**
|
|
* @param data data to write in buffer
|
|
*
|
|
* Write the data in buffer and advance the iterator position
|
|
* by four bytes. The data is written in least significant byte order and the
|
|
* input data is expected to be in host order.
|
|
*/
|
|
void WriteHtolsbU32(uint32_t data);
|
|
/**
|
|
* @param data data to write in buffer
|
|
*
|
|
* Write the data in buffer and advance the iterator position
|
|
* by eight bytes. The data is written in least significant byte order and the
|
|
* input data is expected to be in host order.
|
|
*/
|
|
void WriteHtolsbU64(uint64_t data);
|
|
/**
|
|
* @param data data to write in buffer
|
|
*
|
|
* Write the data in buffer and advance the iterator position
|
|
* by two bytes. The data is written in network order and the
|
|
* input data is expected to be in host order.
|
|
*/
|
|
inline void WriteHtonU16(uint16_t data);
|
|
/**
|
|
* @param data data to write in buffer
|
|
*
|
|
* Write the data in buffer and advance the iterator position
|
|
* by four bytes. The data is written in network order and the
|
|
* input data is expected to be in host order.
|
|
*/
|
|
inline void WriteHtonU32(uint32_t data);
|
|
/**
|
|
* @param data data to write in buffer
|
|
*
|
|
* Write the data in buffer and advance the iterator position
|
|
* by eight bytes. The data is written in network order and the
|
|
* input data is expected to be in host order.
|
|
*/
|
|
void WriteHtonU64(uint64_t data);
|
|
/**
|
|
* @param buffer a byte buffer to copy in the internal buffer.
|
|
* @param size number of bytes to copy.
|
|
*
|
|
* Write the data in buffer and advance the iterator position
|
|
* by size bytes.
|
|
*/
|
|
void Write(const uint8_t* buffer, uint32_t size);
|
|
/**
|
|
* @param start the start of the data to copy
|
|
* @param end the end of the data to copy
|
|
*
|
|
* Write the data delimited by start and end in internal buffer
|
|
* and advance the iterator position by the number of bytes
|
|
* copied.
|
|
* The input iterators _must_ not point to the same Buffer as
|
|
* we do to avoid overlapping copies. This is enforced
|
|
* in debug builds by asserts.
|
|
*/
|
|
void Write(Iterator start, Iterator end);
|
|
|
|
/**
|
|
* @return the byte read in the buffer.
|
|
*
|
|
* Read data, but do not advance the Iterator read.
|
|
*/
|
|
inline uint8_t PeekU8();
|
|
|
|
/**
|
|
* @return the byte read in the buffer.
|
|
*
|
|
* Read data and advance the Iterator by the number of bytes
|
|
* read.
|
|
*/
|
|
inline uint8_t ReadU8();
|
|
/**
|
|
* @return the two bytes read in the buffer.
|
|
*
|
|
* Read data and advance the Iterator by the number of bytes
|
|
* read.
|
|
* The data is read in the format written by writeU16.
|
|
*/
|
|
inline uint16_t ReadU16();
|
|
/**
|
|
* @return the four bytes read in the buffer.
|
|
*
|
|
* Read data and advance the Iterator by the number of bytes
|
|
* read.
|
|
* The data is read in the format written by writeU32.
|
|
*/
|
|
uint32_t ReadU32();
|
|
/**
|
|
* @return the eight bytes read in the buffer.
|
|
*
|
|
* Read data and advance the Iterator by the number of bytes
|
|
* read.
|
|
* The data is read in the format written by writeU64.
|
|
*/
|
|
uint64_t ReadU64();
|
|
/**
|
|
* @return the two bytes read in the buffer.
|
|
*
|
|
* Read data and advance the Iterator by the number of bytes
|
|
* read.
|
|
* The data is read in network format and returned in host format.
|
|
*/
|
|
inline uint16_t ReadNtohU16();
|
|
/**
|
|
* @return the four bytes read in the buffer.
|
|
*
|
|
* Read data and advance the Iterator by the number of bytes
|
|
* read.
|
|
* The data is read in network format and returned in host format.
|
|
*/
|
|
inline uint32_t ReadNtohU32();
|
|
/**
|
|
* @return the eight bytes read in the buffer.
|
|
*
|
|
* Read data and advance the Iterator by the number of bytes
|
|
* read.
|
|
* The data is read in network format and returned in host format.
|
|
*/
|
|
uint64_t ReadNtohU64();
|
|
/**
|
|
* @return the two bytes read in the buffer.
|
|
*
|
|
* Read data and advance the Iterator by the number of bytes
|
|
* read.
|
|
* The data is read in least significant byte format and returned in host format.
|
|
*/
|
|
uint16_t ReadLsbtohU16();
|
|
/**
|
|
* @return the four bytes read in the buffer.
|
|
*
|
|
* Read data and advance the Iterator by the number of bytes
|
|
* read.
|
|
* The data is read in least significant byte format and returned in host format.
|
|
*/
|
|
uint32_t ReadLsbtohU32();
|
|
/**
|
|
* @return the eight bytes read in the buffer.
|
|
*
|
|
* Read data and advance the Iterator by the number of bytes
|
|
* read.
|
|
* The data is read in least significant byte format and returned in host format.
|
|
*/
|
|
uint64_t ReadLsbtohU64();
|
|
/**
|
|
* @param buffer buffer to copy data into
|
|
* @param size number of bytes to copy
|
|
*
|
|
* Copy size bytes of data from the internal buffer to the
|
|
* input buffer and advance the Iterator by the number of
|
|
* bytes read.
|
|
*/
|
|
void Read(uint8_t* buffer, uint32_t size);
|
|
|
|
/**
|
|
* @param start start iterator of the buffer to copy data into
|
|
* @param size number of bytes to copy
|
|
*
|
|
* Copy size bytes of data from the internal buffer to the input buffer via
|
|
* the provided iterator and advance the Iterator by the number of bytes
|
|
* read.
|
|
*/
|
|
inline void Read(Iterator start, uint32_t size);
|
|
|
|
/**
|
|
* @brief Calculate the checksum.
|
|
* @param size size of the buffer.
|
|
* @return checksum
|
|
*/
|
|
uint16_t CalculateIpChecksum(uint16_t size);
|
|
|
|
/**
|
|
* @brief Calculate the checksum.
|
|
* @param size size of the buffer.
|
|
* @param initialChecksum initial value
|
|
* @return checksum
|
|
*/
|
|
uint16_t CalculateIpChecksum(uint16_t size, uint32_t initialChecksum);
|
|
|
|
/**
|
|
* @returns the size of the underlying buffer we are iterating
|
|
*/
|
|
uint32_t GetSize() const;
|
|
|
|
/**
|
|
* @returns the size left to read of the underlying buffer we are iterating
|
|
*/
|
|
uint32_t GetRemainingSize() const;
|
|
|
|
private:
|
|
/// Friend class
|
|
friend class Buffer;
|
|
/**
|
|
* Constructor - initializes the iterator to point to the buffer start
|
|
*
|
|
* @param buffer the buffer this iterator refers to
|
|
*/
|
|
inline Iterator(const Buffer* buffer);
|
|
/**
|
|
* Constructor - initializes the iterator to point to the buffer end
|
|
*
|
|
* @param buffer the buffer this iterator refers to
|
|
* @param dummy not used param
|
|
*/
|
|
inline Iterator(const Buffer* buffer, bool dummy);
|
|
/**
|
|
* Initializes the iterator values
|
|
*
|
|
* @param buffer the buffer this iterator refers to
|
|
*/
|
|
inline void Construct(const Buffer* buffer);
|
|
/**
|
|
* Checks that the [start, end) is not in the "virtual zero area".
|
|
*
|
|
* @param start start buffer position
|
|
* @param end end buffer position
|
|
* @returns true if [start, end) is not in the "virtual zero area".
|
|
*/
|
|
bool CheckNoZero(uint32_t start, uint32_t end) const;
|
|
/**
|
|
* Checks that the buffer position is not in the "virtual zero area".
|
|
*
|
|
* @param i buffer position
|
|
* @returns true if not in the "virtual zero area".
|
|
*/
|
|
bool Check(uint32_t i) const;
|
|
/**
|
|
* @return the two bytes read in the buffer.
|
|
*
|
|
* Read data and advance the Iterator by the number of bytes
|
|
* read.
|
|
* The data is read in network format and returned in host format.
|
|
*
|
|
* @warning this is the slow version, please use ReadNtohU16 ()
|
|
*/
|
|
uint16_t SlowReadNtohU16();
|
|
/**
|
|
* @return the four bytes read in the buffer.
|
|
*
|
|
* Read data and advance the Iterator by the number of bytes
|
|
* read.
|
|
* The data is read in network format and returned in host format.
|
|
*
|
|
* @warning this is the slow version, please use ReadNtohU32 ()
|
|
*/
|
|
uint32_t SlowReadNtohU32();
|
|
/**
|
|
* @brief Returns an appropriate message indicating a read error
|
|
* @returns the error message
|
|
*/
|
|
std::string GetReadErrorMessage() const;
|
|
/**
|
|
* @brief Returns an appropriate message indicating a write error
|
|
*
|
|
* The message depends on the actual Buffer::Iterator status.
|
|
*
|
|
* @returns the error message
|
|
*/
|
|
std::string GetWriteErrorMessage() const;
|
|
|
|
/**
|
|
* offset in virtual bytes from the start of the data buffer to the
|
|
* start of the "virtual zero area".
|
|
*/
|
|
uint32_t m_zeroStart;
|
|
/**
|
|
* offset in virtual bytes from the start of the data buffer to the
|
|
* end of the "virtual zero area".
|
|
*/
|
|
uint32_t m_zeroEnd;
|
|
/**
|
|
* offset in virtual bytes from the start of the data buffer to the
|
|
* start of the data which can be read by this iterator
|
|
*/
|
|
uint32_t m_dataStart;
|
|
/**
|
|
* offset in virtual bytes from the start of the data buffer to the
|
|
* end of the data which can be read by this iterator
|
|
*/
|
|
uint32_t m_dataEnd;
|
|
/**
|
|
* offset in virtual bytes from the start of the data buffer to the
|
|
* current position represented by this iterator.
|
|
*/
|
|
uint32_t m_current;
|
|
/**
|
|
* a pointer to the underlying byte buffer. All offsets are relative
|
|
* to this pointer.
|
|
*/
|
|
uint8_t* m_data;
|
|
};
|
|
|
|
/**
|
|
* @return the number of bytes stored in this buffer.
|
|
*/
|
|
inline uint32_t GetSize() const;
|
|
|
|
/**
|
|
* @return a pointer to the start of the internal
|
|
* byte buffer.
|
|
*
|
|
* The returned pointer points to an area of
|
|
* memory which is ns3::Buffer::GetSize () bytes big.
|
|
* Please, try to never ever use this method. It is really
|
|
* evil and is present only for a few specific uses.
|
|
*/
|
|
const uint8_t* PeekData() const;
|
|
|
|
/**
|
|
* @param start size to reserve
|
|
*
|
|
* Add bytes at the start of the Buffer. The
|
|
* content of these bytes is undefined but debugging
|
|
* builds initialize them to 0x33.
|
|
* Any call to this method invalidates any Iterator
|
|
* pointing to this Buffer.
|
|
*/
|
|
void AddAtStart(uint32_t start);
|
|
/**
|
|
* @param end size to reserve
|
|
*
|
|
* Add bytes at the end of the Buffer. The
|
|
* content of these bytes is undefined but debugging
|
|
* builds initialize them to 0x33.
|
|
* Any call to this method invalidates any Iterator
|
|
* pointing to this Buffer.
|
|
*/
|
|
void AddAtEnd(uint32_t end);
|
|
|
|
/**
|
|
* @param o the buffer to append to the end of this buffer.
|
|
*
|
|
* Add bytes at the end of the Buffer.
|
|
* Any call to this method invalidates any Iterator
|
|
* pointing to this Buffer.
|
|
*/
|
|
void AddAtEnd(const Buffer& o);
|
|
/**
|
|
* @param start size to remove
|
|
*
|
|
* Remove bytes at the start of the Buffer.
|
|
* Any call to this method invalidates any Iterator
|
|
* pointing to this Buffer.
|
|
*/
|
|
void RemoveAtStart(uint32_t start);
|
|
/**
|
|
* @param end size to remove
|
|
*
|
|
* Remove bytes at the end of the Buffer.
|
|
* Any call to this method invalidates any Iterator
|
|
* pointing to this Buffer.
|
|
*/
|
|
void RemoveAtEnd(uint32_t end);
|
|
|
|
/**
|
|
* @param start offset from start of packet
|
|
* @param length
|
|
*
|
|
* @return a fragment of size length starting at offset
|
|
* start.
|
|
*/
|
|
Buffer CreateFragment(uint32_t start, uint32_t length) const;
|
|
|
|
/**
|
|
* @return an Iterator which points to the
|
|
* start of this Buffer.
|
|
*/
|
|
inline Buffer::Iterator Begin() const;
|
|
/**
|
|
* @return an Iterator which points to the
|
|
* end of this Buffer.
|
|
*/
|
|
inline Buffer::Iterator End() const;
|
|
|
|
/**
|
|
* @brief Return the number of bytes required for serialization.
|
|
* @return the number of bytes.
|
|
*/
|
|
uint32_t GetSerializedSize() const;
|
|
|
|
/**
|
|
* @return zero if buffer not large enough
|
|
* @param buffer points to serialization buffer
|
|
* @param maxSize max number of bytes to write
|
|
*
|
|
* This buffer's contents are serialized into the raw
|
|
* character buffer parameter. Note: The zero length
|
|
* data is not copied entirely. Only the length of
|
|
* zero byte data is serialized.
|
|
*/
|
|
uint32_t Serialize(uint8_t* buffer, uint32_t maxSize) const;
|
|
|
|
/**
|
|
* @return zero if a complete buffer is not deserialized
|
|
* @param buffer points to buffer for deserialization
|
|
* @param size number of bytes to deserialize
|
|
*
|
|
* The raw character buffer is deserialized and all the
|
|
* data is placed into this buffer.
|
|
*/
|
|
uint32_t Deserialize(const uint8_t* buffer, uint32_t size);
|
|
|
|
/**
|
|
* Copy the specified amount of data from the buffer to the given output stream.
|
|
*
|
|
* @param os the output stream
|
|
* @param size the maximum amount of bytes to copy. If zero, nothing is copied.
|
|
*/
|
|
void CopyData(std::ostream* os, uint32_t size) const;
|
|
|
|
/**
|
|
* Copy the specified amount of data from the buffer to the given buffer.
|
|
*
|
|
* @param buffer the output buffer
|
|
* @param size the maximum amount of bytes to copy. If zero, nothing is copied.
|
|
* @returns the amount of bytes copied
|
|
*/
|
|
uint32_t CopyData(uint8_t* buffer, uint32_t size) const;
|
|
|
|
/**
|
|
* @brief Copy constructor
|
|
* @param o the buffer to copy
|
|
*/
|
|
inline Buffer(const Buffer& o);
|
|
/**
|
|
* @brief Assignment operator
|
|
* @param o the buffer to copy
|
|
* @return a reference to the buffer
|
|
*/
|
|
Buffer& operator=(const Buffer& o);
|
|
Buffer();
|
|
/**
|
|
* @brief Constructor
|
|
*
|
|
* The buffer will be initialized with zeroes up to its size.
|
|
*
|
|
* @param dataSize the buffer size
|
|
*/
|
|
Buffer(uint32_t dataSize);
|
|
/**
|
|
* @brief Constructor
|
|
*
|
|
* If initialize is set to true, the buffer will be initialized
|
|
* with zeroes up to its size.
|
|
*
|
|
* @param dataSize the buffer size.
|
|
* @param initialize initialize the buffer with zeroes.
|
|
*/
|
|
Buffer(uint32_t dataSize, bool initialize);
|
|
~Buffer();
|
|
|
|
private:
|
|
/**
|
|
* This data structure is variable-sized through its last member whose size
|
|
* is determined at allocation time and stored in the m_size field.
|
|
*
|
|
* The so-called "dirty area" describes the area in the buffer which
|
|
* has been reserved and used by a user. Multiple Buffer instances
|
|
* may reference the same Buffer::Data object instance and may
|
|
* reference different parts of the underlying byte buffer. The
|
|
* "dirty area" is union of all the areas referenced by the Buffer
|
|
* instances which reference the same BufferData instance.
|
|
* New user data can be safely written only outside of the "dirty
|
|
* area" if the reference count is higher than 1 (that is, if
|
|
* more than one Buffer instance references the same BufferData).
|
|
*/
|
|
struct Data
|
|
{
|
|
/**
|
|
* The reference count of an instance of this data structure.
|
|
* Each buffer which references an instance holds a count.
|
|
*/
|
|
#ifdef NS3_MTP
|
|
AtomicCounter m_count;
|
|
#else
|
|
uint32_t m_count;
|
|
#endif
|
|
/**
|
|
* the size of the m_data field below.
|
|
*/
|
|
uint32_t m_size;
|
|
/**
|
|
* offset from the start of the m_data field below to the
|
|
* start of the area in which user bytes were written.
|
|
*/
|
|
uint32_t m_dirtyStart;
|
|
/**
|
|
* offset from the start of the m_data field below to the
|
|
* end of the area in which user bytes were written.
|
|
*/
|
|
uint32_t m_dirtyEnd;
|
|
/**
|
|
* The real data buffer holds _at least_ one byte.
|
|
* Its real size is stored in the m_size field.
|
|
*/
|
|
uint8_t m_data[1];
|
|
};
|
|
|
|
/**
|
|
* @brief Create a full copy of the buffer, including
|
|
* all the internal structures.
|
|
*
|
|
* @returns a copy of the buffer
|
|
*/
|
|
Buffer CreateFullCopy() const;
|
|
|
|
/**
|
|
* @brief Transform a "Virtual byte buffer" into a "Real byte buffer"
|
|
*/
|
|
void TransformIntoRealBuffer() const;
|
|
/**
|
|
* @brief Checks the internal buffer structures consistency
|
|
*
|
|
* Used only for debugging purposes.
|
|
*
|
|
* @returns true if the buffer status is consistent.
|
|
*/
|
|
bool CheckInternalState() const;
|
|
|
|
/**
|
|
* @brief Initializes the buffer with a number of zeroes.
|
|
*
|
|
* @param zeroSize the zeroes size
|
|
*/
|
|
void Initialize(uint32_t zeroSize);
|
|
|
|
/**
|
|
* @brief Get the buffer real size.
|
|
* @warning The real size is the actual memory used by the buffer.
|
|
* @returns the memory used by the buffer.
|
|
*/
|
|
uint32_t GetInternalSize() const;
|
|
|
|
/**
|
|
* @brief Get the buffer end position.
|
|
* @returns the buffer end index.
|
|
*/
|
|
uint32_t GetInternalEnd() const;
|
|
|
|
/**
|
|
* @brief Recycle the buffer memory
|
|
* @param data the buffer data storage
|
|
*/
|
|
static void Recycle(Buffer::Data* data);
|
|
/**
|
|
* @brief Create a buffer data storage
|
|
* @param size the storage size to create
|
|
* @returns a pointer to the created buffer storage
|
|
*/
|
|
static Buffer::Data* Create(uint32_t size);
|
|
/**
|
|
* @brief Allocate a buffer data storage
|
|
* @param reqSize the storage size to create
|
|
* @returns a pointer to the allocated buffer storage
|
|
*/
|
|
static Buffer::Data* Allocate(uint32_t reqSize);
|
|
/**
|
|
* @brief Deallocate the buffer memory
|
|
* @param data the buffer data storage
|
|
*/
|
|
static void Deallocate(Buffer::Data* data);
|
|
|
|
Data* m_data; //!< the buffer data storage
|
|
|
|
/**
|
|
* keep track of the maximum value of m_zeroAreaStart across
|
|
* the lifetime of a Buffer instance. This variable is used
|
|
* purely as a source of information for the heuristics which
|
|
* decide on the position of the zero area in new buffers.
|
|
* It is read from the Buffer destructor to update the global
|
|
* heuristic data and these global heuristic data are used from
|
|
* the Buffer constructor to choose an initial value for
|
|
* m_zeroAreaStart.
|
|
*/
|
|
uint32_t m_maxZeroAreaStart;
|
|
/**
|
|
* location in a newly-allocated buffer where you should start
|
|
* writing data. i.e., m_start should be initialized to this
|
|
* value.
|
|
*/
|
|
static uint32_t g_recommendedStart;
|
|
|
|
/**
|
|
* offset to the start of the virtual zero area from the start
|
|
* of m_data->m_data
|
|
*/
|
|
uint32_t m_zeroAreaStart;
|
|
/**
|
|
* offset to the end of the virtual zero area from the start
|
|
* of m_data->m_data
|
|
*/
|
|
uint32_t m_zeroAreaEnd;
|
|
/**
|
|
* offset to the start of the data referenced by this Buffer
|
|
* instance from the start of m_data->m_data
|
|
*/
|
|
uint32_t m_start;
|
|
/**
|
|
* offset to the end of the data referenced by this Buffer
|
|
* instance from the start of m_data->m_data
|
|
*/
|
|
uint32_t m_end;
|
|
|
|
#ifdef BUFFER_FREE_LIST
|
|
/// Container for buffer data
|
|
typedef std::vector<Buffer::Data*> FreeList;
|
|
|
|
/// Local static destructor structure
|
|
struct LocalStaticDestructor
|
|
{
|
|
~LocalStaticDestructor();
|
|
};
|
|
|
|
static uint32_t g_maxSize; //!< Max observed data size
|
|
static FreeList* g_freeList; //!< Buffer data container
|
|
static LocalStaticDestructor g_localStaticDestructor; //!< Local static destructor
|
|
#endif
|
|
};
|
|
|
|
} // namespace ns3
|
|
|
|
#include "ns3/assert.h"
|
|
|
|
#include <cstring>
|
|
|
|
namespace ns3
|
|
{
|
|
|
|
Buffer::Iterator::Iterator()
|
|
: m_zeroStart(0),
|
|
m_zeroEnd(0),
|
|
m_dataStart(0),
|
|
m_dataEnd(0),
|
|
m_current(0),
|
|
m_data(nullptr)
|
|
{
|
|
}
|
|
|
|
Buffer::Iterator::Iterator(const Buffer* buffer)
|
|
{
|
|
Construct(buffer);
|
|
m_current = m_dataStart;
|
|
}
|
|
|
|
Buffer::Iterator::Iterator(const Buffer* buffer, bool dummy)
|
|
{
|
|
Construct(buffer);
|
|
m_current = m_dataEnd;
|
|
}
|
|
|
|
void
|
|
Buffer::Iterator::Construct(const Buffer* buffer)
|
|
{
|
|
m_zeroStart = buffer->m_zeroAreaStart;
|
|
m_zeroEnd = buffer->m_zeroAreaEnd;
|
|
m_dataStart = buffer->m_start;
|
|
m_dataEnd = buffer->m_end;
|
|
m_data = buffer->m_data->m_data;
|
|
}
|
|
|
|
void
|
|
Buffer::Iterator::Next()
|
|
{
|
|
NS_ASSERT(m_current + 1 <= m_dataEnd);
|
|
m_current++;
|
|
}
|
|
|
|
void
|
|
Buffer::Iterator::Prev()
|
|
{
|
|
NS_ASSERT(m_current >= 1);
|
|
m_current--;
|
|
}
|
|
|
|
void
|
|
Buffer::Iterator::Next(uint32_t delta)
|
|
{
|
|
NS_ASSERT(m_current + delta <= m_dataEnd);
|
|
m_current += delta;
|
|
}
|
|
|
|
void
|
|
Buffer::Iterator::Prev(uint32_t delta)
|
|
{
|
|
NS_ASSERT(m_current >= delta);
|
|
m_current -= delta;
|
|
}
|
|
|
|
void
|
|
Buffer::Iterator::WriteU8(uint8_t data)
|
|
{
|
|
NS_ASSERT_MSG(Check(m_current), GetWriteErrorMessage());
|
|
|
|
if (m_current < m_zeroStart)
|
|
{
|
|
m_data[m_current] = data;
|
|
m_current++;
|
|
}
|
|
else
|
|
{
|
|
m_data[m_current - (m_zeroEnd - m_zeroStart)] = data;
|
|
m_current++;
|
|
}
|
|
}
|
|
|
|
void
|
|
Buffer::Iterator::WriteU8(uint8_t data, uint32_t len)
|
|
{
|
|
NS_ASSERT_MSG(CheckNoZero(m_current, m_current + len), GetWriteErrorMessage());
|
|
if (m_current <= m_zeroStart)
|
|
{
|
|
std::memset(&(m_data[m_current]), data, len);
|
|
m_current += len;
|
|
}
|
|
else
|
|
{
|
|
uint8_t* buffer = &m_data[m_current - (m_zeroEnd - m_zeroStart)];
|
|
std::memset(buffer, data, len);
|
|
m_current += len;
|
|
}
|
|
}
|
|
|
|
void
|
|
Buffer::Iterator::WriteHtonU16(uint16_t data)
|
|
{
|
|
NS_ASSERT_MSG(CheckNoZero(m_current, m_current + 2), GetWriteErrorMessage());
|
|
uint8_t* buffer;
|
|
if (m_current + 2 <= m_zeroStart)
|
|
{
|
|
buffer = &m_data[m_current];
|
|
}
|
|
else
|
|
{
|
|
buffer = &m_data[m_current - (m_zeroEnd - m_zeroStart)];
|
|
}
|
|
buffer[0] = (data >> 8) & 0xff;
|
|
buffer[1] = (data >> 0) & 0xff;
|
|
m_current += 2;
|
|
}
|
|
|
|
void
|
|
Buffer::Iterator::WriteHtonU32(uint32_t data)
|
|
{
|
|
NS_ASSERT_MSG(CheckNoZero(m_current, m_current + 4), GetWriteErrorMessage());
|
|
|
|
uint8_t* buffer;
|
|
if (m_current + 4 <= m_zeroStart)
|
|
{
|
|
buffer = &m_data[m_current];
|
|
}
|
|
else
|
|
{
|
|
buffer = &m_data[m_current - (m_zeroEnd - m_zeroStart)];
|
|
}
|
|
buffer[0] = (data >> 24) & 0xff;
|
|
buffer[1] = (data >> 16) & 0xff;
|
|
buffer[2] = (data >> 8) & 0xff;
|
|
buffer[3] = (data >> 0) & 0xff;
|
|
m_current += 4;
|
|
}
|
|
|
|
uint16_t
|
|
Buffer::Iterator::ReadNtohU16()
|
|
{
|
|
uint8_t* buffer;
|
|
if (m_current + 2 <= m_zeroStart)
|
|
{
|
|
buffer = &m_data[m_current];
|
|
}
|
|
else if (m_current >= m_zeroEnd)
|
|
{
|
|
buffer = &m_data[m_current - (m_zeroEnd - m_zeroStart)];
|
|
}
|
|
else
|
|
{
|
|
return SlowReadNtohU16();
|
|
}
|
|
uint16_t retval = 0;
|
|
retval |= buffer[0];
|
|
retval <<= 8;
|
|
retval |= buffer[1];
|
|
m_current += 2;
|
|
return retval;
|
|
}
|
|
|
|
uint32_t
|
|
Buffer::Iterator::ReadNtohU32()
|
|
{
|
|
uint8_t* buffer;
|
|
if (m_current + 4 <= m_zeroStart)
|
|
{
|
|
buffer = &m_data[m_current];
|
|
}
|
|
else if (m_current >= m_zeroEnd)
|
|
{
|
|
buffer = &m_data[m_current - (m_zeroEnd - m_zeroStart)];
|
|
}
|
|
else
|
|
{
|
|
return SlowReadNtohU32();
|
|
}
|
|
uint32_t retval = 0;
|
|
retval |= buffer[0];
|
|
retval <<= 8;
|
|
retval |= buffer[1];
|
|
retval <<= 8;
|
|
retval |= buffer[2];
|
|
retval <<= 8;
|
|
retval |= buffer[3];
|
|
m_current += 4;
|
|
return retval;
|
|
}
|
|
|
|
uint8_t
|
|
Buffer::Iterator::PeekU8()
|
|
{
|
|
NS_ASSERT_MSG(m_current >= m_dataStart && m_current < m_dataEnd, GetReadErrorMessage());
|
|
|
|
if (m_current < m_zeroStart)
|
|
{
|
|
uint8_t data = m_data[m_current];
|
|
return data;
|
|
}
|
|
else if (m_current < m_zeroEnd)
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
uint8_t data = m_data[m_current - (m_zeroEnd - m_zeroStart)];
|
|
return data;
|
|
}
|
|
}
|
|
|
|
uint8_t
|
|
Buffer::Iterator::ReadU8()
|
|
{
|
|
uint8_t ret = PeekU8();
|
|
m_current++;
|
|
return ret;
|
|
}
|
|
|
|
uint16_t
|
|
Buffer::Iterator::ReadU16()
|
|
{
|
|
uint8_t byte0 = ReadU8();
|
|
uint8_t byte1 = ReadU8();
|
|
uint16_t data = byte1;
|
|
data <<= 8;
|
|
data |= byte0;
|
|
|
|
return data;
|
|
}
|
|
|
|
void
|
|
Buffer::Iterator::Read(Buffer::Iterator start, uint32_t size)
|
|
{
|
|
Buffer::Iterator end = *this;
|
|
end.Next(size);
|
|
|
|
start.Write(*this, end);
|
|
}
|
|
|
|
Buffer::Buffer(const Buffer& o)
|
|
: m_data(o.m_data),
|
|
m_maxZeroAreaStart(o.m_zeroAreaStart),
|
|
m_zeroAreaStart(o.m_zeroAreaStart),
|
|
m_zeroAreaEnd(o.m_zeroAreaEnd),
|
|
m_start(o.m_start),
|
|
m_end(o.m_end)
|
|
{
|
|
m_data->m_count++;
|
|
NS_ASSERT(CheckInternalState());
|
|
}
|
|
|
|
uint32_t
|
|
Buffer::GetSize() const
|
|
{
|
|
return m_end - m_start;
|
|
}
|
|
|
|
Buffer::Iterator
|
|
Buffer::Begin() const
|
|
{
|
|
NS_ASSERT(CheckInternalState());
|
|
return Buffer::Iterator(this);
|
|
}
|
|
|
|
Buffer::Iterator
|
|
Buffer::End() const
|
|
{
|
|
NS_ASSERT(CheckInternalState());
|
|
return Buffer::Iterator(this, false);
|
|
}
|
|
|
|
} // namespace ns3
|
|
|
|
#endif /* BUFFER_H */
|