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

/* vim: set ts=2 sw=2 sta expandtab ai si cin: */

/* 

 * Copyright (c) 2009 Drexel University

 * 

 * 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: Tom Wambold <tom5760@gmail.com>

 */

/* These classes implement RFC 5444 - The Generalized Mobile Ad Hoc Network

 * (MANET) Packet/PbbMessage Format

 * See: http://tools.ietf.org/html/rfc5444 for details */

#include "ns3/ipv4-address.h"

#include "ns3/ipv6-address.h"

#include "ns3/assert.h"

#include "packetbb.h"

static const uint8_t VERSION = 0;

/* Packet flags */

static const uint8_t PHAS_SEQ_NUM = 0x8;

static const uint8_t PHAS_TLV = 0x4;

/* PbbMessage flags */

static const uint8_t MHAS_ORIG = 0x80;

static const uint8_t MHAS_HOP_LIMIT = 0x40;

static const uint8_t MHAS_HOP_COUNT = 0x20;

static const uint8_t MHAS_SEQ_NUM = 0x10;

/* Address block flags */

static const uint8_t AHAS_HEAD = 0x80;

static const uint8_t AHAS_FULL_TAIL = 0x40;

static const uint8_t AHAS_ZERO_TAIL = 0x20;

static const uint8_t AHAS_SINGLE_PRE_LEN = 0x10;

static const uint8_t AHAS_MULTI_PRE_LEN = 0x08;

/* TLV Flags */

static const uint8_t THAS_TYPE_EXT = 0x80;

static const uint8_t THAS_SINGLE_INDEX = 0x40;

static const uint8_t THAS_MULTI_INDEX = 0x20;

static const uint8_t THAS_VALUE = 0x10;

static const uint8_t THAS_EXT_LEN = 0x08;

static const uint8_t TIS_MULTIVALUE = 0x04;

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (PbbPacket);

PbbTlvBlock::PbbTlvBlock (void)

{

  return;

}

PbbTlvBlock::~PbbTlvBlock (void)

{

  Clear ();

}

PbbTlvBlock::Iterator

PbbTlvBlock::Begin (void)

{

  return m_tlvList.begin ();

}

PbbTlvBlock::ConstIterator

PbbTlvBlock::Begin (void) const

{

  return m_tlvList.begin ();

}

PbbTlvBlock::Iterator

PbbTlvBlock::End (void)

{

  return m_tlvList.end ();

}

PbbTlvBlock::ConstIterator

PbbTlvBlock::End (void) const

{

  return m_tlvList.end ();

}

int

PbbTlvBlock::Size (void) const

{

  return m_tlvList.size ();

}

bool

PbbTlvBlock::Empty (void) const

{

  return m_tlvList.empty ();

}

Ptr<PbbTlv>

PbbTlvBlock::Front (void) const

{

  return m_tlvList.front ();

}

Ptr<PbbTlv>

PbbTlvBlock::Back (void) const

{

  return m_tlvList.back ();

}

void

PbbTlvBlock::PushFront (Ptr<PbbTlv> tlv)

{

  m_tlvList.push_front (tlv);

}

void

PbbTlvBlock::PopFront (void)

{

  m_tlvList.pop_front ();

}

void

PbbTlvBlock::PushBack (Ptr<PbbTlv> tlv)

{

  m_tlvList.push_back (tlv);

}

void

PbbTlvBlock::PopBack (void)

{

  m_tlvList.pop_back ();

}

PbbTlvBlock::Iterator

PbbTlvBlock::Insert (PbbTlvBlock::Iterator position, const Ptr<PbbTlv> tlv)

{

  return m_tlvList.insert (position, tlv);

}

PbbTlvBlock::Iterator

PbbTlvBlock::Erase (PbbTlvBlock::Iterator position)

{

  return m_tlvList.erase (position);

}

PbbTlvBlock::Iterator

PbbTlvBlock::Erase (PbbTlvBlock::Iterator first, PbbTlvBlock::Iterator last)

{

  return m_tlvList.erase (first, last);

}

void

PbbTlvBlock::Clear (void)

{

  for (Iterator iter = Begin (); iter != End (); iter++)

    {

      *iter = 0;

    }

  m_tlvList.clear ();

}

uint32_t

PbbTlvBlock::GetSerializedSize (void) const

{

  /* tlv size */

  uint32_t size = 2;

  for (ConstIterator iter = Begin (); iter != End (); iter++)

    {

      size += (*iter)->GetSerializedSize ();

    }

  return size;

}

void

PbbTlvBlock::Serialize (Buffer::Iterator &start) const

{

  if (Empty ())

    {

      start.WriteHtonU16 (0);

      return;

    }

  /* We need to write the size of the TLV block in front, so save its

   * position. */

  Buffer::Iterator tlvsize = start;

  start.Next (2);

  for (ConstIterator iter = Begin (); iter != End (); iter++)

    {

      (*iter)->Serialize (start);

    }

  /* - 2 to not include the size field */

  uint16_t size = start.GetDistanceFrom (tlvsize) - 2;

  tlvsize.WriteHtonU16 (size);

}

void

PbbTlvBlock::Deserialize (Buffer::Iterator &start)

{

  uint16_t size = start.ReadNtohU16 ();

  Buffer::Iterator tlvstart = start;

  if (size > 0)

    {

      while (start.GetDistanceFrom (tlvstart) < size)

        {

          Ptr<PbbTlv> newtlv = Create<PbbTlv> ();

          newtlv->Deserialize (start);

          PushBack (newtlv);

        }

    }

}

void

PbbTlvBlock::Print (std::ostream &os) const

{

  Print (os, 0);

}

void

PbbTlvBlock::Print (std::ostream &os, int level) const

{

  std::string prefix = "";

  for (int i = 0; i < level; i++)

    {

      prefix.append("\t");

    }

  os << prefix << "TLV Block {" << std::endl;

  os << prefix << "\tsize = " << Size () << std::endl;

  os << prefix << "\tmembers [" << std::endl;

  for (ConstIterator iter = Begin (); iter != End (); iter++)

    {

      (*iter)->Print (os, level+2);

    }

  os << prefix << "\t]" << std::endl;

  os << prefix << "}" << std::endl;

}

bool

PbbTlvBlock::operator== (const PbbTlvBlock &other) const

{

  if (Size () != other.Size ())

    {

      return false;

    }

  ConstIterator ti, oi;

  for (ti = Begin (), oi = other.Begin ();

      ti != End () && oi != other.End ();

      ti++, oi++)

    {

      if (**ti != **oi)

        {

          return false;

        }

    }

  return true;

}

bool

PbbTlvBlock::operator!= (const PbbTlvBlock &other) const

{

  return !(*this == other);

}

/* End PbbTlvBlock class */

PbbAddressTlvBlock::PbbAddressTlvBlock (void)

{

  return;

}

PbbAddressTlvBlock::~PbbAddressTlvBlock (void)

{

  Clear ();

}

PbbAddressTlvBlock::Iterator

PbbAddressTlvBlock::Begin (void)

{

  return m_tlvList.begin ();

}

PbbAddressTlvBlock::ConstIterator

PbbAddressTlvBlock::Begin (void) const

{

  return m_tlvList.begin ();

}

PbbAddressTlvBlock::Iterator

PbbAddressTlvBlock::End (void)

{

  return m_tlvList.end ();

}

PbbAddressTlvBlock::ConstIterator

PbbAddressTlvBlock::End (void) const

{

  return m_tlvList.end ();

}

int

PbbAddressTlvBlock::Size (void) const

{

  return m_tlvList.size ();

}

bool

PbbAddressTlvBlock::Empty (void) const

{

  return m_tlvList.empty ();

}

Ptr<PbbAddressTlv>

PbbAddressTlvBlock::Front (void) const

{

  return m_tlvList.front ();

}

Ptr<PbbAddressTlv>

PbbAddressTlvBlock::Back (void) const

{

  return m_tlvList.back ();

}

void

PbbAddressTlvBlock::PushFront (Ptr<PbbAddressTlv> tlv)

{

  m_tlvList.push_front (tlv);

}

void

PbbAddressTlvBlock::PopFront (void)

{

  m_tlvList.pop_front ();

}

void

PbbAddressTlvBlock::PushBack (Ptr<PbbAddressTlv> tlv)

{

  m_tlvList.push_back (tlv);

}

void

PbbAddressTlvBlock::PopBack (void)

{

  m_tlvList.pop_back ();

}

PbbAddressTlvBlock::Iterator

PbbAddressTlvBlock::Insert (PbbAddressTlvBlock::Iterator position, const Ptr<PbbAddressTlv> tlv)

{

  return m_tlvList.insert (position, tlv);

}

PbbAddressTlvBlock::Iterator

PbbAddressTlvBlock::Erase (PbbAddressTlvBlock::Iterator position)

{

  return m_tlvList.erase (position);

}

PbbAddressTlvBlock::Iterator

PbbAddressTlvBlock::Erase (PbbAddressTlvBlock::Iterator first, PbbAddressTlvBlock::Iterator last)

{

  return m_tlvList.erase (first, last);

}

void

PbbAddressTlvBlock::Clear (void)

{

  for (Iterator iter = Begin (); iter != End (); iter++)

    {

      *iter = 0;

    }

  m_tlvList.clear ();

}

uint32_t

PbbAddressTlvBlock::GetSerializedSize (void) const

{

  /* tlv size */

  uint32_t size = 2;

  for (ConstIterator iter = Begin (); iter != End (); iter++)

    {

      size += (*iter)->GetSerializedSize ();

    }

  return size;

}

void

PbbAddressTlvBlock::Serialize (Buffer::Iterator &start) const

{

  if (Empty ())

    {

      start.WriteHtonU16 (0);

      return;

    }

  /* We need to write the size of the TLV block in front, so save its

   * position. */

  Buffer::Iterator tlvsize = start;

  start.Next (2);

  for (ConstIterator iter = Begin (); iter != End (); iter++)

    {

      (*iter)->Serialize (start);

    }

  /* - 2 to not include the size field */

  uint16_t size = start.GetDistanceFrom (tlvsize) - 2;

  tlvsize.WriteHtonU16 (size);

}

void

PbbAddressTlvBlock::Deserialize (Buffer::Iterator &start)

{

  uint16_t size = start.ReadNtohU16 ();

  Buffer::Iterator tlvstart = start;

  if (size > 0)

    {

      while (start.GetDistanceFrom (tlvstart) < size)

      {

        Ptr<PbbAddressTlv> newtlv = Create<PbbAddressTlv> ();

        newtlv->Deserialize (start);

        PushBack (newtlv);

      }

    }

}

void

PbbAddressTlvBlock::Print (std::ostream &os) const

{

  Print (os, 0);

}

void

PbbAddressTlvBlock::Print (std::ostream &os, int level) const

{

  std::string prefix = "";

  for (int i = 0; i < level; i++)

    {

      prefix.append("\t");

    }

  os << prefix << "TLV Block {" << std::endl;

  os << prefix << "\tsize = " << Size () << std::endl;

  os << prefix << "\tmembers [" << std::endl;

  for (ConstIterator iter = Begin (); iter != End (); iter++)

    {

      (*iter)->Print (os, level+2);

    }

  os << prefix << "\t]" << std::endl;

  os << prefix << "}" << std::endl;

}

bool

PbbAddressTlvBlock::operator== (const PbbAddressTlvBlock &other) const

{

  if (Size () != other.Size ())

    {

      return false;

    }

  ConstIterator it, ot;

  for (it = Begin (), ot = other.Begin ();

      it != End () && ot != other.End ();

      it++, ot++)

    {

      if (**it != **ot)

        {

          return false;

        }

    }

  return true;

}

bool

PbbAddressTlvBlock::operator!= (const PbbAddressTlvBlock &other) const

{

  return !(*this == other);

}

/* End PbbAddressTlvBlock Class */

PbbPacket::PbbPacket (void)

{

  m_version = VERSION;

  m_hasseqnum = false;

}

PbbPacket::~PbbPacket (void)

{

  MessageClear ();

}

uint8_t

PbbPacket::GetVersion (void) const

{

  return m_version;

}

void

PbbPacket::SetSequenceNumber (uint16_t number)

{

  m_seqnum = number;

  m_hasseqnum = true;

}

uint16_t

PbbPacket::GetSequenceNumber (void) const

{

  NS_ASSERT (HasSequenceNumber ());

  return m_seqnum;

}

bool

PbbPacket::HasSequenceNumber (void) const

{

  return m_hasseqnum;

}

/* Manipulating Packet TLVs */

PbbPacket::TlvIterator

PbbPacket::TlvBegin (void)

{

  return m_tlvList.Begin ();

}

PbbPacket::ConstTlvIterator

PbbPacket::TlvBegin (void) const

{

  return m_tlvList.Begin ();

}

PbbPacket::TlvIterator

PbbPacket::TlvEnd (void)

{

  return m_tlvList.End ();

}

PbbPacket::ConstTlvIterator

PbbPacket::TlvEnd (void) const

{

  return m_tlvList.End ();

}

int

PbbPacket::TlvSize (void) const

{

  return m_tlvList.Size ();

}

bool

PbbPacket::TlvEmpty (void) const

{

  return m_tlvList.Empty ();

}

Ptr<PbbTlv>

PbbPacket::TlvFront (void)

{

  return m_tlvList.Front ();

}

const Ptr<PbbTlv>

PbbPacket::TlvFront (void) const

{

  return m_tlvList.Front ();

}

Ptr<PbbTlv>

PbbPacket::TlvBack (void)

{

  return m_tlvList.Back ();

}

const Ptr<PbbTlv>

PbbPacket::TlvBack (void) const

{

  return m_tlvList.Back ();

}

void

PbbPacket::TlvPushFront (Ptr<PbbTlv> tlv)

{

  m_tlvList.PushFront (tlv);

}

void

PbbPacket::TlvPopFront (void)

{

  m_tlvList.PopFront ();

}

void

PbbPacket::TlvPushBack (Ptr<PbbTlv> tlv)

{

  m_tlvList.PushBack (tlv);

}

void

PbbPacket::TlvPopBack (void)

{

  m_tlvList.PopBack ();

}

PbbPacket::TlvIterator

PbbPacket::Erase (PbbPacket::TlvIterator position)

{

  return m_tlvList.Erase (position);

}

PbbPacket::TlvIterator

PbbPacket::Erase (PbbPacket::TlvIterator first, PbbPacket::TlvIterator last)

{

  return m_tlvList.Erase (first, last);

}

void

PbbPacket::TlvClear (void)

{

  m_tlvList.Clear ();

}

/* Manipulating Packet Messages */

PbbPacket::MessageIterator

PbbPacket::MessageBegin (void)

{

  return m_messageList.begin ();

}

PbbPacket::ConstMessageIterator

PbbPacket::MessageBegin (void) const

{

  return m_messageList.begin ();

}

PbbPacket::MessageIterator

PbbPacket::MessageEnd (void)

{

  return m_messageList.end ();

}

PbbPacket::ConstMessageIterator

PbbPacket::MessageEnd (void) const

{

  return m_messageList.end ();

}

int

PbbPacket::MessageSize (void) const

{

  return m_messageList.size ();

}

bool

PbbPacket::MessageEmpty (void) const

{

  return m_messageList.empty ();

}

Ptr<PbbMessage>

PbbPacket::MessageFront (void)

{

  return m_messageList.front ();

}

const Ptr<PbbMessage>

PbbPacket::MessageFront (void) const

{

  return m_messageList.front ();

}

Ptr<PbbMessage>

PbbPacket::MessageBack (void)

{

  return m_messageList.back ();

}

const Ptr<PbbMessage>

PbbPacket::MessageBack (void) const

{

  return m_messageList.back ();

}

void

PbbPacket::MessagePushFront (Ptr<PbbMessage> tlv)

{

  m_messageList.push_front (tlv);

}

void

PbbPacket::MessagePopFront (void)

{

  m_messageList.pop_front ();

}

void

PbbPacket::MessagePushBack (Ptr<PbbMessage> tlv)

{

  m_messageList.push_back (tlv);

}

void

PbbPacket::MessagePopBack (void)

{

  m_messageList.pop_back ();

}

PbbPacket::MessageIterator

PbbPacket::Erase (PbbPacket::MessageIterator position)

{

  return m_messageList.erase (position);

}

PbbPacket::MessageIterator

PbbPacket::Erase (PbbPacket::MessageIterator first,

    PbbPacket::MessageIterator last)

{

  return m_messageList.erase (first, last);

}

void

PbbPacket::MessageClear (void)

{

  for (MessageIterator iter = MessageBegin (); iter != MessageEnd (); iter++)

    {

      *iter = 0;

    }

  m_messageList.clear ();

}

TypeId

PbbPacket::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::PbbPacket")

    .SetParent<Header> ()

    .AddConstructor<PbbPacket> ()

  ;

  return tid;

}

TypeId

PbbPacket::GetInstanceTypeId (void) const

{

  return GetTypeId ();

}

uint32_t

PbbPacket::GetSerializedSize (void) const

{

  /* Version number + flags */

  uint32_t size = 1;

  if (HasSequenceNumber())

    {

      size += 2;

    }

  if (!TlvEmpty ())

    {

      size += m_tlvList.GetSerializedSize ();

    }

  for (ConstMessageIterator iter = MessageBegin ();

      iter != MessageEnd ();

      iter++)

    {

      size += (*iter)->GetSerializedSize ();

    }

  return size;

}

void

PbbPacket::Serialize (Buffer::Iterator start) const

{

  /* We remember the start, so we can write the flags after we check for a

   * sequence number and TLV. */

  Buffer::Iterator bufref = start;

  start.Next ();

  uint8_t flags = VERSION;

  /* Make room for 4 bit flags */

  flags <<= 4;

  if (HasSequenceNumber ())

    {

      flags |= PHAS_SEQ_NUM;

      start.WriteHtonU16 (GetSequenceNumber ());

    }

  if (!TlvEmpty ())

    {

      flags |= PHAS_TLV;

      m_tlvList.Serialize (start);

    }

  bufref.WriteU8(flags);

  for (ConstMessageIterator iter = MessageBegin ();

      iter != MessageEnd ();

      iter++)

    {

      (*iter)->Serialize (start);

    }

}

uint32_t

PbbPacket::Deserialize (Buffer::Iterator start)

{

  Buffer::Iterator begin = start;

  uint8_t flags = start.ReadU8 ();

  if (flags & PHAS_SEQ_NUM)

    {

      SetSequenceNumber (start.ReadNtohU16 ());

    }

  if (flags & PHAS_TLV)

    {

      m_tlvList.Deserialize (start);

    }

  while (!start.IsEnd())

    {

      Ptr<PbbMessage> newmsg = PbbMessage::DeserializeMessage (start);

      if (newmsg == 0)

        {

          return start.GetDistanceFrom (begin);

        }

      MessagePushBack (newmsg);

    }

  flags >>= 4;

  m_version = flags;

  return start.GetDistanceFrom (begin);

}

void

PbbPacket::Print (std::ostream &os) const

{

  os << "PbbPacket {" << std::endl;

  if (HasSequenceNumber ())

    {

      os << "\tsequence number = " << GetSequenceNumber ();

    }

  os << std::endl;

  m_tlvList.Print (os, 1);

  for (ConstMessageIterator iter = MessageBegin ();

      iter != MessageEnd ();

      iter++)

    {

      (*iter)->Print (os, 1);

    }

  os << "}" << std::endl;

}

bool

PbbPacket::operator== (const PbbPacket &other) const

{

  if (GetVersion () != other.GetVersion ())

    {

      return false;

    }

  if (HasSequenceNumber () != other.HasSequenceNumber ())

    {

      return false;

    }

  if (HasSequenceNumber ())

    {

      if (GetSequenceNumber () != other.GetSequenceNumber ())

        return false;

    }

  if (m_tlvList != other.m_tlvList)

    {

      return false;

    }

  if (MessageSize () != other.MessageSize ())

    {

        return false;

    }

  ConstMessageIterator tmi, omi;

  for (tmi = MessageBegin (), omi = other.MessageBegin ();

    tmi != MessageEnd () && omi != other.MessageEnd ();

    tmi++, omi++)

    {

      if (**tmi != **omi)

        {

          return false;

        }

    }

  return true;

}

bool

PbbPacket::operator!= (const PbbPacket &other) const

{

  return !(*this == other);

}

/* End PbbPacket class */

PbbMessage::PbbMessage ()

{

  /* Default to IPv4 */

  m_addrSize = IPV4;

  m_hasOriginatorAddress = false;

  m_hasHopLimit = false;

  m_hasHopCount = false;

  m_hasSequenceNumber = false;

}

PbbMessage::~PbbMessage ()

{

  AddressBlockClear ();

}

void

PbbMessage::SetType (uint8_t type)

{

  m_type = type;

}

uint8_t

PbbMessage::GetType (void) const

{

  return m_type;

}

PbbAddressLength

PbbMessage::GetAddressLength (void) const

{

  return m_addrSize;

}

void

PbbMessage::SetOriginatorAddress (Address address)

{

  m_originatorAddress = address;

  m_hasOriginatorAddress = true;

}

Address

PbbMessage::GetOriginatorAddress (void) const

{

  NS_ASSERT (HasOriginatorAddress ());

  return m_originatorAddress;

}

bool

PbbMessage::HasOriginatorAddress (void) const

{

  return m_hasOriginatorAddress;

}

void

PbbMessage::SetHopLimit (uint8_t hopLimit)

{

  m_hopLimit = hopLimit;

  m_hasHopLimit = true;

}

uint8_t

PbbMessage::GetHopLimit (void) const