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

/*

 * Copyright (c) 2007-2009 Strasbourg 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: Sebastien Vincent <vincent@clarinet.u-strasbg.fr>

 *         Mehdi Benamor <benamor.mehdi@ensi.rnu.tn> 

 *         David Gross <gdavid.devel@gmail.com>

 */

#include "ns3/assert.h"

#include "ns3/address-utils.h"

#include "ns3/log.h"

#include "icmpv6-header.h"

namespace ns3

{

NS_OBJECT_ENSURE_REGISTERED (Icmpv6Header);

NS_LOG_COMPONENT_DEFINE ("Icmpv6Header");

TypeId Icmpv6Header::GetTypeId ()

{

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

    .SetParent<Header> ()

    .AddConstructor<Icmpv6Header> ()

  ;

  return tid;

}

TypeId Icmpv6Header::GetInstanceTypeId () const

{

  return GetTypeId ();

}

Icmpv6Header::Icmpv6Header ()

  : m_calcChecksum (true),

    m_checksum (0),

    m_type (0),

    m_code (0)

{

}

Icmpv6Header::~Icmpv6Header ()

{

}

uint8_t Icmpv6Header::GetType () const

{

  return m_type;

}

void Icmpv6Header::SetType (uint8_t type)

{

  m_type = type;

}

uint8_t Icmpv6Header::GetCode () const

{

  return m_code;

}

void Icmpv6Header::SetCode (uint8_t code)

{

  m_code = code;

}

uint16_t Icmpv6Header::GetChecksum () const

{

  return m_checksum;

}

void Icmpv6Header::SetChecksum (uint16_t checksum)

{

  m_checksum = checksum;

}

void Icmpv6Header::Print (std::ostream& os) const

{

  os << "( type = " << (uint32_t)m_type << " code = " << (uint32_t)m_code << " checksum = " << (uint32_t)m_checksum << ")";

}

uint32_t Icmpv6Header::GetSerializedSize () const

{

  return 4;

}

uint32_t Icmpv6Header::Deserialize (Buffer::Iterator start)

{

  Buffer::Iterator i = start;

  m_type = i.ReadU8 ();

  m_code = i.ReadU8 ();

  m_checksum = i.ReadNtohU16 ();

#if 0

  i.ReadU32 (); /* padding */

#endif

  return GetSerializedSize ();

}

void Icmpv6Header::Serialize (Buffer::Iterator start) const

{

  Buffer::Iterator i = start;

  i.WriteU8 (m_type);

  i.WriteU8 (m_code);

  i.WriteU16 (0);

#if 0

  i.WriteU32 (0); /* padding */

#endif

  if (m_calcChecksum)

    {

      i = start;

      uint16_t checksum = i.CalculateIpChecksum (i.GetSize (), m_checksum);

      i = start;

      i.Next (2);

      i.WriteU16 (checksum);

    }

}

void Icmpv6Header::CalculatePseudoHeaderChecksum (Ipv6Address src, Ipv6Address dst, uint16_t length, uint8_t protocol)

{

  Buffer buf = Buffer (40);

  uint8_t tmp[16];

  Buffer::Iterator it;

  buf.AddAtStart (40);

  it = buf.Begin ();

  src.Serialize (tmp);

  it.Write (tmp, 16); /* source IPv6 address */

  dst.Serialize (tmp);

  it.Write (tmp, 16); /* destination IPv6 address */

  it.WriteU16 (0); /* length */

  it.WriteU8 (length >> 8); /* length */

  it.WriteU8 (length & 0xff); /* length */

  it.WriteU16 (0); /* zero */

  it.WriteU8 (0); /* zero */

  it.WriteU8 (protocol); /* next header */

  it = buf.Begin ();

  m_checksum = ~(it.CalculateIpChecksum (40));

}

NS_OBJECT_ENSURE_REGISTERED (Icmpv6NS);

Icmpv6NS::Icmpv6NS ()

{

  SetType (ICMPV6_ND_NEIGHBOR_SOLICITATION);

  SetCode (0);

  SetReserved (0);

  m_checksum = 0;

}

TypeId Icmpv6NS::GetTypeId ()

{

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

    .SetParent<Icmpv6Header> ()

    .AddConstructor<Icmpv6NS> ()

  ;

  return tid;

}

TypeId Icmpv6NS::GetInstanceTypeId () const

{

  return GetTypeId ();

}

Icmpv6NS::Icmpv6NS (Ipv6Address target)

{

  SetType (ICMPV6_ND_NEIGHBOR_SOLICITATION);

  SetCode (0);

  SetReserved (0);

  SetIpv6Target (target);

  m_checksum = 0;

  /* test */

  /*

     m_reserved = 0xdeadbeef;

     */

}

Icmpv6NS::~Icmpv6NS ()

{

}

uint32_t Icmpv6NS::GetReserved () const

{

  return m_reserved;

}

void Icmpv6NS::SetReserved (uint32_t reserved)

{

  m_reserved = reserved;

}

Ipv6Address Icmpv6NS::GetIpv6Target () const

{

  return m_target;

}

void Icmpv6NS::SetIpv6Target (Ipv6Address target)

{

  m_target = target;

}

void Icmpv6NS::Print (std::ostream& os) const

{

  os << "( type = " << (uint32_t)GetType () << " (NS) code = " << (uint32_t)GetCode () << " checksum = " << (uint32_t)GetChecksum ()  << ")";

}

uint32_t Icmpv6NS::GetSerializedSize () const

{

  return 24;

}

void Icmpv6NS::Serialize (Buffer::Iterator start) const

{

  NS_LOG_FUNCTION_NOARGS ();

  uint8_t buff_target[16];

  uint16_t checksum = 0;

  Buffer::Iterator i = start;

  i.WriteU8 (GetType ());

  i.WriteU8 (GetCode ());

  i.WriteU16 (0);

  i.WriteHtonU32 (m_reserved);

  m_target.Serialize (buff_target);

  i.Write (buff_target, 16);

  if (m_calcChecksum)

    {

      i = start;

      checksum = i.CalculateIpChecksum (i.GetSize (), m_checksum);

      i = start;

      i.Next (2);

      i.WriteU16 (checksum);

    }

}

uint32_t Icmpv6NS::Deserialize (Buffer::Iterator start)

{

  uint8_t buf[16];

  Buffer::Iterator i = start;

  SetType (i.ReadU8 ());

  SetCode (i.ReadU8 ());

  m_checksum = i.ReadU16 ();

  m_reserved = i.ReadNtohU32 ();

  i.Read (buf, 16);

  m_target.Set (buf);

  return GetSerializedSize ();

}

NS_OBJECT_ENSURE_REGISTERED (Icmpv6NA);

TypeId Icmpv6NA::GetTypeId ()

{

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

    .SetParent<Icmpv6Header> ()

    .AddConstructor<Icmpv6NA> ()

  ;

  return tid;

}

TypeId Icmpv6NA::GetInstanceTypeId () const

{

  return GetTypeId ();

}

Icmpv6NA::Icmpv6NA ()

{

  SetType (ICMPV6_ND_NEIGHBOR_ADVERTISEMENT);

  SetCode (0);

  SetReserved (0);

  SetFlagR (0);

  SetFlagS (0);

  SetFlagO (0);

  m_checksum = 0;

}

Icmpv6NA::~Icmpv6NA ()

{

}

uint32_t Icmpv6NA::GetReserved () const

{

  return m_reserved;

}

void Icmpv6NA::SetReserved (uint32_t reserved)

{

  m_reserved = reserved;

}

Ipv6Address Icmpv6NA::GetIpv6Target () const

{

  return m_target;

}

bool Icmpv6NA::GetFlagR () const

{

  return m_flagR;

}

void Icmpv6NA::SetFlagR (bool r)

{

  m_flagR = r;

}

bool Icmpv6NA::GetFlagS () const

{

  return m_flagS;

}

void Icmpv6NA::SetFlagS (bool s)

{

  m_flagS = s;

}

bool Icmpv6NA::GetFlagO () const

{

  return m_flagO;

}

void Icmpv6NA::SetFlagO (bool o)

{

  m_flagO = o;

}

void Icmpv6NA::SetIpv6Target (Ipv6Address target)

{

  m_target = target;

}

void Icmpv6NA::Print (std::ostream& os) const

{

  os << "( type = " << (uint32_t)GetType () << " (NA) code = " << (uint32_t)GetCode () << " checksum = " << (uint32_t)GetChecksum () << ")";

}

uint32_t Icmpv6NA::GetSerializedSize () const

{

  return 24;

}

void Icmpv6NA::Serialize (Buffer::Iterator start) const

{

  uint8_t buff_target[16];

  uint16_t checksum = 0;

  Buffer::Iterator i = start;

  uint32_t reserved = m_reserved;

  i.WriteU8 (GetType ());

  i.WriteU8 (GetCode ());

  i.WriteU16 (0);

  if (m_flagR)

    {

      reserved |= (uint32_t)(1 << 31);

    }

  if (m_flagS)

    {

      reserved |= (uint32_t)(1<< 30);

    }

  if (m_flagO)

    {

      reserved |= (uint32_t)(1<< 29);

    }

  i.WriteHtonU32 (reserved);

  m_target.Serialize (buff_target);

  i.Write (buff_target, 16);

  if (m_calcChecksum)

    {

      i = start;

      checksum = i.CalculateIpChecksum (i.GetSize (), GetChecksum ());

      i = start;

      i.Next (2);

      i.WriteU16 (checksum);

    }

}

uint32_t Icmpv6NA::Deserialize (Buffer::Iterator start)

{

  uint8_t buf[16];

  Buffer::Iterator i = start;

  SetType (i.ReadU8 ());

  SetCode (i.ReadU8 ());

  m_checksum = i.ReadU16 ();

  m_reserved = i.ReadNtohU32 ();

  m_flagR = false;

  m_flagS = false;

  m_flagO = false;

  if (m_reserved & (1 << 31))

    {

      m_flagR = true;

    }

  if (m_reserved & (1 << 30))

    {

      m_flagS = true;

    }

  if (m_reserved & (1 << 29))

    {

      m_flagO = true;

    }

  i.Read (buf, 16);

  m_target.Set (buf);

  return GetSerializedSize ();

}

NS_OBJECT_ENSURE_REGISTERED (Icmpv6RA);

TypeId Icmpv6RA::GetTypeId ()

{

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

    .SetParent<Icmpv6Header> ()

    .AddConstructor<Icmpv6RA> ()

  ;

  return tid;

}

TypeId Icmpv6RA::GetInstanceTypeId () const

{

  return GetTypeId ();

}

Icmpv6RA::Icmpv6RA ()

{

  SetType (ICMPV6_ND_ROUTER_ADVERTISEMENT);

  SetCode (0);

  SetFlags (0);

  SetFlagM (0);

  SetFlagO (0);

  SetFlagH (0);

  SetCurHopLimit (0);

  SetLifeTime (0);

  SetRetransmissionTime (0);

  SetReachableTime (0);

}

Icmpv6RA::~Icmpv6RA ()

{

}

void Icmpv6RA::SetCurHopLimit (uint8_t m)

{

  m_curHopLimit = m;

}

uint8_t Icmpv6RA::GetCurHopLimit () const

{

  return m_curHopLimit;

}

uint16_t Icmpv6RA::GetLifeTime () const

{

  return m_LifeTime;

}

uint32_t Icmpv6RA::GetReachableTime () const

{

  return m_ReachableTime;

}

uint32_t Icmpv6RA::GetRetransmissionTime () const

{

  return m_RetransmissionTimer;

}

void Icmpv6RA::SetLifeTime (uint16_t l)

{

  m_LifeTime = l;

}

void Icmpv6RA::SetReachableTime (uint32_t r)

{

  m_ReachableTime = r;

}

void Icmpv6RA::SetRetransmissionTime (uint32_t r)

{

  m_RetransmissionTimer = r;

}

bool Icmpv6RA::GetFlagM () const

{

  return m_flagM;

}

void Icmpv6RA::SetFlagM (bool m)

{

  m_flagM = m;

}

bool Icmpv6RA::GetFlagO () const

{

  return m_flagO;