A Discrete-Event Network Simulator
API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
aodv-packet.cc
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2009 IITP RAS
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Based on
19  * NS-2 AODV model developed by the CMU/MONARCH group and optimized and
20  * tuned by Samir Das and Mahesh Marina, University of Cincinnati;
21  *
22  * AODV-UU implementation by Erik Nordström of Uppsala University
23  * http://core.it.uu.se/core/index.php/AODV-UU
24  *
25  * Authors: Elena Buchatskaia <borovkovaes@iitp.ru>
26  * Pavel Boyko <boyko@iitp.ru>
27  */
28 #include "aodv-packet.h"
29 #include "ns3/address-utils.h"
30 #include "ns3/packet.h"
31 
32 namespace ns3
33 {
34 namespace aodv
35 {
36 
37 NS_OBJECT_ENSURE_REGISTERED (TypeHeader);
38 
39 TypeHeader::TypeHeader (MessageType t) :
40  m_type (t), m_valid (true)
41 {
42 }
43 
44 TypeId
45 TypeHeader::GetTypeId ()
46 {
47  static TypeId tid = TypeId ("ns3::aodv::TypeHeader")
48  .SetParent<Header> ()
49  .AddConstructor<TypeHeader> ()
50  ;
51  return tid;
52 }
53 
54 TypeId
56 {
57  return GetTypeId ();
58 }
59 
60 uint32_t
62 {
63  return 1;
64 }
65 
66 void
68 {
69  i.WriteU8 ((uint8_t) m_type);
70 }
71 
72 uint32_t
74 {
75  Buffer::Iterator i = start;
76  uint8_t type = i.ReadU8 ();
77  m_valid = true;
78  switch (type)
79  {
80  case AODVTYPE_RREQ:
81  case AODVTYPE_RREP:
82  case AODVTYPE_RERR:
83  case AODVTYPE_RREP_ACK:
84  {
85  m_type = (MessageType) type;
86  break;
87  }
88  default:
89  m_valid = false;
90  }
91  uint32_t dist = i.GetDistanceFrom (start);
92  NS_ASSERT (dist == GetSerializedSize ());
93  return dist;
94 }
95 
96 void
97 TypeHeader::Print (std::ostream &os) const
98 {
99  switch (m_type)
100  {
101  case AODVTYPE_RREQ:
102  {
103  os << "RREQ";
104  break;
105  }
106  case AODVTYPE_RREP:
107  {
108  os << "RREP";
109  break;
110  }
111  case AODVTYPE_RERR:
112  {
113  os << "RERR";
114  break;
115  }
116  case AODVTYPE_RREP_ACK:
117  {
118  os << "RREP_ACK";
119  break;
120  }
121  default:
122  os << "UNKNOWN_TYPE";
123  }
124 }
125 
126 bool
127 TypeHeader::operator== (TypeHeader const & o) const
128 {
129  return (m_type == o.m_type && m_valid == o.m_valid);
130 }
131 
132 std::ostream &
133 operator<< (std::ostream & os, TypeHeader const & h)
134 {
135  h.Print (os);
136  return os;
137 }
138 
139 //-----------------------------------------------------------------------------
140 // RREQ
141 //-----------------------------------------------------------------------------
142 RreqHeader::RreqHeader (uint8_t flags, uint8_t reserved, uint8_t hopCount, uint32_t requestID, Ipv4Address dst,
143  uint32_t dstSeqNo, Ipv4Address origin, uint32_t originSeqNo, uint16_t channel) :
144  m_flags (flags), m_reserved (reserved), m_hopCount (hopCount), m_requestID (requestID), m_dst (dst),
145  m_dstSeqNo (dstSeqNo), m_origin (origin), m_originSeqNo (originSeqNo), m_channelNo (channel)
146 {
147 }
148 
149 NS_OBJECT_ENSURE_REGISTERED (RreqHeader);
150 
151 TypeId
152 RreqHeader::GetTypeId ()
153 {
154  static TypeId tid = TypeId ("ns3::aodv::RreqHeader")
155  .SetParent<Header> ()
156  .AddConstructor<RreqHeader> ()
157  ;
158  return tid;
159 }
160 
161 TypeId
163 {
164  return GetTypeId ();
165 }
166 
167 uint32_t
169 {
170  return 25;
171 }
172 
173 void
175 {
176  i.WriteU8 (m_flags);
177  i.WriteU8 (m_reserved);
178  i.WriteU8 (m_hopCount);
180  WriteTo (i, m_dst);
182  WriteTo (i, m_origin);
185 }
186 
187 uint32_t
189 {
190  Buffer::Iterator i = start;
191  m_flags = i.ReadU8 ();
192  m_reserved = i.ReadU8 ();
193  m_hopCount = i.ReadU8 ();
194  m_requestID = i.ReadNtohU32 ();
195  ReadFrom (i, m_dst);
196  m_dstSeqNo = i.ReadNtohU32 ();
197  ReadFrom (i, m_origin);
198  m_originSeqNo = i.ReadNtohU32 ();
199  m_channelNo = i.ReadU16();
200 
201  uint32_t dist = i.GetDistanceFrom (start);
202  NS_ASSERT (dist == GetSerializedSize ());
203  return dist;
204 }
205 
206 void
207 RreqHeader::Print (std::ostream &os) const
208 {
209  os << "RREQ ID " << m_requestID << " destination: ipv4 " << m_dst
210  << " sequence number " << m_dstSeqNo << " source: ipv4 "
211  << m_origin << " sequence number " << m_originSeqNo
212  << " channel number: " << m_channelNo
213  << " flags:" << " Gratuitous RREP " << (*this).GetGratiousRrep ()
214  << " Destination only " << (*this).GetDestinationOnly ()
215  << " Unknown sequence number " << (*this).GetUnknownSeqno ();
216 }
217 
218 std::ostream &
219 operator<< (std::ostream & os, RreqHeader const & h)
220 {
221  h.Print (os);
222  return os;
223 }
224 
225 void
226 RreqHeader::SetGratiousRrep (bool f)
227 {
228  if (f)
229  m_flags |= (1 << 5);
230  else
231  m_flags &= ~(1 << 5);
232 }
233 
234 bool
235 RreqHeader::GetGratiousRrep () const
236 {
237  return (m_flags & (1 << 5));
238 }
239 
240 void
241 RreqHeader::SetDestinationOnly (bool f)
242 {
243  if (f)
244  m_flags |= (1 << 4);
245  else
246  m_flags &= ~(1 << 4);
247 }
248 
249 bool
250 RreqHeader::GetDestinationOnly () const
251 {
252  return (m_flags & (1 << 4));
253 }
254 
255 void
256 RreqHeader::SetUnknownSeqno (bool f)
257 {
258  if (f)
259  m_flags |= (1 << 3);
260  else
261  m_flags &= ~(1 << 3);
262 }
263 
264 bool
265 RreqHeader::GetUnknownSeqno () const
266 {
267  return (m_flags & (1 << 3));
268 }
269 
270 bool
271 RreqHeader::operator== (RreqHeader const & o) const
272 {
273  return (m_flags == o.m_flags && m_reserved == o.m_reserved &&
274  m_hopCount == o.m_hopCount && m_requestID == o.m_requestID &&
275  m_dst == o.m_dst && m_dstSeqNo == o.m_dstSeqNo &&
276  m_origin == o.m_origin && m_originSeqNo == o.m_originSeqNo);
277 }
278 
279 //-----------------------------------------------------------------------------
280 // RREP
281 //-----------------------------------------------------------------------------
282 
283 RrepHeader::RrepHeader (uint8_t prefixSize, uint8_t hopCount, Ipv4Address dst,
284  uint32_t dstSeqNo, Ipv4Address origin, Time lifeTime, uint16_t channel) :
285  m_flags (0), m_prefixSize (prefixSize), m_hopCount (hopCount),
286  m_dst (dst), m_dstSeqNo (dstSeqNo), m_origin (origin), m_channelNo (channel)
287 {
288  m_lifeTime = uint32_t (lifeTime.GetMilliSeconds ());
289 }
290 
291 NS_OBJECT_ENSURE_REGISTERED (RrepHeader);
292 
293 TypeId
294 RrepHeader::GetTypeId ()
295 {
296  static TypeId tid = TypeId ("ns3::aodv::RrepHeader")
297  .SetParent<Header> ()
298  .AddConstructor<RrepHeader> ()
299  ;
300  return tid;
301 }
302 
303 TypeId
305 {
306  return GetTypeId ();
307 }
308 
309 uint32_t
311 {
312  return 21;
313 }
314 
315 void
317 {
318  i.WriteU8 (m_flags);
319  i.WriteU8 (m_prefixSize);
320  i.WriteU8 (m_hopCount);
321  WriteTo (i, m_dst);
323  WriteTo (i, m_origin);
325  i.WriteU16 (m_channelNo);
326 }
327 
328 uint32_t
330 {
331  Buffer::Iterator i = start;
332 
333  m_flags = i.ReadU8 ();
334  m_prefixSize = i.ReadU8 ();
335  m_hopCount = i.ReadU8 ();
336  ReadFrom (i, m_dst);
337  m_dstSeqNo = i.ReadNtohU32 ();
338  ReadFrom (i, m_origin);
339  m_lifeTime = i.ReadNtohU32 ();
340  m_channelNo = i.ReadU16 ();
341 
342  uint32_t dist = i.GetDistanceFrom (start);
343  NS_ASSERT (dist == GetSerializedSize ());
344  return dist;
345 }
346 
347 void
348 RrepHeader::Print (std::ostream &os) const
349 {
350  os << "destination: ipv4 " << m_dst << " sequence number " << m_dstSeqNo;
351  if (m_prefixSize != 0)
352  {
353  os << " prefix size " << m_prefixSize;
354  }
355  os << " source ipv4 " << m_origin << " lifetime " << m_lifeTime
356  << " rx channel number: " << m_channelNo
357  << " acknowledgment required flag " << (*this).GetAckRequired ();
358 }
359 
360 void
361 RrepHeader::SetLifeTime (Time t)
362 {
364 }
365 
366 Time
367 RrepHeader::GetLifeTime () const
368 {
370  return t;
371 }
372 
373 void
374 RrepHeader::SetAckRequired (bool f)
375 {
376  if (f)
377  m_flags |= (1 << 6);
378  else
379  m_flags &= ~(1 << 6);
380 }
381 
382 bool
383 RrepHeader::GetAckRequired () const
384 {
385  return (m_flags & (1 << 6));
386 }
387 
388 void
389 RrepHeader::SetPrefixSize (uint8_t sz)
390 {
391  m_prefixSize = sz;
392 }
393 
394 uint8_t
395 RrepHeader::GetPrefixSize () const
396 {
397  return m_prefixSize;
398 }
399 
400 bool
401 RrepHeader::operator== (RrepHeader const & o) const
402 {
403  return (m_flags == o.m_flags && m_prefixSize == o.m_prefixSize &&
404  m_hopCount == o.m_hopCount && m_dst == o.m_dst && m_dstSeqNo == o.m_dstSeqNo &&
405  m_origin == o.m_origin && m_lifeTime == o.m_lifeTime);
406 }
407 
408 void
409 RrepHeader::SetHello (Ipv4Address origin, uint32_t srcSeqNo, Time lifetime)
410 {
411  m_flags = 0;
412  m_prefixSize = 0;
413  m_hopCount = 0;
414  m_dst = origin;
415  m_dstSeqNo = srcSeqNo;
416  m_origin = origin;
417  m_lifeTime = lifetime.GetMilliSeconds ();
418 }
419 
420 std::ostream &
421 operator<< (std::ostream & os, RrepHeader const & h)
422 {
423  h.Print (os);
424  return os;
425 }
426 
427 //-----------------------------------------------------------------------------
428 // RREP-ACK
429 //-----------------------------------------------------------------------------
430 
432  m_reserved (0)
433 {
434 }
435 
436 NS_OBJECT_ENSURE_REGISTERED (RrepAckHeader);
437 TypeId
438 RrepAckHeader::GetTypeId ()
439 {
440  static TypeId tid = TypeId ("ns3::aodv::RrepAckHeader")
441  .SetParent<Header> ()
442  .AddConstructor<RrepAckHeader> ()
443  ;
444  return tid;
445 }
446 
447 TypeId
449 {
450  return GetTypeId ();
451 }
452 
453 uint32_t
455 {
456  return 1;
457 }
458 
459 void
461 {
462  i.WriteU8 (m_reserved);
463 }
464 
465 uint32_t
467 {
468  Buffer::Iterator i = start;
469  m_reserved = i.ReadU8 ();
470  uint32_t dist = i.GetDistanceFrom (start);
471  NS_ASSERT (dist == GetSerializedSize ());
472  return dist;
473 }
474 
475 void
476 RrepAckHeader::Print (std::ostream &os ) const
477 {
478 }
479 
480 bool
481 RrepAckHeader::operator== (RrepAckHeader const & o ) const
482 {
483  return m_reserved == o.m_reserved;
484 }
485 
486 std::ostream &
487 operator<< (std::ostream & os, RrepAckHeader const & h )
488 {
489  h.Print (os);
490  return os;
491 }
492 
493 //-----------------------------------------------------------------------------
494 // RERR
495 //-----------------------------------------------------------------------------
497  m_flag (0), m_reserved (0)
498 {
499 }
500 
501 NS_OBJECT_ENSURE_REGISTERED (RerrHeader);
502 
503 TypeId
504 RerrHeader::GetTypeId ()
505 {
506  static TypeId tid = TypeId ("ns3::aodv::RerrHeader")
507  .SetParent<Header> ()
508  .AddConstructor<RerrHeader> ()
509  ;
510  return tid;
511 }
512 
513 TypeId
515 {
516  return GetTypeId ();
517 }
518 
519 uint32_t
521 {
522  return (3 + 8 * GetDestCount ());
523 }
524 
525 void
527 {
528  i.WriteU8 (m_flag);
529  i.WriteU8 (m_reserved);
530  i.WriteU8 (GetDestCount ());
531  std::map<Ipv4Address, uint32_t>::const_iterator j;
532  for (j = m_unreachableDstSeqNo.begin (); j != m_unreachableDstSeqNo.end (); ++j)
533  {
534  WriteTo (i, (*j).first);
535  i.WriteHtonU32 ((*j).second);
536  }
537 }
538 
539 uint32_t
541 {
542  Buffer::Iterator i = start;
543  m_flag = i.ReadU8 ();
544  m_reserved = i.ReadU8 ();
545  uint8_t dest = i.ReadU8 ();
546  m_unreachableDstSeqNo.clear ();
547  Ipv4Address address;
548  uint32_t seqNo;
549  for (uint8_t k = 0; k < dest; ++k)
550  {
551  ReadFrom (i, address);
552  seqNo = i.ReadNtohU32 ();
553  m_unreachableDstSeqNo.insert (std::make_pair (address, seqNo));
554  }
555 
556  uint32_t dist = i.GetDistanceFrom (start);
557  NS_ASSERT (dist == GetSerializedSize ());
558  return dist;
559 }
560 
561 void
562 RerrHeader::Print (std::ostream &os ) const
563 {
564  os << "Unreachable destination (ipv4 address, seq. number):";
565  std::map<Ipv4Address, uint32_t>::const_iterator j;
566  for (j = m_unreachableDstSeqNo.begin (); j != m_unreachableDstSeqNo.end (); ++j)
567  {
568  os << (*j).first << ", " << (*j).second;
569  }
570  os << "No delete flag " << (*this).GetNoDelete ();
571 }
572 
573 void
574 RerrHeader::SetNoDelete (bool f )
575 {
576  if (f)
577  m_flag |= (1 << 0);
578  else
579  m_flag &= ~(1 << 0);
580 }
581 
582 bool
583 RerrHeader::GetNoDelete () const
584 {
585  return (m_flag & (1 << 0));
586 }
587 
588 bool
590 {
591  if (m_unreachableDstSeqNo.find (dst) != m_unreachableDstSeqNo.end ())
592  return true;
593 
594  NS_ASSERT (GetDestCount () < 255); // can't support more than 255 destinations in single RERR
595  m_unreachableDstSeqNo.insert (std::make_pair (dst, seqNo));
596  return true;
597 }
598 
599 bool
600 RerrHeader::RemoveUnDestination (std::pair<Ipv4Address, uint32_t> & un )
601 {
602  if (m_unreachableDstSeqNo.empty ())
603  return false;
604  std::map<Ipv4Address, uint32_t>::iterator i = m_unreachableDstSeqNo.begin ();
605  un = *i;
606  m_unreachableDstSeqNo.erase (i);
607  return true;
608 }
609 
610 void
612 {
613  m_unreachableDstSeqNo.clear ();
614  m_flag = 0;
615  m_reserved = 0;
616 }
617 
618 bool
619 RerrHeader::operator== (RerrHeader const & o ) const
620 {
621  if (m_flag != o.m_flag || m_reserved != o.m_reserved || GetDestCount () != o.GetDestCount ())
622  return false;
623 
624  std::map<Ipv4Address, uint32_t>::const_iterator j = m_unreachableDstSeqNo.begin ();
625  std::map<Ipv4Address, uint32_t>::const_iterator k = o.m_unreachableDstSeqNo.begin ();
626  for (uint8_t i = 0; i < GetDestCount (); ++i)
627  {
628  if ((j->first != k->first) || (j->second != k->second))
629  return false;
630 
631  j++;
632  k++;
633  }
634  return true;
635 }
636 
637 std::ostream &
638 operator<< (std::ostream & os, RerrHeader const & h )
639 {
640  h.Print (os);
641  return os;
642 }
643 }
644 }
uint16_t ReadU16(void)
Definition: buffer.h:845
Protocol header serialization and deserialization.
Definition: header.h:42
keep track of time unit.
Definition: nstime.h:149
TypeId GetInstanceTypeId() const
Definition: aodv-packet.cc:55
TypeId GetInstanceTypeId() const
Definition: aodv-packet.cc:448
Route Error (RERR) Message Format.
Definition: aodv-packet.h:295
void Serialize(Buffer::Iterator i) const
Definition: aodv-packet.cc:526
uint32_t m_requestID
RREQ ID.
Definition: aodv-packet.h:154
#define NS_ASSERT(condition)
Definition: assert.h:64
RreqHeader(uint8_t flags=0, uint8_t reserved=0, uint8_t hopCount=0, uint32_t requestID=0, Ipv4Address dst=Ipv4Address(), uint32_t dstSeqNo=0, Ipv4Address origin=Ipv4Address(), uint32_t originSeqNo=0, uint16_t channel=1)
c-tor
Definition: aodv-packet.cc:142
uint32_t m_lifeTime
Lifetime (in milliseconds)
Definition: aodv-packet.h:236
Route Request (RREQ) Message Format.
Definition: aodv-packet.h:102
uint32_t ReadNtohU32(void)
Definition: buffer.h:791
uint32_t Deserialize(Buffer::Iterator start)
Definition: aodv-packet.cc:466
uint32_t GetDistanceFrom(Iterator const &o) const
Definition: buffer.cc:807
iterator in a Buffer instance
Definition: buffer.h:98
uint32_t GetSerializedSize() const
Definition: aodv-packet.cc:520
void Print(std::ostream &os) const
Definition: aodv-packet.cc:207
uint32_t Deserialize(Buffer::Iterator start)
Definition: aodv-packet.cc:540
void Serialize(Buffer::Iterator start) const
Definition: aodv-packet.cc:67
void Clear()
Clear header.
Definition: aodv-packet.cc:611
uint32_t Deserialize(Buffer::Iterator start)
Definition: aodv-packet.cc:73
uint32_t m_originSeqNo
Source Sequence Number.
Definition: aodv-packet.h:158
Ipv4Address m_origin
Source IP Address.
Definition: aodv-packet.h:235
uint32_t Deserialize(Buffer::Iterator start)
Definition: aodv-packet.cc:329
uint8_t GetDestCount() const
Return number of unreachable destinations in RERR message.
Definition: aodv-packet.h:329
uint16_t m_channelNo
RX channel of source.
Definition: aodv-packet.h:159
bool AddUnDestination(Ipv4Address dst, uint32_t seqNo)
Definition: aodv-packet.cc:589
void WriteU16(uint16_t data)
Definition: buffer.cc:895
uint8_t m_flag
No delete flag.
Definition: aodv-packet.h:332
void Print(std::ostream &os) const
Definition: aodv-packet.cc:348
void Print(std::ostream &os) const
Definition: aodv-packet.cc:97
Ipv4Address m_origin
Originator IP Address.
Definition: aodv-packet.h:157
void Serialize(Buffer::Iterator start) const
Definition: aodv-packet.cc:316
uint8_t m_reserved
Not used.
Definition: aodv-packet.h:333
Route Reply (RREP) Message Format.
Definition: aodv-packet.h:183
uint8_t m_flags
A - acknowledgment required flag.
Definition: aodv-packet.h:230
std::ostream & operator<<(std::ostream &os, const Angles &a)
Definition: angles.cc:43
Ipv4Address m_dst
Destination IP Address.
Definition: aodv-packet.h:233
void Serialize(Buffer::Iterator start) const
Definition: aodv-packet.cc:174
void SetHello(Ipv4Address src, uint32_t srcSeqNo, Time lifetime)
Configure RREP to be a Hello message.
Definition: aodv-packet.cc:409
void Serialize(Buffer::Iterator start) const
Definition: aodv-packet.cc:460
void Print(std::ostream &os) const
Definition: aodv-packet.cc:476
bool RemoveUnDestination(std::pair< Ipv4Address, uint32_t > &un)
Definition: aodv-packet.cc:600
uint32_t m_dstSeqNo
Destination Sequence Number.
Definition: aodv-packet.h:234
TypeHeader(MessageType t=AODVTYPE_RREQ)
c-tor
Definition: aodv-packet.cc:39
std::map< Ipv4Address, uint32_t > m_unreachableDstSeqNo
List of Unreachable destination: IP addresses and sequence numbers.
Definition: aodv-packet.h:336
uint16_t m_channelNo
Source RX channel number.
Definition: aodv-packet.h:237
uint32_t GetSerializedSize() const
Definition: aodv-packet.cc:454
void WriteHtonU32(uint32_t data)
Definition: buffer.h:745
uint32_t GetSerializedSize() const
Definition: aodv-packet.cc:310
Route Reply Acknowledgment (RREP-ACK) Message Format.
Definition: aodv-packet.h:253
uint8_t m_hopCount
Hop Count.
Definition: aodv-packet.h:153
uint32_t Deserialize(Buffer::Iterator start)
Definition: aodv-packet.cc:188
void Print(std::ostream &os) const
Definition: aodv-packet.cc:562
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:38
uint32_t GetSerializedSize() const
Definition: aodv-packet.cc:168
void WriteU8(uint8_t data)
Definition: buffer.h:690
Ipv4Address m_dst
Destination IP Address.
Definition: aodv-packet.h:155
uint32_t GetSerializedSize() const
Definition: aodv-packet.cc:61
RrepHeader(uint8_t prefixSize=0, uint8_t hopCount=0, Ipv4Address dst=Ipv4Address(), uint32_t dstSeqNo=0, Ipv4Address origin=Ipv4Address(), Time lifetime=MilliSeconds(0), uint16_t channel=1)
c-tor
Definition: aodv-packet.cc:283
uint8_t ReadU8(void)
Definition: buffer.h:819
Time MilliSeconds(uint64_t ms)
create ns3::Time instances in units of milliseconds.
Definition: nstime.h:601
uint8_t m_hopCount
Hop Count.
Definition: aodv-packet.h:232
uint8_t m_reserved
Not used.
Definition: aodv-packet.h:152
TypeId GetInstanceTypeId() const
Definition: aodv-packet.cc:514
TypeId GetInstanceTypeId() const
Definition: aodv-packet.cc:162
a unique identifier for an interface.
Definition: type-id.h:44
int64_t GetMilliSeconds(void) const
Definition: nstime.h:271
TypeId SetParent(TypeId tid)
Definition: type-id.cc:471
uint8_t m_flags
|J|R|G|D|U| bit flags, see RFC
Definition: aodv-packet.h:151
uint8_t m_prefixSize
Prefix Size.
Definition: aodv-packet.h:231
uint32_t m_dstSeqNo
Destination Sequence Number.
Definition: aodv-packet.h:156
TypeId GetInstanceTypeId() const
Definition: aodv-packet.cc:304