Mercurial Mercurial > ns-3.24 / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/wifi/model/mgt-headers.cc
changeset 10139 17a71cd49da3
parent 9783 828a38d9c799
child 10410 4d4eb8097fa3
equal deleted inserted replaced
10138:2f8e35b43d11 10139:17a71cd49da3 
    48 void
 
    48 void
 
    49 MgtProbeRequestHeader::SetSupportedRates (SupportedRates rates)
 
    49 MgtProbeRequestHeader::SetSupportedRates (SupportedRates rates)
 
    50 {
 
    50 {
 
    51   m_rates = rates;
 
    51   m_rates = rates;
 
    52 }
 
    52 }
 
    53 
    53 void 
       
    54 MgtProbeRequestHeader::SetHtCapabilities(HtCapabilities htcapabilities)
 
       
    55 {
 
       
    56   m_htCapability=htcapabilities;
 
       
    57 }
 
       
    58 
       
    59 HtCapabilities 
       
    60 MgtProbeRequestHeader::GetHtCapabilities (void) const
 
       
    61 {
 
       
    62    return  m_htCapability;
 
       
    63 }
 
    54 SupportedRates
 
    64 SupportedRates
 
    55 MgtProbeRequestHeader::GetSupportedRates (void) const
 
    65 MgtProbeRequestHeader::GetSupportedRates (void) const
 
    56 {
 
    66 {
 
    57   return m_rates;
 
    67   return m_rates;
 
    58 }
 
    68 }
 
    61 {
 
    71 {
 
    62   uint32_t size = 0;
 
    72   uint32_t size = 0;
 
    63   size += m_ssid.GetSerializedSize ();
 
    73   size += m_ssid.GetSerializedSize ();
 
    64   size += m_rates.GetSerializedSize ();
 
    74   size += m_rates.GetSerializedSize ();
 
    65   size += m_rates.extended.GetSerializedSize ();
 
    75   size += m_rates.extended.GetSerializedSize ();
 
       
    76   size += m_htCapability.GetSerializedSize();
 
    66   return size;
 
    77   return size;
 
    67 }
 
    78 }
 
    68 TypeId
 
    79 TypeId
 
    69 MgtProbeRequestHeader::GetTypeId (void)
 
    80 MgtProbeRequestHeader::GetTypeId (void)
 
    70 {
 
    81 {
 
    81 }
 
    92 }
 
    82 void
 
    93 void
 
    83 MgtProbeRequestHeader::Print (std::ostream &os) const
 
    94 MgtProbeRequestHeader::Print (std::ostream &os) const
 
    84 {
 
    95 {
 
    85   os << "ssid=" << m_ssid << ", "
 
    96   os << "ssid=" << m_ssid << ", "
 
    86      << "rates=" << m_rates;
 
    97      << "rates=" << m_rates << ", "
 
       
    98      << "HT Capabilities=" << m_htCapability;
 
    87 }
 
    99 }
 
    88 void
 
   100 void
 
    89 MgtProbeRequestHeader::Serialize (Buffer::Iterator start) const
 
   101 MgtProbeRequestHeader::Serialize (Buffer::Iterator start) const
 
    90 {
 
   102 {
 
    91   Buffer::Iterator i = start;
 
   103   Buffer::Iterator i = start;
 
    92   i = m_ssid.Serialize (i);
 
   104   i = m_ssid.Serialize (i);
 
    93   i = m_rates.Serialize (i);
 
   105   i = m_rates.Serialize (i);
 
    94   i = m_rates.extended.Serialize (i);
 
   106   i = m_rates.extended.Serialize (i);
 
       
   107    i = m_htCapability.Serialize(i);
 
    95 }
 
   108 }
 
    96 uint32_t
 
   109 uint32_t
 
    97 MgtProbeRequestHeader::Deserialize (Buffer::Iterator start)
 
   110 MgtProbeRequestHeader::Deserialize (Buffer::Iterator start)
 
    98 {
 
   111 {
 
    99   Buffer::Iterator i = start;
 
   112   Buffer::Iterator i = start;
 
   100   i = m_ssid.Deserialize (i);
 
   113   i = m_ssid.Deserialize (i);
 
   101   i = m_rates.Deserialize (i);
 
   114   i = m_rates.Deserialize (i);
 
   102   i = m_rates.extended.DeserializeIfPresent (i);
 
   115   i = m_rates.extended.DeserializeIfPresent (i);
 
       
   116   i = m_htCapability.DeserializeIfPresent (i);
 
   103   return i.GetDistanceFrom (start);
 
   117   return i.GetDistanceFrom (start);
 
   104 }
 
   118 }
 
   105 
   119 
   106 
   120 
   107 /***********************************************************
 
   121 /***********************************************************
 
   134 SupportedRates
 
   148 SupportedRates
 
   135 MgtProbeResponseHeader::GetSupportedRates (void) const
 
   149 MgtProbeResponseHeader::GetSupportedRates (void) const
 
   136 {
 
   150 {
 
   137   return m_rates;
 
   151   return m_rates;
 
   138 }
 
   152 }
 
   139 
   153 void 
       
   154 MgtProbeResponseHeader::SetHtCapabilities(HtCapabilities htcapabilities)
 
       
   155 {
 
       
   156   m_htCapability=htcapabilities;
 
       
   157 }
 
       
   158 
       
   159 HtCapabilities 
       
   160 MgtProbeResponseHeader::GetHtCapabilities (void) const
 
       
   161 {
 
       
   162    return  m_htCapability;
 
       
   163 }
 
   140 void
 
   164 void
 
   141 MgtProbeResponseHeader::SetSsid (Ssid ssid)
 
   165 MgtProbeResponseHeader::SetSsid (Ssid ssid)
 
   142 {
 
   166 {
 
   143   m_ssid = ssid;
 
   167   m_ssid = ssid;
 
   144 }
 
   168 }
 
   175   size += m_capability.GetSerializedSize ();
 
   199   size += m_capability.GetSerializedSize ();
 
   176   size += m_ssid.GetSerializedSize ();
 
   200   size += m_ssid.GetSerializedSize ();
 
   177   size += m_rates.GetSerializedSize ();
 
   201   size += m_rates.GetSerializedSize ();
 
   178   //size += 3; // ds parameter set
 
   202   //size += 3; // ds parameter set
 
   179   size += m_rates.extended.GetSerializedSize ();
 
   203   size += m_rates.extended.GetSerializedSize ();
 
       
   204   size += m_htCapability.GetSerializedSize();
 
   180   // xxx
 
   205   // xxx
 
   181   return size;
 
   206   return size;
 
   182 }
 
   207 }
 
   183 void
 
   208 void
 
   184 MgtProbeResponseHeader::Print (std::ostream &os) const
 
   209 MgtProbeResponseHeader::Print (std::ostream &os) const
 
   185 {
 
   210 {
 
   186   os << "ssid=" << m_ssid << ", "
 
   211   os << "ssid=" << m_ssid << ", "
 
   187      << "rates=" << m_rates;
 
   212      << "rates=" << m_rates << ", "
 
       
   213      << "HT Capabilities=" << m_htCapability;
 
   188 }
 
   214 }
 
   189 void
 
   215 void
 
   190 MgtProbeResponseHeader::Serialize (Buffer::Iterator start) const
 
   216 MgtProbeResponseHeader::Serialize (Buffer::Iterator start) const
 
   191 {
 
   217 {
 
   192   // timestamp
 
   218   // timestamp
 
   205   i = m_capability.Serialize (i);
 
   231   i = m_capability.Serialize (i);
 
   206   i = m_ssid.Serialize (i);
 
   232   i = m_ssid.Serialize (i);
 
   207   i = m_rates.Serialize (i);
 
   233   i = m_rates.Serialize (i);
 
   208   //i.WriteU8 (0, 3); // ds parameter set.
 
   234   //i.WriteU8 (0, 3); // ds parameter set.
 
   209   i = m_rates.extended.Serialize (i);
 
   235   i = m_rates.extended.Serialize (i);
 
       
   236   i = m_htCapability.Serialize(i);
 
   210 }
 
   237 }
 
   211 uint32_t
 
   238 uint32_t
 
   212 MgtProbeResponseHeader::Deserialize (Buffer::Iterator start)
 
   239 MgtProbeResponseHeader::Deserialize (Buffer::Iterator start)
 
   213 {
 
   240 {
 
   214   Buffer::Iterator i = start;
 
   241   Buffer::Iterator i = start;
 
   218   i = m_capability.Deserialize (i);
 
   245   i = m_capability.Deserialize (i);
 
   219   i = m_ssid.Deserialize (i);
 
   246   i = m_ssid.Deserialize (i);
 
   220   i = m_rates.Deserialize (i);
 
   247   i = m_rates.Deserialize (i);
 
   221   //i.Next (3); // ds parameter set
 
   248   //i.Next (3); // ds parameter set
 
   222   i = m_rates.extended.DeserializeIfPresent (i);
 
   249   i = m_rates.extended.DeserializeIfPresent (i);
 
       
   250   i = m_htCapability.DeserializeIfPresent (i);
 
   223   return i.GetDistanceFrom (start);
 
   251   return i.GetDistanceFrom (start);
 
   224 }
 
   252 }
 
   225 
   253 
   226 /***********************************************************
 
   254 /***********************************************************
 
   227  *          Assoc Request
 
   255  *          Assoc Request
 
   245 void
 
   273 void
 
   246 MgtAssocRequestHeader::SetSupportedRates (SupportedRates rates)
 
   274 MgtAssocRequestHeader::SetSupportedRates (SupportedRates rates)
 
   247 {
 
   275 {
 
   248   m_rates = rates;
 
   276   m_rates = rates;
 
   249 }
 
   277 }
 
       
   278 void 
       
   279 MgtAssocRequestHeader::SetHtCapabilities(HtCapabilities htcapabilities)
 
       
   280 {
 
       
   281   m_htCapability = htcapabilities;
 
       
   282 }
 
   250 void
 
   283 void
 
   251 MgtAssocRequestHeader::SetListenInterval (uint16_t interval)
 
   284 MgtAssocRequestHeader::SetListenInterval (uint16_t interval)
 
   252 {
 
   285 {
 
   253   m_listenInterval = interval;
 
   286   m_listenInterval = interval;
 
       
   287 }
 
       
   288 HtCapabilities 
       
   289 MgtAssocRequestHeader::GetHtCapabilities (void) const
 
       
   290 {
 
       
   291    return  m_htCapability;
 
   254 }
 
   292 }
 
   255 Ssid
 
   293 Ssid
 
   256 MgtAssocRequestHeader::GetSsid (void) const
 
   294 MgtAssocRequestHeader::GetSsid (void) const
 
   257 {
 
   295 {
 
   258   return m_ssid;
 
   296   return m_ssid;
 
   288   uint32_t size = 0;
 
   326   uint32_t size = 0;
 
   289   size += m_capability.GetSerializedSize ();
 
   327   size += m_capability.GetSerializedSize ();
 
   290   size += 2;
 
   328   size += 2;
 
   291   size += m_ssid.GetSerializedSize ();
 
   329   size += m_ssid.GetSerializedSize ();
 
   292   size += m_rates.GetSerializedSize ();
 
   330   size += m_rates.GetSerializedSize ();
 
       
   331   size += m_htCapability.GetSerializedSize();
 
   293   size += m_rates.extended.GetSerializedSize ();
 
   332   size += m_rates.extended.GetSerializedSize ();
 
   294   return size;
 
   333   return size;
 
   295 }
 
   334 }
 
   296 void
 
   335 void
 
   297 MgtAssocRequestHeader::Print (std::ostream &os) const
 
   336 MgtAssocRequestHeader::Print (std::ostream &os) const
 
   298 {
 
   337 {
 
   299   os << "ssid=" << m_ssid << ", "
 
   338   os << "ssid=" << m_ssid << ", "
 
   300      << "rates=" << m_rates;
 
   339      << "rates=" << m_rates<< ", "
 
       
   340      << "HT Capabilities=" << m_htCapability;
 
   301 }
 
   341 }
 
   302 void
 
   342 void
 
   303 MgtAssocRequestHeader::Serialize (Buffer::Iterator start) const
 
   343 MgtAssocRequestHeader::Serialize (Buffer::Iterator start) const
 
   304 {
 
   344 {
 
   305   Buffer::Iterator i = start;
 
   345   Buffer::Iterator i = start;
 
   306   i = m_capability.Serialize (i);
 
   346   i = m_capability.Serialize (i);
 
   307   i.WriteHtolsbU16 (m_listenInterval);
 
   347   i.WriteHtolsbU16 (m_listenInterval);
 
   308   i = m_ssid.Serialize (i);
 
   348   i = m_ssid.Serialize (i);
 
   309   i = m_rates.Serialize (i);
 
   349   i = m_rates.Serialize (i);
 
   310   i = m_rates.extended.Serialize (i);
 
   350   i = m_rates.extended.Serialize (i);
 
       
   351   i = m_htCapability.Serialize(i);
 
   311 }
 
   352 }
 
   312 uint32_t
 
   353 uint32_t
 
   313 MgtAssocRequestHeader::Deserialize (Buffer::Iterator start)
 
   354 MgtAssocRequestHeader::Deserialize (Buffer::Iterator start)
 
   314 {
 
   355 {
 
   315   Buffer::Iterator i = start;
 
   356   Buffer::Iterator i = start;
 
   316   i = m_capability.Deserialize (i);
 
   357   i = m_capability.Deserialize (i);
 
   317   m_listenInterval = i.ReadLsbtohU16 ();
 
   358   m_listenInterval = i.ReadLsbtohU16 ();
 
   318   i = m_ssid.Deserialize (i);
 
   359   i = m_ssid.Deserialize (i);
 
   319   i = m_rates.Deserialize (i);
 
   360   i = m_rates.Deserialize (i);
 
   320   i = m_rates.extended.DeserializeIfPresent (i);
 
   361   i = m_rates.extended.DeserializeIfPresent (i);
 
       
   362   i = m_htCapability.DeserializeIfPresent (i);
 
   321   return i.GetDistanceFrom (start);
 
   363   return i.GetDistanceFrom (start);
 
   322 }
 
   364 }
 
   323 
   365 
   324 /***********************************************************
 
   366 /***********************************************************
 
   325  *          Assoc Response
 
   367  *          Assoc Response
 
   353 void
 
   395 void
 
   354 MgtAssocResponseHeader::SetSupportedRates (SupportedRates rates)
 
   396 MgtAssocResponseHeader::SetSupportedRates (SupportedRates rates)
 
   355 {
 
   397 {
 
   356   m_rates = rates;
 
   398   m_rates = rates;
 
   357 }
 
   399 }
 
   358 
   400 void 
       
   401 MgtAssocResponseHeader::SetHtCapabilities(HtCapabilities htcapabilities)
 
       
   402 {
 
       
   403   m_htCapability=htcapabilities;
 
       
   404 }
 
       
   405 
       
   406 HtCapabilities 
       
   407 MgtAssocResponseHeader::GetHtCapabilities (void) const
 
       
   408 {
 
       
   409    return  m_htCapability;
 
       
   410 }
 
   359 TypeId
 
   411 TypeId
 
   360 MgtAssocResponseHeader::GetTypeId (void)
 
   412 MgtAssocResponseHeader::GetTypeId (void)
 
   361 {
 
   413 {
 
   362   static TypeId tid = TypeId ("ns3::MgtAssocResponseHeader")
 
   414   static TypeId tid = TypeId ("ns3::MgtAssocResponseHeader")
 
   363     .SetParent<Header> ()
 
   415     .SetParent<Header> ()
 
   377   size += m_capability.GetSerializedSize ();
 
   429   size += m_capability.GetSerializedSize ();
 
   378   size += m_code.GetSerializedSize ();
 
   430   size += m_code.GetSerializedSize ();
 
   379   size += 2; // aid
 
   431   size += 2; // aid
 
   380   size += m_rates.GetSerializedSize ();
 
   432   size += m_rates.GetSerializedSize ();
 
   381   size += m_rates.extended.GetSerializedSize ();
 
   433   size += m_rates.extended.GetSerializedSize ();
 
       
   434 size += m_htCapability.GetSerializedSize();
 
   382   return size;
 
   435   return size;
 
   383 }
 
   436 }
 
   384 
   437 
   385 void
 
   438 void
 
   386 MgtAssocResponseHeader::Print (std::ostream &os) const
 
   439 MgtAssocResponseHeader::Print (std::ostream &os) const
 
   387 {
 
   440 {
 
   388   os << "status code=" << m_code << ", "
 
   441   os << "status code=" << m_code << ", "
 
   389      << "rates=" << m_rates;
 
   442      << "rates=" << m_rates << ", "
 
       
   443   << "HT Capabilities=" << m_htCapability;
 
   390 }
 
   444 }
 
   391 void
 
   445 void
 
   392 MgtAssocResponseHeader::Serialize (Buffer::Iterator start) const
 
   446 MgtAssocResponseHeader::Serialize (Buffer::Iterator start) const
 
   393 {
 
   447 {
 
   394   Buffer::Iterator i = start;
 
   448   Buffer::Iterator i = start;
 
   395   i = m_capability.Serialize (i);
 
   449   i = m_capability.Serialize (i);
 
   396   i = m_code.Serialize (i);
 
   450   i = m_code.Serialize (i);
 
   397   i.WriteHtolsbU16 (m_aid);
 
   451   i.WriteHtolsbU16 (m_aid);
 
   398   i = m_rates.Serialize (i);
 
   452   i = m_rates.Serialize (i);
 
   399   i = m_rates.extended.Serialize (i);
 
   453   i = m_rates.extended.Serialize (i);
 
       
   454  i = m_htCapability.Serialize(i);
 
   400 }
 
   455 }
 
   401 uint32_t
 
   456 uint32_t
 
   402 MgtAssocResponseHeader::Deserialize (Buffer::Iterator start)
 
   457 MgtAssocResponseHeader::Deserialize (Buffer::Iterator start)
 
   403 {
 
   458 {
 
   404   Buffer::Iterator i = start;
 
   459   Buffer::Iterator i = start;
 
   405   i = m_capability.Deserialize (i);
 
   460   i = m_capability.Deserialize (i);
 
   406   i = m_code.Deserialize (i);
 
   461   i = m_code.Deserialize (i);
 
   407   m_aid = i.ReadLsbtohU16 ();
 
   462   m_aid = i.ReadLsbtohU16 ();
 
   408   i = m_rates.Deserialize (i);
 
   463   i = m_rates.Deserialize (i);
 
   409   i = m_rates.extended.DeserializeIfPresent (i);
 
   464   i = m_rates.extended.DeserializeIfPresent (i);
 
       
   465  i = m_htCapability.DeserializeIfPresent (i);
 
   410   return i.GetDistanceFrom (start);
 
   466   return i.GetDistanceFrom (start);
 
   411 }
 
   467 }
 
   412 /**********************************************************
 
   468 /**********************************************************
 
   413  *   ActionFrame
 
   469  *   ActionFrame
 
   414  **********************************************************/
 
   470  **********************************************************/
ns-3.24