packetbb.h

Go to the documentation of this file.

/* -*- 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 */
 
#ifndef PACKETBB_H
#define PACKETBB_H
 
#include <list>
 
#include "ns3/ptr.h"
#include "ns3/address.h"
#include "ns3/header.h"
#include "ns3/buffer.h"
#include "ns3/simple-ref-count.h"
 
namespace ns3 {
 
/* Forward declare objects */
class PbbMessage;
class PbbAddressBlock;
class PbbTlv;
class PbbAddressTlv;
 
enum PbbAddressLength {
  IPV4 = 3,
  IPV6 = 15,
};
 
class PbbTlvBlock
{
public:
  typedef std::list< Ptr<PbbTlv> >::iterator Iterator;
  typedef std::list< Ptr<PbbTlv> >::const_iterator ConstIterator;
 
  PbbTlvBlock (void);
  ~PbbTlvBlock (void);
 
  Iterator Begin (void);
 
  ConstIterator Begin (void) const;
 
  Iterator End (void);
 
  ConstIterator End (void) const;
 
  int Size (void) const;
 
  bool Empty (void) const;
 
  Ptr<PbbTlv> Front (void) const;
 
  Ptr<PbbTlv> Back (void) const;
 
  void PushFront (Ptr<PbbTlv> tlv);
 
  void PopFront (void);
 
  void PushBack (Ptr<PbbTlv> tlv);
 
  void PopBack (void);
 
  Iterator Insert (Iterator position, const Ptr<PbbTlv> tlv);
 
  Iterator Erase (Iterator position);
 
  Iterator Erase (Iterator first, Iterator last);
 
  void Clear (void);
 
  uint32_t GetSerializedSize (void) const;
 
  void Serialize (Buffer::Iterator &start) const;
 
  void Deserialize (Buffer::Iterator &start);
 
  void Print (std::ostream &os) const;
 
  void Print (std::ostream &os, int level) const;
 
  bool operator== (const PbbTlvBlock &other) const;
  bool operator!= (const PbbTlvBlock &other) const;
 
private:
  std::list< Ptr<PbbTlv> > m_tlvList; 
};
 
class PbbAddressTlvBlock
{
public:
  typedef std::list< Ptr<PbbAddressTlv> >::iterator Iterator;
  typedef std::list< Ptr<PbbAddressTlv> >::const_iterator ConstIterator;
 
  PbbAddressTlvBlock (void);
  ~PbbAddressTlvBlock (void);
 
  Iterator Begin (void);
 
  ConstIterator Begin (void) const;
 
  Iterator End (void);
 
  ConstIterator End (void) const;
 
  int Size (void) const;
 
  bool Empty (void) const;
 
  Ptr<PbbAddressTlv> Front (void) const;
 
  Ptr<PbbAddressTlv> Back (void) const;
 
  void PushFront (Ptr<PbbAddressTlv> tlv);
 
  void PopFront (void);
 
  void PushBack (Ptr<PbbAddressTlv> tlv);
 
  void PopBack (void);
 
  Iterator Insert (Iterator position, const Ptr<PbbAddressTlv> tlv);
 
  Iterator Erase (Iterator position);
 
  Iterator Erase (Iterator first, Iterator last);
 
  void Clear (void);
 
  uint32_t GetSerializedSize (void) const;
 
  void Serialize (Buffer::Iterator &start) const;
 
  void Deserialize (Buffer::Iterator &start);
 
  void Print (std::ostream &os) const;
 
  void Print (std::ostream &os, int level) const;
 
  bool operator== (const PbbAddressTlvBlock &other) const;
 
  bool operator!= (const PbbAddressTlvBlock &other) const;
 
private:
  std::list< Ptr<PbbAddressTlv> > m_tlvList; 
};
 
class PbbPacket : public SimpleRefCount<PbbPacket,Header>
{
public:
  typedef std::list< Ptr<PbbTlv> >::iterator TlvIterator;
  typedef std::list< Ptr<PbbTlv> >::const_iterator ConstTlvIterator;
  typedef std::list< Ptr<PbbMessage> >::iterator MessageIterator;
  typedef std::list< Ptr<PbbMessage> >::const_iterator ConstMessageIterator;
 
  PbbPacket (void);
  ~PbbPacket (void);
 
  uint8_t GetVersion (void) const;
 
  void SetSequenceNumber (uint16_t number);
 
  uint16_t GetSequenceNumber (void) const;
 
  bool HasSequenceNumber (void) const;
 
  /* Manipulating Packet TLVs */
 
  TlvIterator TlvBegin (void);
 
  ConstTlvIterator TlvBegin (void) const;
 
  TlvIterator TlvEnd (void);
 
  ConstTlvIterator TlvEnd (void) const;
 
  int TlvSize (void) const;
 
  bool TlvEmpty (void) const;
 
  Ptr<PbbTlv> TlvFront (void);
 
  const Ptr<PbbTlv> TlvFront (void) const;
 
  Ptr<PbbTlv> TlvBack (void);
 
  const Ptr<PbbTlv> TlvBack (void) const;
 
  void TlvPushFront (Ptr<PbbTlv> tlv);
 
  void TlvPopFront (void);
 
  void TlvPushBack (Ptr<PbbTlv> tlv);
 
  void TlvPopBack (void);
 
  TlvIterator Erase (TlvIterator position);
 
  TlvIterator Erase (TlvIterator first, TlvIterator last);
 
  void TlvClear (void);
 
  /* Manipulating Packet Messages */
 
  MessageIterator MessageBegin (void);
 
  ConstMessageIterator MessageBegin (void) const;
 
  MessageIterator MessageEnd (void);
 
  ConstMessageIterator MessageEnd (void) const;
 
  int MessageSize (void) const;
 
  bool MessageEmpty (void) const;
 
  Ptr<PbbMessage> MessageFront (void);
 
  const Ptr<PbbMessage> MessageFront (void) const;
 
  Ptr<PbbMessage> MessageBack (void);
 
  const Ptr<PbbMessage> MessageBack (void) const;
 
  void MessagePushFront (Ptr<PbbMessage> message);
 
  void MessagePopFront (void);
 
  void MessagePushBack (Ptr<PbbMessage> message);
 
  void MessagePopBack (void);
 
  MessageIterator Erase (MessageIterator position);
 
  MessageIterator Erase (MessageIterator first, MessageIterator last);
 
  void MessageClear (void);
 
  static TypeId GetTypeId (void);
  virtual TypeId GetInstanceTypeId (void) const;
 
  virtual uint32_t GetSerializedSize (void) const;
 
  virtual void Serialize (Buffer::Iterator start) const;
 
  virtual uint32_t Deserialize (Buffer::Iterator start);
 
  virtual void Print (std::ostream &os) const;
 
  bool operator== (const PbbPacket &other) const;
  
  bool operator!= (const PbbPacket &other) const;
 
protected:
 
private:
  PbbTlvBlock m_tlvList; 
  std::list< Ptr<PbbMessage> > m_messageList; 
 
  uint8_t m_version; 
 
  bool m_hasseqnum; 
  uint16_t m_seqnum; 
};
 
class PbbMessage : public SimpleRefCount<PbbMessage>
{
public:
  typedef std::list< Ptr<PbbTlv> >::iterator TlvIterator;
  typedef std::list< Ptr<PbbTlv> >::const_iterator ConstTlvIterator;
  typedef std::list< Ptr<PbbAddressBlock> >::iterator AddressBlockIterator;
  typedef std::list< Ptr<PbbAddressBlock> >::const_iterator ConstAddressBlockIterator;
 
  PbbMessage ();
  virtual ~PbbMessage ();
 
  void SetType (uint8_t type);
 
  uint8_t GetType (void) const;
 
  void SetOriginatorAddress (Address address);
 
  Address GetOriginatorAddress (void) const;
 
  bool HasOriginatorAddress (void) const;
 
  void SetHopLimit (uint8_t hoplimit);
 
  uint8_t GetHopLimit (void) const;
 
  bool HasHopLimit (void) const;
 
  void SetHopCount (uint8_t hopcount);
 
  uint8_t GetHopCount (void) const;
 
  bool HasHopCount (void) const;
 
  void SetSequenceNumber (uint16_t seqnum);
 
  uint16_t GetSequenceNumber (void) const;
 
  bool HasSequenceNumber (void) const;
 
  /* Manipulating PbbMessage TLVs */
 
  TlvIterator TlvBegin ();
 
  ConstTlvIterator TlvBegin () const;
 
  TlvIterator TlvEnd ();
 
  ConstTlvIterator TlvEnd () const;
 
  int TlvSize (void) const;
 
  bool TlvEmpty (void) const;
 
  Ptr<PbbTlv> TlvFront (void);
 
  const Ptr<PbbTlv> TlvFront (void) const;
 
  Ptr<PbbTlv> TlvBack (void);
 
  const Ptr<PbbTlv> TlvBack (void) const;
 
  void TlvPushFront (Ptr<PbbTlv> tlv);
 
  void TlvPopFront (void);
 
  void TlvPushBack (Ptr<PbbTlv> tlv);
 
  void TlvPopBack (void);
 
  TlvIterator TlvErase (TlvIterator position);
 
  TlvIterator TlvErase (TlvIterator first, TlvIterator last);
 
  void TlvClear (void);
 
  /* Manipulating Address Block and Address TLV pairs */
 
  AddressBlockIterator AddressBlockBegin ();
 
  ConstAddressBlockIterator AddressBlockBegin () const;
 
  AddressBlockIterator AddressBlockEnd ();
 
  ConstAddressBlockIterator AddressBlockEnd () const;
 
  int AddressBlockSize (void) const;
 
  bool AddressBlockEmpty (void) const;
 
  Ptr<PbbAddressBlock> AddressBlockFront (void);
 
  const Ptr<PbbAddressBlock> AddressBlockFront (void) const;
 
  Ptr<PbbAddressBlock> AddressBlockBack (void);
 
  const Ptr<PbbAddressBlock> AddressBlockBack (void) const;
 
  void AddressBlockPushFront (Ptr<PbbAddressBlock> block);
 
  void AddressBlockPopFront (void);
 
  void AddressBlockPushBack (Ptr<PbbAddressBlock> block);
 
  void AddressBlockPopBack (void);
 
  AddressBlockIterator AddressBlockErase (AddressBlockIterator position);
 
  AddressBlockIterator AddressBlockErase (AddressBlockIterator first,
                                          AddressBlockIterator last);
 
  void AddressBlockClear (void);
 
  static Ptr<PbbMessage> DeserializeMessage (Buffer::Iterator &start);
 
  uint32_t GetSerializedSize (void) const;
 
  void Serialize (Buffer::Iterator &start) const;
 
  void Deserialize (Buffer::Iterator &start);
 
  void Print (std::ostream &os) const;
 
  void Print (std::ostream &os, int level) const;
 
  bool operator== (const PbbMessage &other) const;
  bool operator!= (const PbbMessage &other) const;
 
protected:  
  virtual PbbAddressLength GetAddressLength (void) const = 0;
 
  virtual void SerializeOriginatorAddress (Buffer::Iterator &start) const = 0;
  virtual Address DeserializeOriginatorAddress (Buffer::Iterator &start) const = 0;
  virtual void PrintOriginatorAddress (std::ostream &os) const = 0;
 
  virtual Ptr<PbbAddressBlock> AddressBlockDeserialize (Buffer::Iterator &start) const = 0;
 
private:
  PbbTlvBlock m_tlvList; 
  std::list< Ptr<PbbAddressBlock> > m_addressBlockList; 
 
  uint8_t m_type; 
  PbbAddressLength m_addrSize; 
 
  bool m_hasOriginatorAddress; 
  Address m_originatorAddress; 
 
  bool m_hasHopLimit; 
  uint8_t m_hopLimit; 
 
  bool m_hasHopCount; 
  uint8_t m_hopCount; 
 
  bool m_hasSequenceNumber;  
  uint16_t m_sequenceNumber; 
};
 
class PbbMessageIpv4 : public PbbMessage {
public:
  PbbMessageIpv4 ();
  virtual ~PbbMessageIpv4 ();
 
protected:
  virtual PbbAddressLength GetAddressLength (void) const;
 
  virtual void SerializeOriginatorAddress (Buffer::Iterator &start) const;
  virtual Address DeserializeOriginatorAddress (Buffer::Iterator &start) const;
  virtual void PrintOriginatorAddress (std::ostream &os) const;
 
  virtual Ptr<PbbAddressBlock> AddressBlockDeserialize (Buffer::Iterator &start) const;
};
 
class PbbMessageIpv6 : public PbbMessage {
public:
  PbbMessageIpv6 ();
  virtual ~PbbMessageIpv6 ();
 
protected:
  virtual PbbAddressLength GetAddressLength (void) const;
 
  virtual void SerializeOriginatorAddress (Buffer::Iterator &start) const;
  virtual Address DeserializeOriginatorAddress (Buffer::Iterator &start) const;
  virtual void PrintOriginatorAddress (std::ostream &os) const;
 
  virtual Ptr<PbbAddressBlock> AddressBlockDeserialize (Buffer::Iterator &start) const;
};
 
class PbbAddressBlock : public SimpleRefCount<PbbAddressBlock>
{
public:
  typedef std::list< Address >::iterator AddressIterator;
  typedef std::list< Address >::const_iterator ConstAddressIterator;
 
  typedef std::list<uint8_t>::iterator PrefixIterator;
  typedef std::list<uint8_t>::const_iterator ConstPrefixIterator;
 
  typedef PbbAddressTlvBlock::Iterator TlvIterator;
  typedef PbbAddressTlvBlock::ConstIterator ConstTlvIterator;
 
  PbbAddressBlock ();
  virtual ~PbbAddressBlock ();
 
  /* Manipulating the address block */
 
  AddressIterator AddressBegin (void);
 
  ConstAddressIterator AddressBegin (void) const;
 
  AddressIterator AddressEnd (void);
 
  ConstAddressIterator AddressEnd (void) const;
 
  int AddressSize (void) const;
 
  bool AddressEmpty (void) const;
 
  Address AddressFront (void) const;
 
  Address AddressBack (void) const;
 
  void AddressPushFront (Address address);
 
  void AddressPopFront (void);
 
  void AddressPushBack (Address address);
 
  void AddressPopBack (void);
 
  AddressIterator AddressInsert (AddressIterator position,
                                 const Address value);
 
  AddressIterator AddressErase (AddressIterator position);
 
  AddressIterator AddressErase (AddressIterator first, AddressIterator last);
 
  void AddressClear (void);
 
  /* Prefix methods */
 
  PrefixIterator PrefixBegin (void);
 
  ConstPrefixIterator PrefixBegin (void) const;
 
  PrefixIterator PrefixEnd (void);
 
  ConstPrefixIterator PrefixEnd (void) const;
 
  int PrefixSize (void) const;
 
  bool PrefixEmpty (void) const;
 
  uint8_t PrefixFront (void) const;
 
  uint8_t PrefixBack (void) const;
 
  void PrefixPushFront (uint8_t prefix);
 
  void PrefixPopFront (void);
 
  void PrefixPushBack (uint8_t prefix);
 
  void PrefixPopBack (void);
 
  PrefixIterator PrefixInsert (PrefixIterator position, const uint8_t value);
 
  PrefixIterator PrefixErase (PrefixIterator position);
 
  PrefixIterator PrefixErase (PrefixIterator first, PrefixIterator last);
 
  void PrefixClear (void);
 
  /* Manipulating the TLV block */
 
  TlvIterator TlvBegin (void);
 
  ConstTlvIterator TlvBegin (void) const;
 
  TlvIterator TlvEnd (void);
 
  ConstTlvIterator TlvEnd (void) const;
 
  int TlvSize (void) const;
 
  bool TlvEmpty (void) const;
 
  Ptr<PbbAddressTlv> TlvFront (void);
 
  const Ptr<PbbAddressTlv> TlvFront (void) const;
 
  Ptr<PbbAddressTlv> TlvBack (void);
 
  const Ptr<PbbAddressTlv> TlvBack (void) const;
 
  void TlvPushFront (Ptr<PbbAddressTlv> address);
 
  void TlvPopFront (void);
 
  void TlvPushBack (Ptr<PbbAddressTlv> address);
 
  void TlvPopBack (void);
 
  TlvIterator TlvInsert (TlvIterator position, const Ptr<PbbTlv> value);
 
  TlvIterator TlvErase (TlvIterator position);
 
  TlvIterator TlvErase (TlvIterator first, TlvIterator last);
 
  void TlvClear (void);
 
  uint32_t GetSerializedSize (void) const;
 
  void Serialize (Buffer::Iterator &start) const;
 
  void Deserialize (Buffer::Iterator &start);
 
  void Print (std::ostream &os) const;
 
  void Print (std::ostream &os, int level) const;
 
  bool operator== (const PbbAddressBlock &other) const;
  
  bool operator!= (const PbbAddressBlock &other) const;
 
protected:
  virtual uint8_t GetAddressLength (void) const = 0;
  virtual void SerializeAddress (uint8_t *buffer, ConstAddressIterator iter) const = 0;
  virtual Address DeserializeAddress (uint8_t *buffer) const = 0;
  virtual void PrintAddress (std::ostream &os, ConstAddressIterator iter) const = 0;
 
private:
  uint8_t GetPrefixFlags (void) const;
  void GetHeadTail (uint8_t *head, uint8_t &headlen,
                    uint8_t *tail, uint8_t &taillen) const;
 
  bool HasZeroTail (const uint8_t *tail, uint8_t taillen) const;
 
  std::list<Address> m_addressList; 
  std::list<uint8_t> m_prefixList; 
  PbbAddressTlvBlock m_addressTlvList; 
};
 
class PbbAddressBlockIpv4 : public PbbAddressBlock
{
public:
  PbbAddressBlockIpv4 ();
  virtual ~PbbAddressBlockIpv4 ();
 
protected:
  virtual uint8_t GetAddressLength (void) const;
  virtual void SerializeAddress (uint8_t *buffer, ConstAddressIterator iter) const;
  virtual Address DeserializeAddress (uint8_t *buffer) const;
  virtual void PrintAddress (std::ostream &os, ConstAddressIterator iter) const;
};
 
class PbbAddressBlockIpv6 : public PbbAddressBlock
{
public:
  PbbAddressBlockIpv6 ();
  virtual ~PbbAddressBlockIpv6 ();
 
protected:
  virtual uint8_t GetAddressLength (void) const;
  virtual void SerializeAddress (uint8_t *buffer, ConstAddressIterator iter) const;
  virtual Address DeserializeAddress (uint8_t *buffer) const;
  virtual void PrintAddress (std::ostream &os, ConstAddressIterator iter) const;
};
 
class PbbTlv : public SimpleRefCount<PbbTlv>
{
public:
  PbbTlv (void);
  virtual ~PbbTlv (void);
 
  void SetType (uint8_t type);
 
  uint8_t GetType (void) const;
 
  void SetTypeExt (uint8_t type);
 
  uint8_t GetTypeExt (void) const;
 
  bool HasTypeExt (void) const;
 
  void SetValue (Buffer start);
 
  void SetValue (const uint8_t * buffer, uint32_t size);
 
  Buffer GetValue (void) const;
 
  bool HasValue (void) const;
 
  uint32_t GetSerializedSize (void) const;
 
  void Serialize (Buffer::Iterator &start) const;
 
  void Deserialize (Buffer::Iterator &start);
 
  void Print (std::ostream &os) const;
 
  void Print (std::ostream &os, int level) const;
 
  bool operator== (const PbbTlv &other) const;
 
  bool operator!= (const PbbTlv &other) const;
 
protected:
  void SetIndexStart (uint8_t index);
  uint8_t GetIndexStart (void) const;
  bool HasIndexStart (void) const;
 
  void SetIndexStop (uint8_t index);
  uint8_t GetIndexStop (void) const;
  bool HasIndexStop (void) const;
 
  void SetMultivalue (bool isMultivalue);
  bool IsMultivalue (void) const;
 
private:
  uint8_t m_type; 
 
  bool m_hasTypeExt; 
  uint8_t m_typeExt; 
 
  bool m_hasIndexStart; 
  uint8_t m_indexStart; 
 
  bool m_hasIndexStop; 
  uint8_t m_indexStop; 
 
  bool m_isMultivalue; 
  bool m_hasValue;     
  Buffer m_value;      
};
 
class PbbAddressTlv : public PbbTlv
{
public:
  void SetIndexStart (uint8_t index);
 
  uint8_t GetIndexStart (void) const;
 
  bool HasIndexStart (void) const;
 
  void SetIndexStop (uint8_t index);
 
  uint8_t GetIndexStop (void) const;
 
  bool HasIndexStop (void) const;
 
  void SetMultivalue (bool isMultivalue);
 
  bool IsMultivalue (void) const;
};
 
} /* namespace ns3 */
 
#endif /* PACKETBB_H */