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

/*

 * Copyright (c) 2008,2009 IITP RAS

 *

 * 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: Kirill Andreev <andreev@iitp.ru>

 */

#include "ie-dot11s-preq.h"

#include "ns3/address-utils.h"

#include "ns3/node.h"

#include "ns3/assert.h"

#include "ns3/test.h"

#include "ns3/packet.h"

namespace ns3 {

namespace dot11s {

/*************************

 * DestinationAddressUnit

 ************************/

DestinationAddressUnit::DestinationAddressUnit ():

  m_do (false),

  m_rf (false),

  m_usn (false),

  m_destinationAddress (Mac48Address ()),

  m_destSeqNumber (0)

{

}

void

DestinationAddressUnit::SetFlags (bool doFlag, bool rfFlag, bool usnFlag)

{

  m_do = doFlag;

  m_rf = rfFlag;

  m_usn = usnFlag;

}

void

DestinationAddressUnit::SetDestSeqNumber (uint32_t dest_seq_number)

{

  m_destSeqNumber = dest_seq_number;

  if(m_destSeqNumber != 0)

    m_usn = true;

}

void

DestinationAddressUnit::SetDestinationAddress (Mac48Address dest_address)

{

  m_destinationAddress = dest_address;

}

bool

DestinationAddressUnit::IsDo ()

{

  return m_do;

}

bool

DestinationAddressUnit::IsRf ()

{

  return m_rf;

}

bool

DestinationAddressUnit::IsUsn ()

{

  return m_usn;

}

uint32_t

DestinationAddressUnit::GetDestSeqNumber () const

{

  return m_destSeqNumber;

}

Mac48Address

DestinationAddressUnit::GetDestinationAddress () const

{

  return m_destinationAddress;

}

/********************************

 * IePreq

 *******************************/

IePreq::~IePreq ()

{

}

TypeId

IePreq::GetTypeId ()

{

  static TypeId tid = TypeId ("ns3::dot11s::IePreq")

                      .SetParent<Object> ();

  return tid;

}

TypeId

IePreq::GetInstanceTypeId () const

{

  return GetTypeId ();

}

IePreq::IePreq ():

    m_maxSize (32),

    m_flags (0),

    m_hopCount (0),

    m_ttl (0),

    m_preqId (0),

    m_originatorAddress (Mac48Address::GetBroadcast()),

    m_originatorSeqNumber (0),

    m_lifetime (0),

    m_metric (0),

    m_destCount (0)

{

}

void

IePreq::SetUnicastPreq ()

{

  m_flags |= 1<<1;

}

void

IePreq::SetNeedNotPrep ()

{

  m_flags |= 1<<2;

}

//void

//IePreq::SetFlags (uint8_t flags)

//{

// m_flags = flags;

//}

void

IePreq::SetHopcount (uint8_t hopcount)

{

  m_hopCount = hopcount;

}

void

IePreq::SetTTL (uint8_t ttl)

{

  m_ttl = ttl;

}

void

IePreq::SetPreqID (uint32_t preq_id)

{

  m_preqId = preq_id;

}

void

IePreq::SetMetric (uint32_t metric)

{

  m_metric = metric;

}

void

IePreq::SetOriginatorAddress (Mac48Address originator_address)

{

  m_originatorAddress = originator_address;

}

void

IePreq::SetOriginatorSeqNumber (uint32_t originator_seq_number)

{

  m_originatorSeqNumber = originator_seq_number;

}

void

IePreq::SetLifetime (uint32_t lifetime)

{

  m_lifetime = lifetime;

}

void

IePreq::SetDestCount (uint8_t dest_count)

{

  m_destCount = dest_count;

}

bool

IePreq::IsUnicastPreq () const

{

  return (m_flags & (1<<1));

}

bool

IePreq::IsNeedNotPrep () const

{

  return (m_flags & (1<<2));

}

uint8_t

IePreq::GetHopCount () const

{

  return m_hopCount;

}

uint8_t

IePreq::GetTtl () const

{

  return m_ttl;

}

uint32_t

IePreq::GetPreqID () const

{

  return m_preqId;

}

uint32_t

IePreq::GetMetric () const

{

  return m_metric;

}

Mac48Address

IePreq::GetOriginatorAddress () const

{

  return m_originatorAddress;

}

uint32_t

IePreq::GetOriginatorSeqNumber () const

{

  return m_originatorSeqNumber;

}

uint32_t

IePreq::GetLifetime () const

{

  return m_lifetime;

}

uint8_t

IePreq::GetDestCount () const

{

  return m_destCount;

}

void

IePreq::DecrementTtl ()

{

  m_ttl --;

  m_hopCount ++;

}

void

IePreq::IncrementMetric (uint32_t metric)

{

  m_metric +=metric;

}

void

IePreq::SerializeInformation (Buffer::Iterator i) const

{

  i.WriteU8 (m_flags);

  i.WriteU8 (m_hopCount);

  i.WriteU8 (m_ttl);

  i.WriteHtonU32 (m_preqId);

  WriteTo (i, m_originatorAddress);

  i.WriteHtonU32 (m_originatorSeqNumber);

  i.WriteHtonU32 (m_lifetime);

  i.WriteHtonU32 (m_metric);

  i.WriteU8 (m_destCount);

  int written = 0;

  for (std::vector<Ptr<DestinationAddressUnit> >::const_iterator j = m_destinations.begin (); j != m_destinations.end(); j++)

    {

      uint8_t flags = 0;

      if ((*j)->IsDo ())

        flags += 128;

      if ((*j)->IsRf ())

        flags += 64;

      if((*j)->IsUsn ())

        flags += 32;

      i.WriteU8 (flags);

      WriteTo (i, (*j)->GetDestinationAddress());

      i.WriteHtonU32 ((*j)->GetDestSeqNumber ());

      written++;

      if (written > m_maxSize)

        break;

    }

}

uint8_t

IePreq::DeserializeInformation (Buffer::Iterator start, uint8_t length)

{

  Buffer::Iterator i = start;

  m_flags = i.ReadU8 ();

  m_hopCount = i.ReadU8 ();

  m_ttl = i.ReadU8 ();

  m_preqId = i.ReadNtohU32 ();

  ReadFrom (i, m_originatorAddress);

  m_originatorSeqNumber = i.ReadNtohU32 ();

  m_lifetime = i.ReadNtohU32 ();

  m_metric = i.ReadNtohU32 ();

  m_destCount = i.ReadU8 ();

  for (int j = 0; j < m_destCount; j++ )

    {

      Ptr<DestinationAddressUnit> new_element = Create<DestinationAddressUnit> ();

      bool doFlag = false;

      bool rfFlag = false;

      bool usnFlag = false;

      uint8_t flags = i.ReadU8 ();

      if (flags >= 128)

        {

          doFlag = true;

          flags -=128;

        }

      if (flags >=64)

      {

        rfFlag = true;

        flags -= 64;

      }

      if (flags >= 32)

        usnFlag = true;

      new_element->SetFlags (doFlag, rfFlag, usnFlag);

      Mac48Address addr;

      ReadFrom (i,addr);

      new_element->SetDestinationAddress (addr);

      new_element->SetDestSeqNumber (i.ReadNtohU32());

      m_destinations.push_back (new_element);

      NS_ASSERT (28+j*11 < length);

    }

  return i.GetDistanceFrom (start);

}

uint8_t

IePreq::GetInformationSize () const

{

  uint8_t retval =

     1 //Flags

    +1 //Hopcount

    +1 //TTL

    +4 //PREQ ID

    +6 //Source address (originator)

    +4 //Originator seqno

    +4 //Lifetime

    +4 //metric

    +1; //destination count

  if (m_destCount > m_maxSize)

     retval += (m_maxSize*11);

  else

     retval += (m_destCount*11);

  return retval;

}

void

IePreq::PrintInformation (std::ostream &os) const

{

  os << " originator address  = " << m_originatorAddress << "\n";

  os << " TTL                 = "  <<  (uint16_t)m_ttl << "\n";

  os << " hop count           = "  <<  (uint16_t)m_hopCount << "\n";

  os << " metric              = " << m_metric << "\n";

  os << " seqno               = " << m_originatorSeqNumber << "\n";

  os << " lifetime            = " << m_lifetime << "\n";

  os << " preq ID             = " <<m_preqId << "\n";

  os << " Destinations are:\n";

  for (int j = 0; j < m_destCount; j++ )

    os << "    " << m_destinations[j]->GetDestinationAddress () << "\n";

}

std::vector<Ptr<DestinationAddressUnit> >

IePreq::GetDestinationList ()

{

  return m_destinations;

}

void

IePreq::AddDestinationAddressElement (

  bool doFlag, bool rfFlag,

  Mac48Address dest_address,

  uint32_t dest_seq_number

)

{

  for (std::vector<Ptr<DestinationAddressUnit> >::const_iterator i = m_destinations.begin (); i != m_destinations.end(); i++ )

    if ((*i)->GetDestinationAddress () == dest_address)

      return;

  Ptr<DestinationAddressUnit>new_element = Create<DestinationAddressUnit> ();

  new_element->SetFlags (doFlag, rfFlag, false);

  new_element->SetDestinationAddress (dest_address);

  new_element->SetDestSeqNumber (dest_seq_number);

  m_destinations.push_back (new_element);

  m_destCount++;

}

void

IePreq::DelDestinationAddressElement (Mac48Address dest_address)

{

  for (std::vector<Ptr<DestinationAddressUnit> >::iterator i = m_destinations.begin (); i != m_destinations.end(); i++)

    if ((*i)->GetDestinationAddress () == dest_address)

      {

        m_destinations.erase (i);

        m_destCount--;

        break;

      }

}

void

IePreq::ClearDestinationAddressElement ()

{

  int i;

  for (std::vector<Ptr<DestinationAddressUnit> >::iterator j = m_destinations.begin (); j != m_destinations.end(); j++)

    (*j) = 0;

  for (i = 0; i < m_destCount; i ++)

    m_destinations.pop_back ();

  m_destinations.clear ();

}

bool operator== (const DestinationAddressUnit & a, const DestinationAddressUnit & b)

{

  return (a.m_do == b.m_do 

      &&  a.m_rf == b.m_rf

      &&  a.m_usn == b.m_usn

      &&  a.m_destinationAddress == b.m_destinationAddress

      &&  a.m_destSeqNumber == b.m_destSeqNumber

    );

}

bool operator== (const IePreq & a, const IePreq & b)

{

  bool ok = ( a.m_flags == b.m_flags 

    && a.m_hopCount == b.m_hopCount

    && a.m_ttl == b.m_ttl

    && a.m_preqId == b.m_preqId 

    && a.m_originatorAddress == b.m_originatorAddress

    && a.m_originatorSeqNumber == b.m_originatorSeqNumber

    && a.m_lifetime == b.m_lifetime

    && a.m_metric == b.m_metric

    && a.m_destCount == b.m_destCount

  );

  if (! ok) 

    return false;

  if (a.m_destinations.size() != b.m_destinations.size())

    return false;

  for (size_t i = 0; i < a.m_destinations.size(); ++i)

    if (!( *(PeekPointer (a.m_destinations[i])) == 

           *(PeekPointer (b.m_destinations[i]))

         )

       )

      return false;

  return true;

}

bool

IePreq::MayAddAddress (Mac48Address originator)

{

  if (m_originatorAddress != originator)

    return false;

  if(m_destinations[0]->GetDestinationAddress () == Mac48Address::GetBroadcast ())

    return false;

  return true;

}

#ifdef RUN_SELF_TESTS

/// Built-in self test for IePreq

{

  virtual bool RunTests(); 

};

/// Test instance

static IePreqBist g_IePreqBist;

bool IePreqBist::RunTests ()

{

  bool result(true);

  // create test information element

  IePreq a;

  a.SetHopcount (0);

  a.SetTTL (1);

  a.SetPreqID (2);

  a.SetOriginatorAddress ( Mac48Address("11:22:33:44:55:66") );

  a.SetOriginatorSeqNumber (3);

  a.SetLifetime (4);

  a.AddDestinationAddressElement (false, false, Mac48Address("11:11:11:11:11:11"), 5);

  a.AddDestinationAddressElement (false, false, Mac48Address("22:22:22:22:22:22"), 6);

  return result;

}

#endif // RUN_SELF_TESTS

} // namespace dot11s

} //namespace ns3