/* -*- 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: David Gross <gdavid.devel@gmail.com>

 */

#include <list>

#include <ctime>

#include "ns3/log.h"

#include "ns3/assert.h"

#include "ns3/uinteger.h"

#include "ns3/object-vector.h"

#include "ns3/ipv6-address.h"

#include "ns3/ipv6-header.h"

#include "ns3/ipv6-l3-protocol.h"

#include "ns3/ipv6-static-routing.h"

#include "ns3/ipv6-list-routing.h"

#include "ns3/ipv6-route.h"

#include "ns3/trace-source-accessor.h"

#include "icmpv6-l4-protocol.h"

#include "ipv6-extension-demux.h"

#include "ipv6-extension.h"

#include "ipv6-extension-header.h"

#include "ipv6-option-demux.h"

#include "ipv6-option.h"

#include "udp-header.h"

NS_LOG_COMPONENT_DEFINE ("Ipv6Extension");

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (Ipv6Extension);

TypeId Ipv6Extension::GetTypeId ()

{

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

    .SetParent<Object> ()

    .AddAttribute ("ExtensionNumber", "The IPv6 extension number.",

                   UintegerValue (0),

                   MakeUintegerAccessor (&Ipv6Extension::GetExtensionNumber),

                   MakeUintegerChecker<uint8_t> ())

  ;

  return tid;

}

Ipv6Extension::Ipv6Extension ()

{

  NS_LOG_FUNCTION_NOARGS ();

  m_uvar = CreateObject<UniformRandomVariable> ();

}

Ipv6Extension::~Ipv6Extension ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

void Ipv6Extension::SetNode (Ptr<Node> node)

{

  NS_LOG_FUNCTION (this << node);

  m_node = node;

}

Ptr<Node> Ipv6Extension::GetNode () const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_node;

}

{

  NS_LOG_FUNCTION (this << packet << offset << length << ipv6Header << dst << nextHeader << isDropped);

  // For ICMPv6 Error packets

  Ptr<Packet> malformedPacket = packet->Copy ();

  malformedPacket->AddHeader (ipv6Header);

  Ptr<Icmpv6L4Protocol> icmpv6 = GetNode ()->GetObject<Ipv6L3Protocol> ()->GetIcmpv6 ();

  Ptr<Packet> p = packet->Copy ();

  p->RemoveAtStart (offset);

  Ptr<Ipv6OptionDemux> ipv6OptionDemux = GetNode ()->GetObject<Ipv6OptionDemux> ();

  Ptr<Ipv6Option> ipv6Option;

  uint8_t processedSize = 0;

  uint32_t size = p->GetSize ();

  uint8_t *data = new uint8_t[size];

  p->CopyData (data, size);

  uint8_t optionType = 0;

  uint8_t optionLength = 0;

  while (length > processedSize && !isDropped)

    {

      optionType = *(data + processedSize);

      ipv6Option = ipv6OptionDemux->GetOption (optionType);

      if (ipv6Option == 0)

        {

          optionType >>= 6;

          switch (optionType)

            {

            case 0:

              optionLength = *(data + processedSize + 1) + 2;

              break;

            case 1:

              NS_LOG_LOGIC ("Unknown Option. Drop!");

              optionLength = 0;

              isDropped = true;

              break;

            case 2:

              NS_LOG_LOGIC ("Unknown Option. Drop!");

              icmpv6->SendErrorParameterError (malformedPacket, ipv6Header.GetSourceAddress (), Icmpv6Header::ICMPV6_UNKNOWN_OPTION, offset + processedSize);

              optionLength = 0;

              isDropped = true;

              break;

            case 3:

              NS_LOG_LOGIC ("Unknown Option. Drop!");

              if (!ipv6Header.GetDestinationAddress ().IsMulticast ())

                {

                  icmpv6->SendErrorParameterError (malformedPacket, ipv6Header.GetSourceAddress (), Icmpv6Header::ICMPV6_UNKNOWN_OPTION, offset + processedSize);

                }

              optionLength = 0;

              isDropped = true;

              break;

            default:

              break;

            }

        }

      else

        {

          optionLength = ipv6Option->Process (packet, offset + processedSize, ipv6Header, isDropped);

        }

      processedSize += optionLength;

      p->RemoveAtStart (optionLength);

    }

  delete [] data;

  return processedSize;

}

int64_t

Ipv6Extension::AssignStreams (int64_t stream)

{

  NS_LOG_FUNCTION (this << stream);

  m_uvar->SetStream (stream);

  return 1;

}

NS_OBJECT_ENSURE_REGISTERED (Ipv6ExtensionHopByHop);

TypeId Ipv6ExtensionHopByHop::GetTypeId ()

{

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

    .SetParent<Ipv6Extension> ()

    .AddConstructor<Ipv6ExtensionHopByHop> ()

  ;

  return tid;

}

Ipv6ExtensionHopByHop::Ipv6ExtensionHopByHop ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

Ipv6ExtensionHopByHop::~Ipv6ExtensionHopByHop ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

uint8_t Ipv6ExtensionHopByHop::GetExtensionNumber () const

{

  NS_LOG_FUNCTION_NOARGS ();

  return EXT_NUMBER;

}

{

  NS_LOG_FUNCTION (this << packet << offset << ipv6Header << dst << nextHeader << isDropped);

  Ptr<Packet> p = packet->Copy ();

  p->RemoveAtStart (offset);

  Ipv6ExtensionHopByHopHeader hopbyhopHeader;

  p->RemoveHeader (hopbyhopHeader);

  if (nextHeader)

    {

      *nextHeader = hopbyhopHeader.GetNextHeader ();

    }

  uint8_t processedSize = hopbyhopHeader.GetOptionsOffset ();

  offset += processedSize;

  uint8_t length = hopbyhopHeader.GetLength () - hopbyhopHeader.GetOptionsOffset ();

  return processedSize;

}

NS_OBJECT_ENSURE_REGISTERED (Ipv6ExtensionDestination);

TypeId Ipv6ExtensionDestination::GetTypeId ()

{

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

    .SetParent<Ipv6Extension> ()

    .AddConstructor<Ipv6ExtensionDestination> ()

  ;

  return tid;

}

Ipv6ExtensionDestination::Ipv6ExtensionDestination ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

Ipv6ExtensionDestination::~Ipv6ExtensionDestination ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

uint8_t Ipv6ExtensionDestination::GetExtensionNumber () const

{

  NS_LOG_FUNCTION_NOARGS ();

  return EXT_NUMBER;

}

{

  NS_LOG_FUNCTION (this << packet << offset << ipv6Header << dst << nextHeader << isDropped);

  Ptr<Packet> p = packet->Copy ();

  p->RemoveAtStart (offset);

  Ipv6ExtensionDestinationHeader destinationHeader;

  p->RemoveHeader (destinationHeader);

  if (nextHeader)

    {

      *nextHeader = destinationHeader.GetNextHeader ();

    }

  uint8_t processedSize = destinationHeader.GetOptionsOffset ();

  offset += processedSize;

  uint8_t length = destinationHeader.GetLength () - destinationHeader.GetOptionsOffset ();

  return processedSize;

}

NS_OBJECT_ENSURE_REGISTERED (Ipv6ExtensionFragment);

TypeId Ipv6ExtensionFragment::GetTypeId ()

{

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

    .SetParent<Ipv6Extension> ()

    .AddConstructor<Ipv6ExtensionFragment> ()

  ;

  return tid;

}

Ipv6ExtensionFragment::Ipv6ExtensionFragment ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

Ipv6ExtensionFragment::~Ipv6ExtensionFragment ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

void Ipv6ExtensionFragment::DoDispose ()

{

  NS_LOG_FUNCTION_NOARGS ();

  for (MapFragments_t::iterator it = m_fragments.begin (); it != m_fragments.end (); it++)

    {

      it->second = 0;

    }

  m_fragments.clear ();

  Ipv6Extension::DoDispose ();

}

uint8_t Ipv6ExtensionFragment::GetExtensionNumber () const

{

  NS_LOG_FUNCTION_NOARGS ();

  return EXT_NUMBER;

}

{

  NS_LOG_FUNCTION (this << packet << offset << ipv6Header << dst << nextHeader << isDropped);

  Ptr<Packet> p = packet->Copy ();

  p->RemoveAtStart (offset);

  Ipv6ExtensionFragmentHeader fragmentHeader;

  p->RemoveHeader (fragmentHeader);

  if (nextHeader)

    {

      *nextHeader = fragmentHeader.GetNextHeader ();

    }

  bool moreFragment = fragmentHeader.GetMoreFragment ();

  uint16_t fragmentOffset = fragmentHeader.GetOffset ();

  uint32_t identification = fragmentHeader.GetIdentification ();

  Ipv6Address src = ipv6Header.GetSourceAddress ();

  std::pair<Ipv6Address, uint32_t> fragmentsId = std::pair<Ipv6Address, uint32_t> (src, identification);

  Ptr<Fragments> fragments;

  Ipv6Header ipHeader = ipv6Header;

  ipHeader.SetNextHeader (fragmentHeader.GetNextHeader ());

  MapFragments_t::iterator it = m_fragments.find (fragmentsId);

  if (it == m_fragments.end ())

    {

      fragments = Create<Fragments> ();

      m_fragments.insert (std::make_pair (fragmentsId, fragments));

      EventId timeout = Simulator::Schedule (Seconds (60),

                                             &Ipv6ExtensionFragment::HandleFragmentsTimeout, this,

                                             fragmentsId, ipHeader);

      fragments->SetTimeoutEventId (timeout);

    }

  else

    {

      fragments = it->second;

    }

  if (fragmentOffset == 0)

    {

      Ptr<Packet> unfragmentablePart = packet->Copy ();

      unfragmentablePart->RemoveAtEnd (packet->GetSize () - offset);

      fragments->SetUnfragmentablePart (unfragmentablePart);

    }

  fragments->AddFragment (p, fragmentOffset, moreFragment);

  if (fragments->IsEntire ())

    {

      packet = fragments->GetPacket ();

      fragments->CancelTimeout ();

      m_fragments.erase (fragmentsId);

    }

  else

    {

    }

  return 0;

}

void Ipv6ExtensionFragment::GetFragments (Ptr<Packet> packet, uint32_t maxFragmentSize, std::list<Ptr<Packet> >& listFragments)

{

  Ptr<Packet> p = packet->Copy ();

  Ipv6Header ipv6Header;

  p->RemoveHeader (ipv6Header);

  uint8_t nextHeader = ipv6Header.GetNextHeader ();

  uint8_t ipv6HeaderSize = ipv6Header.GetSerializedSize ();

  uint8_t type;

  p->CopyData (&type, sizeof(type));

  bool moreHeader = true;

  if (!(nextHeader == Ipv6Header::IPV6_EXT_HOP_BY_HOP || nextHeader == Ipv6Header::IPV6_EXT_ROUTING

        || (nextHeader == Ipv6Header::IPV6_EXT_DESTINATION && type == Ipv6Header::IPV6_EXT_ROUTING)))

    {

      moreHeader = false;

      ipv6Header.SetNextHeader (Ipv6Header::IPV6_EXT_FRAGMENTATION);

    }

  std::list<std::pair<Ipv6ExtensionHeader *, uint8_t> > unfragmentablePart;

  uint32_t unfragmentablePartSize = 0;

  Ptr<Ipv6ExtensionDemux> extensionDemux = GetNode ()->GetObject<Ipv6ExtensionDemux> ();

  Ptr<Ipv6Extension> extension = extensionDemux->GetExtension (nextHeader);

  uint8_t extensionHeaderLength;

  while (moreHeader)

    {

      if (nextHeader == Ipv6Header::IPV6_EXT_HOP_BY_HOP)

        {

          Ipv6ExtensionHopByHopHeader *hopbyhopHeader = new Ipv6ExtensionHopByHopHeader ();

          p->RemoveHeader (*hopbyhopHeader);

          nextHeader = hopbyhopHeader->GetNextHeader ();

          extensionHeaderLength = hopbyhopHeader->GetLength ();

          uint8_t type;

          p->CopyData (&type, sizeof(type));

          if (!(nextHeader == Ipv6Header::IPV6_EXT_HOP_BY_HOP || nextHeader == Ipv6Header::IPV6_EXT_ROUTING

                || (nextHeader == Ipv6Header::IPV6_EXT_DESTINATION && type == Ipv6Header::IPV6_EXT_ROUTING)))

            {

              moreHeader = false;

              hopbyhopHeader->SetNextHeader (Ipv6Header::IPV6_EXT_FRAGMENTATION);

            }

          unfragmentablePart.push_back (std::pair<Ipv6ExtensionHeader *, uint8_t> (hopbyhopHeader, Ipv6Header::IPV6_EXT_HOP_BY_HOP));

          unfragmentablePartSize += extensionHeaderLength;

        }

      else if (nextHeader == Ipv6Header::IPV6_EXT_ROUTING)

        {

          uint8_t buf[2];

          p->CopyData (buf, sizeof(buf));

          uint8_t numberAddress = buf[1] / 2;

          Ipv6ExtensionLooseRoutingHeader *routingHeader = new Ipv6ExtensionLooseRoutingHeader ();

          routingHeader->SetNumberAddress (numberAddress);

          p->RemoveHeader (*routingHeader);

          nextHeader = routingHeader->GetNextHeader ();

          extensionHeaderLength = routingHeader->GetLength ();

          uint8_t type;

          p->CopyData (&type, sizeof(type));

          if (!(nextHeader == Ipv6Header::IPV6_EXT_HOP_BY_HOP || nextHeader == Ipv6Header::IPV6_EXT_ROUTING

                || (nextHeader == Ipv6Header::IPV6_EXT_DESTINATION && type == Ipv6Header::IPV6_EXT_ROUTING)))

            {

              moreHeader = false;

              routingHeader->SetNextHeader (Ipv6Header::IPV6_EXT_FRAGMENTATION);

            }

          unfragmentablePart.push_back (std::pair<Ipv6ExtensionHeader *, uint8_t> (routingHeader, Ipv6Header::IPV6_EXT_ROUTING));

          unfragmentablePartSize += extensionHeaderLength;

        }

      else if (nextHeader == Ipv6Header::IPV6_EXT_DESTINATION)

        {

          Ipv6ExtensionDestinationHeader *destinationHeader = new Ipv6ExtensionDestinationHeader ();

          p->RemoveHeader (*destinationHeader);