00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "ns3/assert.h"
00022
00023 #include "olsr-header.h"
00024 #include "ns3/log.h"
00025
00026 #define IPV4_ADDRESS_SIZE 4
00027 #define OLSR_MSG_HEADER_SIZE 12
00028 #define OLSR_PKT_HEADER_SIZE 4
00029
00030 namespace ns3 {
00031 namespace olsr {
00032
00033
00034 NS_LOG_COMPONENT_DEFINE("OlsrHeader");
00035
00036
00037 #define OLSR_C 0.0625
00038
00039
00040
00041
00042
00043
00044
00045 uint8_t
00046 SecondsToEmf (double seconds)
00047 {
00048 int a, b = 0;
00049
00050
00051 for (b = 0; (seconds/OLSR_C) >= (1 << b); ++b)
00052 ;
00053 NS_ASSERT ((seconds/OLSR_C) < (1 << b));
00054 b--;
00055 NS_ASSERT ((seconds/OLSR_C) >= (1 << b));
00056
00057
00058 double tmp = 16*(seconds/(OLSR_C*(1<<b))-1);
00059
00060
00061 a = (int) ceil (tmp);
00062
00063
00064 if (a == 16)
00065 {
00066 b += 1;
00067 a = 0;
00068 }
00069
00070
00071 NS_ASSERT (a >= 0 && a < 16);
00072 NS_ASSERT (b >= 0 && b < 16);
00073
00074
00075 return (uint8_t) ((a << 4) | b);
00076 }
00077
00078
00079
00080
00081
00082
00083
00084 double
00085 EmfToSeconds (uint8_t olsrFormat)
00086 {
00087 int a = (olsrFormat >> 4);
00088 int b = (olsrFormat & 0xf);
00089
00090 return OLSR_C * (1 + a/16.0) * (1 << b);
00091 }
00092
00093
00094
00095
00096
00097 NS_OBJECT_ENSURE_REGISTERED (PacketHeader);
00098
00099 PacketHeader::PacketHeader ()
00100 {}
00101
00102 PacketHeader::~PacketHeader ()
00103 {}
00104
00105 TypeId
00106 PacketHeader::GetTypeId (void)
00107 {
00108 static TypeId tid = TypeId ("ns3::olsr::PacketHeader")
00109 .SetParent<Header> ()
00110 .AddConstructor<PacketHeader> ()
00111 ;
00112 return tid;
00113 }
00114 TypeId
00115 PacketHeader::GetInstanceTypeId (void) const
00116 {
00117 return GetTypeId ();
00118 }
00119
00120 uint32_t
00121 PacketHeader::GetSerializedSize (void) const
00122 {
00123 return OLSR_PKT_HEADER_SIZE;
00124 }
00125
00126 void
00127 PacketHeader::Print (std::ostream &os) const
00128 {
00129
00130 }
00131
00132 void
00133 PacketHeader::Serialize (Buffer::Iterator start) const
00134 {
00135 Buffer::Iterator i = start;
00136 i.WriteHtonU16 (m_packetLength);
00137 i.WriteHtonU16 (m_packetSequenceNumber);
00138 }
00139
00140 uint32_t
00141 PacketHeader::Deserialize (Buffer::Iterator start)
00142 {
00143 Buffer::Iterator i = start;
00144 m_packetLength = i.ReadNtohU16 ();
00145 m_packetSequenceNumber = i.ReadNtohU16 ();
00146 return GetSerializedSize ();
00147 }
00148
00149
00150
00151
00152 NS_OBJECT_ENSURE_REGISTERED (MessageHeader);
00153
00154 MessageHeader::MessageHeader ()
00155 : m_messageType (MessageHeader::MessageType (0))
00156 {}
00157
00158 MessageHeader::~MessageHeader ()
00159 {}
00160
00161 TypeId
00162 MessageHeader::GetTypeId (void)
00163 {
00164 static TypeId tid = TypeId ("ns3::olsr::MessageHeader")
00165 .SetParent<Header> ()
00166 .AddConstructor<MessageHeader> ()
00167 ;
00168 return tid;
00169 }
00170 TypeId
00171 MessageHeader::GetInstanceTypeId (void) const
00172 {
00173 return GetTypeId ();
00174 }
00175
00176 uint32_t
00177 MessageHeader::GetSerializedSize (void) const
00178 {
00179 uint32_t size = OLSR_MSG_HEADER_SIZE;
00180 switch (m_messageType)
00181 {
00182 case MID_MESSAGE:
00183 size += m_message.mid.GetSerializedSize ();
00184 break;
00185 case HELLO_MESSAGE:
00186 NS_LOG_DEBUG ("Hello Message Size: " << size << " + " << m_message.hello.GetSerializedSize ());
00187 size += m_message.hello.GetSerializedSize ();
00188 break;
00189 case TC_MESSAGE:
00190 size += m_message.tc.GetSerializedSize ();
00191 break;
00192 case HNA_MESSAGE:
00193 size += m_message.hna.GetSerializedSize ();
00194 break;
00195 default:
00196 NS_ASSERT (false);
00197 }
00198 return size;
00199 }
00200
00201 void
00202 MessageHeader::Print (std::ostream &os) const
00203 {
00204
00205 }
00206
00207 void
00208 MessageHeader::Serialize (Buffer::Iterator start) const
00209 {
00210 Buffer::Iterator i = start;
00211 i.WriteU8 (m_messageType);
00212 i.WriteU8 (m_vTime);
00213 i.WriteHtonU16 (GetSerializedSize ());
00214 i.WriteHtonU32 (m_originatorAddress.Get ());
00215 i.WriteU8 (m_timeToLive);
00216 i.WriteU8 (m_hopCount);
00217 i.WriteHtonU16 (m_messageSequenceNumber);
00218
00219 switch (m_messageType)
00220 {
00221 case MID_MESSAGE:
00222 m_message.mid.Serialize (i);
00223 break;
00224 case HELLO_MESSAGE:
00225 m_message.hello.Serialize (i);
00226 break;
00227 case TC_MESSAGE:
00228 m_message.tc.Serialize (i);
00229 break;
00230 case HNA_MESSAGE:
00231 m_message.hna.Serialize (i);
00232 break;
00233 default:
00234 NS_ASSERT (false);
00235 }
00236
00237 }
00238
00239 uint32_t
00240 MessageHeader::Deserialize (Buffer::Iterator start)
00241 {
00242 uint32_t size;
00243 Buffer::Iterator i = start;
00244 m_messageType = (MessageType) i.ReadU8 ();
00245 NS_ASSERT (m_messageType >= HELLO_MESSAGE && m_messageType <= HNA_MESSAGE);
00246 m_vTime = i.ReadU8 ();
00247 m_messageSize = i.ReadNtohU16 ();
00248 m_originatorAddress = Ipv4Address (i.ReadNtohU32 ());
00249 m_timeToLive = i.ReadU8 ();
00250 m_hopCount = i.ReadU8 ();
00251 m_messageSequenceNumber = i.ReadNtohU16 ();
00252 size = OLSR_MSG_HEADER_SIZE;
00253 switch (m_messageType)
00254 {
00255 case MID_MESSAGE:
00256 size += m_message.mid.Deserialize (i, m_messageSize - OLSR_MSG_HEADER_SIZE);
00257 break;
00258 case HELLO_MESSAGE:
00259 size += m_message.hello.Deserialize (i, m_messageSize - OLSR_MSG_HEADER_SIZE);
00260 break;
00261 case TC_MESSAGE:
00262 size += m_message.tc.Deserialize (i, m_messageSize - OLSR_MSG_HEADER_SIZE);
00263 break;
00264 case HNA_MESSAGE:
00265 size += m_message.hna.Deserialize (i, m_messageSize - OLSR_MSG_HEADER_SIZE);
00266 break;
00267 default:
00268 NS_ASSERT (false);
00269 }
00270 return size;
00271 }
00272
00273
00274
00275
00276 uint32_t
00277 MessageHeader::Mid::GetSerializedSize (void) const
00278 {
00279 return this->interfaceAddresses.size () * IPV4_ADDRESS_SIZE;
00280 }
00281
00282 void
00283 MessageHeader::Mid::Print (std::ostream &os) const
00284 {
00285
00286 }
00287
00288 void
00289 MessageHeader::Mid::Serialize (Buffer::Iterator start) const
00290 {
00291 Buffer::Iterator i = start;
00292
00293 for (std::vector<Ipv4Address>::const_iterator iter = this->interfaceAddresses.begin ();
00294 iter != this->interfaceAddresses.end (); iter++)
00295 {
00296 i.WriteHtonU32 (iter->Get ());
00297 }
00298 }
00299
00300 uint32_t
00301 MessageHeader::Mid::Deserialize (Buffer::Iterator start, uint32_t messageSize)
00302 {
00303 Buffer::Iterator i = start;
00304
00305 this->interfaceAddresses.clear ();
00306 NS_ASSERT (messageSize >= 0);
00307 NS_ASSERT (messageSize % IPV4_ADDRESS_SIZE == 0);
00308
00309 int numAddresses = messageSize / IPV4_ADDRESS_SIZE;
00310 this->interfaceAddresses.erase (this->interfaceAddresses.begin(),
00311 this->interfaceAddresses.end ());
00312 for (int n = 0; n < numAddresses; ++n)
00313 this->interfaceAddresses.push_back (Ipv4Address (i.ReadNtohU32 ()));
00314 return GetSerializedSize ();
00315 }
00316
00317
00318
00319
00320
00321 uint32_t
00322 MessageHeader::Hello::GetSerializedSize (void) const
00323 {
00324 uint32_t size = 4;
00325 for (std::vector<LinkMessage>::const_iterator iter = this->linkMessages.begin ();
00326 iter != this->linkMessages.end (); iter++)
00327 {
00328 const LinkMessage &lm = *iter;
00329 size += 4;
00330 size += IPV4_ADDRESS_SIZE * lm.neighborInterfaceAddresses.size ();
00331 }
00332 return size;
00333 }
00334
00335 void
00336 MessageHeader::Hello::Print (std::ostream &os) const
00337 {
00338
00339 }
00340
00341 void
00342 MessageHeader::Hello::Serialize (Buffer::Iterator start) const
00343 {
00344 Buffer::Iterator i = start;
00345
00346 i.WriteU16 (0);
00347 i.WriteU8 (this->hTime);
00348 i.WriteU8 (this->willingness);
00349
00350 for (std::vector<LinkMessage>::const_iterator iter = this->linkMessages.begin ();
00351 iter != this->linkMessages.end (); iter++)
00352 {
00353 const LinkMessage &lm = *iter;
00354
00355 i.WriteU8 (lm.linkCode);
00356 i.WriteU8 (0);
00357
00358
00359
00360
00361
00362 i.WriteHtonU16 (4 + lm.neighborInterfaceAddresses.size () * IPV4_ADDRESS_SIZE);
00363
00364 for (std::vector<Ipv4Address>::const_iterator neigh_iter = lm.neighborInterfaceAddresses.begin ();
00365 neigh_iter != lm.neighborInterfaceAddresses.end (); neigh_iter++)
00366 {
00367 i.WriteHtonU32 (neigh_iter->Get ());
00368 }
00369 }
00370 }
00371
00372 uint32_t
00373 MessageHeader::Hello::Deserialize (Buffer::Iterator start, uint32_t messageSize)
00374 {
00375 Buffer::Iterator i = start;
00376
00377 NS_ASSERT (messageSize >= 4);
00378
00379 this->linkMessages.clear ();
00380
00381 uint16_t helloSizeLeft = messageSize;
00382
00383 i.ReadNtohU16 ();
00384 this->hTime = i.ReadU8 ();
00385 this->willingness = i.ReadU8 ();
00386
00387 helloSizeLeft -= 4;
00388
00389 while (helloSizeLeft)
00390 {
00391 LinkMessage lm;
00392 NS_ASSERT (helloSizeLeft >= 4);
00393 lm.linkCode = i.ReadU8 ();
00394 i.ReadU8 ();
00395 uint16_t lmSize = i.ReadNtohU16 ();
00396 NS_ASSERT ((lmSize - 4) % IPV4_ADDRESS_SIZE == 0);
00397 for (int n = (lmSize - 4) / IPV4_ADDRESS_SIZE; n; --n)
00398 {
00399 lm.neighborInterfaceAddresses.push_back (Ipv4Address (i.ReadNtohU32 ()));
00400 }
00401 helloSizeLeft -= lmSize;
00402 this->linkMessages.push_back (lm);
00403 }
00404
00405 return messageSize;
00406 }
00407
00408
00409
00410
00411
00412 uint32_t
00413 MessageHeader::Tc::GetSerializedSize (void) const
00414 {
00415 return 4 + this->neighborAddresses.size () * IPV4_ADDRESS_SIZE;
00416 }
00417
00418 void
00419 MessageHeader::Tc::Print (std::ostream &os) const
00420 {
00421
00422 }
00423
00424 void
00425 MessageHeader::Tc::Serialize (Buffer::Iterator start) const
00426 {
00427 Buffer::Iterator i = start;
00428
00429 i.WriteHtonU16 (this->ansn);
00430 i.WriteHtonU16 (0);
00431
00432 for (std::vector<Ipv4Address>::const_iterator iter = this->neighborAddresses.begin ();
00433 iter != this->neighborAddresses.end (); iter++)
00434 {
00435 i.WriteHtonU32 (iter->Get ());
00436 }
00437 }
00438
00439 uint32_t
00440 MessageHeader::Tc::Deserialize (Buffer::Iterator start, uint32_t messageSize)
00441 {
00442 Buffer::Iterator i = start;
00443
00444 this->neighborAddresses.clear ();
00445 NS_ASSERT (messageSize >= 4);
00446
00447 this->ansn = i.ReadNtohU16 ();
00448 i.ReadNtohU16 ();
00449
00450 NS_ASSERT ((messageSize - 4) % IPV4_ADDRESS_SIZE == 0);
00451 int numAddresses = (messageSize - 4) / IPV4_ADDRESS_SIZE;
00452 this->neighborAddresses.clear ();
00453 for (int n = 0; n < numAddresses; ++n)
00454 this->neighborAddresses.push_back (Ipv4Address (i.ReadNtohU32 ()));
00455
00456 return messageSize;
00457 }
00458
00459
00460
00461
00462 uint32_t
00463 MessageHeader::Hna::GetSerializedSize (void) const
00464 {
00465 return 2*this->associations.size () * IPV4_ADDRESS_SIZE;
00466 }
00467
00468 void
00469 MessageHeader::Hna::Print (std::ostream &os) const
00470 {
00471
00472 }
00473
00474 void
00475 MessageHeader::Hna::Serialize (Buffer::Iterator start) const
00476 {
00477 Buffer::Iterator i = start;
00478
00479 for (size_t n = 0; n < this->associations.size (); ++n)
00480 {
00481 i.WriteHtonU32 (this->associations[n].address.Get ());
00482 i.WriteHtonU32 (this->associations[n].mask.Get ());
00483 }
00484 }
00485
00486 uint32_t
00487 MessageHeader::Hna::Deserialize (Buffer::Iterator start, uint32_t messageSize)
00488 {
00489 Buffer::Iterator i = start;
00490
00491 NS_ASSERT (messageSize % (IPV4_ADDRESS_SIZE*2) == 0);
00492 int numAddresses = messageSize / IPV4_ADDRESS_SIZE / 2;
00493 this->associations.clear ();
00494 for (int n = 0; n < numAddresses; ++n)
00495 {
00496 Ipv4Address address (i.ReadNtohU32 ());
00497 Ipv4Mask mask (i.ReadNtohU32 ());
00498 this->associations.push_back ((Association) {address, mask});
00499 }
00500 return messageSize;
00501 }
00502
00503
00504
00505 }}
00506
00507
00508 #ifdef RUN_SELF_TESTS
00509
00510
00511 #include "ns3/test.h"
00512 #include "ns3/packet.h"
00513 #include <math.h>
00514
00515
00516 namespace ns3 {
00517
00518 class OlsrHeaderTest : public ns3::Test {
00519 private:
00520 public:
00521 OlsrHeaderTest ();
00522 virtual bool RunTests (void);
00523
00524
00525 };
00526
00527 OlsrHeaderTest::OlsrHeaderTest ()
00528 : ns3::Test ("OlsrHeader")
00529 {}
00530
00531
00532 bool
00533 OlsrHeaderTest::RunTests (void)
00534 {
00535 bool result = true;
00536
00537
00538 {
00539 Packet packet;
00540
00541 {
00542 olsr::PacketHeader hdr;
00543 olsr::MessageHeader msg1;
00544 olsr::MessageHeader::Mid &mid1 = msg1.GetMid ();
00545 olsr::MessageHeader msg2;
00546 olsr::MessageHeader::Mid &mid2 = msg2.GetMid ();
00547
00548
00549 {
00550 std::vector<Ipv4Address> &addresses = mid1.interfaceAddresses;
00551 addresses.clear ();
00552 addresses.push_back (Ipv4Address ("1.2.3.4"));
00553 addresses.push_back (Ipv4Address ("1.2.3.5"));
00554 }
00555
00556 msg1.SetTimeToLive (255);
00557 msg1.SetOriginatorAddress (Ipv4Address ("11.22.33.44"));
00558 msg1.SetVTime (Seconds (9));
00559 msg1.SetMessageSequenceNumber (7);
00560
00561
00562 {
00563 std::vector<Ipv4Address> &addresses = mid2.interfaceAddresses;
00564 addresses.clear ();
00565 addresses.push_back (Ipv4Address ("2.2.3.4"));
00566 addresses.push_back (Ipv4Address ("2.2.3.5"));
00567 }
00568
00569 msg2.SetTimeToLive (254);
00570 msg2.SetOriginatorAddress (Ipv4Address ("12.22.33.44"));
00571 msg2.SetVTime (Seconds (10));
00572 msg2.SetMessageType (olsr::MessageHeader::MID_MESSAGE);
00573 msg2.SetMessageSequenceNumber (7);
00574
00575
00576 hdr.SetPacketLength (hdr.GetSerializedSize () + msg1.GetSerializedSize () + msg2.GetSerializedSize ());
00577 hdr.SetPacketSequenceNumber (123);
00578
00579
00580
00581 packet.AddHeader (msg2);
00582 packet.AddHeader (msg1);
00583 packet.AddHeader (hdr);
00584 }
00585
00586 {
00587 olsr::PacketHeader hdr;
00588 packet.RemoveHeader (hdr);
00589 NS_TEST_ASSERT_EQUAL (hdr.GetPacketSequenceNumber (), 123);
00590 uint32_t sizeLeft = hdr.GetPacketLength () - hdr.GetSerializedSize ();
00591 {
00592 olsr::MessageHeader msg1;
00593
00594 packet.RemoveHeader (msg1);
00595
00596 NS_TEST_ASSERT_EQUAL (msg1.GetTimeToLive (), 255);
00597 NS_TEST_ASSERT_EQUAL (msg1.GetOriginatorAddress (), Ipv4Address ("11.22.33.44"));
00598 NS_TEST_ASSERT_EQUAL (msg1.GetVTime (), Seconds (9));
00599 NS_TEST_ASSERT_EQUAL (msg1.GetMessageType (), olsr::MessageHeader::MID_MESSAGE);
00600 NS_TEST_ASSERT_EQUAL (msg1.GetMessageSequenceNumber (), 7);
00601
00602 olsr::MessageHeader::Mid &mid1 = msg1.GetMid ();
00603 NS_TEST_ASSERT_EQUAL (mid1.interfaceAddresses.size (), 2);
00604 NS_TEST_ASSERT_EQUAL (*mid1.interfaceAddresses.begin (), Ipv4Address ("1.2.3.4"));
00605
00606 sizeLeft -= msg1.GetSerializedSize ();
00607 NS_TEST_ASSERT (sizeLeft > 0);
00608 }
00609 {
00610
00611 olsr::MessageHeader msg2;
00612
00613 packet.RemoveHeader (msg2);
00614
00615 NS_TEST_ASSERT_EQUAL (msg2.GetTimeToLive (), 254);
00616 NS_TEST_ASSERT_EQUAL (msg2.GetOriginatorAddress (), Ipv4Address ("12.22.33.44"));
00617 NS_TEST_ASSERT_EQUAL (msg2.GetVTime (), Seconds (10));
00618 NS_TEST_ASSERT_EQUAL (msg2.GetMessageType (), olsr::MessageHeader::MID_MESSAGE);
00619 NS_TEST_ASSERT_EQUAL (msg2.GetMessageSequenceNumber (), 7);
00620
00621 olsr::MessageHeader::Mid mid2 = msg2.GetMid ();
00622 NS_TEST_ASSERT_EQUAL (mid2.interfaceAddresses.size (), 2);
00623 NS_TEST_ASSERT_EQUAL (*mid2.interfaceAddresses.begin (), Ipv4Address ("2.2.3.4"));
00624
00625 sizeLeft -= msg2.GetSerializedSize ();
00626 NS_TEST_ASSERT_EQUAL (sizeLeft, 0);
00627 }
00628 }
00629 }
00630
00631
00632 {
00633 Packet packet;
00634 olsr::MessageHeader msgIn;
00635 olsr::MessageHeader::Hello &helloIn = msgIn.GetHello ();
00636
00637 helloIn.SetHTime (Seconds (7));
00638 helloIn.willingness = 66;
00639
00640 {
00641 olsr::MessageHeader::Hello::LinkMessage lm1;
00642 lm1.linkCode = 2;
00643 lm1.neighborInterfaceAddresses.push_back (Ipv4Address ("1.2.3.4"));
00644 lm1.neighborInterfaceAddresses.push_back (Ipv4Address ("1.2.3.5"));
00645 helloIn.linkMessages.push_back (lm1);
00646
00647 olsr::MessageHeader::Hello::LinkMessage lm2;
00648 lm2.linkCode = 3;
00649 lm2.neighborInterfaceAddresses.push_back (Ipv4Address ("2.2.3.4"));
00650 lm2.neighborInterfaceAddresses.push_back (Ipv4Address ("2.2.3.5"));
00651 helloIn.linkMessages.push_back (lm2);
00652 }
00653
00654 packet.AddHeader (msgIn);
00655
00656 olsr::MessageHeader msgOut;
00657 packet.RemoveHeader (msgOut);
00658 olsr::MessageHeader::Hello &helloOut = msgOut.GetHello ();
00659
00660 NS_TEST_ASSERT_EQUAL (helloOut.GetHTime (), Seconds (7));
00661 NS_TEST_ASSERT_EQUAL (helloOut.willingness, 66);
00662 NS_TEST_ASSERT_EQUAL (helloOut.linkMessages.size (), 2);
00663
00664 NS_TEST_ASSERT_EQUAL (helloOut.linkMessages[0].linkCode, 2);
00665 NS_TEST_ASSERT_EQUAL (helloOut.linkMessages[0].neighborInterfaceAddresses[0],
00666 Ipv4Address ("1.2.3.4"));
00667 NS_TEST_ASSERT_EQUAL (helloOut.linkMessages[0].neighborInterfaceAddresses[1],
00668 Ipv4Address ("1.2.3.5"));
00669
00670 NS_TEST_ASSERT_EQUAL (helloOut.linkMessages[1].linkCode, 3);
00671 NS_TEST_ASSERT_EQUAL (helloOut.linkMessages[1].neighborInterfaceAddresses[0],
00672 Ipv4Address ("2.2.3.4"));
00673 NS_TEST_ASSERT_EQUAL (helloOut.linkMessages[1].neighborInterfaceAddresses[1],
00674 Ipv4Address ("2.2.3.5"));
00675
00676
00677 NS_TEST_ASSERT_EQUAL (packet.GetSize (), 0);
00678 }
00679
00680
00681 {
00682 Packet packet;
00683 olsr::MessageHeader msgIn;
00684 olsr::MessageHeader::Tc &tcIn = msgIn.GetTc ();
00685
00686 tcIn.ansn = 0x1234;
00687 tcIn.neighborAddresses.push_back (Ipv4Address ("1.2.3.4"));
00688 tcIn.neighborAddresses.push_back (Ipv4Address ("1.2.3.5"));
00689 packet.AddHeader (msgIn);
00690
00691 olsr::MessageHeader msgOut;
00692 packet.RemoveHeader (msgOut);
00693 olsr::MessageHeader::Tc &tcOut = msgOut.GetTc ();
00694
00695 NS_TEST_ASSERT_EQUAL (tcOut.ansn, 0x1234);
00696 NS_TEST_ASSERT_EQUAL (tcOut.neighborAddresses.size (), 2);
00697
00698 NS_TEST_ASSERT_EQUAL (tcOut.neighborAddresses[0],
00699 Ipv4Address ("1.2.3.4"));
00700 NS_TEST_ASSERT_EQUAL (tcOut.neighborAddresses[1],
00701 Ipv4Address ("1.2.3.5"));
00702
00703
00704 NS_TEST_ASSERT_EQUAL (packet.GetSize (), 0);
00705 }
00706
00707
00708 {
00709 Packet packet;
00710 olsr::MessageHeader msgIn;
00711 olsr::MessageHeader::Hna &hnaIn = msgIn.GetHna ();
00712
00713 hnaIn.associations.push_back ((olsr::MessageHeader::Hna::Association)
00714 { Ipv4Address ("1.2.3.4"), Ipv4Mask ("255.255.255.0")});
00715 hnaIn.associations.push_back ((olsr::MessageHeader::Hna::Association)
00716 {Ipv4Address ("1.2.3.5"), Ipv4Mask ("255.255.0.0")});
00717 packet.AddHeader (msgIn);
00718
00719 olsr::MessageHeader msgOut;
00720 packet.RemoveHeader (msgOut);
00721 olsr::MessageHeader::Hna &hnaOut = msgOut.GetHna ();
00722
00723 NS_TEST_ASSERT_EQUAL (hnaOut.associations.size (), 2);
00724
00725 NS_TEST_ASSERT_EQUAL (hnaOut.associations[0].address,
00726 Ipv4Address ("1.2.3.4"));
00727 NS_TEST_ASSERT_EQUAL (hnaOut.associations[0].mask,
00728 Ipv4Mask ("255.255.255.0"));
00729
00730 NS_TEST_ASSERT_EQUAL (hnaOut.associations[1].address,
00731 Ipv4Address ("1.2.3.5"));
00732 NS_TEST_ASSERT_EQUAL (hnaOut.associations[1].mask,
00733 Ipv4Mask ("255.255.0.0"));
00734
00735
00736 NS_TEST_ASSERT_EQUAL (packet.GetSize (), 0);
00737 }
00738
00739 for (int time = 1; time <= 30; time++)
00740 {
00741 uint8_t emf = olsr::SecondsToEmf (time);
00742 double seconds = olsr::EmfToSeconds (emf);
00743 if (seconds < 0 || fabs (seconds - time) > 0.1)
00744 {
00745 result = false;
00746 Failure () << "In " << time << " out " << seconds << std::endl;
00747 }
00748 }
00749
00750 return result;
00751 }
00752
00753 static OlsrHeaderTest gOlsrHeaderTest;
00754
00755 };
00756
00757
00758 #endif