/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2006,2007 INRIA

 * All rights reserved.

 *

 * 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>

 */

#include <utility>

#include "ns3/assert.h"

#include "ns3/fatal-error.h"

#include "packet-history.h"

#include "chunk.h"

#include "buffer.h"

namespace ns3 {

bool PacketHistory::m_enable = false;

PacketHistory::ChunkFactories PacketHistory::m_factories;

uint32_t PacketHistory::m_maxSize = 0;

PacketHistory::DataFreeList PacketHistory::m_freeList;

void 

PacketHistory::Enable (void)

{

  m_enable = true;

}

PacketHistory::PacketHistory ()

  : m_data (0),

    m_end (0),

    m_n (0),

    m_aggregated (false)

{

  Construct (0, 0);

}

PacketHistory::PacketHistory (uint32_t uid, uint32_t size)

  : m_data (0),

    m_end (0),

    m_n (0),

    m_aggregated (false)

{

  Construct (uid, size);

}

void

PacketHistory::Construct (uint32_t uid, uint32_t size)

{

  if (m_enable) 

    {

      m_data = PacketHistory::Create (size);

      AppendOneCommand (PacketHistory::INIT_UID,

                        uid);

    }

}

PacketHistory::PacketHistory (PacketHistory const &o)

  : m_data (o.m_data),

    m_end (o.m_end),

    m_n (o.m_n),

    m_aggregated (o.m_aggregated)

{

  if (m_data != 0) 

    {

      m_data->m_count++;

    }

}

PacketHistory &

PacketHistory::operator = (PacketHistory const& o)

{

  if (m_data == o.m_data) 

    {

      // self assignment

      return *this;

    }

  if (m_data != 0) 

    {

      m_data->m_count--;

      if (m_data->m_count == 0) 

        {

          PacketHistory::Recycle (m_data);

        }

    }

  m_data = o.m_data;

  m_end = o.m_end;

  m_n = o.m_n;

  m_aggregated = o.m_aggregated;

  if (m_data != 0) 

    {

      m_data->m_count++;

    }

  return *this;

}

PacketHistory::~PacketHistory ()

{

  if (m_data != 0) 

    {

      m_data->m_count--;

      if (m_data->m_count == 0) 

        {

          PacketHistory::Recycle (m_data);

        }

    }

}

struct PacketHistory::CommandData *

PacketHistory::Create (uint32_t size)

{

  if (size > m_maxSize)

    {

      m_maxSize = size;

    }

  while (!m_freeList.empty ()) 

    {

      struct PacketHistory::CommandData *data = m_freeList.back ();

      m_freeList.pop_back ();

      if (data->m_size >= size) 

        {

          data->m_count = 1;

          return data;

        }

      PacketHistory::Deallocate (data);

    }

  return PacketHistory::Allocate (size);

}

void

PacketHistory::Recycle (struct CommandData *data)

{

  NS_ASSERT (data->m_count == 0);

  if (m_freeList.size () > 1000 ||

      data->m_size < m_maxSize) 

    {

      PacketHistory::Deallocate (data);

    } 

  else 

    {

      m_freeList.push_back (data);

    }

}

struct PacketHistory::CommandData *

PacketHistory::Allocate (uint32_t n)

{

  uint32_t size = sizeof (struct CommandData);

  if (n <= 4)

    {

      n = 4;

    }

  size += (n-4) * (4 + 1);

  uint8_t *buf = new uint8_t [size];

  struct CommandData *data = (struct CommandData *)buf;

  data->m_size = n;

  data->m_count = 1;

  return data;

}

void 

PacketHistory::Deallocate (struct CommandData *data)

{

  uint8_t *buf = (uint8_t *)data;

  delete [] buf;

}

void

PacketHistory::AppendOneCommand (uint32_t type, uint32_t data0, uint32_t data1)

{

  NS_ASSERT (m_data != 0);

  uint32_t n = GetUleb128Size (type);

  n += GetUleb128Size (data0);

  n += GetUleb128Size (data1);

  if (m_data->m_size > m_end + n)

    {

      if (m_data->m_count == 1 ||

          m_data->m_dirtyEnd == m_end)

        {

          AppendValue (data1);

          AppendValue (data0);

          AppendValue (type);

          m_n++;

          return;

        }

      else

        {

          uint8_t *buffer = &(m_data->m_data[m_end]);

          if (lastType == type)

            {

              if (lastData == data0)

                {

                  if (lastData == data1)

                    {

                      return;

                    }

                }

            }

        }

    }

  Reserve (n);

  AppendValue (data1);

  AppendValue (data0);

  AppendValue (type);

  m_n++;

}

void

PacketHistory::AppendOneCommand (uint32_t type, uint32_t data)

{

  NS_ASSERT (m_data != 0);

  uint32_t n = GetUleb128Size (data);

  n += GetUleb128Size (type);

  if (m_data->m_size > m_end + n)

    {

      if (m_data->m_count == 1 ||

          m_data->m_dirtyEnd == m_end)

        {

          AppendValue (data);

          AppendValue (type);

          m_n++;

          return;

        }

      else

        {

          uint8_t *buffer = &(m_data->m_data[m_end]);

          if (lastType == type)

            {

              if (lastData == data)

                {

                  return;

                }

            }

        }

    }

  Reserve (n);

  AppendValue (data);

  AppendValue (type);

  m_n++;

}

void

PacketHistory::ReserveCopy (uint32_t size)

{

  struct CommandData *newData = PacketHistory::Create (m_end + size);

  memcpy (newData->m_data, m_data->m_data, m_end);

  newData->m_dirtyEnd = m_end;

  m_data->m_count--;

  if (m_data->m_count == 0) 

    {

      PacketHistory::Recycle (m_data);

    }

  m_data = newData;

}

void

PacketHistory::Reserve (uint32_t size)

{

  NS_ASSERT (m_data != 0);

  if (m_data->m_size > m_end + size &&

      (m_data->m_count == 1 ||

       m_data->m_dirtyEnd == m_end))

    {

      /* enough room, not dirty. */

    }

  else 

    {

      /* (enough room and dirty) or (not enough room) */

      ReserveCopy (size);

    }

}

uint32_t 

PacketHistory::GetUleb128Size (uint32_t value) const

{

  uint32_t n = 0;

  uint32_t tmp = value;

  do {

    tmp >>= 7;

    n++;

  } while (tmp != 0);

  return n;

}

uint32_t 

PacketHistory::GetReverseUleb128Size (uint8_t *buffer) const

{

  uint8_t *cur = buffer;

  uint8_t byte = *cur;

  if (byte & 0x80)

    {

      NS_FATAL_ERROR ("The last byte should have a zero high bit");

    }

  cur--;

  while ((byte & 0x80) && (buffer - cur) < 5)

    {

      cur--;

      byte = *cur;

    }

  uint32_t n = buffer - cur;

  return n;

}

void

PacketHistory::AppendValue (uint32_t value)

{

  uint32_t n = 0;

  uint8_t *buffer = &m_data->m_data[m_end];

  do {

    uint8_t byte = value & (~0x80);

    value >>= 7;

    if (value != 0)

      {

        /* more bytes to come */

        byte |= 0x80;

      }

    n++;

    *buffer = byte;

    buffer++;

  } while (value != 0);

  m_end += n;

  if (m_end > m_data->m_dirtyEnd)

    {

      m_data->m_dirtyEnd = m_end;

    }

}

uint32_t

{

  uint32_t result = 0;

  uint8_t shift, byte;

  result = 0;

  shift = 0;

  do {

    byte = *buffer;

    buffer++;

    result |= (byte & (~0x80))<<shift;

    shift += 7;

  } while (byte & 0x80 && 

           /* a LEB128 unsigned number is at most 5 bytes long. */

           shift < (7*5)); 

  if (byte & 0x80)

    {

      /* This means that the LEB128 number was not valid.

       * ie: the last (5th) byte did not have the high-order bit zeroed.

       */

      result = -1;

    }

  *pBuffer = *pBuffer - n;

  return result;

}

PacketHistory 

PacketHistory::CreateFragment (uint32_t start, uint32_t end) const

{

  PacketHistory fragment = *this;

  fragment.RemoveAtStart (start);

  fragment.RemoveAtEnd (end);

  return fragment;

}

void 

PacketHistory::AddHeader (uint32_t uid, Chunk const & header, uint32_t size)

{

  if (m_enable) 

    {

      AppendOneCommand (PacketHistory::ADD_HEADER, uid, size);

    }  

}

void 

PacketHistory::RemoveHeader (uint32_t uid, Chunk const & header, uint32_t size)

{

  if (m_enable) 

    {

      AppendOneCommand (PacketHistory::REM_HEADER, uid, size);

    }

}

void 

PacketHistory::AddTrailer (uint32_t uid, Chunk const & trailer, uint32_t size)

{

  if (m_enable) 

    {

      AppendOneCommand (PacketHistory::ADD_TRAILER, uid, size);

    }

}

void 

PacketHistory::RemoveTrailer (uint32_t uid, Chunk const & trailer, uint32_t size)

{

  if (m_enable) 

    {

      AppendOneCommand (PacketHistory::REM_TRAILER, uid, size);

    }

}

void

PacketHistory::AddAtEnd (PacketHistory const&o)

{

  if (m_enable) 

    {

      m_aggregated = true;

      uint32_t n = GetUleb128Size (PacketHistory::ADD_AT_END);

      n += o.m_end;

      Reserve (n);

      memcpy (&m_data->m_data[m_end], o.m_data->m_data, o.m_end);

      m_end += o.m_end;

      if (m_end > m_data->m_dirtyEnd)

        {

          m_data->m_dirtyEnd = m_end;

        }

      AppendOneCommand (PacketHistory::ADD_AT_END, 0);

    }

}

void

PacketHistory::AddPaddingAtEnd (uint32_t end)

{

  if (m_enable)

    {

      AppendOneCommand (PacketHistory::PADDING_AT_END, end);

    }

}

void 

PacketHistory::RemoveAtStart (uint32_t start)

{

  if (m_enable) 

    {

      AppendOneCommand (PacketHistory::REM_AT_START, start);

    }

}

void 

PacketHistory::RemoveAtEnd (uint32_t end)

{

  if (m_enable) 

    {

      AppendOneCommand (PacketHistory::REM_AT_END, end);

    }

}

void 

PacketHistory::PrintSimple (std::ostream &os, Buffer buffer) const

{

  Buffer original = buffer;

  HeadersToPrint headersToPrint;

  TrailersToPrint trailersToPrint;

  uint8_t *dataBuffer = &m_data->m_data[m_end] - 1;

  int32_t start = 0;

  int32_t end = buffer.GetSize ();

  int32_t curStart = start;

  int32_t curEnd = end;

  for (uint32_t i = 0; i < m_n; i++)

    {

      switch (type)

        {

        case PacketHistory::INIT_UID:

          break;

        case PacketHistory::INIT_SIZE:

          std::cout << "init size=" << data << std::endl;

          break;

        case PacketHistory::ADD_HEADER: {

          if (curStart == start)

            {

              if (start + size < end)

                {

                  headersToPrint.push_back (std::make_pair (data, curStart));

                }

              curStart += size;

              start += size;

            }

          else if (curStart + size <= start)

            {

              // header lies entirely outside of data area.

              curStart += size;

            }

          else if (curStart < start)

            {

              // header lies partly inside and outside of data area

              // potentially, because we fragmented the packet in the middle

              // of this header.

              curStart += size;

            }

          else

            {

              // header lies entirely inside data area but there is some 

              // data at the start of the data area which does not belong

              // to this header. Potentially, because we fragmented

              // the packet in the middle of a previous header.