buffer.h

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2005,2006,2007 INRIA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */
#ifndef BUFFER_H
#define BUFFER_H

#include <stdint.h>
#include <vector>
#include <ostream>
#include "ns3/assert.h"

#define noBUFFER_FREE_LIST 1

namespace ns3 {

class Buffer 
{
public:
  class Iterator 
  {
public:
    inline Iterator ();
    inline void Next (void);
    inline void Prev (void);
    inline void Next (uint32_t delta);
    inline void Prev (uint32_t delta);
    uint32_t GetDistanceFrom (Iterator const &o) const;

    bool IsEnd (void) const;
    bool IsStart (void) const;

    inline void WriteU8 (uint8_t  data);
    inline void WriteU8 (uint8_t data, uint32_t len);
    void WriteU16 (uint16_t data);
    void WriteU32 (uint32_t data);
    void WriteU64 (uint64_t data);
    void WriteHtolsbU16 (uint16_t data);
    void WriteHtolsbU32 (uint32_t data);
    void WriteHtolsbU64 (uint64_t data);
    inline void WriteHtonU16 (uint16_t data);
    inline void WriteHtonU32 (uint32_t data);
    void WriteHtonU64 (uint64_t data);
    void Write (uint8_t const*buffer, uint32_t size);
    void Write (Iterator start, Iterator end);

    inline uint8_t  ReadU8 (void);
    inline uint16_t ReadU16 (void);
    uint32_t ReadU32 (void);
    uint64_t ReadU64 (void);
    inline uint16_t ReadNtohU16 (void);
    inline uint32_t ReadNtohU32 (void);
    uint64_t ReadNtohU64 (void);
    uint16_t ReadLsbtohU16 (void);
    uint32_t ReadLsbtohU32 (void);
    uint64_t ReadLsbtohU64 (void);
    void Read (uint8_t *buffer, uint32_t size);

    uint16_t CalculateIpChecksum (uint16_t size);

    uint16_t CalculateIpChecksum (uint16_t size, uint32_t initialChecksum);

    uint32_t GetSize (void) const;

private:
    friend class Buffer;
    inline Iterator (Buffer const*buffer);
    inline Iterator (Buffer const*buffer, bool);
    inline void Construct (const Buffer *buffer);
    bool CheckNoZero (uint32_t start, uint32_t end) const;
    bool Check (uint32_t i) const;
    uint16_t SlowReadNtohU16 (void);
    uint32_t SlowReadNtohU32 (void);
    std::string GetReadErrorMessage (void) const;
    std::string GetWriteErrorMessage (void) 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;
  };

  inline uint32_t GetSize (void) const;

  uint8_t const*PeekData (void) const;

  bool AddAtStart (uint32_t start);
  bool AddAtEnd (uint32_t end);

  void AddAtEnd (const Buffer &o);
  void RemoveAtStart (uint32_t start);
  void RemoveAtEnd (uint32_t end);

  Buffer CreateFragment (uint32_t start, uint32_t length) const;

  inline Buffer::Iterator Begin (void) const;
  inline Buffer::Iterator End (void) const;

  Buffer CreateFullCopy (void) const;

  uint32_t GetSerializedSize (void) const;

  uint32_t Serialize (uint8_t* buffer, uint32_t maxSize) const;

  uint32_t Deserialize (const uint8_t* buffer, uint32_t size);

  int32_t GetCurrentStartOffset (void) const;
  int32_t GetCurrentEndOffset (void) const;

  void CopyData (std::ostream *os, uint32_t size) const;

  uint32_t CopyData (uint8_t *buffer, uint32_t size) const;

  inline Buffer (Buffer const &o);
  Buffer &operator = (Buffer const &o);
  Buffer ();
  Buffer (uint32_t dataSize);
  Buffer (uint32_t dataSize, bool initialize);
  ~Buffer ();
private:
  struct Data
  {
    /* The reference count of an instance of this data structure.
     * Each buffer which references an instance holds a count.
       */
    uint32_t m_count;
    /* 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];
  };

  void TransformIntoRealBuffer (void) const;
  bool CheckInternalState (void) const;
  void Initialize (uint32_t zeroSize);
  uint32_t GetInternalSize (void) const;
  uint32_t GetInternalEnd (void) const;
  static void Recycle (struct Buffer::Data *data);
  static struct Buffer::Data *Create (uint32_t size);
  static struct Buffer::Data *Allocate (uint32_t reqSize);
  static void Deallocate (struct Buffer::Data *data);

  struct Data *m_data;

  /* 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;
  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
  typedef std::vector<struct Buffer::Data*> FreeList;
  struct LocalStaticDestructor 
  {
    ~LocalStaticDestructor ();
  };
  static uint32_t g_maxSize;
  static FreeList *g_freeList;
  static struct LocalStaticDestructor g_localStaticDestructor;
#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 (0)
{
}
Buffer::Iterator::Iterator (Buffer const*buffer)
{
  Construct (buffer);
  m_current = m_dataStart;
}
Buffer::Iterator::Iterator (Buffer const*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 (void)
{
  NS_ASSERT (m_current + 1 <= m_dataEnd);
  m_current++;
}
void 
Buffer::Iterator::Prev (void)
{
  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 (void)
{
  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];
    }
  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 (void)
{
  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];
    }
  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::ReadU8 (void)
{
  NS_ASSERT_MSG (m_current >= m_dataStart &&
                 m_current <= m_dataEnd,
                 GetReadErrorMessage ());

  if (m_current < m_zeroStart)
    {
      uint8_t data = m_data[m_current];
      m_current++;
      return data;
    }
  else if (m_current < m_zeroEnd)
    {
      m_current++;
      return 0;
    }
  else
    {
      uint8_t data = m_data[m_current - (m_zeroEnd-m_zeroStart)];
      m_current++;
      return data;
    }
}

uint16_t 
Buffer::Iterator::ReadU16 (void)
{
  uint8_t byte0 = ReadU8 ();
  uint8_t byte1 = ReadU8 ();
  uint16_t data = byte1;
  data <<= 8;
  data |= byte0;

  return data;
}

Buffer::Buffer (Buffer const&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 (void) const
{
  return m_end - m_start;
}

Buffer::Iterator 
Buffer::Begin (void) const
{
  NS_ASSERT (CheckInternalState ());
  return Buffer::Iterator (this);
}
Buffer::Iterator 
Buffer::End (void) const
{
  NS_ASSERT (CheckInternalState ());
  return Buffer::Iterator (this, false);
}



} // namespace ns3

#endif /* BUFFER_H */