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

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

    17  *

    17  *

    18  * Author: Mirko Banchi <mk.banchi@gmail.com>

    18  * Author: Mirko Banchi <mk.banchi@gmail.com>

    19  */

    19  */

    20 #include "ns3/fatal-error.h"

    20 #include "ns3/fatal-error.h"

    21 

    22 

    22 #include "ctrl-headers.h"

    23 #include "ctrl-headers.h"

    23 

    26 

    24 namespace ns3 {

    27 namespace ns3 {

    25 

    28 

    26 /***********************************

    29 /***********************************

    27  *       Block ack request

    30  *       Block ack request

    32 CtrlBAckRequestHeader::CtrlBAckRequestHeader ()

    35 CtrlBAckRequestHeader::CtrlBAckRequestHeader ()

    33   : m_barAckPolicy (false),

    36   : m_barAckPolicy (false),

    34     m_multiTid (false),

    37     m_multiTid (false),

    35     m_compressed (false)

    38     m_compressed (false)

    36 {

    39 {

    37 }

    41 }

    38 

    42 

    39 CtrlBAckRequestHeader::~CtrlBAckRequestHeader ()

    43 CtrlBAckRequestHeader::~CtrlBAckRequestHeader ()

    40 {

    44 {

    41 }

    46 }

    42 

    47 

    43 TypeId

    48 TypeId

    44 CtrlBAckRequestHeader::GetTypeId (void)

    49 CtrlBAckRequestHeader::GetTypeId (void)

    45 {

    50 {

    46   static TypeId tid = TypeId ("ns3::CtrlBAckRequestHeader")

    52   static TypeId tid = TypeId ("ns3::CtrlBAckRequestHeader")

    47     .SetParent<Header> ()

    53     .SetParent<Header> ()

    48     .AddConstructor<CtrlBAckRequestHeader> ()

    54     .AddConstructor<CtrlBAckRequestHeader> ()

    49   ;

    55   ;

    50   return tid;

    56   return tid;

    51 }

    57 }

    52 

    58 

    53 TypeId

    59 TypeId

    54 CtrlBAckRequestHeader::GetInstanceTypeId (void) const

    60 CtrlBAckRequestHeader::GetInstanceTypeId (void) const

    55 {

    61 {

    56   return GetTypeId ();

    63   return GetTypeId ();

    57 }

    64 }

    58 

    65 

    59 void

    66 void

    60 CtrlBAckRequestHeader::Print (std::ostream &os) const

    67 CtrlBAckRequestHeader::Print (std::ostream &os) const

    61 {

    68 {

    62   os << "TID_INFO=" << m_tidInfo << ", StartingSeq=" << std::hex << m_startingSeq;

    70   os << "TID_INFO=" << m_tidInfo << ", StartingSeq=" << std::hex << m_startingSeq;

    63 }

    71 }

    64 

    72 

    65 uint32_t

    73 uint32_t

    66 CtrlBAckRequestHeader::GetSerializedSize () const

    74 CtrlBAckRequestHeader::GetSerializedSize () const

    67 {

    75 {

    68   uint32_t size = 0;

    77   uint32_t size = 0;

    69   size += 2; //Bar control

    78   size += 2; //Bar control

    70   if (!m_multiTid)

    79   if (!m_multiTid)

    71     {

    80     {

    72       size += 2; //Starting sequence control

    81       size += 2; //Starting sequence control

    86 }

    95 }

    87 

    96 

    88 void

    97 void

    89 CtrlBAckRequestHeader::Serialize (Buffer::Iterator start) const

    98 CtrlBAckRequestHeader::Serialize (Buffer::Iterator start) const

    90 {

    99 {

    91   Buffer::Iterator i = start;

   101   Buffer::Iterator i = start;

    92   i.WriteHtolsbU16 (GetBarControl ());

   102   i.WriteHtolsbU16 (GetBarControl ());

    93   if (!m_multiTid)

   103   if (!m_multiTid)

    94     {

   104     {

    95       i.WriteHtolsbU16 (GetStartingSequenceControl ());

   105       i.WriteHtolsbU16 (GetStartingSequenceControl ());

   108 }

   118 }

   109 

   119 

   110 uint32_t

   120 uint32_t

   111 CtrlBAckRequestHeader::Deserialize (Buffer::Iterator start)

   121 CtrlBAckRequestHeader::Deserialize (Buffer::Iterator start)

   112 {

   122 {

   113   Buffer::Iterator i = start;

   124   Buffer::Iterator i = start;

   114   SetBarControl (i.ReadLsbtohU16 ());

   125   SetBarControl (i.ReadLsbtohU16 ());

   115   if (!m_multiTid)

   126   if (!m_multiTid)

   116     {

   127     {

   117       SetStartingSequenceControl (i.ReadLsbtohU16 ());

   128       SetStartingSequenceControl (i.ReadLsbtohU16 ());

   131 }

   142 }

   132 

   143 

   133 uint16_t

   144 uint16_t

   134 CtrlBAckRequestHeader::GetBarControl (void) const

   145 CtrlBAckRequestHeader::GetBarControl (void) const

   135 {

   146 {

   136   uint16_t res = 0;

   148   uint16_t res = 0;

   137   if (m_barAckPolicy)

   149   if (m_barAckPolicy)

   138     {

   150     {

   139       res |= 0x1;

   151       res |= 0x1;

   140     }

   152     }

   151 }

   163 }

   152 

   164 

   153 void

   165 void

   154 CtrlBAckRequestHeader::SetBarControl (uint16_t bar)

   166 CtrlBAckRequestHeader::SetBarControl (uint16_t bar)

   155 {

   167 {

   156   m_barAckPolicy = ((bar & 0x01) == 1) ? true : false;

   169   m_barAckPolicy = ((bar & 0x01) == 1) ? true : false;

   157   m_multiTid = (((bar >> 1) & 0x01) == 1) ? true : false;

   170   m_multiTid = (((bar >> 1) & 0x01) == 1) ? true : false;

   158   m_compressed = (((bar >> 2) & 0x01) == 1) ? true : false;

   171   m_compressed = (((bar >> 2) & 0x01) == 1) ? true : false;

   159   m_tidInfo = (bar >> 12) & 0x0f;

   172   m_tidInfo = (bar >> 12) & 0x0f;

   160 }

   173 }

   161 

   174 

   162 uint16_t

   175 uint16_t

   163 CtrlBAckRequestHeader::GetStartingSequenceControl (void) const

   176 CtrlBAckRequestHeader::GetStartingSequenceControl (void) const

   164 {

   177 {

   165   return (m_startingSeq << 4) & 0xfff0;

   179   return (m_startingSeq << 4) & 0xfff0;

   166 }

   180 }

   167 

   181 

   168 void

   182 void

   169 CtrlBAckRequestHeader::SetStartingSequenceControl (uint16_t seqControl)

   183 CtrlBAckRequestHeader::SetStartingSequenceControl (uint16_t seqControl)

   170 {

   184 {

   171   m_startingSeq = (seqControl >> 4) & 0x0fff;

   186   m_startingSeq = (seqControl >> 4) & 0x0fff;

   172 }

   187 }

   173 

   188 

   174 void

   189 void

   175 CtrlBAckRequestHeader::SetHtImmediateAck (bool immediateAck)

   190 CtrlBAckRequestHeader::SetHtImmediateAck (bool immediateAck)

   176 {

   191 {

   177   m_barAckPolicy = immediateAck;

   193   m_barAckPolicy = immediateAck;

   178 }

   194 }

   179 

   195 

   180 void

   196 void

   181 CtrlBAckRequestHeader::SetType (enum BlockAckType type)

   197 CtrlBAckRequestHeader::SetType (enum BlockAckType type)

   182 {

   198 {

   183   switch (type)

   200   switch (type)

   184     {

   201     {

   185     case BASIC_BLOCK_ACK:

   202     case BASIC_BLOCK_ACK:

   186       m_multiTid = false;

   203       m_multiTid = false;

   187       m_compressed = false;

   204       m_compressed = false;

   201 }

   218 }

   202 

   219 

   203 void

   220 void

   204 CtrlBAckRequestHeader::SetTidInfo (uint8_t tid)

   221 CtrlBAckRequestHeader::SetTidInfo (uint8_t tid)

   205 {

   222 {

   206   m_tidInfo = static_cast<uint16_t> (tid);

   224   m_tidInfo = static_cast<uint16_t> (tid);

   207 }

   225 }

   208 

   226 

   209 void

   227 void

   210 CtrlBAckRequestHeader::SetStartingSequence (uint16_t seq)

   228 CtrlBAckRequestHeader::SetStartingSequence (uint16_t seq)

   211 {

   229 {

   212   m_startingSeq = seq;

   231   m_startingSeq = seq;

   213 }

   232 }

   214 

   233 

   215 bool

   234 bool

   216 CtrlBAckRequestHeader::MustSendHtImmediateAck (void) const

   235 CtrlBAckRequestHeader::MustSendHtImmediateAck (void) const

   217 {

   236 {

   218   return m_barAckPolicy;

   238   return m_barAckPolicy;

   219 }

   239 }

   220 

   240 

   221 uint8_t

   241 uint8_t

   222 CtrlBAckRequestHeader::GetTidInfo (void) const

   242 CtrlBAckRequestHeader::GetTidInfo (void) const

   223 {

   243 {

   224   uint8_t tid = static_cast<uint8_t> (m_tidInfo);

   245   uint8_t tid = static_cast<uint8_t> (m_tidInfo);

   225   return tid;

   246   return tid;

   226 }

   247 }

   227 

   248 

   228 uint16_t

   249 uint16_t

   229 CtrlBAckRequestHeader::GetStartingSequence (void) const

   250 CtrlBAckRequestHeader::GetStartingSequence (void) const

   230 {

   251 {

   231   return m_startingSeq;

   253   return m_startingSeq;

   232 }

   254 }

   233 

   255 

   234 bool

   256 bool

   235 CtrlBAckRequestHeader::IsBasic (void) const

   257 CtrlBAckRequestHeader::IsBasic (void) const

   236 {

   258 {

   237   return (!m_multiTid && !m_compressed) ? true : false;

   260   return (!m_multiTid && !m_compressed) ? true : false;

   238 }

   261 }

   239 

   262 

   240 bool

   263 bool

   241 CtrlBAckRequestHeader::IsCompressed (void) const

   264 CtrlBAckRequestHeader::IsCompressed (void) const

   242 {

   265 {

   243   return (!m_multiTid && m_compressed) ? true : false;

   267   return (!m_multiTid && m_compressed) ? true : false;

   244 }

   268 }

   245 

   269 

   246 bool

   270 bool

   247 CtrlBAckRequestHeader::IsMultiTid (void) const

   271 CtrlBAckRequestHeader::IsMultiTid (void) const

   248 {

   272 {

   249   return (m_multiTid && m_compressed) ? true : false;

   274   return (m_multiTid && m_compressed) ? true : false;

   250 }

   275 }

   251 

   276 

   252 /***********************************

   277 /***********************************

   253  *       Block ack response

   278  *       Block ack response

   258 CtrlBAckResponseHeader::CtrlBAckResponseHeader ()

   283 CtrlBAckResponseHeader::CtrlBAckResponseHeader ()

   259   : m_baAckPolicy (false),

   284   : m_baAckPolicy (false),

   260     m_multiTid (false),

   285     m_multiTid (false),

   261     m_compressed (false)

   286     m_compressed (false)

   262 {

   287 {

   263   memset (&bitmap, 0, sizeof (bitmap));

   289   memset (&bitmap, 0, sizeof (bitmap));

   264 }

   290 }

   265 

   291 

   266 CtrlBAckResponseHeader::~CtrlBAckResponseHeader ()

   292 CtrlBAckResponseHeader::~CtrlBAckResponseHeader ()

   267 {

   293 {

   268 }

   295 }

   269 

   296 

   270 TypeId

   297 TypeId

   271 CtrlBAckResponseHeader::GetTypeId (void)

   298 CtrlBAckResponseHeader::GetTypeId (void)

   272 {

   299 {

   284 }

   311 }

   285 

   312 

   286 void

   313 void

   287 CtrlBAckResponseHeader::Print (std::ostream &os) const

   314 CtrlBAckResponseHeader::Print (std::ostream &os) const

   288 {

   315 {

   289   os << "TID_INFO=" << m_tidInfo << ", StartingSeq=" << std::hex << m_startingSeq;

   317   os << "TID_INFO=" << m_tidInfo << ", StartingSeq=" << std::hex << m_startingSeq;

   290 }

   318 }

   291 

   319 

   292 uint32_t

   320 uint32_t

   293 CtrlBAckResponseHeader::GetSerializedSize (void) const

   321 CtrlBAckResponseHeader::GetSerializedSize (void) const

   294 {

   322 {

   295   uint32_t size = 0;

   324   uint32_t size = 0;

   296   size += 2; //Bar control

   325   size += 2; //Bar control

   297   if (!m_multiTid)

   326   if (!m_multiTid)

   298     {

   327     {

   299       if (!m_compressed)

   328       if (!m_compressed)

   320 }

   349 }

   321 

   350 

   322 void

   351 void

   323 CtrlBAckResponseHeader::Serialize (Buffer::Iterator start) const

   352 CtrlBAckResponseHeader::Serialize (Buffer::Iterator start) const

   324 {

   353 {

   325   Buffer::Iterator i = start;

   355   Buffer::Iterator i = start;

   326   i.WriteHtolsbU16 (GetBaControl ());

   356   i.WriteHtolsbU16 (GetBaControl ());

   327   if (!m_multiTid)

   357   if (!m_multiTid)

   328     {

   358     {

   329       i.WriteHtolsbU16 (GetStartingSequenceControl ());

   359       i.WriteHtolsbU16 (GetStartingSequenceControl ());

   343 }

   373 }

   344 

   374 

   345 uint32_t

   375 uint32_t

   346 CtrlBAckResponseHeader::Deserialize (Buffer::Iterator start)

   376 CtrlBAckResponseHeader::Deserialize (Buffer::Iterator start)

   347 {

   377 {

   348   Buffer::Iterator i = start;

   379   Buffer::Iterator i = start;

   349   SetBaControl (i.ReadLsbtohU16 ());

   380   SetBaControl (i.ReadLsbtohU16 ());

   350   if (!m_multiTid)

   381   if (!m_multiTid)

   351     {

   382     {

   352       SetStartingSequenceControl (i.ReadLsbtohU16 ());

   383       SetStartingSequenceControl (i.ReadLsbtohU16 ());

   367 }

   398 }

   368 

   399 

   369 void

   400 void

   370 CtrlBAckResponseHeader::SetHtImmediateAck (bool immediateAck)

   401 CtrlBAckResponseHeader::SetHtImmediateAck (bool immediateAck)

   371 {

   402 {

   372   m_baAckPolicy = immediateAck;

   404   m_baAckPolicy = immediateAck;

   373 }

   405 }

   374 

   406 

   375 void

   407 void

   376 CtrlBAckResponseHeader::SetType (enum BlockAckType type)

   408 CtrlBAckResponseHeader::SetType (enum BlockAckType type)

   377 {

   409 {

   378   switch (type)

   411   switch (type)

   379     {

   412     {

   380     case BASIC_BLOCK_ACK:

   413     case BASIC_BLOCK_ACK:

   381       m_multiTid = false;

   414       m_multiTid = false;

   382       m_compressed = false;

   415       m_compressed = false;

   396 }

   429 }

   397 

   430 

   398 void

   431 void

   399 CtrlBAckResponseHeader::SetTidInfo (uint8_t tid)

   432 CtrlBAckResponseHeader::SetTidInfo (uint8_t tid)

   400 {

   433 {

   401   m_tidInfo = static_cast<uint16_t> (tid);

   435   m_tidInfo = static_cast<uint16_t> (tid);

   402 }

   436 }

   403 

   437 

   404 void

   438 void

   405 CtrlBAckResponseHeader::SetStartingSequence (uint16_t seq)

   439 CtrlBAckResponseHeader::SetStartingSequence (uint16_t seq)

   406 {

   440 {

   407   m_startingSeq = seq;

   442   m_startingSeq = seq;

   408 }

   443 }

   409 

   444 

   410 bool

   445 bool

   411 CtrlBAckResponseHeader::MustSendHtImmediateAck (void) const

   446 CtrlBAckResponseHeader::MustSendHtImmediateAck (void) const

   412 {

   447 {

   413   return (m_baAckPolicy) ? true : false;

   449   return (m_baAckPolicy) ? true : false;

   414 }

   450 }

   415 

   451 

   416 uint8_t

   452 uint8_t

   417 CtrlBAckResponseHeader::GetTidInfo (void) const

   453 CtrlBAckResponseHeader::GetTidInfo (void) const

   418 {

   454 {

   419   uint8_t tid = static_cast<uint8_t> (m_tidInfo);

   456   uint8_t tid = static_cast<uint8_t> (m_tidInfo);

   420   return tid;

   457   return tid;

   421 }

   458 }

   422 

   459 

   423 uint16_t

   460 uint16_t

   424 CtrlBAckResponseHeader::GetStartingSequence (void) const

   461 CtrlBAckResponseHeader::GetStartingSequence (void) const

   425 {

   462 {

   426   return m_startingSeq;

   464   return m_startingSeq;

   427 }

   465 }

   428 

   466 

   429 bool

   467 bool

   430 CtrlBAckResponseHeader::IsBasic (void) const

   468 CtrlBAckResponseHeader::IsBasic (void) const

   431 {

   469 {

   432   return (!m_multiTid && !m_compressed) ? true : false;

   471   return (!m_multiTid && !m_compressed) ? true : false;

   433 }

   472 }

   434 

   473 

   435 bool

   474 bool

   436 CtrlBAckResponseHeader::IsCompressed (void) const

   475 CtrlBAckResponseHeader::IsCompressed (void) const

   437 {

   476 {

   438   return (!m_multiTid && m_compressed) ? true : false;

   478   return (!m_multiTid && m_compressed) ? true : false;

   439 }

   479 }

   440 

   480 

   441 bool

   481 bool

   442 CtrlBAckResponseHeader::IsMultiTid (void) const

   482 CtrlBAckResponseHeader::IsMultiTid (void) const

   443 {

   483 {

   444   return (m_multiTid && m_compressed) ? true : false;

   485   return (m_multiTid && m_compressed) ? true : false;

   445 }

   486 }

   446 

   487 

   447 uint16_t

   488 uint16_t

   448 CtrlBAckResponseHeader::GetBaControl (void) const

   489 CtrlBAckResponseHeader::GetBaControl (void) const

   449 {

   490 {

   450   uint16_t res = 0;

   492   uint16_t res = 0;

   451   if (m_baAckPolicy)

   493   if (m_baAckPolicy)

   452     {

   494     {

   453       res |= 0x1;

   495       res |= 0x1;

   454     }

   496     }

   465 }

   507 }

   466 

   508 

   467 void

   509 void

   468 CtrlBAckResponseHeader::SetBaControl (uint16_t ba)

   510 CtrlBAckResponseHeader::SetBaControl (uint16_t ba)

   469 {

   511 {

   470   m_baAckPolicy = ((ba & 0x01) == 1) ? true : false;

   513   m_baAckPolicy = ((ba & 0x01) == 1) ? true : false;

   471   m_multiTid = (((ba >> 1) & 0x01) == 1) ? true : false;

   514   m_multiTid = (((ba >> 1) & 0x01) == 1) ? true : false;

   472   m_compressed = (((ba >> 2) & 0x01) == 1) ? true : false;

   515   m_compressed = (((ba >> 2) & 0x01) == 1) ? true : false;

   473   m_tidInfo = (ba >> 12) & 0x0f;

   516   m_tidInfo = (ba >> 12) & 0x0f;

   474 }

   517 }

   475 

   518 

   476 uint16_t

   519 uint16_t

   477 CtrlBAckResponseHeader::GetStartingSequenceControl (void) const

   520 CtrlBAckResponseHeader::GetStartingSequenceControl (void) const

   478 {

   521 {

   479   return (m_startingSeq << 4) & 0xfff0;

   523   return (m_startingSeq << 4) & 0xfff0;

   480 }

   524 }

   481 

   525 

   482 void

   526 void

   483 CtrlBAckResponseHeader::SetStartingSequenceControl (uint16_t seqControl)

   527 CtrlBAckResponseHeader::SetStartingSequenceControl (uint16_t seqControl)

   484 {

   528 {

   485   m_startingSeq = (seqControl >> 4) & 0x0fff;

   530   m_startingSeq = (seqControl >> 4) & 0x0fff;

   486 }

   531 }

   487 

   532 

   488 Buffer::Iterator

   533 Buffer::Iterator

   489 CtrlBAckResponseHeader::SerializeBitmap (Buffer::Iterator start) const

   534 CtrlBAckResponseHeader::SerializeBitmap (Buffer::Iterator start) const

   490 {

   535 {

   491   Buffer::Iterator i = start;

   537   Buffer::Iterator i = start;

   492   if (!m_multiTid)

   538   if (!m_multiTid)

   493     {

   539     {

   494       if (!m_compressed)

   540       if (!m_compressed)

   495         {

   541         {

   518 }

   564 }

   519 

   565 

   520 Buffer::Iterator

   566 Buffer::Iterator

   521 CtrlBAckResponseHeader::DeserializeBitmap (Buffer::Iterator start)

   567 CtrlBAckResponseHeader::DeserializeBitmap (Buffer::Iterator start)

   522 {

   568 {

   523   Buffer::Iterator i = start;

   570   Buffer::Iterator i = start;

   524   if (!m_multiTid)

   571   if (!m_multiTid)

   525     {

   572     {

   526       if (!m_compressed)

   573       if (!m_compressed)

   527         {

   574         {

   550 }

   597 }

   551 

   598 

   552 void

   599 void

   553 CtrlBAckResponseHeader::SetReceivedPacket (uint16_t seq)

   600 CtrlBAckResponseHeader::SetReceivedPacket (uint16_t seq)

   554 {

   601 {

   555   if (!IsInBitmap (seq))

   603   if (!IsInBitmap (seq))

   556     {

   604     {

   557       return;

   605       return;

   558     }

   606     }

   559   if (!m_multiTid)

   607   if (!m_multiTid)

   583 }

   631 }

   584 

   632 

   585 void

   633 void

   586 CtrlBAckResponseHeader::SetReceivedFragment (uint16_t seq, uint8_t frag)

   634 CtrlBAckResponseHeader::SetReceivedFragment (uint16_t seq, uint8_t frag)

   587 {

   635 {

   588   NS_ASSERT (frag < 16);

   637   NS_ASSERT (frag < 16);

   589   if (!IsInBitmap (seq))

   638   if (!IsInBitmap (seq))

   590     {

   639     {

   591       return;

   640       return;

   592     }

   641     }

   616 }

   665 }

   617 

   666 

   618 bool

   667 bool

   619 CtrlBAckResponseHeader::IsPacketReceived (uint16_t seq) const

   668 CtrlBAckResponseHeader::IsPacketReceived (uint16_t seq) const

   620 {

   669 {

   621   if (!IsInBitmap (seq))

   671   if (!IsInBitmap (seq))

   622     {

   672     {

   623       return false;

   673       return false;

   624     }

   674     }

   625   if (!m_multiTid)

   675   if (!m_multiTid)

   650 }

   700 }

   651 

   701 

   652 bool

   702 bool

   653 CtrlBAckResponseHeader::IsFragmentReceived (uint16_t seq, uint8_t frag) const

   703 CtrlBAckResponseHeader::IsFragmentReceived (uint16_t seq, uint8_t frag) const

   654 {

   704 {

   655   NS_ASSERT (frag < 16);

   706   NS_ASSERT (frag < 16);

   656   if (!IsInBitmap (seq))

   707   if (!IsInBitmap (seq))

   657     {

   708     {

   658       return false;

   709       return false;

   659     }

   710     }

   687 }

   738 }

   688 

   739 

   689 uint8_t

   740 uint8_t

   690 CtrlBAckResponseHeader::IndexInBitmap (uint16_t seq) const

   741 CtrlBAckResponseHeader::IndexInBitmap (uint16_t seq) const

   691 {

   742 {

   692   uint8_t index;

   744   uint8_t index;

   693   if (seq >= m_startingSeq)

   745   if (seq >= m_startingSeq)

   694     {

   746     {

   695       index = seq - m_startingSeq;

   747       index = seq - m_startingSeq;

   696     }

   748     }

   703 }

   755 }

   704 

   756 

   705 bool

   757 bool

   706 CtrlBAckResponseHeader::IsInBitmap (uint16_t seq) const

   758 CtrlBAckResponseHeader::IsInBitmap (uint16_t seq) const

   707 {

   759 {

   708   return (seq - m_startingSeq + 4096) % 4096 < 64;

   761   return (seq - m_startingSeq + 4096) % 4096 < 64;

   709 }

   762 }

   710 

   763 

   711 const uint16_t*

   764 const uint16_t*

   712 CtrlBAckResponseHeader::GetBitmap (void) const

   765 CtrlBAckResponseHeader::GetBitmap (void) const

   713 {

   766 {

   714   return bitmap.m_bitmap;

   768   return bitmap.m_bitmap;

   715 }

   769 }

   716 

   770 

   717 uint64_t

   771 uint64_t

   718 CtrlBAckResponseHeader::GetCompressedBitmap (void) const

   772 CtrlBAckResponseHeader::GetCompressedBitmap (void) const

   719 {

   773 {

   720   return bitmap.m_compressedBitmap;

   775   return bitmap.m_compressedBitmap;

   721 }

   776 }

   722 

   777 

   723 void

   778 void

   724 CtrlBAckResponseHeader::ResetBitmap (void)

   779 CtrlBAckResponseHeader::ResetBitmap (void)

   725 {

   780 {

   726   memset (&bitmap, 0, sizeof (bitmap));

   782   memset (&bitmap, 0, sizeof (bitmap));

   727 }

   783 }

   728 

   784 

   729 }  // namespace ns3

   785 }  // namespace ns3