Attachment #1184 for bug #1084

View | Details | Raw Unified | Return to bug 1084
Collapse All | Expand All

(-)a/src/mesh/model/dot11s/peer-link-frame.cc (-6 / +12 lines)

Lines 119-126	Link Here

119

120

  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)

120

  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)

121

122

      size += m_rates.GetSerializedSize ();

122

      SupportedRatesIE srIE(&m_rates);

123

      size += m_rates.extended.GetSerializedSize ();

123

      size += srIE.GetSerializedSize ();

124

      ExtendedSupportedRatesIE esrIE(&m_rates);

125

      size += esrIE.GetSerializedSize ();

124

126

125

  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)

127

  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)

126

128

Lines 152-159	Link Here

152

154

153

  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)

155

  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)

154

156

155

      i = m_rates.Serialize (i);

157

      SupportedRatesIE srIE(&m_rates);

156

      i = m_rates.extended.Serialize (i);

158

      i = srIE.Serialize (i);

159

      ExtendedSupportedRatesIE esrIE(&m_rates);

160

      i = esrIE.Serialize (i);

157

161

158

  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)

162

  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)

159

163

Lines 193-200	Link Here

193

197

194

  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)

198

  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)

195

199

196

      i = m_rates.Deserialize (i);

200

      SupportedRatesIE srIE(&m_rates);

197

      i = m_rates.extended.DeserializeIfPresent (i);

201

      i = srIE.Deserialize (i);

202

      ExtendedSupportedRatesIE esrIE(&m_rates);

203

      i = esrIE.DeserializeIfPresent (i);

198

204

199

  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)

205

  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)

200

206

(-)a/src/wifi/model/mgt-headers.cc (-24 / +48 lines)

Lines 61-68	Link Here

  uint32_t size = 0;

  uint32_t size = 0;

  size += m_ssid.GetSerializedSize ();

  size += m_ssid.GetSerializedSize ();

  size += m_rates.GetSerializedSize ();

  SupportedRatesIE srIE(&m_rates);

  size += m_rates.extended.GetSerializedSize ();

  size += srIE.GetSerializedSize ();

  ExtendedSupportedRatesIE esrIE(&m_rates);

  size += esrIE.GetSerializedSize ();

  return size;

  return size;

TypeId

TypeId

Lines 90-105	Link Here

  Buffer::Iterator i = start;

  Buffer::Iterator i = start;

  i = m_ssid.Serialize (i);

  i = m_ssid.Serialize (i);

  i = m_rates.Serialize (i);

  SupportedRatesIE srIE(&m_rates);

  i = m_rates.extended.Serialize (i);

  i = srIE.Serialize (i);

  ExtendedSupportedRatesIE esrIE(&m_rates);

  i = esrIE.Serialize (i);

uint32_t

100

uint32_t

MgtProbeRequestHeader::Deserialize (Buffer::Iterator start)

101

MgtProbeRequestHeader::Deserialize (Buffer::Iterator start)

102

  Buffer::Iterator i = start;

103

  Buffer::Iterator i = start;

100

  i = m_ssid.Deserialize (i);

104

  i = m_ssid.Deserialize (i);

101

  i = m_rates.Deserialize (i);

105

  SupportedRatesIE srIE(&m_rates);

102

  i = m_rates.extended.DeserializeIfPresent (i);

106

  i = srIE.Deserialize (i);

107

  ExtendedSupportedRatesIE esrIE(&m_rates);

108

  i = esrIE.DeserializeIfPresent (i);

103

  return i.GetDistanceFrom (start);

109

  return i.GetDistanceFrom (start);

104

110

105

111

Lines 174-182	Link Here

174

  size += 2; // beacon interval

180

  size += 2; // beacon interval

175

  size += m_capability.GetSerializedSize ();

181

  size += m_capability.GetSerializedSize ();

176

  size += m_ssid.GetSerializedSize ();

182

  size += m_ssid.GetSerializedSize ();

177

  size += m_rates.GetSerializedSize ();

183

  SupportedRatesIE srIE(&m_rates);

184

  size += srIE.GetSerializedSize ();

178

  //size += 3; // ds parameter set

185

  //size += 3; // ds parameter set

179

  size += m_rates.extended.GetSerializedSize ();

186

  ExtendedSupportedRatesIE esrIE(&m_rates);

187

  size += esrIE.GetSerializedSize ();

180

  // xxx

188

  // xxx

181

  return size;

189

  return size;

182

190

Lines 204-212	Link Here

204

  i.WriteHtolsbU16 (m_beaconInterval / 1024);

212

  i.WriteHtolsbU16 (m_beaconInterval / 1024);

205

  i = m_capability.Serialize (i);

213

  i = m_capability.Serialize (i);

206

  i = m_ssid.Serialize (i);

214

  i = m_ssid.Serialize (i);

207

  i = m_rates.Serialize (i);

215

  SupportedRatesIE srIE(&m_rates);

216

  i = srIE.Serialize (i);

208

  //i.WriteU8 (0, 3); // ds parameter set.

217

  //i.WriteU8 (0, 3); // ds parameter set.

209

  i = m_rates.extended.Serialize (i);

218

  ExtendedSupportedRatesIE esrIE(&m_rates);

219

  i = esrIE.Serialize (i);

210

220

211

uint32_t

221

uint32_t

212

MgtProbeResponseHeader::Deserialize (Buffer::Iterator start)

222

MgtProbeResponseHeader::Deserialize (Buffer::Iterator start)

Lines 217-225	Link Here

217

  m_beaconInterval *= 1024;

227

  m_beaconInterval *= 1024;

218

  i = m_capability.Deserialize (i);

228

  i = m_capability.Deserialize (i);

219

  i = m_ssid.Deserialize (i);

229

  i = m_ssid.Deserialize (i);

220

  i = m_rates.Deserialize (i);

230

  SupportedRatesIE srIE(&m_rates);

231

  i = srIE.Deserialize (i);

221

  //i.Next (3); // ds parameter set

232

  //i.Next (3); // ds parameter set

222

  i = m_rates.extended.DeserializeIfPresent (i);

233

  ExtendedSupportedRatesIE esrIE(&m_rates);

234

  i = esrIE.DeserializeIfPresent (i);

223

  return i.GetDistanceFrom (start);

235

  return i.GetDistanceFrom (start);

224

236

225

237

Lines 289-296	Link Here

289

  size += m_capability.GetSerializedSize ();

301

  size += m_capability.GetSerializedSize ();

290

  size += 2;

302

  size += 2;

291

  size += m_ssid.GetSerializedSize ();

303

  size += m_ssid.GetSerializedSize ();

292

  size += m_rates.GetSerializedSize ();

304

  SupportedRatesIE srIE(&m_rates);

293

  size += m_rates.extended.GetSerializedSize ();

305

  size += srIE.GetSerializedSize ();

306

  ExtendedSupportedRatesIE esrIE(&m_rates);

307

  size += esrIE.GetSerializedSize ();

294

  return size;

308

  return size;

295

309

296

void

310

void

Lines 306-313	Link Here

306

  i = m_capability.Serialize (i);

320

  i = m_capability.Serialize (i);

307

  i.WriteHtolsbU16 (m_listenInterval);

321

  i.WriteHtolsbU16 (m_listenInterval);

308

  i = m_ssid.Serialize (i);

322

  i = m_ssid.Serialize (i);

309

  i = m_rates.Serialize (i);

323

  SupportedRatesIE srIE(&m_rates);

310

  i = m_rates.extended.Serialize (i);

324

  i = srIE.Serialize (i);

325

  ExtendedSupportedRatesIE esrIE(&m_rates);

326

  i = esrIE.Serialize (i);

311

327

312

uint32_t

328

uint32_t

313

MgtAssocRequestHeader::Deserialize (Buffer::Iterator start)

329

MgtAssocRequestHeader::Deserialize (Buffer::Iterator start)

Lines 316-323	Link Here

316

  i = m_capability.Deserialize (i);

332

  i = m_capability.Deserialize (i);

317

  m_listenInterval = i.ReadLsbtohU16 ();

333

  m_listenInterval = i.ReadLsbtohU16 ();

318

  i = m_ssid.Deserialize (i);

334

  i = m_ssid.Deserialize (i);

319

  i = m_rates.Deserialize (i);

335

  SupportedRatesIE srIE(&m_rates);

320

  i = m_rates.extended.DeserializeIfPresent (i);

336

  i = srIE.Deserialize (i);

337

  ExtendedSupportedRatesIE esrIE(&m_rates);

338

  i = esrIE.DeserializeIfPresent (i);

321

  return i.GetDistanceFrom (start);

339

  return i.GetDistanceFrom (start);

322

340

323

341

Lines 377-384	Link Here

377

  size += m_capability.GetSerializedSize ();

395

  size += m_capability.GetSerializedSize ();

378

  size += m_code.GetSerializedSize ();

396

  size += m_code.GetSerializedSize ();

379

  size += 2; // aid

397

  size += 2; // aid

380

  size += m_rates.GetSerializedSize ();

398

  SupportedRatesIE srIE(&m_rates);

381

  size += m_rates.extended.GetSerializedSize ();

399

  size += srIE.GetSerializedSize ();

400

  ExtendedSupportedRatesIE esrIE(&m_rates);

401

  size += esrIE.GetSerializedSize ();

382

  return size;

402

  return size;

383

403

384

404

Lines 395-402	Link Here

395

  i = m_capability.Serialize (i);

415

  i = m_capability.Serialize (i);

396

  i = m_code.Serialize (i);

416

  i = m_code.Serialize (i);

397

  i.WriteHtolsbU16 (m_aid);

417

  i.WriteHtolsbU16 (m_aid);

398

  i = m_rates.Serialize (i);

418

  SupportedRatesIE srIE(&m_rates);

399

  i = m_rates.extended.Serialize (i);

419

  i = srIE.Serialize (i);

420

  ExtendedSupportedRatesIE esrIE(&m_rates);

421

  i = esrIE.Serialize (i);

400

422

401

uint32_t

423

uint32_t

402

MgtAssocResponseHeader::Deserialize (Buffer::Iterator start)

424

MgtAssocResponseHeader::Deserialize (Buffer::Iterator start)

Lines 405-412	Link Here

405

  i = m_capability.Deserialize (i);

427

  i = m_capability.Deserialize (i);

406

  i = m_code.Deserialize (i);

428

  i = m_code.Deserialize (i);

407

  m_aid = i.ReadLsbtohU16 ();

429

  m_aid = i.ReadLsbtohU16 ();

408

  i = m_rates.Deserialize (i);

430

  SupportedRatesIE srIE(&m_rates);

409

  i = m_rates.extended.DeserializeIfPresent (i);

431

  i = srIE.Deserialize (i);

432

  ExtendedSupportedRatesIE esrIE(&m_rates);

433

  i = esrIE.DeserializeIfPresent (i);

410

  return i.GetDistanceFrom (start);

434

  return i.GetDistanceFrom (start);

411

435

412

/**********************************************************

436

/**********************************************************




namespace ns3 {

SupportedRates::SupportedRates ()
  : m_nRates (0)
    m_nRates (0)
{
}


  return (m_rates[i] & 0x7f) * 500000;
}

SupportedRatesIE::SupportedRatesIE (SupportedRates *rates)
{
  m_supportedRatesStore = rates;
  m_supportedRatesStoreReadOnly = rates;
}

SupportedRatesIE::SupportedRatesIE (const SupportedRates *rates)
{
  m_supportedRatesStoreReadOnly = rates;
  m_supportedRatesStore = NULL;
}

WifiInformationElementId
SupportedRatesIE::ElementId () const
{
  return IE_SUPPORTED_RATES;
}
uint8_t
SupportedRatesIE::GetInformationFieldSize () const
{
  // Confirm that we have a pointer to a SupportedRates object. We're
  // happy to treat it as const in this method.
  NS_ASSERT (m_supportedRatesStoreReadOnly);
  // The Supported Rates Information Element contains only the first 8
  // supported rates - the remainder appear in the Extended Supported
  // Rates Information Element.
  return std::max((int)m_supportedRatesStoreReadOnly->m_nRates, 8);
}
void
SupportedRatesIE::SerializeInformationField (Buffer::Iterator start) const
{
  // Confirm that we have a pointer to a SupportedRates object. We're
  // happy to treat it as const in this method.
  NS_ASSERT (m_supportedRatesStoreReadOnly);
  // The Supported Rates Information Element contains only the first 8
  // supported rates - the remainder appear in the Extended Supported
  // Rates Information Element.
  start.Write (m_supportedRatesStoreReadOnly->m_rates,
               std::max((int)m_supportedRatesStoreReadOnly->m_nRates, 8));
}
uint8_t
SupportedRatesIE::DeserializeInformationField (Buffer::Iterator start,
                                               uint8_t length)
{
  // Confirm that we have a pointer to a SupportedRates object that we
  // can modify (as opposed to one we have to treat as const).
  NS_ASSERT (m_supportedRatesStore);
  NS_ASSERT (length <= 8);
  m_supportedRatesStore->m_nRates = length;
  start.Read (m_supportedRatesStore->m_rates, m_supportedRatesStore->m_nRates);
  return m_supportedRatesStore->m_nRates;
}



ExtendedSupportedRatesIE::ExtendedSupportedRatesIE (SupportedRates *rates)
{
  m_supportedRatesStore = rates;
  m_supportedRatesStoreReadOnly = rates;
}

ExtendedSupportedRatesIE::ExtendedSupportedRatesIE (const SupportedRates *rates)
{
  m_supportedRatesStoreReadOnly = rates;
  m_supportedRatesStore = NULL;
}

WifiInformationElementId

uint8_t
ExtendedSupportedRatesIE::GetInformationFieldSize () const
{
  // Confirm that we have a pointer to a SupportedRates object. We're
  // happy to treat it as const in this method.
  NS_ASSERT (m_supportedRatesStoreReadOnly);
  // If there are 8 or fewer rates then we don't need an Extended
  // Supported Rates IE and so could return zero here, but we're
  // overriding the GetSerializedSize() method, so if this function is
  // invoked in that case then it indicates a programming error. Hence
  // we have an assertion on that condition.
  NS_ASSERT (m_supportedRatesStoreReadOnly->m_nRates > 8);

  // The number of rates we have beyond the initial 8 is the size of
  // the information field.
  return (m_supportedRatesStoreReadOnly->m_nRates - 8);
}

void
ExtendedSupportedRatesIE::SerializeInformationField (Buffer::Iterator start) const
{
  // Confirm that we have a pointer to a SupportedRates object. We're
  // happy to treat it as const in this method.
  NS_ASSERT (m_supportedRatesStoreReadOnly);
  // If there are 8 or fewer rates then there should be no Extended
  // Supported Rates Information Element at all so being here would
  // seemingly indicate a programming error.

  // Our overridden version of the Serialize() method should ensure
  // that this routine is never invoked in that case (by ensuring that
  // WifiInformationElement::Serialize() is not invoked).
  NS_ASSERT (m_supportedRatesStoreReadOnly->m_nRates > 8);
  start.Write (m_supportedRatesStoreReadOnly->m_rates + 8,
               m_supportedRatesStoreReadOnly->m_nRates - 8);
}

Buffer::Iterator
ExtendedSupportedRatesIE::Serialize (Buffer::Iterator start) const
{
  // Confirm that we have a pointer to a SupportedRates object. We're
  // happy to treat it as const in this method.
  NS_ASSERT (m_supportedRatesStoreReadOnly);
  // If there are 8 or fewer rates then we don't need an Extended
  // Supported Rates IE, so we don't serialise anything.
  if (m_supportedRatesStoreReadOnly->m_nRates <= 8)
    {
      return start;
    }

uint16_t
ExtendedSupportedRatesIE::GetSerializedSize () const
{
  // Confirm that we have a pointer to a SupportedRates object. We're
  // happy to treat it as const in this method.
  NS_ASSERT (m_supportedRatesStoreReadOnly);
  // If there are 8 or fewer rates then we don't need an Extended
  // Supported Rates IE, so it's serialised length will be zero.
  if (m_supportedRatesStoreReadOnly->m_nRates <= 8)
    {
      return 0;
    }

ExtendedSupportedRatesIE::DeserializeInformationField (Buffer::Iterator start,
                                                       uint8_t length)
{
  // Confirm that we have a pointer to a SupportedRates object that we
  // can modify (as opposed to one we have to treat as const).
  NS_ASSERT (m_supportedRatesStore);
  NS_ASSERT (length > 0);
  NS_ASSERT (m_supportedRatesStore->m_nRates + length <= MAX_SUPPORTED_RATES);
  start.Read (m_supportedRatesStore->m_rates + m_supportedRatesStore->m_nRates,
              length);
  m_supportedRatesStore->m_nRates += length;
  return length;
}






#include <stdint.h>
#include <ostream>
#include "ns3/buffer.h"
#include "ns3/wifi-information-element.h"

namespace ns3 {

 */
#define MAX_SUPPORTED_RATES (12)

/**
 * \brief A storage class for supported rates
 * \ingroup wifi
 */
class SupportedRates
{
public:
  SupportedRates ();

  void AddSupportedRate (uint32_t bs);
  void SetBasicRate (uint32_t bs);

  bool IsSupportedRate (uint32_t bs) const;
  bool IsBasicRate (uint32_t bs) const;

  uint8_t GetNRates (void) const;
  uint32_t GetRate (uint8_t i) const;

  /*
   * The classes which serialise and deserialise Supported Rates and
   * Extended Supported Rates Information Elements need access to our
   * internals and thus need to be our friends
   */
  friend class SupportedRatesIE;
  friend class ExtendedSupportedRatesIE;
private:
  uint8_t m_nRates;
  uint8_t m_rates[MAX_SUPPORTED_RATES];
};

std::ostream &operator << (std::ostream &os, const SupportedRates &rates);

/**
 * \brief The Supported Rates Information Element
 * \ingroup wifi
 *
 * This class knows how to serialise and deserialise the Supported
 * Rates Element that holds the first 8 (non-HT) supported rates.
 *
 * The \c ExtendedSupportedRatesIE class deals with rates beyond the
 * first 8.
 */
class SupportedRatesIE : public WifiInformationElement
{
public:
  /**
   * This constructor is used when non-const access is available to
   * the SupportedRates object that stores the list of supported
   * rates. This is a requirement if a non-const method of this class
   * (e.g., Deserialize ()) is to be called.
   */
  SupportedRatesIE (SupportedRates *rates);
  /**
   * This constructor is used when the SupportedRates object that
   * stores the list of supported rates must be treated as const -
   * perhaps because the method that creates an instance of this class
   * only has const access to the SupportedRates object. This level of
   * access is sufficient (and appropriate) for determining the size
   * of the IE, and serialising it.
   */
  SupportedRatesIE (const SupportedRates *rates);

  WifiInformationElementId ElementId () const;
  uint8_t GetInformationFieldSize () const;
  void SerializeInformationField (Buffer::Iterator start) const;
  uint8_t DeserializeInformationField (Buffer::Iterator start,
                                       uint8_t length);

private:
  /**
   * Pointer to a supported rates store which this instance of this
   * class is allowed to modify (e.g., deserialise to). It is NULL if
   * no such privileges have been granted during object construction,
   * and if not NULL will point to the same object as \c
   * m_supportedRatesStoreReadOnly.
   */
  SupportedRates *m_supportedRatesStore;
  /**
   * Pointer to a supported rates store which this class is to treat
   * as read only (perhaps because the method that creates an instance
   * of this class is a const member of the class in which the
   * SupportedRates object is a member).
   */
  const SupportedRates *m_supportedRatesStoreReadOnly;
};


/**
 * \brief The Extended Supported Rates Information Element

 * This class knows how to serialise and deserialise the Extended
 * Supported Rates Element that holds (non-HT) rates beyond the 8 that
 * the original Supported Rates element can carry.
 *
 * The \c SupportedRates class still records all the rates, and an
 * instance of \c ExtendedSupportedRatesIE lies within \c
 * SupportedRates.
 */
class ExtendedSupportedRatesIE : public WifiInformationElement
{
public:
  /**
   * This constructor is used when non-const access is available to
   * the SupportedRates object that stores the list of supported
   * rates. This is a requirement if a non-const method of this class
   * (e.g., Deserialize ()) is to be called.
   */
  ExtendedSupportedRatesIE (SupportedRates *rates);
  /**
   * This constructor is used when the SupportedRates object that
   * stores the list of supported rates must be treated as const -
   * perhaps because the method that creates an instance of this class
   * only has const access to the SupportedRates object. This level of
   * access is sufficient (and appropriate) for determining the size
   * of the IE, and serialising it.
   */
  ExtendedSupportedRatesIE (const SupportedRates *rates);

  WifiInformationElementId ElementId () const;
  uint8_t GetInformationFieldSize () const;

   */
  Buffer::Iterator Serialize (Buffer::Iterator start) const;
  uint16_t GetSerializedSize () const;

private:
  /**
   * Pointer to a supported rates store which this instance of this
   * class is allowed to modify (e.g., deserialise to). It is NULL if
   * no such privileges have been granted during object construction,
   * and if not NULL will point to the same object as \c
   * m_supportedRatesStoreReadOnly.
   */
  SupportedRates *m_supportedRatesStore;
  /**
   * Pointer to a supported rates store which this class is to treat
   * as read only (perhaps because the method that creates an instance
   * of this class is a const member of the class in which the
   * SupportedRates object is a member).
   */
  const SupportedRates *m_supportedRatesStoreReadOnly;
};


/**
 * \brief The Supported Rates Information Element
 * \ingroup wifi
 *
 * This class knows how to serialise and deserialise the Supported
 * Rates Element that holds the first 8 (non-HT) supported rates.
 *
 * The \c ExtendedSupportedRatesIE class (of which an instance exists
 * in objects of this class) deals with rates beyond the first 8.
 */
class SupportedRates : public WifiInformationElement
{
public:
  SupportedRates ();

  void AddSupportedRate (uint32_t bs);
  void SetBasicRate (uint32_t bs);

  bool IsSupportedRate (uint32_t bs) const;
  bool IsBasicRate (uint32_t bs) const;

  uint8_t GetNRates (void) const;
  uint32_t GetRate (uint8_t i) const;

  WifiInformationElementId ElementId () const;
  uint8_t GetInformationFieldSize () const;
  void SerializeInformationField (Buffer::Iterator start) const;
  uint8_t DeserializeInformationField (Buffer::Iterator start,
                                       uint8_t length);

  /*
   * We support the Extended Supported Rates Information Element
   * through the ExtendedSupportedRatesIE object which is declared
   * above. We allow this class to be a friend so that it can access
   * our private data detailing the rates, and create an instance as
   * extended.
   */
  friend class ExtendedSupportedRatesIE;
  ExtendedSupportedRatesIE extended;
private:
  uint8_t m_nRates;
  uint8_t m_rates[MAX_SUPPORTED_RATES];
};

std::ostream &operator << (std::ostream &os, const SupportedRates &rates);

} // namespace ns3

#endif /* SUPPORTED_RATES_H */

Return to bug 1084