Attachment #2113 for bug #1482

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

(-)a/src/mesh/model/dot11s/dot11s-mac-header.cc (-3 / +3 lines)

Lines 164-172	Link Here

164

void

164

void

165

MeshHeader::Print (std::ostream &os) const

165

MeshHeader::Print (std::ostream &os) const

166

167

  os << "flags = " << (uint16_t) m_meshFlags << std::endl << "ttl = " << (uint16_t) m_meshTtl

167

  os << "flags=" << (uint16_t) m_meshFlags << ", ttl=" << (uint16_t) m_meshTtl

168

     << std::endl << "seqno = " << m_meshSeqno << std::endl<< "addr4 = " << m_addr4 << std::endl

168

     << ", seqno=" << m_meshSeqno << ", addr4=" << m_addr4

169

     << "addr5 = " << m_addr5 << std::endl << "addr6 = " << m_addr6 << std::endl;

169

     << ", addr5=" << m_addr5 << ", addr6=" << m_addr6;

170

171

bool

171

bool

172

operator== (const MeshHeader & a, const MeshHeader & b)

172

operator== (const MeshHeader & a, const MeshHeader & b)




void
IeBeaconTiming::Print (std::ostream& os) const
{
  os << "BeaconTiming=(Number of units=" << (uint16_t) m_numOfUnits;
  os << "Number of units: " << (uint16_t) m_numOfUnits << std::endl;
  for (NeighboursTimingUnitsList::const_iterator j = m_neighbours.begin (); j != m_neighbours.end (); j++)
    {
      os << "(AID=" << (uint16_t)(*j)->GetAid () << ", Last beacon at=" << (*j)->GetLastBeacon ()
         << ", with beacon interval=" << (*j)->GetBeaconInterval () << ")";
    }
  os << ")";
}
void
IeBeaconTiming::SerializeInformationField (Buffer::Iterator i) const




void
IeConfiguration::Print (std::ostream& os) const
{
  os << "MeshConfiguration=(neighbors=" << (uint16_t) m_neighbors
     << ", Active Path Selection Protocol ID=" << (uint32_t) m_APSPId
     << ", Active Path Selection Metric ID=" << (uint32_t) m_APSMId
     << ", Congestion Control Mode ID=" << (uint32_t) m_CCMId
     << ", Synchronize protocol ID=" << (uint32_t) m_SPId
     << ", Authentication protocol ID=" << (uint32_t) m_APId
     << ", Capabilities=" << m_meshCap.GetUint8 ();
  os << ")";
  os << "</information_element>" << std::endl;
}
void
IeConfiguration::SetRouting (dot11sPathSelectionProtocol routingId)

(-)a/src/mesh/model/dot11s/ie-dot11s-id.cc (-3 / +1 lines)

Lines 115-123	Link Here

115

void

115

void

116

IeMeshId::Print (std::ostream& os) const

116

IeMeshId::Print (std::ostream& os) const

117

118

  os << std::endl << "<information_element id=" << ElementId () << ">" << std::endl;

118

  os << "MeshId=(meshId=" << PeekString () << ")";

119

  os << "meshId =  " << PeekString ();

120

  os << "</information_element>" << std::endl;

121

119

122

bool

120

bool

123

operator== (const IeMeshId & a, const IeMeshId & b)

121

operator== (const IeMeshId & a, const IeMeshId & b)

(-)a/src/mesh/model/dot11s/ie-dot11s-metric-report.cc (-3 / +1 lines)

Lines 66-74	Link Here

void

void

IeLinkMetricReport::Print (std::ostream& os) const

IeLinkMetricReport::Print (std::ostream& os) const

  os << std::endl << "<information_element id=" << ElementId () << ">" << std::endl;

  os << "Metric=" << m_metric;

  os << "Metric = " << m_metric;

  os << "</information_element>" << std::endl;

bool

bool

operator== (const IeLinkMetricReport & a, const IeLinkMetricReport & b)

operator== (const IeLinkMetricReport & a, const IeLinkMetricReport & b)




void
IePeerManagement::Print (std::ostream& os) const
{
  os << "PeerMgmt=(Subtype=" << (uint16_t) m_subtype
     << ", Length=" << (uint16_t) m_length
     << ", LocalLinkId=" << m_localLinkId
     << ", PeerLinkId=" << m_peerLinkId
     << ", ReasonCode=" << m_reasonCode
     << ")";
  os << "</information_element>" << std::endl;
}
bool
operator== (const IePeerManagement & a, const IePeerManagement & b)

(-)a/src/mesh/model/dot11s/ie-dot11s-peering-protocol.cc (-3 / +1 lines)

Lines 50-58	Link Here

void

void

IePeeringProtocol::Print (std::ostream& os) const

IePeeringProtocol::Print (std::ostream& os) const

  os << std::endl << "<information_element id=" << ElementId () << ">" << std::endl;

  os << "PeeringProtocol=(peering protocol=" << m_protocol << ")";

  os << "peering protocol = " << m_protocol;

  os << "</information_element>" << std::endl;

std::ostream &

std::ostream &

operator << (std::ostream &os, const IePeeringProtocol &a)

operator << (std::ostream &os, const IePeeringProtocol &a)




void
IePerr::Print (std::ostream &os) const
{
  os << "PERR=(Number of failed destinations=" << m_addressUnits.size ();
  os << "Number of failed destinations: = " << m_addressUnits.size ();
  for (unsigned int j = 0; j < m_addressUnits.size (); j++)
    {
      os << "(Failed destination address=" << m_addressUnits[j].destination << ", sequence number = "
         << m_addressUnits[j].seqnum << ")";
    }
  os << ")";
}
uint8_t
IePerr::GetNumOfDest () const




void
IePrep::Print (std::ostream& os) const
{
  os << "PREP=(Flags=" << m_flags << ", Hopcount=" << m_hopcount << ", TTL=" << m_ttl
     << ",Destination=" << m_destinationAddress << ", Dest. seqnum=" << m_destSeqNumber
     << ", Lifetime=" << m_lifetime << ", Metric=" << m_metric << ", Originator="
     << m_originatorAddress << ", Orig. seqnum=" << m_originatorSeqNumber << ")";
     << m_originatorAddress << std::endl << "Orig. seqnum: = " << m_originatorSeqNumber << std::endl;
  os << "</information_element>" << std::endl;
}
bool
operator== (const IePrep & a, const IePrep & b)




void
IePreq::Print (std::ostream &os) const
{
  os << "PREQ=(originator address  = " << m_originatorAddress
     << ", TTL                 = " << (uint16_t) m_ttl
     << ", hop count           = " << (uint16_t) m_hopCount
     << ", metric              = " << m_metric
     << ", seqno               = " << m_originatorSeqNumber
     << ", lifetime            = " << m_lifetime
     << ", preq ID             = " << m_preqId
     << ", Destinations=(";
  os << " Destinations are:" << std::endl;
  for (int j = 0; j < m_destCount; j++)
    {
      os << m_destinations[j]->GetDestinationAddress ();
    }
  os << ")";
}
std::vector<Ptr<DestinationAddressUnit> >
IePreq::GetDestinationList ()




void
IeRann::Print (std::ostream &os) const
{
  os << "RANN=(flags=" << (int) m_flags
     << ", hop count=" << (int) m_hopcount
     << ", TTL=" << (int) m_ttl
     << ", originator address=" << m_originatorAddress
     << ", dst seq. number=" << m_destSeqNumber
     << ", metric=" << m_metric
     << ")";
  os << "</information_element>" << std::endl;
}

bool




NS_OBJECT_ENSURE_REGISTERED (PeerLinkOpenStart);

PeerLinkOpenStart::PeerLinkOpenStart () :
  m_capability (0), m_rates (SupportedRates ()), m_meshId (),
  m_config (IeConfiguration ())
{
}
void
PeerLinkOpenStart::SetPlinkOpenStart (PeerLinkOpenStart::PlinkOpenStartFields fields)
{
  m_capability = fields.capability;
  m_rates = fields.rates;
  m_meshId = fields.meshId;
  m_config = fields.config;
      m_capability = fields.capability;
    }
  if (m_subtype == (uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM))
    {
      m_aid = fields.aid;
    }
  if (m_subtype != (uint8_t)(WifiActionHeader::PEER_LINK_CLOSE))
    {
      m_rates = fields.rates;
    }
  if (m_subtype != (uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM))
    {
      m_meshId = fields.meshId;
    }
  if (m_subtype != (uint8_t)(WifiActionHeader::PEER_LINK_CLOSE))
    {
      m_config = fields.config;
    }
  else
    {
      //reasonCode not used here
    }
}
PeerLinkOpenStart::PlinkOpenStartFields
PeerLinkOpenStart::GetFields () const
{
  PlinkOpenStartFields retval;
  /// \todo protocol version:
  retval.subtype = m_subtype;
  retval.capability = m_capability;
  retval.aid = m_aid;
  retval.rates = m_rates;
  retval.meshId = m_meshId;
  retval.config = m_config;

void
PeerLinkOpenStart::Print (std::ostream &os) const
{
  os << "capability=" << m_capability << ", rates=" << m_rates;
  os << ", ";
  m_meshId.Print (os);
  os << ", ";
  m_config.Print (os);
  os << std::endl << "reason code = " << m_reasonCode;
}
uint32_t
PeerLinkOpenStart::GetSerializedSize () const
{
  uint32_t size =0; //Peering protocol
  size += 2; //capability
  size += m_rates.GetSerializedSize ();
  size += m_rates.extended.GetSerializedSize ();
  size += m_meshId.GetInformationFieldSize () + 2;
  size += m_config.GetInformationFieldSize () + 2;
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) == m_subtype)
    {
      size += 2; //AID of remote peer
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      size += m_rates.GetSerializedSize ();
      size += m_rates.extended.GetSerializedSize ();
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)
    {
      size += m_meshId.GetInformationFieldSize () + 2;
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      size += m_config.GetInformationFieldSize () + 2;
    }
  else
    {
      //reasonCode not used here
    }
  return size;
}
void
PeerLinkOpenStart::Serialize (Buffer::Iterator start) const
{
  Buffer::Iterator i = start;
  NS_ASSERT (m_subtype < 4);
  
  i.WriteHtolsbU16 (m_capability);
  i = m_rates.Serialize (i);
  i = m_rates.extended.Serialize (i);
  i = m_meshId.Serialize (i);
  i = m_config.Serialize (i);
    {
      i.WriteHtolsbU16 (m_aid);
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      i = m_rates.Serialize (i);
      i = m_rates.extended.Serialize (i);
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)
    {
      i = m_meshId.Serialize (i);
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      i = m_config.Serialize (i);
    }
  else
    {
      //reasonCode not used here
    }
}
uint32_t
PeerLinkOpenStart::Deserialize (Buffer::Iterator start)
{
  Buffer::Iterator i = start;
  NS_ASSERT (m_subtype < 4);
  
  m_capability = i.ReadLsbtohU16 ();
  i = m_rates.Deserialize (i);
  i = m_rates.extended.DeserializeIfPresent (i);
  uint8_t id = i.ReadU8 ();
  uint8_t length = i.ReadU8 ();
  m_meshId.DeserializeInformationField (i, length);
  if ((m_meshId.ElementId () != (WifiInformationElementId) id) || (m_meshId.GetInformationFieldSize () != length))
    {
      NS_FATAL_ERROR ("Broken frame: Element ID does not match IE itself!");
    }
  i.Next (m_meshId.GetInformationFieldSize ());
  id = i.ReadU8 ();
  length = i.ReadU8 ();
  m_config.DeserializeInformationField (i, length);
  if ((m_config.ElementId () != (WifiInformationElementId) id) || (m_config.GetInformationFieldSize () != length))
    {
      NS_FATAL_ERROR ("Broken frame: Element ID does not match IE itself!");
    }
  i.Next (m_config.GetInformationFieldSize ());
 
      i = m_rates.Deserialize (i);
      i = m_rates.extended.DeserializeIfPresent (i);
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)
    {
      uint8_t id = i.ReadU8 ();
      uint8_t length = i.ReadU8 ();
      m_meshId.DeserializeInformationField (i, length);
      if ((m_meshId.ElementId () != (WifiInformationElementId) id) || (m_meshId.GetInformationFieldSize () != length))
        {
          NS_FATAL_ERROR ("Broken frame: Element ID does not match IE itself!");
        }
      i.Next (m_meshId.GetInformationFieldSize ());
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      uint8_t id = i.ReadU8 ();
      uint8_t length = i.ReadU8 ();
      m_config.DeserializeInformationField (i, length);
      if ((m_config.ElementId () != (WifiInformationElementId) id) || (m_config.GetInformationFieldSize () != length))
        {
          NS_FATAL_ERROR ("Broken frame: Element ID does not match IE itself!");
        }
      i.Next (m_config.GetInformationFieldSize ());
    }
  else
    {
       //reasonCode not used here
    }
  return i.GetDistanceFrom (start);
}
bool
operator== (const PeerLinkOpenStart & a, const PeerLinkOpenStart & b)
{
  return ((a.m_capability == b.m_capability)
          && (a.m_meshId.IsEqual (b.m_meshId)) && (a.m_config == b.m_config));
  
}
NS_OBJECT_ENSURE_REGISTERED (PeerLinkCloseStart);

PeerLinkCloseStart::PeerLinkCloseStart () :
  m_meshId ()
  m_config (IeConfiguration ())
{
}
void
PeerLinkCloseStart::SetPlinkCloseStart (PeerLinkCloseStart::PlinkCloseStartFields fields)
{
  m_meshId = fields.meshId;
  
  if (m_subtype != (uint8_t)(WifiActionHeader::PEER_LINK_CLOSE))
    {
      m_capability = fields.capability;
    }
  if (m_subtype == (uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM))
    {
      m_aid = fields.aid;
    }
  if (m_subtype != (uint8_t)(WifiActionHeader::PEER_LINK_CLOSE))
    {
      m_rates = fields.rates;
    }
  if (m_subtype != (uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM))
    {
      m_meshId = fields.meshId;
    }
  if (m_subtype != (uint8_t)(WifiActionHeader::PEER_LINK_CLOSE))
    {
      m_config = fields.config;
    }
  else
    {
      //reasonCode not used here
    }
}
PeerLinkCloseStart::PlinkCloseStartFields
PeerLinkCloseStart::GetFields () const
{
  PlinkCloseStartFields retval;
  /// \todo protocol version:
  retval.subtype = m_subtype;
  retval.capability = m_capability;
  retval.aid = m_aid;
  retval.rates = m_rates;
  retval.meshId = m_meshId;
  retval.config = m_config;
  
  return retval;
}

void
PeerLinkCloseStart::Print (std::ostream &os) const
{
  os << "subtype = " << (uint16_t) m_subtype << std::endl << "capability = " << m_capability << std::endl << "laid = "
     << (uint16_t) m_aid << std::endl << "rates = " << m_rates << std::endl << "meshId = ";
  m_meshId.Print (os);
  os << std::endl << "configuration = ";
  m_config.Print (os);
  os << std::endl << "reason code = " << m_reasonCode;
}
uint32_t
PeerLinkCloseStart::GetSerializedSize () const
{
  uint32_t size =0; //Peering protocol
  size += m_meshId.GetInformationFieldSize () + 2;
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      size += 2; //capability
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) == m_subtype)
    {
      size += 2; //AID of remote peer
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      size += m_rates.GetSerializedSize ();
      size += m_rates.extended.GetSerializedSize ();
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)
    {
      size += m_meshId.GetInformationFieldSize () + 2;
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      size += m_config.GetInformationFieldSize () + 2;
    }
  else
    {
      //reasonCode not used here
    }
  return size;
}
void
PeerLinkCloseStart::Serialize (Buffer::Iterator start) const
{
  Buffer::Iterator i = start;
  i = m_meshId.Serialize (i);
  
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      i.WriteHtolsbU16 (m_capability);
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) == m_subtype)
    {
      i.WriteHtolsbU16 (m_aid);
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      i = m_rates.Serialize (i);
      i = m_rates.extended.Serialize (i);
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)
    {
      i = m_meshId.Serialize (i);
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      i = m_config.Serialize (i);
    }
  else
    {
      //reasonCode not used here
    }
}
uint32_t
PeerLinkCloseStart::Deserialize (Buffer::Iterator start)
{
  Buffer::Iterator i = start;
  NS_ASSERT (m_subtype < 4);
  
  uint8_t id = i.ReadU8 ();
  uint8_t length = i.ReadU8 ();
  m_meshId.DeserializeInformationField (i, length);
  if ((m_meshId.ElementId () != (WifiInformationElementId) id) || (m_meshId.GetInformationFieldSize () != length))
    {
      NS_FATAL_ERROR ("Broken frame: Element ID does not match IE itself!");
    }
  i.Next (m_meshId.GetInformationFieldSize ());
    {
      m_aid = i.ReadLsbtohU16 ();
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      i = m_rates.Deserialize (i);
      i = m_rates.extended.DeserializeIfPresent (i);
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)
    {
      uint8_t id = i.ReadU8 ();
      uint8_t length = i.ReadU8 ();
      m_meshId.DeserializeInformationField (i, length);
      if ((m_meshId.ElementId () != (WifiInformationElementId) id) || (m_meshId.GetInformationFieldSize () != length))
        {
          NS_FATAL_ERROR ("Broken frame: Element ID does not match IE itself!");
        }
      i.Next (m_meshId.GetInformationFieldSize ());
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      uint8_t id = i.ReadU8 ();
      uint8_t length = i.ReadU8 ();
      m_config.DeserializeInformationField (i, length);
      if ((m_config.ElementId () != (WifiInformationElementId) id) || (m_config.GetInformationFieldSize () != length))
        {
          NS_FATAL_ERROR ("Broken frame: Element ID does not match IE itself!");
        }
      i.Next (m_config.GetInformationFieldSize ());
    }
  else
    {
       //reasonCode not used here
    }
  return i.GetDistanceFrom (start);
}
bool
operator== (const PeerLinkCloseStart & a, const PeerLinkCloseStart & b)
{
  return ((a.m_meshId.IsEqual (b.m_meshId)));
          && (a.m_meshId.IsEqual (b.m_meshId)) && (a.m_config == b.m_config));
  
}
NS_OBJECT_ENSURE_REGISTERED (PeerLinkConfirmStart);

PeerLinkConfirmStart::PeerLinkConfirmStart () :
  m_capability (0), m_aid (0), m_rates (SupportedRates ()),
  m_config (IeConfiguration ())
{
}
void
PeerLinkConfirmStart::SetPlinkConfirmStart (PeerLinkConfirmStart::PlinkConfirmStartFields fields)
{
  m_capability = fields.capability;
  m_aid = fields.aid;
  m_rates = fields.rates;
  m_config = fields.config;
      m_capability = fields.capability;
    }
  if (m_subtype == (uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM))
    {
      m_aid = fields.aid;
    }
  if (m_subtype != (uint8_t)(WifiActionHeader::PEER_LINK_CLOSE))
    {
      m_rates = fields.rates;
    }
  if (m_subtype != (uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM))
    {
      m_meshId = fields.meshId;
    }
  if (m_subtype != (uint8_t)(WifiActionHeader::PEER_LINK_CLOSE))
    {
      m_config = fields.config;
    }
  else
    {
      //reasonCode not used here
    }
}
PeerLinkConfirmStart::PlinkConfirmStartFields
PeerLinkConfirmStart::GetFields () const
{
  PlinkConfirmStartFields retval;
  /// \todo protocol version:
  retval.subtype = m_subtype;
  retval.capability = m_capability;
  retval.aid = m_aid;
  retval.rates = m_rates;
  retval.meshId = m_meshId;
  retval.config = m_config;
  
  return retval;

void
PeerLinkConfirmStart::Print (std::ostream &os) const
{
  os << "capability=" << m_capability << ", rates=" << m_rates;
  os << ", ";
  m_meshId.Print (os);
  os << std::endl << "configuration = ";
  m_config.Print (os);
  os << std::endl << "reason code = " << m_reasonCode;
}
uint32_t
PeerLinkConfirmStart::GetSerializedSize () const
{
  uint32_t size =0; //Peering protocol
  size += 2; //capability
  size += 2; //AID of remote peer
  size += m_rates.GetSerializedSize ();
  size += m_rates.extended.GetSerializedSize ();
  size += m_config.GetInformationFieldSize () + 2;
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) == m_subtype)
    {
      size += 2; //AID of remote peer
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      size += m_rates.GetSerializedSize ();
      size += m_rates.extended.GetSerializedSize ();
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)
    {
      size += m_meshId.GetInformationFieldSize () + 2;
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      size += m_config.GetInformationFieldSize () + 2;
    }
  else
    {
      //reasonCode not used here
    }
  return size;
}
void
PeerLinkConfirmStart::Serialize (Buffer::Iterator start) const
{
  Buffer::Iterator i = start;
  NS_ASSERT (m_subtype < 4);
  
  i.WriteHtolsbU16 (m_capability);
  i.WriteHtolsbU16 (m_aid);
  i = m_rates.Serialize (i);
  i = m_rates.extended.Serialize (i);
  i = m_config.Serialize (i);
    {
      i.WriteHtolsbU16 (m_aid);
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      i = m_rates.Serialize (i);
      i = m_rates.extended.Serialize (i);
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)
    {
      i = m_meshId.Serialize (i);
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      i = m_config.Serialize (i);
    }
  else
    {
      //reasonCode not used here
    }
}
uint32_t
PeerLinkConfirmStart::Deserialize (Buffer::Iterator start)
{
  Buffer::Iterator i = start;
  NS_ASSERT (m_subtype < 4);
  
  m_capability = i.ReadLsbtohU16 ();
  m_aid = i.ReadLsbtohU16 ();
  i = m_rates.Deserialize (i);
  i = m_rates.extended.DeserializeIfPresent (i);
  uint8_t id = i.ReadU8 ();
  uint8_t length = i.ReadU8 ();
  m_config.DeserializeInformationField (i, length);
  if ((m_config.ElementId () != (WifiInformationElementId) id) || (m_config.GetInformationFieldSize () != length))
    {
      NS_FATAL_ERROR ("Broken frame: Element ID does not match IE itself!");
    }
  i.Next (m_config.GetInformationFieldSize ());
    {
      m_aid = i.ReadLsbtohU16 ();
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      i = m_rates.Deserialize (i);
      i = m_rates.extended.DeserializeIfPresent (i);
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)
    {
      uint8_t id = i.ReadU8 ();
      uint8_t length = i.ReadU8 ();
      m_meshId.DeserializeInformationField (i, length);
      if ((m_meshId.ElementId () != (WifiInformationElementId) id) || (m_meshId.GetInformationFieldSize () != length))
        {
          NS_FATAL_ERROR ("Broken frame: Element ID does not match IE itself!");
        }
      i.Next (m_meshId.GetInformationFieldSize ());
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      uint8_t id = i.ReadU8 ();
      uint8_t length = i.ReadU8 ();
      m_config.DeserializeInformationField (i, length);
      if ((m_config.ElementId () != (WifiInformationElementId) id) || (m_config.GetInformationFieldSize () != length))
        {
          NS_FATAL_ERROR ("Broken frame: Element ID does not match IE itself!");
        }
      i.Next (m_config.GetInformationFieldSize ());
    }
  else
    {
       //reasonCode not used here
    }
  return i.GetDistanceFrom (start);
}
bool
operator== (const PeerLinkConfirmStart & a, const PeerLinkConfirmStart & b)
{
  return ((a.m_capability == b.m_capability) && (a.m_aid == b.m_aid)
          && (a.m_config == b.m_config));
  
}
} // namespace dot11s
} // namespace ns3




 *
 * \brief 802.11s Peer link open management frame
 * 
 * Peer link opent frame includes the following:
 * - Capability
 * - Association ID field
 * - Supported rates
 * - Mesh ID of mesh
 * - Configuration
 */
class PeerLinkOpenStart : public Header
{

  ///\brief fields:
  struct PlinkOpenStartFields
  {
    IePeeringProtocol protocol; //Peering protocol version - 3 octets
    IePeeringProtocol protocol; //Peering protocol version - in all subtypes - 3 octets
    uint16_t capability;        //open and confirm
    uint16_t aid;               //confirm only
    SupportedRates rates;       //open and confirm
    IeMeshId meshId;            //open and close
    IeConfiguration config;     //open and confirm
    uint16_t reasonCode;        //close only
  };
  void SetPlinkOpenStart (PlinkOpenStartFields);
  PlinkOpenStartFields GetFields () const;

  virtual uint32_t Deserialize (Buffer::Iterator start);

private:
  uint8_t m_subtype;
  IePeeringProtocol m_protocol;
  uint16_t m_capability;
  uint16_t m_aid;
  SupportedRates m_rates;
  IeMeshId m_meshId;
  IeConfiguration m_config;
  uint16_t m_reasonCode;

  friend bool operator== (const PeerLinkOpenStart & a, const PeerLinkOpenStart & b);


 *
 * \brief 802.11s Peer link close management frame
 * 
 * Peer link close frame includes the following:
 * - Subtype field
 * - Association ID field
 * - Supported rates
 * - Mesh ID of mesh
 */
class PeerLinkCloseStart : public Header

  ///\brief fields:
  struct PlinkCloseStartFields
  {
    IePeeringProtocol protocol; //Peering protocol version - 3 octets
    IePeeringProtocol protocol; //Peering protocol version - in all subtypes - 3 octets
    uint16_t capability;        //open and confirm
    uint16_t aid;               //confirm only
    SupportedRates rates;       //open and confirm
    IeMeshId meshId;            //open and close
    IeConfiguration config;     //open and confirm
    uint16_t reasonCode;        //close only
  };
  void SetPlinkCloseStart (PlinkCloseStartFields);
  PlinkCloseStartFields GetFields () const;

  virtual uint32_t Deserialize (Buffer::Iterator start);

private:
  uint8_t m_subtype;
  IePeeringProtocol m_protocol;
  uint16_t m_capability;
  uint16_t m_aid;
  SupportedRates m_rates;
  IeMeshId m_meshId;
  IeConfiguration m_config;
  uint16_t m_reasonCode;

  friend bool operator== (const PeerLinkCloseStart & a, const PeerLinkCloseStart & b);


 *
 * \brief 802.11s Peer link confirm management frame
 * 
 * Peer link confirm frame includes the following:
 * - Subtype field
 * - Association ID field
 * - Supported rates
 * - Configuration
 */
class PeerLinkConfirmStart : public Header
{

  ///\brief fields:
  struct PlinkConfirmStartFields
  {
    IePeeringProtocol protocol; //Peering protocol version - 3 octets
    IePeeringProtocol protocol; //Peering protocol version - in all subtypes - 3 octets
    uint16_t capability;        //open and confirm
    uint16_t aid;               //confirm only
    SupportedRates rates;       //open and confirm
    IeMeshId meshId;            //open and close
    IeConfiguration config;     //open and confirm
    uint16_t reasonCode;        //close only
  };
  void SetPlinkConfirmStart (PlinkConfirmStartFields);
  PlinkConfirmStartFields GetFields () const;

  virtual uint32_t Deserialize (Buffer::Iterator start);

private:
  uint8_t m_subtype;
  IePeeringProtocol m_protocol;
  uint16_t m_capability;
  uint16_t m_aid;
  SupportedRates m_rates;
  IeMeshId m_meshId;
  IeConfiguration m_config;
  uint16_t m_reasonCode;

  friend bool operator== (const PeerLinkConfirmStart & a, const PeerLinkConfirmStart & b);





          PeerLinkOpenStart peerFrame;
          packet->RemoveHeader (peerFrame);
          fields = peerFrame.GetFields ();
          NS_ASSERT (fields.subtype == actionValue.selfProtectedAction); 
          if (!fields.meshId.IsEqual ( *(m_protocol->GetMeshId ())))
            {
              m_protocol->ConfigurationMismatch (m_ifIndex, peerAddress);

              m_stats.brokenMgt++;
              return false;
            }
          aid = fields.aid;
          config = fields.config;
        }
      else if (actionValue.selfProtectedAction == WifiActionHeader::PEER_LINK_CONFIRM)

          PeerLinkConfirmStart peerFrame;
          packet->RemoveHeader (peerFrame);
          fields = peerFrame.GetFields ();
          NS_ASSERT (fields.subtype == actionValue.selfProtectedAction); 
          if (!(m_parent->CheckSupportedRates (fields.rates)))
            {
              m_protocol->ConfigurationMismatch (m_ifIndex, peerAddress);

          PeerLinkCloseStart peerFrame;
          packet->RemoveHeader (peerFrame);
          fields = peerFrame.GetFields ();
          NS_ASSERT (fields.subtype == actionValue.selfProtectedAction); 
          if (!fields.meshId.IsEqual ( *(m_protocol->GetMeshId ())))
            {
              m_protocol->ConfigurationMismatch (m_ifIndex, peerAddress);

              m_stats.brokenMgt++;
              return false;
            }
          aid = fields.aid;
          config = fields.config;
        }
      else
        {
          NS_FATAL_ERROR ("Unknown Self-protected Action type: " << actionValue.selfProtectedAction);
        }
      Ptr<IePeerManagement> peerElement;
      //Peer Management element is the last element in this frame - so, we can use MeshInformationElementVector

      peerElement = DynamicCast<IePeerManagement>(elements.FindFirst (IE11S_PEERING_MANAGEMENT));

      NS_ASSERT (peerElement != 0);
      //Check that frame subtype corresponds to peer link subtype
      if (peerElement->SubtypeIsOpen ())
        {
          m_stats.rxOpen++;
          NS_ASSERT (actionValue.selfProtectedAction == WifiActionHeader::PEER_LINK_OPEN);
        }
      if (peerElement->SubtypeIsConfirm ())
        {
          m_stats.rxConfirm++;
          NS_ASSERT (actionValue.selfProtectedAction == WifiActionHeader::PEER_LINK_CONFIRM); 
        }
      if (peerElement->SubtypeIsClose ())
        {
          m_stats.rxClose++;
          NS_ASSERT (actionValue.selfProtectedAction == WifiActionHeader::PEER_LINK_CLOSE); 
        }
      //Deliver Peer link management frame to protocol:
      m_protocol->ReceivePeerLinkFrame (m_ifIndex, peerAddress, peerMpAddress, aid, *peerElement, config);

      m_stats.txOpen++;
      WifiActionHeader::ActionValue action;
      action.selfProtectedAction = WifiActionHeader::PEER_LINK_OPEN;
      fields.subtype = WifiActionHeader::PEER_LINK_OPEN;
      actionHdr.SetAction (WifiActionHeader::SELF_PROTECTED, action); 
      plinkOpen.SetPlinkOpenStart (fields);
      packet->AddHeader (plinkOpen);

      PeerLinkConfirmStart::PlinkConfirmStartFields fields;
      fields.rates = m_parent->GetSupportedRates ();
      fields.capability = 0;
      fields.meshId = *(m_protocol->GetMeshId ());
      fields.config = meshConfig;
      PeerLinkConfirmStart plinkConfirm;
      WifiActionHeader actionHdr;

      WifiActionHeader::ActionValue action;
      action.selfProtectedAction = WifiActionHeader::PEER_LINK_CONFIRM; 
      fields.aid = aid;
      fields.subtype = WifiActionHeader::PEER_LINK_CONFIRM;
      actionHdr.SetAction (WifiActionHeader::SELF_PROTECTED, action); 
      plinkConfirm.SetPlinkConfirmStart (fields);
      packet->AddHeader (plinkConfirm);

  if (peerElement.SubtypeIsClose ())
    {
      PeerLinkCloseStart::PlinkCloseStartFields fields;
      fields.rates = m_parent->GetSupportedRates ();
      fields.capability = 0;
      fields.meshId = *(m_protocol->GetMeshId ());
      fields.config = meshConfig;
      PeerLinkCloseStart plinkClose;
      WifiActionHeader actionHdr;
      m_stats.txClose++;
      WifiActionHeader::ActionValue action;
      action.selfProtectedAction = WifiActionHeader::PEER_LINK_CLOSE; 
      fields.subtype = WifiActionHeader::PEER_LINK_CLOSE;
      fields.reasonCode = peerElement.GetReasonCode ();
      actionHdr.SetAction (WifiActionHeader::SELF_PROTECTED, action); 
      plinkClose.SetPlinkCloseStart (fields);
      packet->AddHeader (plinkClose);

(-)a/src/mesh/model/flame/flame-header.cc (-2 / +2 lines)

Lines 52-59	Link Here

void

void

FlameHeader::Print (std::ostream &os) const

FlameHeader::Print (std::ostream &os) const

  os << "Cost             = " << (uint16_t) m_cost << std::endl << "Sequence number  = " << m_seqno

  os << "Cost= " << (uint16_t) m_cost << ", Sequence number= " << m_seqno

     << std::endl << "Orig Destination = " << m_origDst << std::endl << "Orig Source      = " << m_origSrc << std::endl;

     << ", Orig Destination= " << m_origDst << ", Orig Source= " << m_origSrc;

uint32_t

uint32_t

FlameHeader::GetSerializedSize (void) const

FlameHeader::GetSerializedSize (void) const




  {
    PeerLinkOpenStart a;
    PeerLinkOpenStart::PlinkOpenStartFields fields;
    fields.subtype = (uint8_t)(WifiActionHeader::PEER_LINK_OPEN);
    fields.capability = 0;
    fields.aid = 101;
    fields.reasonCode = 12;
    fields.meshId = IeMeshId ("qwertyuiop");
    a.SetPlinkOpenStart (fields);
    Ptr<Packet> packet = Create<Packet> ();

  {
    PeerLinkConfirmStart a;
    PeerLinkConfirmStart::PlinkConfirmStartFields fields;
    fields.subtype = (uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM);
    fields.capability = 0;
    fields.aid = 1234;
    fields.reasonCode = 12;
    fields.meshId = IeMeshId ("qwerty");
    a.SetPlinkConfirmStart (fields);
    Ptr<Packet> packet = Create<Packet> ();
    packet->AddHeader (a);

  {
    PeerLinkCloseStart a;
    PeerLinkCloseStart::PlinkCloseStartFields fields;
    fields.subtype = (uint8_t)(WifiActionHeader::PEER_LINK_CLOSE);
    fields.capability = 0;
    fields.aid = 10;
    fields.meshId = IeMeshId ("qqq");
    fields.reasonCode = 12;
    a.SetPlinkCloseStart (fields);
    Ptr<Packet> packet = Create<Packet> ();
    packet->AddHeader (a);




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

#include <sstream>
#include "mgt-headers.h"
#include "ns3/simulator.h"
#include "ns3/assert.h"

  return GetTypeId ();
}

std::string
WifiActionHeader::CategoryValueToString (CategoryValue value) const
{
  if (value == BLOCK_ACK)
    {
      return "BlockAck"; 
    }
  else if (value == MESH)
    {  
      return "Mesh";
    }
  else if (value == SELF_PROTECTED)
    {
      return "SelfProtected";
    }
  else if (value == VENDOR_SPECIFIC_ACTION)
    {
      return "VendorSpecificAction";
    }
  else
    {
      std::ostringstream convert;
      convert << value;
      return convert.str ();
    }
}
std::string
WifiActionHeader::SelfProtectedActionValueToString (SelfProtectedActionValue value) const
{
  if (value == PEER_LINK_OPEN)
    {
      return "PeerLinkOpen";
    }
  else if (value == PEER_LINK_CONFIRM)
    {
      return "PeerLinkConfirm";
    }
  else if (value == PEER_LINK_CLOSE)
    {
      return "PeerLinkClose";
    }
  else if (value == GROUP_KEY_INFORM)
    {
      return "GroupKeyInform";
    }
  else if (value == GROUP_KEY_ACK)
    {
      return "GroupKeyAck";
    }
  else
    {
      std::ostringstream convert;
      convert << value;
      return convert.str ();
    }
}

void
WifiActionHeader::Print (std::ostream &os) const
{
  os << "category=" << CategoryValueToString ((CategoryValue) m_category) 
     << ", value=" << SelfProtectedActionValueToString ((SelfProtectedActionValue) m_actionValue);
}

uint32_t

(-)a/src/wifi/model/mgt-headers.h (+2 lines)

Lines 473-478	Link Here

473

474

475

private:

475

private:

476

  std::string CategoryValueToString (CategoryValue value) const;

477

  std::string SelfProtectedActionValueToString (SelfProtectedActionValue value) const;

476

  uint8_t m_category; //!< Category of the action

478

  uint8_t m_category; //!< Category of the action

477

  uint8_t m_actionValue; //!< Action value

479

  uint8_t m_actionValue; //!< Action value

478

};

480

};

(-)a/src/wifi/model/wifi-information-element-vector.cc (-1 / +6 lines)

Lines 115-121	Link Here

115

void

115

void

116

WifiInformationElementVector::Print (std::ostream & os) const

116

WifiInformationElementVector::Print (std::ostream & os) const

117

118

  /// \todo

118

  for (IE_VECTOR::const_iterator i = m_elements.begin (); i != m_elements.end (); i++)

119

120

       os << "(";

121

      (*i)->Print (os);

122

       os << ")";

123

119

124

120

125

121

void

126

void




    case WIFI_MAC_MGT_ACTION_NO_ACK:
      PrintFrameControl (os);
      os << " Duration/ID=" << m_duration << "us"
         << ", DA=" << m_addr1 << ", SA=" << m_addr2 << ", BSSID=" << m_addr3
         << ", FragNumber=" << std::hex << (int) m_seqFrag << std::dec << ", SeqNumber=" << m_seqSeq;
      break;
    case WIFI_MAC_MGT_MULTIHOP_ACTION:
      os << " Duration/ID=" << m_duration << "us"
         << ", RA=" << m_addr1 << ", TA=" << m_addr2 << ", DA=" << m_addr3
         << ", FragNumber=" << std::hex << (int) m_seqFrag << std::dec << ", SeqNumber=" << m_seqSeq;
      break;
    case WIFI_MAC_DATA:

      os << " Duration/ID=" << m_duration << "us";
      if (!m_ctrlToDs && !m_ctrlFromDs)
        {
          os << ", DA=" << m_addr1 << ", SA=" << m_addr2 << ", BSSID=" << m_addr3;
        }
      else if (!m_ctrlToDs && m_ctrlFromDs)
        {
          os << ", DA=" << m_addr1 << ", SA=" << m_addr3 << ", BSSID=" << m_addr2;
        }
      else if (m_ctrlToDs && !m_ctrlFromDs)
        {
          os << ", DA=" << m_addr3 << ", SA=" << m_addr2 << ", BSSID=" << m_addr1;
        }
      else if (m_ctrlToDs && m_ctrlFromDs)
        {
          os << ", DA=" << m_addr3 << ", SA=" << m_addr4 << ", RA=" << m_addr1 << ", TA=" << m_addr2;
        }
      else
        {

Return to bug 1482