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

     2 /* vim: set noai ts=2 sw=2 expandtab: */

     3 /* 

     4  * Copyright (c) 2009 Drexel University

     5  * 

     6  * This program is free software; you can redistribute it and/or modify

     7  * it under the terms of the GNU General Public License version 2 as

     8  * published by the Free Software Foundation;

     9  *

    10  * This program is distributed in the hope that it will be useful,

    11  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    13  * GNU General Public License for more details.

    14  *

    15  * You should have received a copy of the GNU General Public License

    16  * along with this program; if not, write to the Free Software

    17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    18  * 

    19  * Author: Tom Wambold <tom5760@gmail.com>

    20  */

    21 /* TODO:

    22  * - Check style

    23  * - Check copy constructors

    24  */

    25 

    26 #include "ns3/ipv4-address.h"

    27 #include "ns3/ipv6-address.h"

    28 

    29 #include "packetbb.h"

    30 

    31 static const uint8_t VERSION = 0;

    32 /* Packet flags */

    33 static const uint8_t PHAS_SEQ_NUM = 0x8;

    34 static const uint8_t PHAS_TLV = 0x4;

    35 

    36 /* Message flags */

    37 static const uint8_t MHAS_ORIG = 0x80;

    38 static const uint8_t MHAS_HOP_LIMIT = 0x40;

    39 static const uint8_t MHAS_HOP_COUNT = 0x20;

    40 static const uint8_t MHAS_SEQ_NUM = 0x10;

    41 

    42 /* Address block flags */

    43 static const uint8_t AHAS_HEAD = 0x80;

    44 static const uint8_t AHAS_FULL_TAIL = 0x40;

    45 static const uint8_t AHAS_ZERO_TAIL = 0x20;

    46 static const uint8_t AHAS_SINGLE_PRE_LEN = 0x10;

    47 static const uint8_t AHAS_MULTI_PRE_LEN = 0x08;

    48 

    49 /* TLV Flags */

    50 static const uint8_t THAS_TYPE_EXT = 0x80;

    51 static const uint8_t THAS_SINGLE_INDEX = 0x40;

    52 static const uint8_t THAS_MULTI_INDEX = 0x20;

    53 static const uint8_t THAS_VALUE = 0x10;

    54 static const uint8_t THAS_EXT_LEN = 0x08;

    55 static const uint8_t TIS_MULTIVALUE = 0x04;

    56 

    57 namespace ns3 {

    58 

    59 namespace pbb {

    60 

    61 NS_OBJECT_ENSURE_REGISTERED (PacketBB);

    62 

    63 TlvBlock::Iterator

    64 TlvBlock::Begin (void)

    65 {

    66   return m_tlvList.begin ();

    67 }

    68 

    69 TlvBlock::ConstIterator

    70 TlvBlock::Begin (void) const

    71 {

    72   return m_tlvList.begin ();

    73 }

    74 

    75 TlvBlock::Iterator

    76 TlvBlock::End (void)

    77 {

    78   return m_tlvList.end ();

    79 }

    80 

    81 TlvBlock::ConstIterator

    82 TlvBlock::End (void) const

    83 {

    84   return m_tlvList.end ();

    85 }

    86 

    87 int

    88 TlvBlock::Size (void) const

    89 {

    90   return m_tlvList.size ();

    91 }

    92 

    93 bool

    94 TlvBlock::Empty (void) const

    95 {

    96   return m_tlvList.empty ();

    97 }

    98 

    99 Ptr<Tlv>

   100 TlvBlock::Front (void) const

   101 {

   102   return m_tlvList.front ();

   103 }

   104 

   105 Ptr<Tlv>

   106 TlvBlock::Back (void) const

   107 {

   108   return m_tlvList.back ();

   109 }

   110 

   111 void

   112 TlvBlock::PushFront (Ptr<Tlv> tlv)

   113 {

   114   //Ptr<Tlv> * newptr = new Ptr<Tlv> (GetPointer<Tlv> (tlv));

   115   m_tlvList.push_front (tlv);

   116 }

   117 

   118 void

   119 TlvBlock::PopFront (void)

   120 {

   121   m_tlvList.pop_front ();

   122 }

   123 

   124 void

   125 TlvBlock::PushBack (Ptr<Tlv> tlv)

   126 {

   127   //Ptr<Tlv> * newptr = new Ptr<Tlv> (GetPointer<Tlv> (tlv));

   128   m_tlvList.push_back (tlv);

   129 }

   130 

   131 void

   132 TlvBlock::PopBack (void)

   133 {

   134   m_tlvList.pop_back ();

   135 }

   136 

   137 TlvBlock::Iterator

   138 TlvBlock::Insert (TlvBlock::Iterator position, const Ptr<Tlv> tlv)

   139 {

   140   return m_tlvList.insert (position, tlv);

   141 }

   142 

   143 TlvBlock::Iterator

   144 TlvBlock::Erase (TlvBlock::Iterator position)

   145 {

   146   return m_tlvList.erase (position);

   147 }

   148 

   149 TlvBlock::Iterator

   150 TlvBlock::Erase (TlvBlock::Iterator first, TlvBlock::Iterator last)

   151 {

   152   return m_tlvList.erase (first, last);

   153 }

   154 

   155 void

   156 TlvBlock::Clear (void)

   157 {

   158   m_tlvList.clear ();

   159 }

   160 

   161 uint32_t

   162 TlvBlock::GetSerializedSize (void) const

   163 {

   164   /* tlv size */

   165   uint32_t size = 2;

   166   for (ConstIterator iter = Begin (); iter != End (); iter++)

   167   {

   168     size += (*iter)->GetSerializedSize ();

   169   }

   170   return size;

   171 }

   172 

   173 void

   174 TlvBlock::Serialize (Buffer::Iterator &start) const

   175 {

   176   if (Empty ())

   177   {

   178     start.WriteHtonU16 (0);

   179     return;

   180   }

   181 

   182   /* We need to write the size of the TLV block in front, so save its

   183    * position. */

   184   Buffer::Iterator tlvsize = start;

   185   start.Next (2);

   186   for (ConstIterator iter = Begin (); iter != End (); iter++)

   187   {

   188     (*iter)->Serialize (start);

   189   }

   190   /* - 2 to not include the size field */

   191   uint16_t size = start.GetDistanceFrom (tlvsize) - 2;

   192   tlvsize.WriteHtonU16 (size);

   193 }

   194 

   195 void

   196 TlvBlock::Deserialize (Buffer::Iterator &start)

   197 {

   198   uint16_t size = start.ReadNtohU16 ();

   199 

   200   Buffer::Iterator tlvstart = start;

   201   if (size > 0)

   202   {

   203     while (start.GetDistanceFrom (tlvstart) < size)

   204     {

   205       Ptr<Tlv> newtlv = Create<Tlv> ();

   206       //Tlv * newtlv = new Tlv ();

   207       newtlv->Deserialize (start);

   208 

   209       //Ptr<Tlv> * newptr = new Ptr<Tlv> (newtlv);

   210       PushBack (newtlv);

   211     }

   212   }

   213 }

   214 

   215 void

   216 TlvBlock::Print (std::ostream &os) const

   217 {

   218   Print (os, 0);

   219 }

   220 

   221 void

   222 TlvBlock::Print (std::ostream &os, int level) const

   223 {

   224   std::string prefix = "";

   225   for (int i = 0; i < level; i++)

   226     prefix.append("\t");

   227 

   228   os << prefix << "TLV Block {" << std::endl;

   229   os << prefix << "\tsize = " << Size () << std::endl;

   230   os << prefix << "\tmembers [" << std::endl;

   231   for (ConstIterator iter = Begin (); iter != End (); iter++)

   232   {

   233     (*iter)->Print (os, level+2);

   234   }

   235   os << prefix << "\t]" << std::endl;

   236   os << prefix << "}" << std::endl;

   237 }

   238 

   239 bool

   240 TlvBlock::operator== (const TlvBlock &other) const

   241 {

   242   if (Size () != other.Size ())

   243     return false;

   244 

   245   ConstIterator ti, oi;

   246   for (ti = Begin (), oi = other.Begin ();

   247       ti != End () && oi != other.End ();

   248       ti++, oi++)

   249   {

   250     if (**ti != **oi)

   251       return false;

   252   }

   253   return true;

   254 }

   255 

   256 bool

   257 TlvBlock::operator!= (const TlvBlock &other) const

   258 {

   259   return !(*this == other);

   260 }

   261 

   262 /* End TlvBlock class */

   263 

   264 AddressTlvBlock::Iterator

   265 AddressTlvBlock::Begin (void)

   266 {

   267   return m_tlvList.begin ();

   268 }

   269 

   270 AddressTlvBlock::ConstIterator

   271 AddressTlvBlock::Begin (void) const

   272 {

   273   return m_tlvList.begin ();

   274 }

   275 

   276 AddressTlvBlock::Iterator

   277 AddressTlvBlock::End (void)

   278 {

   279   return m_tlvList.end ();

   280 }

   281 

   282 AddressTlvBlock::ConstIterator

   283 AddressTlvBlock::End (void) const

   284 {

   285   return m_tlvList.end ();

   286 }

   287 

   288 int

   289 AddressTlvBlock::Size (void) const

   290 {

   291   return m_tlvList.size ();

   292 }

   293 

   294 bool

   295 AddressTlvBlock::Empty (void) const

   296 {

   297   return m_tlvList.empty ();

   298 }

   299 

   300 Ptr<AddressTlv>

   301 AddressTlvBlock::Front (void) const

   302 {

   303   return m_tlvList.front ();

   304 }

   305 

   306 Ptr<AddressTlv>

   307 AddressTlvBlock::Back (void) const

   308 {

   309   return m_tlvList.back ();

   310 }

   311 

   312 void

   313 AddressTlvBlock::PushFront (Ptr<AddressTlv> tlv)

   314 {

   315   m_tlvList.push_front (tlv);

   316 }

   317 

   318 void

   319 AddressTlvBlock::PopFront (void)

   320 {

   321   m_tlvList.pop_front ();

   322 }

   323 

   324 void

   325 AddressTlvBlock::PushBack (Ptr<AddressTlv> tlv)

   326 {

   327   m_tlvList.push_back (tlv);

   328 }

   329 

   330 void

   331 AddressTlvBlock::PopBack (void)

   332 {

   333   m_tlvList.pop_back ();

   334 }

   335 

   336 AddressTlvBlock::Iterator

   337 AddressTlvBlock::Insert (AddressTlvBlock::Iterator position, const Ptr<AddressTlv> tlv)

   338 {

   339   return m_tlvList.insert (position, tlv);

   340 }

   341 

   342 AddressTlvBlock::Iterator

   343 AddressTlvBlock::Erase (AddressTlvBlock::Iterator position)

   344 {

   345   return m_tlvList.erase (position);

   346 }

   347 

   348 AddressTlvBlock::Iterator

   349 AddressTlvBlock::Erase (AddressTlvBlock::Iterator first, AddressTlvBlock::Iterator last)

   350 {

   351   return m_tlvList.erase (first, last);

   352 }

   353 

   354 void

   355 AddressTlvBlock::Clear (void)

   356 {

   357   m_tlvList.clear ();

   358 }

   359 

   360 uint32_t

   361 AddressTlvBlock::GetSerializedSize (void) const

   362 {

   363   /* tlv size */

   364   uint32_t size = 2;

   365   for (ConstIterator iter = Begin (); iter != End (); iter++)

   366   {

   367     size += (*iter)->GetSerializedSize ();

   368   }

   369   return size;

   370 }

   371 

   372 void

   373 AddressTlvBlock::Serialize (Buffer::Iterator &start) const

   374 {

   375   if (Empty ())

   376   {

   377     start.WriteHtonU16 (0);

   378     return;

   379   }

   380 

   381   /* We need to write the size of the TLV block in front, so save its

   382    * position. */

   383   Buffer::Iterator tlvsize = start;

   384   start.Next (2);

   385   for (ConstIterator iter = Begin (); iter != End (); iter++)

   386   {

   387     (*iter)->Serialize (start);

   388   }

   389   /* - 2 to not include the size field */

   390   uint16_t size = start.GetDistanceFrom (tlvsize) - 2;

   391   tlvsize.WriteHtonU16 (size);

   392 }

   393 

   394 void

   395 AddressTlvBlock::Deserialize (Buffer::Iterator &start)

   396 {

   397   uint16_t size = start.ReadNtohU16 ();

   398 

   399   Buffer::Iterator tlvstart = start;

   400   if (size > 0)

   401   {

   402     while (start.GetDistanceFrom (tlvstart) < size)

   403     {

   404       Ptr<AddressTlv> newtlv = Create<AddressTlv> ();

   405       //AddressTlv * newtlv = new AddressTlv ();

   406       newtlv->Deserialize (start);

   407 

   408       //Ptr<AddressTlv> * newptr = new Ptr<AddressTlv> (newtlv);

   409       PushBack (newtlv);

   410     }

   411   }

   412 }

   413 

   414 void

   415 AddressTlvBlock::Print (std::ostream &os) const

   416 {

   417   Print (os, 0);

   418 }

   419 

   420 void

   421 AddressTlvBlock::Print (std::ostream &os, int level) const

   422 {

   423   std::string prefix = "";

   424   for (int i = 0; i < level; i++)

   425     prefix.append("\t");

   426 

   427   os << prefix << "TLV Block {" << std::endl;

   428   os << prefix << "\tsize = " << Size () << std::endl;

   429   os << prefix << "\tmembers [" << std::endl;

   430   for (ConstIterator iter = Begin (); iter != End (); iter++)

   431   {

   432     (*iter)->Print (os, level+2);

   433   }

   434   os << prefix << "\t]" << std::endl;

   435   os << prefix << "}" << std::endl;

   436 }

   437 

   438 bool

   439 AddressTlvBlock::operator== (const AddressTlvBlock &other) const

   440 {

   441   if (Size () != other.Size ())

   442     return false;

   443 

   444   ConstIterator it, ot;

   445   for (it = Begin (), ot = other.Begin ();

   446       it != End () && ot != other.End ();

   447       it++, ot++)

   448   {

   449     if (**it != **ot)

   450       return false;

   451   }

   452   return true;

   453 }

   454 

   455 bool

   456 AddressTlvBlock::operator!= (const AddressTlvBlock &other) const

   457 {

   458   return !(*this == other);

   459 }

   460 

   461 

   462 /* End AddressTlvBlock Class */

   463 

   464 PacketBB::PacketBB (void)

   465 {

   466   m_refCount = 1;

   467   m_version = VERSION;

   468   m_hasseqnum = false;

   469 }

   470 

   471 uint8_t

   472 PacketBB::GetVersion (void) const

   473 {

   474   return m_version;

   475 }

   476 

   477 void

   478 PacketBB::SetSequenceNumber (uint16_t number)

   479 {

   480   m_seqnum = number;

   481   m_hasseqnum = true;

   482 }

   483 

   484 uint16_t

   485 PacketBB::GetSequenceNumber (void) const throw (PacketBBError)

   486 {

   487   if (!HasSequenceNumber ())

   488   {

   489     throw PacketBBError ("Packet has no sequence number.");

   490   }

   491   return m_seqnum;

   492 }

   493 

   494 bool

   495 PacketBB::HasSequenceNumber (void) const

   496 {

   497   return m_hasseqnum;

   498 }

   499 

   500 /* Manipulating Packet TLVs */

   501 

   502 PacketBB::TlvIterator

   503 PacketBB::TlvBegin (void)

   504 {

   505   return m_tlvList.Begin ();

   506 }

   507 

   508 PacketBB::ConstTlvIterator

   509 PacketBB::TlvBegin (void) const

   510 {

   511   return m_tlvList.Begin ();

   512 }

   513 

   514 PacketBB::TlvIterator

   515 PacketBB::TlvEnd (void)

   516 {

   517   return m_tlvList.End ();

   518 }

   519 

   520 PacketBB::ConstTlvIterator

   521 PacketBB::TlvEnd (void) const

   522 {

   523   return m_tlvList.End ();

   524 }

   525 

   526 int

   527 PacketBB::TlvSize (void) const

   528 {

   529   return m_tlvList.Size ();

   530 }

   531 

   532 bool

   533 PacketBB::TlvEmpty (void) const

   534 {

   535   return m_tlvList.Empty ();

   536 }

   537 

   538 Ptr<Tlv>

   539 PacketBB::TlvFront (void)

   540 {

   541   return m_tlvList.Front ();

   542 }

   543 

   544 const Ptr<Tlv>

   545 PacketBB::TlvFront (void) const

   546 {

   547   return m_tlvList.Front ();

   548 }

   549 

   550 Ptr<Tlv>

   551 PacketBB::TlvBack (void)

   552 {

   553   return m_tlvList.Back ();

   554 }

   555 

   556 const Ptr<Tlv>

   557 PacketBB::TlvBack (void) const

   558 {

   559   return m_tlvList.Back ();

   560 }

   561 

   562 void

   563 PacketBB::TlvPushFront (Ptr<Tlv> tlv)

   564 {

   565   m_tlvList.PushFront (tlv);

   566 }

   567 

   568 void

   569 PacketBB::TlvPopFront (void)

   570 {

   571   m_tlvList.PopFront ();

   572 }

   573 

   574 void

   575 PacketBB::TlvPushBack (Ptr<Tlv> tlv)

   576 {

   577   m_tlvList.PushBack (tlv);

   578 }

   579 

   580 void

   581 PacketBB::TlvPopBack (void)

   582 {

   583   m_tlvList.PopBack ();

   584 }

   585 

   586 PacketBB::TlvIterator

   587 PacketBB::Erase (PacketBB::TlvIterator position)

   588 {

   589   return m_tlvList.Erase (position);

   590 }

   591 

   592 PacketBB::TlvIterator

   593 PacketBB::Erase (PacketBB::TlvIterator first, PacketBB::TlvIterator last)

   594 {

   595   return m_tlvList.Erase (first, last);

   596 }

   597 

   598 void

   599 PacketBB::TlvClear (void)

   600 {

   601   m_tlvList.Clear ();

   602 }

   603 

   604 /* Manipulating Packet Messages */

   605 

   606 PacketBB::MessageIterator

   607 PacketBB::MessageBegin (void)

   608 {

   609   return m_messageList.begin ();

   610 }

   611 

   612 PacketBB::ConstMessageIterator

   613 PacketBB::MessageBegin (void) const

   614 {

   615   return m_messageList.begin ();

   616 }

   617 

   618 PacketBB::MessageIterator

   619 PacketBB::MessageEnd (void)

   620 {

   621   return m_messageList.end ();

   622 }

   623 

   624 PacketBB::ConstMessageIterator

   625 PacketBB::MessageEnd (void) const

   626 {

   627   return m_messageList.end ();

   628 }

   629 

   630 int

   631 PacketBB::MessageSize (void) const

   632 {

   633   return m_messageList.size ();

   634 }

   635 

   636 bool

   637 PacketBB::MessageEmpty (void) const

   638 {

   639   return m_messageList.empty ();

   640 }

   641 

   642 Ptr<Message>

   643 PacketBB::MessageFront (void)

   644 {

   645   return m_messageList.front ();

   646 }

   647 

   648 const Ptr<Message>

   649 PacketBB::MessageFront (void) const

   650 {

   651   return m_messageList.front ();

   652 }

   653 

   654 Ptr<Message>

   655 PacketBB::MessageBack (void)

   656 {

   657   return m_messageList.back ();

   658 }

   659 

   660 const Ptr<Message>

   661 PacketBB::MessageBack (void) const

   662 {

   663   return m_messageList.back ();

   664 }

   665 

   666 void

   667 PacketBB::MessagePushFront (Ptr<Message> tlv)

   668 {

   669   m_messageList.push_front (tlv);

   670 }

   671 

   672 void

   673 PacketBB::MessagePopFront (void)

   674 {

   675   m_messageList.pop_front ();

   676 }

   677 

   678 void

   679 PacketBB::MessagePushBack (Ptr<Message> tlv)

   680 {

   681   m_messageList.push_back (tlv);

   682 }

   683 

   684 void

   685 PacketBB::MessagePopBack (void)

   686 {

   687   m_messageList.pop_back ();

   688 }

   689 

   690 PacketBB::MessageIterator

   691 PacketBB::Erase (PacketBB::MessageIterator position)

   692 {

   693   return m_messageList.erase (position);

   694 }

   695 

   696 PacketBB::MessageIterator

   697 PacketBB::Erase (PacketBB::MessageIterator first,

   698     PacketBB::MessageIterator last)

   699 {

   700   return m_messageList.erase (first, last);

   701 }

   702 

   703 void

   704 PacketBB::MessageClear (void)

   705 {

   706   m_messageList.clear ();

   707 }

   708 

   709 void

   710 PacketBB::Ref (void) const

   711 {

   712   m_refCount++;

   713 }

   714 

   715 void

   716 PacketBB::Unref (void) const

   717 {

   718   m_refCount--;

   719   if (m_refCount == 0)

   720   {

   721     delete this;

   722   }

   723 }

   724 

   725 TypeId

   726 PacketBB::GetTypeId (void)

   727 {

   728   static TypeId tid = TypeId ("PacketBB")

   729     .SetParent<Header> ()

   730     .AddConstructor<PacketBB> ()

   731   ;

   732   return tid;

   733 }

   734 

   735 TypeId

   736 PacketBB::GetInstanceTypeId (void) const

   737 {

   738   return GetTypeId ();

   739 }

   740 

   741 uint32_t

   742 PacketBB::GetSerializedSize (void) const

   743 {

   744   /* Version number + flags */

   745   uint32_t size = 1;

   746 

   747   if (HasSequenceNumber())

   748   {

   749     size += 2;

   750   }

   751 

   752   if (!TlvEmpty ())

   753     size += m_tlvList.GetSerializedSize ();

   754 

   755   for (ConstMessageIterator iter = MessageBegin (); iter != MessageEnd ();

   756       iter++)

   757   {

   758     size += (*iter)->GetSerializedSize ();

   759   }

   760 

   761   return size;

   762 }

   763 

   764 void

   765 PacketBB::Serialize (Buffer::Iterator start) const

   766 {

   767   /* We remember the start, so we can write the flags after we check for a

   768    * sequence number and TLV. */

   769   Buffer::Iterator bufref = start;

   770   start.Next ();

   771 

   772   uint8_t flags = VERSION;

   773   /* Make room for 4 bit flags */

   774   flags <<= 4;

   775 

   776   if (HasSequenceNumber ())

   777   {

   778     flags |= PHAS_SEQ_NUM;

   779     start.WriteHtonU16 (GetSequenceNumber ());

   780   }

   781 

   782   if (!TlvEmpty ())

   783   {

   784     flags |= PHAS_TLV;

   785     m_tlvList.Serialize (start);

   786   }

   787 

   788   bufref.WriteU8(flags);

   789 

   790   for (ConstMessageIterator iter = MessageBegin ();

   791       iter != MessageEnd ();

   792       iter++)

   793   {

   794     (*iter)->Serialize (start);

   795   }

   796 }

   797 

   798 uint32_t

   799 PacketBB::Deserialize (Buffer::Iterator start)

   800 {

   801   Buffer::Iterator begin = start;

   802 

   803   uint8_t flags = start.ReadU8 ();

   804 

   805   if (flags & PHAS_SEQ_NUM)

   806     SetSequenceNumber (start.ReadNtohU16 ());

   807 

   808   if (flags & PHAS_TLV)

   809     m_tlvList.Deserialize (start);

   810 

   811   while (!start.IsEnd())

   812   {

   813     Ptr<Message> newmsg = Message::DeserializeMessage (start);

   814     //Message * newmsg = Message::DeserializeMessage (start);

   815     //Ptr<Message> * newptr = new Ptr<Message> (newmsg);

   816     MessagePushBack (newmsg);

   817   }

   818 

   819   flags >>= 4;

   820   m_version = flags;

   821 

   822   return start.GetDistanceFrom (begin);

   823 }

   824 

   825 void

   826 PacketBB::Print (std::ostream &os) const

   827 {

   828   os << "PacketBB {" << std::endl;

   829 

   830   if (HasSequenceNumber ())

   831     os << "\tsequence number = " << GetSequenceNumber ();

   832 

   833   os << std::endl;

   834 

   835   m_tlvList.Print (os, 1);

   836 

   837   for (ConstMessageIterator iter = MessageBegin ();

   838       iter != MessageEnd ();

   839       iter++)

   840   {

   841     (*iter)->Print (os, 1);

   842   }

   843 

   844   os << "}" << std::endl;

   845 }

   846 

   847 bool

   848 PacketBB::operator== (const PacketBB &other) const

   849 {

   850   if (GetVersion () != other.GetVersion ())

   851     return false;

   852 

   853   if (HasSequenceNumber () != other.HasSequenceNumber ())

   854     return false;

   855 

   856   if (HasSequenceNumber ())

   857   {

   858     if (GetSequenceNumber () != other.GetSequenceNumber ())

   859       return false;

   860   }

   861 

   862   if (m_tlvList != other.m_tlvList)

   863     return false;

   864 

   865   if (MessageSize () != other.MessageSize ())

   866       return false;

   867 

   868   ConstMessageIterator tmi, omi;

   869   for (tmi = MessageBegin (), omi = other.MessageBegin ();

   870     tmi != MessageEnd () && omi != other.MessageEnd ();

   871     tmi++, omi++)

   872   {

   873     if (**tmi != **omi)

   874       return false;

   875   }

   876   return true;

   877 }

   878 

   879 bool

   880 PacketBB::operator!= (const PacketBB &other) const

   881 {

   882   return !(*this == other);

   883 }

   884 

   885 /* End PacketBB class */

   886 

   887 Message::Message (void)

   888 {

   889   m_refCount = 1;

   890   /* Default to IPv4 */

   891   m_addrSize = IPV4;

   892   m_hasOriginatorAddress = false;

   893   m_hasHopLimit = false;

   894   m_hasHopCount = false;

   895   m_hasSequenceNumber = false;

   896 }

   897 

   898 void

   899 Message::SetType (uint8_t type)

   900 {

   901   m_type = type;

   902 }

   903 

   904 uint8_t

   905 Message::GetType (void) const

   906 {

   907   return m_type;

   908 }

   909 

   910 AddressLength

   911 Message::GetAddressLength (void) const

   912 {

   913   return m_addrSize;

   914 }

   915 

   916 void

   917 Message::SetOriginatorAddress (Address address)

   918 {

   919   m_originatorAddress = address;

   920   m_hasOriginatorAddress = true;

   921 }

   922 

   923 Address

   924 Message::GetOriginatorAddress (void) const throw (PacketBBError)

   925 {

   926   if (!HasOriginatorAddress()) 

   927   {

   928     throw PacketBBError ("Message has no originator address.");

   929   }

   930   return m_originatorAddress;

   931 }

   932 

   933 bool

   934 Message::HasOriginatorAddress (void) const

   935 {

   936   return m_hasOriginatorAddress;

   937 }

   938 

   939 void

   940 Message::SetHopLimit (uint8_t hopLimit)

   941 {

   942   m_hopLimit = hopLimit;

   943   m_hasHopLimit = true;

   944 }

   945 

   946 uint8_t

   947 Message::GetHopLimit (void) const throw (PacketBBError)

   948 {

   949   if (!HasHopLimit())

   950   {

   951     throw PacketBBError ("Message has no hop limit.");

   952   }

   953   return m_hopLimit;

   954 }

   955 

   956 bool

   957 Message::HasHopLimit (void) const

   958 {

   959   return m_hasHopLimit;

   960 }

   961 

   962 void

   963 Message::SetHopCount (uint8_t hopCount)

   964 {

   965   m_hopCount = hopCount;

   966   m_hasHopCount = true;

   967 }

   968 

   969 uint8_t

   970 Message::GetHopCount (void) const throw (PacketBBError)

   971 {

   972   if (!HasHopCount())

   973   {

   974     throw PacketBBError ("Message has no hop count.");

   975   }

   976   return m_hopCount;

   977 }

   978 

   979 bool

   980 Message::HasHopCount (void) const

   981 {

   982   return m_hasHopCount;

   983 }

   984 

   985 void

   986 Message::SetSequenceNumber (uint16_t sequenceNumber)

   987 {

   988   m_sequenceNumber = sequenceNumber;

   989   m_hasSequenceNumber = true;

   990 }

   991 

   992 uint16_t

   993 Message::GetSequenceNumber (void) const throw (PacketBBError)

   994 {

   995   if (!HasSequenceNumber())

   996   {

   997     throw PacketBBError ("Message has no sequence number.");

   998   }

   999   return m_sequenceNumber;

  1000 }

  1001 

  1002 bool

  1003 Message::HasSequenceNumber (void) const

  1004 {

  1005   return m_hasSequenceNumber;

  1006 }

  1007 

  1008 /* Manipulating Message TLVs */

  1009 

  1010 Message::TlvIterator

  1011 Message::TlvBegin (void)

  1012 {

  1013   return m_tlvList.Begin();

  1014 }

  1015 

  1016 Message::ConstTlvIterator

  1017 Message::TlvBegin (void) const

  1018 {

  1019   return m_tlvList.Begin();

  1020 }

  1021 

  1022 Message::TlvIterator

  1023 Message::TlvEnd (void)

  1024 {

  1025   return m_tlvList.End();

  1026 }

  1027 

  1028 Message::ConstTlvIterator

  1029 Message::TlvEnd (void) const

  1030 {

  1031   return m_tlvList.End();

  1032 }

  1033 

  1034 int

  1035 Message::TlvSize (void) const

  1036 {

  1037   return m_tlvList.Size();

  1038 }

  1039 

  1040 bool

  1041 Message::TlvEmpty (void) const

  1042 {

  1043   return m_tlvList.Empty();

  1044 }

  1045 

  1046 Ptr<Tlv>

  1047 Message::TlvFront (void)

  1048 {

  1049   return m_tlvList.Front();

  1050 }

  1051 

  1052 const Ptr<Tlv>

  1053 Message::TlvFront (void) const

  1054 {

  1055   return m_tlvList.Front();

  1056 }

  1057 

  1058 Ptr<Tlv>

  1059 Message::TlvBack (void)

  1060 {

  1061   return m_tlvList.Back();

  1062 }

  1063 

  1064 const Ptr<Tlv>

  1065 Message::TlvBack (void) const

  1066 {

  1067   return m_tlvList.Back();

  1068 }

  1069 

  1070 void

  1071 Message::TlvPushFront (Ptr<Tlv> tlv)

  1072 {

  1073   m_tlvList.PushFront(tlv);

  1074 }

  1075 

  1076 void

  1077 Message::TlvPopFront (void)

  1078 {

  1079   m_tlvList.PopFront();

  1080 }

  1081 

  1082 void

  1083 Message::TlvPushBack (Ptr<Tlv> tlv)

  1084 {

  1085   m_tlvList.PushBack(tlv);

  1086 }

  1087 

  1088 void

  1089 Message::TlvPopBack (void)

  1090 {

  1091   m_tlvList.PopBack();

  1092 }

  1093 

  1094 Message::TlvIterator

  1095 Message::TlvErase (Message::TlvIterator position)

  1096 {

  1097   return m_tlvList.Erase(position);

  1098 }

  1099 

  1100 Message::TlvIterator

  1101 Message::TlvErase (Message::TlvIterator first, Message::TlvIterator last)

  1102 {

  1103   return m_tlvList.Erase(first, last);

  1104 }

  1105 

  1106 void

  1107 Message::TlvClear (void)

  1108 {

  1109   return m_tlvList.Clear();

  1110 }

  1111 

  1112 /* Manipulating Address Block and Address TLV pairs */

  1113 

  1114 Message::AddressBlockIterator

  1115 Message::AddressBlockBegin (void)

  1116 {

  1117   return m_addressBlockList.begin();

  1118 }

  1119 

  1120 Message::ConstAddressBlockIterator

  1121 Message::AddressBlockBegin (void) const

  1122 {

  1123   return m_addressBlockList.begin();

  1124 }

  1125 

  1126 Message::AddressBlockIterator

  1127 Message::AddressBlockEnd (void)

  1128 {

  1129   return m_addressBlockList.end();

  1130 }

  1131 

  1132 Message::ConstAddressBlockIterator

  1133 Message::AddressBlockEnd (void) const

  1134 {

  1135   return m_addressBlockList.end();