23 #include "ns3/assert.h"
26 #include "olsr-header.h"
28 #define IPV4_ADDRESS_SIZE 4
29 #define OLSR_MSG_HEADER_SIZE 12
30 #define OLSR_PKT_HEADER_SIZE 4
48 SecondsToEmf (
double seconds)
53 for (b = 0; (seconds/OLSR_C) >= (1 << b); ++b)
60 double tmp = 16*(seconds/(OLSR_C*(1<<b))-1);
63 a = (int) std::ceil (tmp);
77 return (uint8_t)((a << 4) | b);
87 EmfToSeconds (uint8_t olsrFormat)
89 int a = (olsrFormat >> 4);
90 int b = (olsrFormat & 0xf);
92 return OLSR_C * (1 + a/16.0) * (1 << b);
99 NS_OBJECT_ENSURE_REGISTERED (PacketHeader);
101 PacketHeader::PacketHeader ()
105 PacketHeader::~PacketHeader ()
110 PacketHeader::GetTypeId (
void)
112 static TypeId tid = TypeId (
"ns3::olsr::PacketHeader")
113 .SetParent<Header> ()
114 .AddConstructor<PacketHeader> ()
127 return OLSR_PKT_HEADER_SIZE;
158 MessageHeader::MessageHeader ()
163 MessageHeader::~MessageHeader ()
168 MessageHeader::GetTypeId (
void)
170 static TypeId tid = TypeId (
"ns3::olsr::MessageHeader")
171 .SetParent<Header> ()
172 .AddConstructor<MessageHeader> ()
185 uint32_t size = OLSR_MSG_HEADER_SIZE;
186 switch (m_messageType)
189 size += m_message.mid.GetSerializedSize ();
192 NS_LOG_DEBUG (
"Hello Message Size: " << size <<
" + " << m_message.hello.GetSerializedSize ());
193 size += m_message.hello.GetSerializedSize ();
196 size += m_message.tc.GetSerializedSize ();
199 size += m_message.hna.GetSerializedSize ();
225 switch (m_messageType)
228 m_message.mid.Serialize (i);
231 m_message.hello.Serialize (i);
234 m_message.tc.Serialize (i);
237 m_message.hna.Serialize (i);
250 m_messageType = (MessageType) i.
ReadU8 ();
251 NS_ASSERT (m_messageType >= HELLO_MESSAGE && m_messageType <= HNA_MESSAGE);
255 m_timeToLive = i.
ReadU8 ();
258 size = OLSR_MSG_HEADER_SIZE;
259 switch (m_messageType)
262 size += m_message.mid.Deserialize (i, m_messageSize - OLSR_MSG_HEADER_SIZE);
265 size += m_message.hello.Deserialize (i, m_messageSize - OLSR_MSG_HEADER_SIZE);
268 size += m_message.tc.Deserialize (i, m_messageSize - OLSR_MSG_HEADER_SIZE);
271 size += m_message.hna.Deserialize (i, m_messageSize - OLSR_MSG_HEADER_SIZE);
283 MessageHeader::Mid::GetSerializedSize (
void)
const
285 return this->interfaceAddresses.size () * IPV4_ADDRESS_SIZE;
289 MessageHeader::Mid::Print (std::ostream &os)
const
295 MessageHeader::Mid::Serialize (Buffer::Iterator start)
const
297 Buffer::Iterator i = start;
299 for (std::vector<Ipv4Address>::const_iterator iter = this->interfaceAddresses.begin ();
300 iter != this->interfaceAddresses.end (); iter++)
302 i.WriteHtonU32 (iter->Get ());
307 MessageHeader::Mid::Deserialize (Buffer::Iterator start, uint32_t messageSize)
309 Buffer::Iterator i = start;
311 this->interfaceAddresses.clear ();
312 NS_ASSERT (messageSize % IPV4_ADDRESS_SIZE == 0);
314 int numAddresses = messageSize / IPV4_ADDRESS_SIZE;
315 this->interfaceAddresses.erase (this->interfaceAddresses.begin (),
316 this->interfaceAddresses.end ());
317 for (
int n = 0; n < numAddresses; ++n)
318 this->interfaceAddresses.push_back (Ipv4Address (i.ReadNtohU32 ()));
327 MessageHeader::Hello::GetSerializedSize (
void)
const
330 for (std::vector<LinkMessage>::const_iterator iter = this->linkMessages.begin ();
331 iter != this->linkMessages.end (); iter++)
333 const LinkMessage &lm = *iter;
335 size += IPV4_ADDRESS_SIZE * lm.neighborInterfaceAddresses.size ();
341 MessageHeader::Hello::Print (std::ostream &os)
const
347 MessageHeader::Hello::Serialize (Buffer::Iterator start)
const
349 Buffer::Iterator i = start;
352 i.WriteU8 (this->hTime);
353 i.WriteU8 (this->willingness);
355 for (std::vector<LinkMessage>::const_iterator iter = this->linkMessages.begin ();
356 iter != this->linkMessages.end (); iter++)
358 const LinkMessage &lm = *iter;
360 i.WriteU8 (lm.linkCode);
367 i.WriteHtonU16 (4 + lm.neighborInterfaceAddresses.size () * IPV4_ADDRESS_SIZE);
369 for (std::vector<Ipv4Address>::const_iterator neigh_iter = lm.neighborInterfaceAddresses.begin ();
370 neigh_iter != lm.neighborInterfaceAddresses.end (); neigh_iter++)
372 i.WriteHtonU32 (neigh_iter->Get ());
378 MessageHeader::Hello::Deserialize (Buffer::Iterator start, uint32_t messageSize)
380 Buffer::Iterator i = start;
384 this->linkMessages.clear ();
386 uint16_t helloSizeLeft = messageSize;
389 this->hTime = i.ReadU8 ();
390 this->willingness = i.ReadU8 ();
394 while (helloSizeLeft)
398 lm.linkCode = i.ReadU8 ();
400 uint16_t lmSize = i.ReadNtohU16 ();
401 NS_ASSERT ((lmSize - 4) % IPV4_ADDRESS_SIZE == 0);
402 for (
int n = (lmSize - 4) / IPV4_ADDRESS_SIZE; n; --n)
404 lm.neighborInterfaceAddresses.push_back (Ipv4Address (i.ReadNtohU32 ()));
406 helloSizeLeft -= lmSize;
407 this->linkMessages.push_back (lm);
418 MessageHeader::Tc::GetSerializedSize (
void)
const
420 return 4 + this->neighborAddresses.size () * IPV4_ADDRESS_SIZE;
424 MessageHeader::Tc::Print (std::ostream &os)
const
430 MessageHeader::Tc::Serialize (Buffer::Iterator start)
const
432 Buffer::Iterator i = start;
434 i.WriteHtonU16 (this->ansn);
437 for (std::vector<Ipv4Address>::const_iterator iter = this->neighborAddresses.begin ();
438 iter != this->neighborAddresses.end (); iter++)
440 i.WriteHtonU32 (iter->Get ());
445 MessageHeader::Tc::Deserialize (Buffer::Iterator start, uint32_t messageSize)
447 Buffer::Iterator i = start;
449 this->neighborAddresses.clear ();
452 this->ansn = i.ReadNtohU16 ();
455 NS_ASSERT ((messageSize - 4) % IPV4_ADDRESS_SIZE == 0);
456 int numAddresses = (messageSize - 4) / IPV4_ADDRESS_SIZE;
457 this->neighborAddresses.clear ();
458 for (
int n = 0; n < numAddresses; ++n)
459 this->neighborAddresses.push_back (Ipv4Address (i.ReadNtohU32 ()));
468 MessageHeader::Hna::GetSerializedSize (
void)
const
470 return 2*this->associations.size () * IPV4_ADDRESS_SIZE;
474 MessageHeader::Hna::Print (std::ostream &os)
const
480 MessageHeader::Hna::Serialize (Buffer::Iterator start)
const
482 Buffer::Iterator i = start;
484 for (
size_t n = 0; n < this->associations.size (); ++n)
486 i.WriteHtonU32 (this->associations[n].address.Get ());
487 i.WriteHtonU32 (this->associations[n].mask.Get ());
492 MessageHeader::Hna::Deserialize (Buffer::Iterator start, uint32_t messageSize)
494 Buffer::Iterator i = start;
496 NS_ASSERT (messageSize % (IPV4_ADDRESS_SIZE*2) == 0);
497 int numAddresses = messageSize / IPV4_ADDRESS_SIZE / 2;
498 this->associations.clear ();
499 for (
int n = 0; n < numAddresses; ++n)
501 Ipv4Address address (i.ReadNtohU32 ());
502 Ipv4Mask mask (i.ReadNtohU32 ());
503 this->associations.push_back ((Association) { address, mask});
#define NS_ASSERT(condition)
#define NS_LOG_COMPONENT_DEFINE(name)
uint32_t ReadNtohU32(void)
iterator in a Buffer instance
void WriteHtonU16(uint16_t data)
void WriteHtonU32(uint32_t data)
Ipv4 addresses are stored in host order in this class.
void WriteU8(uint8_t data)
#define NS_LOG_DEBUG(msg)
uint16_t ReadNtohU16(void)