ipv6-extension.h

Go to the documentation of this file.

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

#ifndef IPV6_EXTENSION_H
#define IPV6_EXTENSION_H

#include <map>
#include <list>
#include <tuple>

#include "ns3/object.h"
#include "ns3/node.h"
#include "ns3/ptr.h"
#include "ipv6-interface.h"
#include "ns3/ipv6-header.h"
#include "ns3/buffer.h"
#include "ns3/packet.h"
#include "ns3/random-variable-stream.h"
#include "ns3/ipv6-address.h"
#include "ns3/ipv6-l3-protocol.h"
#include "ns3/traced-callback.h"


namespace ns3 {

class Ipv6Extension : public Object
{
public:
  static TypeId GetTypeId ();

  Ipv6Extension ();

  virtual ~Ipv6Extension ();

  void SetNode (Ptr<Node> node);

  Ptr<Node> GetNode () const;

  virtual uint8_t GetExtensionNumber () const = 0;

  virtual uint8_t Process (Ptr<Packet>& packet,
                           uint8_t offset,
                           Ipv6Header const& ipv6Header,
                           Ipv6Address dst,
                           uint8_t *nextHeader,
                           bool& stopProcessing,
                           bool& isDropped,
                           Ipv6L3Protocol::DropReason& dropReason) = 0;

  virtual uint8_t ProcessOptions (Ptr<Packet>& packet,
                                  uint8_t offset,
                                  uint8_t length,
                                  Ipv6Header const& ipv6Header,
                                  Ipv6Address dst,
                                  uint8_t *nextHeader,
                                  bool& stopProcessing,
                                  bool& isDropped,
                                  Ipv6L3Protocol::DropReason& dropReason
                                  );

  int64_t AssignStreams (int64_t stream);

protected:
  Ptr<UniformRandomVariable> m_uvar;

private:
  Ptr<Node> m_node;
};

class Ipv6ExtensionHopByHop : public Ipv6Extension
{
public:
  static const uint8_t EXT_NUMBER = 0;

  static TypeId GetTypeId ();

  Ipv6ExtensionHopByHop ();

  ~Ipv6ExtensionHopByHop ();

  virtual uint8_t GetExtensionNumber () const;

  virtual uint8_t Process (Ptr<Packet>& packet,
                           uint8_t offset,
                           Ipv6Header const& ipv6Header,
                           Ipv6Address dst,
                           uint8_t *nextHeader,
                           bool& stopProcessing,
                           bool& isDropped,
                           Ipv6L3Protocol::DropReason& dropReason);
};

class Ipv6ExtensionDestination : public Ipv6Extension
{
public:
  static const uint8_t EXT_NUMBER = 60;

  static TypeId GetTypeId ();

  Ipv6ExtensionDestination ();

  ~Ipv6ExtensionDestination ();

  virtual uint8_t GetExtensionNumber () const;

  virtual uint8_t Process (Ptr<Packet>& packet,
                           uint8_t offset,
                           Ipv6Header const& ipv6Header,
                           Ipv6Address dst,
                           uint8_t *nextHeader,
                           bool& stopProcessing,
                           bool& isDropped,
                           Ipv6L3Protocol::DropReason& dropReason);
};

class Ipv6ExtensionFragment : public Ipv6Extension
{
public:
  static const uint8_t EXT_NUMBER = 44;

  static TypeId GetTypeId ();

  Ipv6ExtensionFragment ();

  ~Ipv6ExtensionFragment ();

  virtual uint8_t GetExtensionNumber () const;

  virtual uint8_t Process (Ptr<Packet>& packet,
                           uint8_t offset,
                           Ipv6Header const& ipv6Header,
                           Ipv6Address dst,
                           uint8_t *nextHeader,
                           bool& stopProcessing,
                           bool& isDropped,
                           Ipv6L3Protocol::DropReason& dropReason);

  typedef std::pair<Ptr<Packet>, Ipv6Header> Ipv6PayloadHeaderPair;

  void GetFragments (Ptr<Packet> packet, Ipv6Header ipv6Header, uint32_t fragmentSize, std::list<Ipv6PayloadHeaderPair>& listFragments);

protected:
  virtual void DoDispose ();

private:

  typedef std::pair<Ipv6Address, uint32_t> FragmentKey_t;

  typedef std::list< std::tuple <Time, FragmentKey_t, Ipv6Header > > FragmentsTimeoutsList_t;
  typedef std::list< std::tuple <Time, FragmentKey_t, Ipv6Header > >::iterator FragmentsTimeoutsListI_t;

  class Fragments : public SimpleRefCount<Fragments>
  {
public:
    Fragments ();

    ~Fragments ();

    void AddFragment (Ptr<Packet> fragment, uint16_t fragmentOffset, bool moreFragment);

    void SetUnfragmentablePart (Ptr<Packet> unfragmentablePart);

    bool IsEntire () const;

    Ptr<Packet> GetPacket () const;

    Ptr<Packet> GetPartialPacket () const;

    void SetTimeoutIter (FragmentsTimeoutsListI_t iter);

    FragmentsTimeoutsListI_t GetTimeoutIter ();

private:
    bool m_moreFragment;

    std::list<std::pair<Ptr<Packet>, uint16_t> > m_packetFragments;

    Ptr<Packet> m_unfragmentable;

    FragmentsTimeoutsListI_t m_timeoutIter;
  };

  void HandleFragmentsTimeout (FragmentKey_t key, Ipv6Header ipHeader);

  Ptr<Packet> GetPartialPacket () const;

  void SetTimeoutEventId (EventId event);

  void CancelTimeout ();

  typedef std::map<FragmentKey_t, Ptr<Fragments> > MapFragments_t;

  MapFragments_t m_fragments;

  FragmentsTimeoutsListI_t SetTimeout (FragmentKey_t key, Ipv6Header ipHeader);

  void HandleTimeout (void);

  FragmentsTimeoutsList_t m_timeoutEventList;  
  EventId m_timeoutEvent;  
  Time m_fragmentExpirationTimeout; 
};

class Ipv6ExtensionRouting : public Ipv6Extension
{
public:
  static const uint8_t EXT_NUMBER = 43;

  static TypeId GetTypeId ();

  Ipv6ExtensionRouting ();

  ~Ipv6ExtensionRouting ();

  virtual uint8_t GetExtensionNumber () const;

  virtual uint8_t GetTypeRouting () const;

  virtual uint8_t Process (Ptr<Packet>& packet,
                           uint8_t offset,
                           Ipv6Header const& ipv6Header,
                           Ipv6Address dst,
                           uint8_t *nextHeader,
                           bool& stopProcessing,
                           bool& isDropped,
                           Ipv6L3Protocol::DropReason& dropReason);
};

class Ipv6ExtensionRoutingDemux : public Object
{
public:
  static TypeId GetTypeId ();

  Ipv6ExtensionRoutingDemux ();

  virtual ~Ipv6ExtensionRoutingDemux ();

  void SetNode (Ptr<Node> node);

  void Insert (Ptr<Ipv6ExtensionRouting> extensionRouting);

  Ptr<Ipv6ExtensionRouting> GetExtensionRouting (uint8_t typeRouting);

  void Remove (Ptr<Ipv6ExtensionRouting> extensionRouting);

protected:
  virtual void DoDispose ();

private:
  typedef std::list<Ptr<Ipv6ExtensionRouting> > Ipv6ExtensionRoutingList_t;

  Ipv6ExtensionRoutingList_t m_extensionsRouting;

  Ptr<Node> m_node;
};

class Ipv6ExtensionLooseRouting : public Ipv6ExtensionRouting
{
public:
  static const uint8_t TYPE_ROUTING = 0;

  static TypeId GetTypeId ();

  Ipv6ExtensionLooseRouting ();

  ~Ipv6ExtensionLooseRouting ();

  virtual uint8_t GetTypeRouting () const;

  virtual uint8_t Process (Ptr<Packet>& packet,
                           uint8_t offset,
                           Ipv6Header const& ipv6Header,
                           Ipv6Address dst,
                           uint8_t *nextHeader,
                           bool& stopProcessing,
                           bool& isDropped,
                           Ipv6L3Protocol::DropReason& dropReason);
};

class Ipv6ExtensionESP : public Ipv6Extension
{
public:
  static const uint8_t EXT_NUMBER = 50;

  static TypeId GetTypeId ();

  Ipv6ExtensionESP ();

  ~Ipv6ExtensionESP ();

  virtual uint8_t GetExtensionNumber () const;

  virtual uint8_t Process (Ptr<Packet>& packet,
                           uint8_t offset,
                           Ipv6Header const& ipv6Header,
                           Ipv6Address dst,
                           uint8_t *nextHeader,
                           bool& stopProcessing,
                           bool& isDropped,
                           Ipv6L3Protocol::DropReason& dropReason);
};

class Ipv6ExtensionAH : public Ipv6Extension
{
public:
  static const uint8_t EXT_NUMBER = 51;

  static TypeId GetTypeId ();

  Ipv6ExtensionAH ();

  ~Ipv6ExtensionAH ();

  virtual uint8_t GetExtensionNumber () const;

  virtual uint8_t Process (Ptr<Packet>& packet,
                           uint8_t offset,
                           Ipv6Header const& ipv6Header,
                           Ipv6Address dst,
                           uint8_t *nextHeader,
                           bool& stopProcessing,
                           bool& isDropped,
                           Ipv6L3Protocol::DropReason& dropReason);
};

} /* namespace ns3 */

#endif /* IPV6_EXTENSION_H */