Attachment #2110 for bug #1482

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





namespace ns3 {
namespace dot11s {
NS_OBJECT_ENSURE_REGISTERED (PeerLinkOpenStart);

PeerLinkOpenStart::PeerLinkOpenStart () :
  m_subtype ((uint8_t)(WifiActionHeader::PEER_LINK_OPEN)), m_capability (0), m_aid (0), m_rates (SupportedRates ()), m_meshId (),
  m_config (IeConfiguration ())
{
}
void
PeerLinkOpenStart::SetPlinkOpenStart (PeerLinkOpenStart::PlinkOpenStartFields fields)
{
  m_subtype = subtype;
}
void
PeerLinkFrameStart::SetPlinkFrameStart (PeerLinkFrameStart::PlinkFrameStartFields fields)
{
  m_subtype = fields.subtype;
  

      //reasonCode not used here
    }
}
PeerLinkOpenStart::PlinkOpenStartFields
PeerLinkOpenStart::GetFields () const
{
  PlinkOpenStartFields retval;
  /// \todo protocol version:
  retval.subtype = m_subtype;
  retval.capability = m_capability;

  return retval;
}
TypeId
PeerLinkOpenStart::GetTypeId ()
{
  static TypeId tid = TypeId ("ns3::dot11s::PeerLinkOpenStart")
    .SetParent<Header> ()
    .SetGroupName ("Mesh")
    .AddConstructor<PeerLinkOpenStart> ()
  ;
  return tid;
}
TypeId
PeerLinkOpenStart::GetInstanceTypeId () const
{
  return GetTypeId ();
}
void
PeerLinkOpenStart::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 = ";

  os << std::endl << "reason code = " << m_reasonCode;
}
uint32_t
PeerLinkOpenStart::GetSerializedSize () const
{
  uint32_t size =0; //Peering protocol
  NS_ASSERT (m_subtype < 4);

  return size;
}
void
PeerLinkOpenStart::Serialize (Buffer::Iterator start) const
{
  Buffer::Iterator i = start;
  NS_ASSERT (m_subtype < 4);

    }
}
uint32_t
PeerLinkOpenStart::Deserialize (Buffer::Iterator start)
{
  Buffer::Iterator i = start;
  NS_ASSERT (m_subtype < 4);

  return i.GetDistanceFrom (start);
}
bool
operator== (const PeerLinkOpenStart & a, const PeerLinkOpenStart & b)
{
  return ((a.m_subtype == b.m_subtype) && (a.m_capability == b.m_capability) && (a.m_aid == b.m_aid)
          && (a.m_meshId.IsEqual (b.m_meshId)) && (a.m_config == b.m_config));
  
}
NS_OBJECT_ENSURE_REGISTERED (PeerLinkCloseStart);

PeerLinkCloseStart::PeerLinkCloseStart () :
  m_subtype ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE)), m_capability (0), m_aid (0), m_rates (SupportedRates ()), m_meshId (),
  m_config (IeConfiguration ())
{
}
void
PeerLinkCloseStart::SetPlinkCloseStart (PeerLinkCloseStart::PlinkCloseStartFields fields)
{
  m_subtype = fields.subtype;
  
  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;
}
TypeId
PeerLinkCloseStart::GetTypeId ()
{
  static TypeId tid = TypeId ("ns3::dot11s::PeerLinkCloseStart")
    .SetParent<Header> ()
    .SetGroupName ("Mesh")
    .AddConstructor<PeerLinkCloseStart> ()
  ;
  return tid;
}
TypeId
PeerLinkCloseStart::GetInstanceTypeId () const
{
  return GetTypeId ();
}
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
  NS_ASSERT (m_subtype < 4);
  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;
  NS_ASSERT (m_subtype < 4);
  
  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);
  
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      m_capability = i.ReadLsbtohU16 ();
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) == m_subtype)
    {
      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_subtype == b.m_subtype) && (a.m_capability == b.m_capability) && (a.m_aid == b.m_aid)
          && (a.m_meshId.IsEqual (b.m_meshId)) && (a.m_config == b.m_config));
  
}
NS_OBJECT_ENSURE_REGISTERED (PeerLinkConfirmStart);

PeerLinkConfirmStart::PeerLinkConfirmStart () :
  m_subtype ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM)), m_capability (0), m_aid (0), m_rates (SupportedRates ()), m_meshId (),
  m_config (IeConfiguration ())
{
}
void
PeerLinkConfirmStart::SetPlinkConfirmStart (PeerLinkConfirmStart::PlinkConfirmStartFields fields)
{
  m_subtype = fields.subtype;
  
  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
    }
}
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;
}
TypeId
PeerLinkConfirmStart::GetTypeId ()
{
  static TypeId tid = TypeId ("ns3::dot11s::PeerLinkConfirmStart")
    .SetParent<Header> ()
    .SetGroupName ("Mesh")
    .AddConstructor<PeerLinkConfirmStart> ()
  ;
  return tid;
}
TypeId
PeerLinkConfirmStart::GetInstanceTypeId () const
{
  return GetTypeId ();
}
void
PeerLinkConfirmStart::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
PeerLinkConfirmStart::GetSerializedSize () const
{
  uint32_t size =0; //Peering protocol
  NS_ASSERT (m_subtype < 4);
  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
PeerLinkConfirmStart::Serialize (Buffer::Iterator start) const
{
  Buffer::Iterator i = start;
  NS_ASSERT (m_subtype < 4);
  
  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
PeerLinkConfirmStart::Deserialize (Buffer::Iterator start)
{
  Buffer::Iterator i = start;
  NS_ASSERT (m_subtype < 4);
  
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
    {
      m_capability = i.ReadLsbtohU16 ();
    }
  if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) == m_subtype)
    {
      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_subtype == b.m_subtype) && (a.m_capability == b.m_capability) && (a.m_aid == b.m_aid)
          && (a.m_meshId.IsEqual (b.m_meshId)) && (a.m_config == b.m_config));




#include "ie-dot11s-id.h"
namespace ns3
{
class MeshWifiInterfaceMac;
namespace dot11s
{
/**
 * \ingroup dot11s
 *
 * \brief 802.11s Peer link open management frame
 * 
 * Peer link management frame included the following (see chapters 7.4.12.1-7.4.12.3 of 802.11s):
 * - Subtype field

 * - Supported rates
 * - Mesh ID of mesh
 */
class PeerLinkOpenStart : public Header
{
public:
  PeerLinkOpenStart ();
  ///\brief fields:
  struct PlinkOpenStartFields
  {
    uint8_t subtype;
    IePeeringProtocol protocol; //Peering protocol version - in all subtypes - 3 octets

    IeConfiguration config;     //open and confirm
    uint16_t reasonCode;        //close only
  };
  void SetPlinkOpenStart (PlinkOpenStartFields);
  PlinkOpenStartFields GetFields () const;
  void SetPlinkFrameSubtype (uint8_t subtype);
  void SetPlinkFrameStart (PlinkFrameStartFields);
  PlinkFrameStartFields GetFields () const;

  // Inherited from header:
  static  TypeId   GetTypeId ();

  IeConfiguration m_config;
  uint16_t m_reasonCode;

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

  PeerLinkOpenStart& operator= (const PeerLinkOpenStart &);
  PeerLinkOpenStart (const PeerLinkOpenStart &);

};

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

/**
 * \ingroup dot11s
 *
 * \brief 802.11s Peer link close management frame
 * 
 * Peer link management frame included the following (see chapters 7.4.12.1-7.4.12.3 of 802.11s):
 * - Subtype field
 * - Association ID field
 * - Supported rates
 * - Mesh ID of mesh
 */
class PeerLinkCloseStart : public Header
{
public:
  PeerLinkCloseStart ();
  ///\brief fields:
  struct PlinkCloseStartFields
  {
    uint8_t subtype;
    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;

  // Inherited from header:
  static  TypeId   GetTypeId ();
  virtual TypeId   GetInstanceTypeId () const;
  virtual void     Print (std::ostream &os) const;
  virtual uint32_t GetSerializedSize () const;
  virtual void     Serialize (Buffer::Iterator start) 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);

  PeerLinkCloseStart& operator= (const PeerLinkCloseStart &);
  PeerLinkCloseStart (const PeerLinkCloseStart &);

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

/**
 * \ingroup dot11s
 *
 * \brief 802.11s Peer link confirm management frame
 * 
 * Peer link management frame included the following (see chapters 7.4.12.1-7.4.12.3 of 802.11s):
 * - Subtype field
 * - Association ID field
 * - Supported rates
 * - Mesh ID of mesh
 */
class PeerLinkConfirmStart : public Header
{
public:
  PeerLinkConfirmStart ();
  ///\brief fields:
  struct PlinkConfirmStartFields
  {
    uint8_t subtype;
    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;

  // Inherited from header:
  static  TypeId   GetTypeId ();
  virtual TypeId   GetInstanceTypeId () const;
  virtual void     Print (std::ostream &os) const;
  virtual uint32_t GetSerializedSize () const;
  virtual void     Serialize (Buffer::Iterator start) 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);

  PeerLinkConfirmStart& operator= (const PeerLinkConfirmStart &);
  PeerLinkConfirmStart (const PeerLinkConfirmStart &);

};
bool operator== (const PeerLinkConfirmStart & a, const PeerLinkConfirmStart & b);
} // namespace dot11s
} // namespace ns3
#endif




      // Beacon shall not be dropped. May be needed to another plugins
      return true;
    }
  uint16_t aid;
  IeConfiguration config;
  if (header.IsAction ())
    {
      WifiActionHeader actionHdr;

      m_stats.rxMgtBytes += packet->GetSize ();
      Mac48Address peerAddress = header.GetAddr2 ();
      Mac48Address peerMpAddress = header.GetAddr3 ();
      if (actionValue.selfProtectedAction == WifiActionHeader::PEER_LINK_OPEN)
      {
        PeerLinkFrameStart peerFrame;
        peerFrame.SetPlinkFrameSubtype ((uint8_t) actionValue.selfProtectedAction);
        packet->RemoveHeader (peerFrame);
        fields = peerFrame.GetFields ();
        NS_ASSERT (fields.subtype == actionValue.selfProtectedAction); 
      }
      if ((actionValue.selfProtectedAction != WifiActionHeader::PEER_LINK_CLOSE) && !(m_parent->CheckSupportedRates (fields.rates))) 
        {
          PeerLinkOpenStart::PlinkOpenStartFields fields;
          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);
              // Broken peer link frame - drop it
              m_stats.brokenMgt++;
              return false;
            }
          if (!(m_parent->CheckSupportedRates (fields.rates)))
            {
              m_protocol->ConfigurationMismatch (m_ifIndex, peerAddress);
              // Broken peer link frame - drop it
              m_stats.brokenMgt++;
              return false;
            }
          aid = fields.aid;
          config = fields.config;
        }
      else if (actionValue.selfProtectedAction == WifiActionHeader::PEER_LINK_CONFIRM)
            *(m_protocol->GetMeshId ())))
        {
          PeerLinkConfirmStart::PlinkConfirmStartFields fields;
          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);
              // Broken peer link frame - drop it
              m_stats.brokenMgt++;
              return false;
            }
          aid = fields.aid;
          config = fields.config;
        }
      else if (actionValue.selfProtectedAction == WifiActionHeader::PEER_LINK_CLOSE)
        {
          PeerLinkCloseStart::PlinkCloseStartFields fields;
          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);
              // Broken peer link frame - drop it
              m_stats.brokenMgt++;
              return false;
            }
          aid = fields.aid;
          config = fields.config;
        }
      else
        {
          NS_FATAL_ERROR ("Unknown subtype" << actionValue.selfProtectedAction);
        }
      Ptr<IePeerManagement> peerElement;
      //Peer Management element is the last element in this frame - so, we can use MeshInformationElementVector

           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);
                                        fields.config);
      // if we can handle a frame - drop it
      return false;
    }

  MeshInformationElementVector elements;
  elements.AddInformationElement (Ptr<IePeerManagement> (&peerElement));
  packet->AddHeader (elements);
  PeerLinkFrameStart::PlinkFrameStartFields fields;
  fields.rates = m_parent->GetSupportedRates ();
  fields.capability = 0;
  fields.meshId = *(m_protocol->GetMeshId ());
  fields.config = meshConfig;
  PeerLinkFrameStart plinkFrame;
  //Create an 802.11 frame header:
  //Send management frame to MAC:
  WifiActionHeader actionHdr;
  if (peerElement.SubtypeIsOpen ())
    {
      PeerLinkOpenStart::PlinkOpenStartFields fields;
      fields.rates = m_parent->GetSupportedRates ();
      fields.capability = 0;
      fields.meshId = *(m_protocol->GetMeshId ());
      fields.config = meshConfig;
      PeerLinkOpenStart plinkOpen;
      WifiActionHeader actionHdr;
      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);
      packet->AddHeader (actionHdr);
    }
  if (peerElement.SubtypeIsConfirm ())
    {
      PeerLinkConfirmStart::PlinkConfirmStartFields fields;
      fields.rates = m_parent->GetSupportedRates ();
      fields.capability = 0;
      fields.meshId = *(m_protocol->GetMeshId ());
      fields.config = meshConfig;
      PeerLinkConfirmStart plinkConfirm;
      WifiActionHeader actionHdr;
      m_stats.txConfirm++;
      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);
      packet->AddHeader (actionHdr);
    }
  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);
      packet->AddHeader (actionHdr);
    }
  plinkFrame.SetPlinkFrameStart (fields);
  packet->AddHeader (plinkFrame);
  packet->AddHeader (actionHdr);
  m_stats.txMgt++;
  m_stats.txMgtBytes += packet->GetSize ();
  // Wifi Mac header:




PeerLinkFrameStartTest::DoRun ()
{
  {
    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> ();
    packet->AddHeader (a);
    PeerLinkOpenStart b;
    b.SetPlinkFrameSubtype ((uint8_t)(WifiActionHeader::PEER_LINK_OPEN));
    packet->RemoveHeader (b);
    NS_TEST_EXPECT_MSG_EQ (a, b, "PEER_LINK_OPEN works");
  }
  {
    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);
    PeerLinkConfirmStart b;
    b.SetPlinkFrameSubtype ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM));
    packet->RemoveHeader (b);
    NS_TEST_EXPECT_MSG_EQ (a, b, "PEER_LINK_CONFIRM works");
  }
  {
    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);
    PeerLinkCloseStart b;
    b.SetPlinkFrameSubtype ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE));
    packet->RemoveHeader (b);
    NS_TEST_EXPECT_MSG_EQ (a, b, "PEER_LINK_CLOSE works");
  }

Return to bug 1482