Attachment #3054 for bug #2831

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




}

void
ApWifiMac::SendAssocResp (Mac48Address to, bool success, bool isReassoc)
{
  NS_LOG_FUNCTION (this << to << success << isReassoc);
  WifiMacHeader hdr;
  hdr.SetType (isReassoc ? WIFI_MAC_MGT_REASSOCIATION_RESPONSE : WIFI_MAC_MGT_ASSOCIATION_RESPONSE);
  hdr.SetAddr1 (to);
  hdr.SetAddr2 (GetAddress ());
  hdr.SetAddr3 (GetAddress ());

  if (success)
    {
      code.SetSuccess ();
      uint16_t aid;
      bool found = false;
      if (isReassoc)
        {
          for (std::map<uint16_t, Mac48Address>::const_iterator i = m_staList.begin (); i != m_staList.end (); ++i)
            {
              if (i->second == to)
                {
                      aid = i->first;
                      found = true;
                      break;
                }
            }
        }
      if (!found)
        {
          aid = GetNextAssociationId ();
          m_staList.insert (std::make_pair (aid, to));
        }
      assoc.SetAssociationId (aid);
    }
  else

{
  NS_LOG_FUNCTION (this);
  RegularWifiMac::TxOk (hdr);
  if ((hdr.IsAssocResp () || hdr.IsReassocResp ())
  if (hdr.IsAssocResp ()
      && m_stationManager->IsWaitAssocTxOk (hdr.GetAddr1 ()))
    {
      NS_LOG_DEBUG ("associated with sta=" << hdr.GetAddr1 ());

  NS_LOG_FUNCTION (this);
  RegularWifiMac::TxFailed (hdr);

  if ((hdr.IsAssocResp () || hdr.IsReassocResp ())
      && m_stationManager->IsWaitAssocTxOk (hdr.GetAddr1 ()))
    {
      NS_LOG_DEBUG ("association failed with sta=" << hdr.GetAddr1 ());
      m_stationManager->RecordGotAssocTxFailed (hdr.GetAddr1 ());
    }
}

ApWifiMac::Receive (Ptr<Packet> packet, const WifiMacHeader *hdr)
{
  NS_LOG_FUNCTION (this << packet << hdr);

  Mac48Address from = hdr->GetAddr2 ();

  if (hdr->IsData ())
    {
      Mac48Address bssid = hdr->GetAddr1 ();

      if (hdr->IsProbeReq ())
        {
          NS_ASSERT (hdr->GetAddr1 ().IsBroadcast ());
          NS_LOG_DEBUG ("Probe request received from " << from << ": send probe response");
          SendProbeResp (from);
          return;
        }

        {
          if (hdr->IsAssocReq ())
            {
              NS_LOG_DEBUG ("Association request received from " << from);
              //first, verify that the the station's supported
              //rate set is compatible with our Basic Rate set
              MgtAssocRequestHeader assocReq;

                }
              if (problem)
                {
                  NS_LOG_DEBUG ("One of the Basic Rate set mode is not supported by the station: send association response with an error status");
                  SendAssocResp (hdr->GetAddr2 (), false, false);
                  //response with an error status.
                  SendAssocResp (hdr->GetAddr2 (), false);
                }
              else
                {
                  NS_LOG_DEBUG ("The Basic Rate set modes are supported by the station");
                  //record all its supported modes in its associated WifiRemoteStation
                  for (uint8_t j = 0; j < m_phy->GetNModes (); j++)
                    {

                  if (!isHtStation)
                    {
                      m_nonHtStations.push_back (hdr->GetAddr2 ());
                      m_nonHtStations.unique ();
                    }
                  if (!isErpStation && isDsssStation)
                    {
                      m_nonErpStations.push_back (hdr->GetAddr2 ());
                      m_nonErpStations.unique ();
                    }
                  NS_LOG_DEBUG ("Send association response with success status");
                  SendAssocResp (hdr->GetAddr2 (), true, false);
                }
              return;
            }
          else if (hdr->IsReassocReq ())
            {
              NS_LOG_DEBUG ("Reassociation request received from " << from);
              //first, verify that the the station's supported
              //rate set is compatible with our Basic Rate set
              MgtReassocRequestHeader reassocReq;
              packet->RemoveHeader (reassocReq);
              CapabilityInformation capabilities = reassocReq.GetCapabilities ();
              m_stationManager->AddSupportedPlcpPreamble (from, capabilities.IsShortPreamble ());
              SupportedRates rates = reassocReq.GetSupportedRates ();
              bool problem = false;
              bool isHtStation = false;
              bool isOfdmStation = false;
              bool isErpStation = false;
              bool isDsssStation = false;
              for (uint8_t i = 0; i < m_stationManager->GetNBasicModes (); i++)
                {
                  WifiMode mode = m_stationManager->GetBasicMode (i);
                  if (!rates.IsSupportedRate (mode.GetDataRate (m_phy->GetChannelWidth ())))
                    {
                      if ((mode.GetModulationClass () == WIFI_MOD_CLASS_DSSS) || (mode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS))
                        {
                          isDsssStation = false;
                        }
                      else if (mode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM)
                        {
                          isErpStation = false;
                        }
                      else if (mode.GetModulationClass () == WIFI_MOD_CLASS_OFDM)
                        {
                          isOfdmStation = false;
                        }
                      if (isDsssStation == false && isErpStation == false && isOfdmStation == false)
                        {
                          problem = true;
                          break;
                        }
                    }
                  else
                    {
                      if ((mode.GetModulationClass () == WIFI_MOD_CLASS_DSSS) || (mode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS))
                        {
                          isDsssStation = true;
                        }
                      else if (mode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM)
                        {
                          isErpStation = true;
                        }
                      else if (mode.GetModulationClass () == WIFI_MOD_CLASS_OFDM)
                        {
                          isOfdmStation = true;
                        }
                    }
                }
              m_stationManager->AddSupportedErpSlotTime (from, capabilities.IsShortSlotTime () && isErpStation);
              if (m_htSupported)
                {
                  //check whether the HT STA supports all MCSs in Basic MCS Set
                  HtCapabilities htcapabilities = reassocReq.GetHtCapabilities ();
                  if (htcapabilities.IsSupportedMcs (0))
                    {
                      isHtStation = true;
                      for (uint8_t i = 0; i < m_stationManager->GetNBasicMcs (); i++)
                        {
                          WifiMode mcs = m_stationManager->GetBasicMcs (i);
                          if (!htcapabilities.IsSupportedMcs (mcs.GetMcsValue ()))
                            {
                              problem = true;
                              break;
                            }
                        }
                    }
                }
              if (m_vhtSupported)
                {
                  //check whether the VHT STA supports all MCSs in Basic MCS Set
                  VhtCapabilities vhtcapabilities = reassocReq.GetVhtCapabilities ();
                  if (vhtcapabilities.GetVhtCapabilitiesInfo () != 0)
                    {
                      for (uint8_t i = 0; i < m_stationManager->GetNBasicMcs (); i++)
                        {
                          WifiMode mcs = m_stationManager->GetBasicMcs (i);
                          if (!vhtcapabilities.IsSupportedTxMcs (mcs.GetMcsValue ()))
                            {
                              problem = true;
                              break;
                            }
                        }
                    }
                }
              if (m_heSupported)
                {
                  //check whether the HE STA supports all MCSs in Basic MCS Set
                  HeCapabilities hecapabilities = reassocReq.GetHeCapabilities ();
                  if (hecapabilities.GetSupportedMcsAndNss () != 0)
                    {
                      for (uint8_t i = 0; i < m_stationManager->GetNBasicMcs (); i++)
                        {
                          WifiMode mcs = m_stationManager->GetBasicMcs (i);
                          if (!hecapabilities.IsSupportedTxMcs (mcs.GetMcsValue ()))
                            {
                              problem = true;
                              break;
                            }
                        }
                    }
                }
              if (problem)
                {
                  NS_LOG_DEBUG ("One of the Basic Rate set mode is not supported by the station: send reassociation response with an error status");
                  SendAssocResp (hdr->GetAddr2 (), false, true);
                }
              else
                {
                  NS_LOG_DEBUG ("The Basic Rate set modes are supported by the station");
                  //update all its supported modes in its associated WifiRemoteStation
                  for (uint8_t j = 0; j < m_phy->GetNModes (); j++)
                    {
                      WifiMode mode = m_phy->GetMode (j);
                      if (rates.IsSupportedRate (mode.GetDataRate (m_phy->GetChannelWidth ())))
                        {
                          m_stationManager->AddSupportedMode (from, mode);
                        }
                    }
                  if (m_htSupported)
                    {
                      HtCapabilities htCapabilities = reassocReq.GetHtCapabilities ();
                      if (htCapabilities.IsSupportedMcs (0))
                        {
                          m_stationManager->AddStationHtCapabilities (from, htCapabilities);
                        }
                    }
                  if (m_vhtSupported)
                    {
                      VhtCapabilities vhtCapabilities = reassocReq.GetVhtCapabilities ();
                      //we will always fill in RxHighestSupportedLgiDataRate field at TX, so this can be used to check whether it supports VHT
                      if (vhtCapabilities.GetRxHighestSupportedLgiDataRate () > 0)
                        {
                          m_stationManager->AddStationVhtCapabilities (from, vhtCapabilities);
                          for (uint8_t i = 0; i < m_phy->GetNMcs (); i++)
                            {
                              WifiMode mcs = m_phy->GetMcs (i);
                              if (mcs.GetModulationClass () == WIFI_MOD_CLASS_VHT && vhtCapabilities.IsSupportedTxMcs (mcs.GetMcsValue ()))
                                {
                                  m_stationManager->AddSupportedMcs (hdr->GetAddr2 (), mcs);
                                  //here should add a control to add basic MCS when it is implemented
                                }
                            }
                        }
                    }
                  if (m_heSupported)
                    {
                      HeCapabilities heCapabilities = reassocReq.GetHeCapabilities ();
                      //todo: once we support non constant rate managers, we should add checks here whether HE is supported by the peer
                      m_stationManager->AddStationHeCapabilities (from, heCapabilities);
                      for (uint8_t i = 0; i < m_phy->GetNMcs (); i++)
                        {
                          WifiMode mcs = m_phy->GetMcs (i);
                          if (mcs.GetModulationClass () == WIFI_MOD_CLASS_HE && heCapabilities.IsSupportedTxMcs (mcs.GetMcsValue ()))
                            {
                              m_stationManager->AddSupportedMcs (hdr->GetAddr2 (), mcs);
                              //here should add a control to add basic MCS when it is implemented
                            }
                        }
                    }
                  m_stationManager->RecordWaitAssocTxOk (from);
                  if (!isHtStation)
                    {
                      m_nonHtStations.push_back (hdr->GetAddr2 ());
                      m_nonHtStations.unique ();
                    }
                  if (!isErpStation && isDsssStation)
                    {
                      m_nonErpStations.push_back (hdr->GetAddr2 ());
                      m_nonErpStations.unique ();
                    }
                  NS_LOG_DEBUG ("Send reassociation response with success status");
                  SendAssocResp (hdr->GetAddr2 (), true, true);
                }
              return;
            }
          else if (hdr->IsDisassociation ())
            {
              NS_LOG_DEBUG ("Disassociation received from " << from);
              m_stationManager->RecordDisassociated (from);
              for (std::map<uint16_t, Mac48Address>::const_iterator j = m_staList.begin (); j != m_staList.end (); j++)
                {




   */
  void SendProbeResp (Mac48Address to);
  /**
   * Forward an association or a reassociation response packet to the DCF.
   * The standard is not clear on the correct queue for management frames if QoS is supported.
   * We always use the DCF.
   *
   * \param to the address of the STA we are sending an association response to
   * \param success indicates whether the association was successful or not
   * \param isReassoc indicates whether it is a reassociation response
   */
  void SendAssocResp (Mac48Address to, bool success, bool isReassoc);
  /**
   * Forward a beacon packet to the beacon special DCF.
   */






/***********************************************************
 *          Ressoc Request
 ***********************************************************/

NS_OBJECT_ENSURE_REGISTERED (MgtReassocRequestHeader);

MgtReassocRequestHeader::MgtReassocRequestHeader ()
  : m_currentApAddr (Mac48Address ())
{
}

MgtReassocRequestHeader::~MgtReassocRequestHeader ()
{
}

void
MgtReassocRequestHeader::SetSsid (Ssid ssid)
{
  m_ssid = ssid;
}

void
MgtReassocRequestHeader::SetSupportedRates (SupportedRates rates)
{
  m_rates = rates;
}

void
MgtReassocRequestHeader::SetListenInterval (uint16_t interval)
{
  m_listenInterval = interval;
}

void
MgtReassocRequestHeader::SetCapabilities (CapabilityInformation capabilities)
{
  m_capability = capabilities;
}

CapabilityInformation
MgtReassocRequestHeader::GetCapabilities (void) const
{
  return m_capability;
}

void
MgtReassocRequestHeader::SetExtendedCapabilities (ExtendedCapabilities extendedcapabilities)
{
  m_extendedCapability = extendedcapabilities;
}

ExtendedCapabilities
MgtReassocRequestHeader::GetExtendedCapabilities (void) const
{
  return m_extendedCapability;
}

void
MgtReassocRequestHeader::SetHtCapabilities (HtCapabilities htcapabilities)
{
  m_htCapability = htcapabilities;
}

HtCapabilities
MgtReassocRequestHeader::GetHtCapabilities (void) const
{
  return m_htCapability;
}

void
MgtReassocRequestHeader::SetVhtCapabilities (VhtCapabilities vhtcapabilities)
{
  m_vhtCapability = vhtcapabilities;
}

VhtCapabilities
MgtReassocRequestHeader::GetVhtCapabilities (void) const
{
  return m_vhtCapability;
}

void
MgtReassocRequestHeader::SetHeCapabilities (HeCapabilities hecapabilities)
{
  m_heCapability = hecapabilities;
}

HeCapabilities
MgtReassocRequestHeader::GetHeCapabilities (void) const
{
  return m_heCapability;
}

Ssid
MgtReassocRequestHeader::GetSsid (void) const
{
  return m_ssid;
}

SupportedRates
MgtReassocRequestHeader::GetSupportedRates (void) const
{
  return m_rates;
}

uint16_t
MgtReassocRequestHeader::GetListenInterval (void) const
{
  return m_listenInterval;
}

void
MgtReassocRequestHeader::SetCurrentApAddress (Mac48Address currentApAddr)
{
  m_currentApAddr = currentApAddr;
}

TypeId
MgtReassocRequestHeader::GetTypeId (void)
{
  static TypeId tid = TypeId ("ns3::MgtReassocRequestHeader")
    .SetParent<Header> ()
    .SetGroupName ("Wifi")
    .AddConstructor<MgtReassocRequestHeader> ()
  ;
  return tid;
}

TypeId
MgtReassocRequestHeader::GetInstanceTypeId (void) const
{
  return GetTypeId ();
}

uint32_t
MgtReassocRequestHeader::GetSerializedSize (void) const
{
  uint32_t size = 0;
  size += m_capability.GetSerializedSize ();
  size += 2; //listen interval
  size += 6; //current AP address
  size += m_ssid.GetSerializedSize ();
  size += m_rates.GetSerializedSize ();
  size += m_rates.extended.GetSerializedSize ();
  size += m_extendedCapability.GetSerializedSize ();
  size += m_htCapability.GetSerializedSize ();
  size += m_vhtCapability.GetSerializedSize ();
  size += m_heCapability.GetSerializedSize ();
  return size;
}

void
MgtReassocRequestHeader::Print (std::ostream &os) const
{
  os << "current AP address=" << m_currentApAddr << ", "
     << "ssid=" << m_ssid << ", "
     << "rates=" << m_rates << ", "
     << "HT Capabilities=" << m_htCapability << " , "
     << "VHT Capabilities=" << m_vhtCapability << " , "
     << "HE Capabilities=" << m_heCapability;
}

void
MgtReassocRequestHeader::Serialize (Buffer::Iterator start) const
{
  Buffer::Iterator i = start;
  i = m_capability.Serialize (i);
  i.WriteHtolsbU16 (m_listenInterval);
  WriteTo (i, m_currentApAddr);
  i = m_ssid.Serialize (i);
  i = m_rates.Serialize (i);
  i = m_rates.extended.Serialize (i);
  i = m_extendedCapability.Serialize (i);
  i = m_htCapability.Serialize (i);
  i = m_vhtCapability.Serialize (i);
  i = m_heCapability.Serialize (i);
}

uint32_t
MgtReassocRequestHeader::Deserialize (Buffer::Iterator start)
{
  Buffer::Iterator i = start;
  i = m_capability.Deserialize (i);
  m_listenInterval = i.ReadLsbtohU16 ();
  ReadFrom (i, m_currentApAddr);
  i = m_ssid.Deserialize (i);
  i = m_rates.Deserialize (i);
  i = m_rates.extended.DeserializeIfPresent (i);
  i = m_extendedCapability.DeserializeIfPresent (i);
  i = m_htCapability.DeserializeIfPresent (i);
  i = m_vhtCapability.DeserializeIfPresent (i);
  i = m_heCapability.DeserializeIfPresent (i);
  return i.GetDistanceFrom (start);
}


/***********************************************************
 *          Assoc/Reassoc Response
 ***********************************************************/

NS_OBJECT_ENSURE_REGISTERED (MgtAssocResponseHeader);




#include "edca-parameter-set.h"
#include "he-capabilities.h"
#include "he-operation.h"
#include "ns3/address-utils.h"

namespace ns3 {



/**
 * \ingroup wifi
 * Implement the header for management frames of type reassociation request.
 */
class MgtReassocRequestHeader : public Header
{
public:
  MgtReassocRequestHeader ();
  ~MgtReassocRequestHeader ();

  /**
   * Set the Service Set Identifier (SSID).
   *
   * \param ssid SSID
   */
  void SetSsid (Ssid ssid);
  /**
   * Set the supported rates.
   *
   * \param rates the supported rates
   */
  void SetSupportedRates (SupportedRates rates);
  /**
   * Set the listen interval.
   *
   * \param interval the listen interval
   */
  void SetListenInterval (uint16_t interval);
  /**
   * Set the Capability information.
   *
   * \param capabilities Capability information
   */
  void SetCapabilities (CapabilityInformation capabilities);
  /**
   * Set the Extended Capabilities.
   *
   * \param extendedcapabilities the Extended Capabilities
   */
  void SetExtendedCapabilities (ExtendedCapabilities extendedcapabilities);
  /**
   * Set the HT capabilities.
   *
   * \param htcapabilities HT capabilities
   */
  void SetHtCapabilities (HtCapabilities htcapabilities);
  /**
   * Set the VHT capabilities.
   *
   * \param vhtcapabilities VHT capabilities
   */
  void SetVhtCapabilities (VhtCapabilities vhtcapabilities);
  /**
   * Set the HE capabilities.
   *
   * \param hecapabilities HE capabilities
   */
  void SetHeCapabilities (HeCapabilities hecapabilities);
  /**
   * Return the Capability information.
   *
   * \return Capability information
   */
  CapabilityInformation GetCapabilities (void) const;
  /**
   * Return the extended capabilities.
   *
   * \return the extended capabilities
   */
  ExtendedCapabilities GetExtendedCapabilities (void) const;
  /**
   * Return the HT capabilities.
   *
   * \return HT capabilities
   */
  HtCapabilities GetHtCapabilities (void) const;
  /**
   * Return the VHT capabilities.
   *
   * \return VHT capabilities
   */
  VhtCapabilities GetVhtCapabilities (void) const;
  /**
   * Return the HE capabilities.
   *
   * \return HE capabilities
   */
  HeCapabilities GetHeCapabilities (void) const;
  /**
   * Return the Service Set Identifier (SSID).
   *
   * \return SSID
   */
  Ssid GetSsid (void) const;
  /**
   * Return the supported rates.
   *
   * \return the supported rates
   */
  SupportedRates GetSupportedRates (void) const;
  /**
   * Return the listen interval.
   *
   * \return the listen interval
   */
  uint16_t GetListenInterval (void) const;
  /**
   * Set the address of the current access point.
   *
   * \param currentApAddr address of the current access point
   */
  void SetCurrentApAddress (Mac48Address currentApAddr);

  /**
   * Register this type.
   * \return The TypeId.
   */
  static TypeId GetTypeId (void);
  TypeId GetInstanceTypeId (void) const;
  void Print (std::ostream &os) const;
  uint32_t GetSerializedSize (void) const;
  void Serialize (Buffer::Iterator start) const;
  uint32_t Deserialize (Buffer::Iterator start);


private:
  Mac48Address m_currentApAddr;       //!< Address of the current access point
  Ssid m_ssid;                        //!< Service Set ID (SSID)
  SupportedRates m_rates;             //!< List of supported rates
  CapabilityInformation m_capability; //!< Capability information
  ExtendedCapabilities m_extendedCapability; //!< Extended capabilities
  HtCapabilities m_htCapability;      //!< HT capabilities
  VhtCapabilities m_vhtCapability;    //!< VHT capabilities
  HeCapabilities m_heCapability;      //!< HE capabilities
  uint16_t m_listenInterval;          //!< listen interval
};


/**
 * \ingroup wifi
 * Implement the header for management frames of type association and reassociation response.
 */
class MgtAssocResponseHeader : public Header
{

(-)a/src/wifi/model/regular-wifi-mac.h (-1 / +1 lines)

Lines 216-222	Link Here

216

/**

216

/**

217

   * \param phy the physical layer attached to this MAC.

217

   * \param phy the physical layer attached to this MAC.

218

*/

218

*/

219

  void SetWifiPhy (const Ptr<WifiPhy> phy);

219

  virtual void SetWifiPhy (const Ptr<WifiPhy> phy);

220

/**

220

/**

221

   * \return the physical layer attached to this MAC.

221

   * \return the physical layer attached to this MAC.

222

*/

222

*/




                   TimeValue (Seconds (0.05)),
                   MakeTimeAccessor (&StaWifiMac::m_probeRequestTimeout),
                   MakeTimeChecker ())
    .AddAttribute ("AssocRequestTimeout", "The interval between two consecutive association request attempts.",
                   TimeValue (Seconds (0.5)),
                   MakeTimeAccessor (&StaWifiMac::m_assocRequestTimeout),
                   MakeTimeChecker ())

  m_activeProbing = enable;
}

bool
StaWifiMac::GetActiveProbing (void) const
{
  return m_activeProbing;
}

void
StaWifiMac::SetWifiPhy (const Ptr<WifiPhy> phy)
{
  NS_LOG_FUNCTION (this << phy);
  RegularWifiMac::SetWifiPhy (phy);
  m_phy->SetCapabilitiesChangedCallback (MakeCallback (&StaWifiMac::PhyCapabilitiesChanged, this));
}

void
StaWifiMac::SendProbeRequest (void)
{
  NS_LOG_FUNCTION (this);

}

void
StaWifiMac::SendAssociationRequest (bool isReassoc)
{
  NS_LOG_FUNCTION (this << GetBssid () << isReassoc);
  WifiMacHeader hdr;
  hdr.SetType (isReassoc ? WIFI_MAC_MGT_REASSOCIATION_REQUEST : WIFI_MAC_MGT_ASSOCIATION_REQUEST);
  hdr.SetAddr1 (GetBssid ());
  hdr.SetAddr2 (GetAddress ());
  hdr.SetAddr3 (GetBssid ());

  hdr.SetDsNotTo ();
  hdr.SetNoOrder ();
  Ptr<Packet> packet = Create<Packet> ();
  if (!isReassoc)
  assoc.SetSsid (GetSsid ());
  assoc.SetSupportedRates (GetSupportedRates ());
  assoc.SetCapabilities (GetCapabilities ());
  if (m_htSupported || m_vhtSupported || m_heSupported)
    {
      MgtAssocRequestHeader assoc;
      assoc.SetSsid (GetSsid ());
      assoc.SetSupportedRates (GetSupportedRates ());
      assoc.SetCapabilities (GetCapabilities ());
      if (m_htSupported || m_vhtSupported || m_heSupported)
        {
          assoc.SetExtendedCapabilities (GetExtendedCapabilities ());
          assoc.SetHtCapabilities (GetHtCapabilities ());
        }
      if (m_vhtSupported || m_heSupported)
        {
          assoc.SetVhtCapabilities (GetVhtCapabilities ());
        }
      if (m_heSupported)
        {
          assoc.SetHeCapabilities (GetHeCapabilities ());
        }
      packet->AddHeader (assoc);
    }
  else
    {
      MgtReassocRequestHeader reassoc;
      reassoc.SetCurrentApAddress (GetBssid ());
      reassoc.SetSsid (GetSsid ());
      reassoc.SetSupportedRates (GetSupportedRates ());
      reassoc.SetCapabilities (GetCapabilities ());
      if (m_htSupported || m_vhtSupported || m_heSupported)
        {
          reassoc.SetExtendedCapabilities (GetExtendedCapabilities ());
          reassoc.SetHtCapabilities (GetHtCapabilities ());
        }
      if (m_vhtSupported || m_heSupported)
        {
          reassoc.SetVhtCapabilities (GetVhtCapabilities ());
        }
      if (m_heSupported)
        {
          reassoc.SetHeCapabilities (GetHeCapabilities ());
        }
      packet->AddHeader (reassoc);
    }
  if (m_heSupported)
    {
      assoc.SetHeCapabilities (GetHeCapabilities ());
    }
  packet->AddHeader (assoc);

  //The standard is not clear on the correct queue for management
  //frames if we are a QoS AP. The approach taken here is to always

        }
      break;
    case WAIT_ASSOC_RESP:
      /* we have sent an association request so we do not need to
         re-send an association request right now. We just need to
         wait until either assoc-request-timeout or until
         we get an association response.
       */
      break;
    case REFUSED:
      /* we have sent an association request and received a negative
         association response. We wait until someone restarts an
         association with a given ssid.
       */
      break;

{
  NS_LOG_FUNCTION (this);
  SetState (WAIT_ASSOC_RESP);
  SendAssociationRequest (false);
}

void

      return;
    }
  else if (hdr->IsProbeReq ()
           || hdr->IsAssocReq ()
           || hdr->IsReassocReq ())
    {
      //This is a frame aimed at an AP, so we can safely ignore it.
      NotifyRxDrop (packet);

    }
  else if (hdr->IsBeacon ())
    {
      NS_LOG_DEBUG ("Beacon received");
      MgtBeaconHeader beacon;
      packet->RemoveHeader (beacon);
      CapabilityInformation capabilities = beacon.GetCapabilities ();

      if (goodBeacon && m_state == BEACON_MISSED)
        {
          SetState (WAIT_ASSOC_RESP);
          NS_LOG_DEBUG ("Good beacon received: send association request");
          SendAssociationRequest (false);
        }
      return;
    }

    {
      if (m_state == WAIT_PROBE_RESP)
        {
          NS_LOG_DEBUG ("Probe response received");
          MgtProbeResponseHeader probeResp;
          packet->RemoveHeader (probeResp);
          CapabilityInformation capabilities = probeResp.GetCapabilities ();
          if (!probeResp.GetSsid ().IsEqual (GetSsid ()))
            {
              NS_LOG_DEBUG ("Probe response is not for our SSID");
              return;
            }
          SupportedRates rates = probeResp.GetSupportedRates ();

              uint8_t selector = m_phy->GetBssMembershipSelector (i);
              if (!rates.IsBssMembershipSelectorRate (selector))
                {
                  NS_LOG_DEBUG ("Supported rates do not fit with the BSS membership selector");
                  return;
                }
            }

              m_probeRequestEvent.Cancel ();
            }
          SetState (WAIT_ASSOC_RESP);
          SendAssociationRequest (false);
        }
      return;
    }
  else if (hdr->IsAssocResp () || hdr->IsReassocResp ())
    {
      if (m_state == WAIT_ASSOC_RESP)
        {

          if (assocResp.GetStatusCode ().IsSuccess ())
            {
              SetState (ASSOCIATED);
              if (hdr->IsReassocResp ())
                {
                  NS_LOG_DEBUG ("reassociation done");
                }
              else
                {
                  NS_LOG_DEBUG ("association completed");
                }
              CapabilityInformation capabilities = assocResp.GetCapabilities ();
              SupportedRates rates = assocResp.GetSupportedRates ();
              bool isShortPreambleEnabled = capabilities.IsShortPreamble ();

            }
          else
            {
              NS_LOG_DEBUG ("association refused");
              SetState (REFUSED);
            }
        }

  edca->SetTxopLimit (txopLimit);
}

void
StaWifiMac::PhyCapabilitiesChanged (void)
{
  NS_LOG_FUNCTION (this);
  if (IsAssociated ())
    {
      NS_LOG_DEBUG ("PHY capabilities changed: send reassociation request");
      SetState (WAIT_ASSOC_RESP);
      SendAssociationRequest (true);
    }
}

} //namespace ns3

(-)a/src/wifi/model/sta-wifi-mac.h (-3 / +17 lines)

Lines 58-63	Link Here

*/

*/

  void Enqueue (Ptr<const Packet> packet, Mac48Address to);

  void Enqueue (Ptr<const Packet> packet, Mac48Address to);

/**

   * \param phy the physical layer attached to this MAC.

*/

  void SetWifiPhy (const Ptr<WifiPhy> phy);

private:

private:

/**

/**

Lines 93-102	Link Here

*/

*/

  void SendProbeRequest (void);

  void SendProbeRequest (void);

/**

100

/**

   * Forward an association request packet to the DCF. The standard is not clear on the correct

101

   * Forward an association or reassociation request packet to the DCF.

   * queue for management frames if QoS is supported. We always use the DCF.

102

   * The standard is not clear on the correct queue for management frames if QoS is supported.

103

   * We always use the DCF.

104

105

   * \param isReassoc flag whether it is a reassociation request

106

*/

107

*/

  void SendAssociationRequest (void);

108

  void SendAssociationRequest (bool isReassoc);

100

/**

109

/**

101

   * Try to ensure that we are associated with an AP by taking an appropriate action

110

   * Try to ensure that we are associated with an AP by taking an appropriate action

102

   * depending on the current association status.

111

   * depending on the current association status.

Lines 164-169	Link Here

164

*/

173

*/

165

  CapabilityInformation GetCapabilities (void) const;

174

  CapabilityInformation GetCapabilities (void) const;

166

175

176

/**

177

   * Indicate that PHY capabilities have changed.

178

*/

179

  void PhyCapabilitiesChanged (void);

180

167

  MacState m_state;            ///< MAC state

181

  MacState m_state;            ///< MAC state

168

  Time m_probeRequestTimeout;  ///< probe request timeout

182

  Time m_probeRequestTimeout;  ///< probe request timeout

169

  Time m_assocRequestTimeout;  ///< assoc request timeout

183

  Time m_assocRequestTimeout;  ///< assoc request timeout

(-)a/src/wifi/model/wifi-net-device.cc (+1 lines)

Lines 98-103	Link Here

void

void

WifiNetDevice::DoInitialize (void)

WifiNetDevice::DoInitialize (void)

100

101

  NS_LOG_FUNCTION_NOARGS ();

101

  m_phy->Initialize ();

102

  m_phy->Initialize ();

102

  m_mac->Initialize ();

103

  m_mac->Initialize ();

103

  m_stationManager->Initialize ();

104

  m_stationManager->Initialize ();

(-)a/src/wifi/model/wifi-phy.cc (+22 lines)

Lines 435-440	Link Here

435

436

437

void

437

void

438

WifiPhy::SetCapabilitiesChangedCallback (Callback<void> callback)

439

440

  m_capabilitiesChangedCallback = callback;

441

442

443

void

438

WifiPhy::InitializeFrequencyChannelNumber (void)

444

WifiPhy::InitializeFrequencyChannelNumber (void)

439

445

440

  NS_LOG_FUNCTION (this);

446

  NS_LOG_FUNCTION (this);

Lines 1267-1275	Link Here

1267

void

1273

void

1268

WifiPhy::SetChannelWidth (uint8_t channelwidth)

1274

WifiPhy::SetChannelWidth (uint8_t channelwidth)

1269

1275

1276

  NS_LOG_FUNCTION (this << static_cast<uint16_t>(channelwidth));

1270

  NS_ASSERT_MSG (channelwidth == 5 || channelwidth == 10 || channelwidth == 20 || channelwidth == 22 || channelwidth == 40 || channelwidth == 80 || channelwidth == 160, "wrong channel width value");

1277

  NS_ASSERT_MSG (channelwidth == 5 || channelwidth == 10 || channelwidth == 20 || channelwidth == 22 || channelwidth == 40 || channelwidth == 80 || channelwidth == 160, "wrong channel width value");

1278

  bool changed = (m_channelWidth == channelwidth);

1271

  m_channelWidth = channelwidth;

1279

  m_channelWidth = channelwidth;

1272

  AddSupportedChannelWidth (channelwidth);

1280

  AddSupportedChannelWidth (channelwidth);

1281

  if (changed && !m_capabilitiesChangedCallback.IsNull ())

1282

1283

      m_capabilitiesChangedCallback ();

1284

1273

1285

1274

1286

1275

uint8_t

1287

uint8_t

Lines 1296-1303	Link Here

1296

WifiPhy::SetMaxSupportedTxSpatialStreams (uint8_t streams)

1308

WifiPhy::SetMaxSupportedTxSpatialStreams (uint8_t streams)

1297

1309

1298

  NS_ASSERT (streams <= GetNumberOfAntennas ());

1310

  NS_ASSERT (streams <= GetNumberOfAntennas ());

1311

  bool changed = (m_txSpatialStreams == streams);

1299

  m_txSpatialStreams = streams;

1312

  m_txSpatialStreams = streams;

1300

  ConfigureHtDeviceMcsSet ();

1313

  ConfigureHtDeviceMcsSet ();

1314

  if (changed && !m_capabilitiesChangedCallback.IsNull ())

1315

1316

      m_capabilitiesChangedCallback ();

1317

1301

1318

1302

1319

1303

uint8_t

1320

uint8_t

Lines 1310-1316	Link Here

1310

WifiPhy::SetMaxSupportedRxSpatialStreams (uint8_t streams)

1327

WifiPhy::SetMaxSupportedRxSpatialStreams (uint8_t streams)

1311

1328

1312

  NS_ASSERT (streams <= GetNumberOfAntennas ());

1329

  NS_ASSERT (streams <= GetNumberOfAntennas ());

1330

  bool changed = (m_rxSpatialStreams == streams);

1313

  m_rxSpatialStreams = streams;

1331

  m_rxSpatialStreams = streams;

1332

  if (changed && !m_capabilitiesChangedCallback.IsNull ())

1333

1334

      m_capabilitiesChangedCallback ();

1335

1314

1336

1315

1337

1316

uint8_t

1338

uint8_t

(-)a/src/wifi/model/wifi-phy.h (+7 lines)

Lines 258-263	Link Here

258

  void UnregisterListener (WifiPhyListener *listener);

258

  void UnregisterListener (WifiPhyListener *listener);

259

260

/**

260

/**

261

   * \param callback the callback to invoke when PHY capabilities have changed.

262

*/

263

  void SetCapabilitiesChangedCallback (Callback<void> callback);

264

265

/**

261

   * Starting receiving the plcp of a packet (i.e. the first bit of the preamble has arrived).

266

   * Starting receiving the plcp of a packet (i.e. the first bit of the preamble has arrived).

262

267

263

   * \param packet the arriving packet

268

   * \param packet the arriving packet

Lines 1987-1992	Link Here

1987

  Ptr<InterferenceHelper::Event> m_currentEvent; //!< Hold the current event

1992

  Ptr<InterferenceHelper::Event> m_currentEvent; //!< Hold the current event

1988

  Ptr<FrameCaptureModel> m_frameCaptureModel; //!< Frame capture model

1993

  Ptr<FrameCaptureModel> m_frameCaptureModel; //!< Frame capture model

1989

  Ptr<WifiRadioEnergyModel> m_wifiRadioEnergyModel; //!< Wifi radio energy model

1994

  Ptr<WifiRadioEnergyModel> m_wifiRadioEnergyModel; //!< Wifi radio energy model

1995

1996

  Callback<void> m_capabilitiesChangedCallback; //!< Callback when PHY capabilities changed

1990

};

1997

};

1991

1998

1992

/**

1999

/**




  NS_TEST_ASSERT_MSG_EQ (std::get<3> (m_distinctTuples[1]), WifiModulationClass::WIFI_MOD_CLASS_VHT, "Second tuple should be VHT_OFDM");
}

//-----------------------------------------------------------------------------
/**
 * Make sure that the channel width and the channel number can be changed at runtime.
 *
 * The scenario considers an access point and a station using a 20 MHz channel width.
 * After 1s, we change the channel width and the channel number to use a 40 MHz channel.
 * The tests checks the operational channel width sent in Beacon frames
 * and verify that a reassociation procedure is executed.
 *
 * See \bugid{2831}
 */

class Bug2831TestCase : public TestCase
{
public:
  Bug2831TestCase ();
  virtual ~Bug2831TestCase ();
  virtual void DoRun (void);

private:
  void ChangeSupportedChannelWidth (void);
  void RxCallback (std::string context, Ptr<const Packet> p);

  Ptr<YansWifiPhy> m_apPhy;
  Ptr<YansWifiPhy> m_staPhy;

  uint8_t m_reassocReqCount;
  uint8_t m_reassocRespCount;
  uint8_t m_countOperationalChannelWidth20;
  uint8_t m_countOperationalChannelWidth40;
};

Bug2831TestCase::Bug2831TestCase ()
  : TestCase ("Test case for Bug 2831"),
    m_reassocReqCount (0),
    m_reassocRespCount (0),
    m_countOperationalChannelWidth20 (0),
    m_countOperationalChannelWidth40 (0)
{
}

Bug2831TestCase::~Bug2831TestCase ()
{
}

void
Bug2831TestCase::ChangeSupportedChannelWidth ()
{
  m_apPhy->SetChannelNumber (38);
  m_apPhy->SetChannelWidth (40);
  m_staPhy->SetChannelNumber (38);
  m_staPhy->SetChannelWidth (40);
}

void
Bug2831TestCase::RxCallback (std::string context, Ptr<const Packet> p)
{
  Ptr<Packet> packet = p->Copy ();
  WifiMacHeader hdr;
  packet->RemoveHeader(hdr);
  if (hdr.IsReassocReq ())
    {
      m_reassocReqCount++;
    }
  else if (hdr.IsReassocResp ())
    {
      m_reassocRespCount++;
    }
  else if (hdr.IsBeacon ())
    {
      MgtBeaconHeader beacon;
      packet->RemoveHeader (beacon);
      HtOperation htOperation = beacon.GetHtOperation ();
      if (htOperation.GetStaChannelWidth () > 0)
        {
          m_countOperationalChannelWidth40++;
        }
      else
        {
          m_countOperationalChannelWidth20++;
        }
    }
}

void
Bug2831TestCase::DoRun (void)
{
  Ptr<YansWifiChannel> channel = CreateObject<YansWifiChannel> ();
  ObjectFactory propDelay;
  propDelay.SetTypeId ("ns3::ConstantSpeedPropagationDelayModel");
  Ptr<PropagationDelayModel> propagationDelay = propDelay.Create<PropagationDelayModel> ();
  Ptr<PropagationLossModel> propagationLoss = CreateObject<RandomPropagationLossModel> ();
  channel->SetPropagationDelayModel (propagationDelay);
  channel->SetPropagationLossModel (propagationLoss);

  Ptr<Node> apNode = CreateObject<Node> ();
  Ptr<WifiNetDevice> apDev = CreateObject<WifiNetDevice> ();
  ObjectFactory mac;
  mac.SetTypeId ("ns3::ApWifiMac");
  Ptr<WifiMac> apMac = mac.Create<WifiMac> ();
  apMac->ConfigureStandard (WIFI_PHY_STANDARD_80211n_5GHZ);
  
  Ptr<Node> staNode = CreateObject<Node> ();
  Ptr<WifiNetDevice> staDev = CreateObject<WifiNetDevice> ();
  mac.SetTypeId ("ns3::StaWifiMac");
  Ptr<WifiMac> staMac = mac.Create<WifiMac> ();
  staMac->ConfigureStandard (WIFI_PHY_STANDARD_80211n_5GHZ);

  Ptr<ConstantPositionMobilityModel> apMobility = CreateObject<ConstantPositionMobilityModel> ();
  apMobility->SetPosition (Vector (0.0, 0.0, 0.0));
  apNode->AggregateObject (apMobility);

  Ptr<ErrorRateModel> error = CreateObject<YansErrorRateModel> ();
  m_apPhy = CreateObject<YansWifiPhy> ();
  m_apPhy->SetErrorRateModel (error);
  m_apPhy->SetChannel (channel);
  m_apPhy->SetMobility (apMobility);
  m_apPhy->SetDevice (apDev);
  m_apPhy->ConfigureStandard (WIFI_PHY_STANDARD_80211n_5GHZ);
  m_apPhy->SetChannelNumber (36);
  m_apPhy->SetChannelWidth (20);

  Ptr<ConstantPositionMobilityModel> staMobility = CreateObject<ConstantPositionMobilityModel> ();
  staMobility->SetPosition (Vector (1.0, 0.0, 0.0));
  staNode->AggregateObject (staMobility);

  m_staPhy = CreateObject<YansWifiPhy> ();
  m_staPhy->SetErrorRateModel (error);
  m_staPhy->SetChannel (channel);
  m_staPhy->SetMobility (staMobility);
  m_staPhy->SetDevice (apDev);
  m_staPhy->ConfigureStandard (WIFI_PHY_STANDARD_80211n_5GHZ);
  m_staPhy->SetChannelNumber (36);
  m_staPhy->SetChannelWidth (20);

  apMac->SetAddress (Mac48Address::Allocate ());
  apDev->SetMac (apMac);
  apDev->SetPhy (m_apPhy);
  ObjectFactory manager;
  manager.SetTypeId ("ns3::ConstantRateWifiManager");
  apDev->SetRemoteStationManager (manager.Create<WifiRemoteStationManager> ());
  apNode->AddDevice (apDev);

  staMac->SetAddress (Mac48Address::Allocate ());
  staDev->SetMac (staMac);
  staDev->SetPhy (m_staPhy);
  staDev->SetRemoteStationManager (manager.Create<WifiRemoteStationManager> ());
  staNode->AddDevice (staDev);

  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/PhyRxBegin", MakeCallback (&Bug2831TestCase::RxCallback, this));

  Simulator::Schedule (Seconds (1.0), &Bug2831TestCase::ChangeSupportedChannelWidth, this);

  Simulator::Stop (Seconds (3.0));
  Simulator::Run ();
  Simulator::Destroy ();

  NS_TEST_ASSERT_MSG_EQ (m_reassocReqCount, 1, "Reassociation request not received");
  NS_TEST_ASSERT_MSG_EQ (m_reassocRespCount, 1, "Reassociation response not received");
  NS_TEST_ASSERT_MSG_EQ (m_countOperationalChannelWidth20, 10, "Incorrect operational channel width before channel change");
  NS_TEST_ASSERT_MSG_EQ (m_countOperationalChannelWidth40, 20, "Incorrect operational channel width after channel change");
}

/**
 * \ingroup wifi-test
 * \ingroup tests

  AddTestCase (new SetChannelFrequencyTest, TestCase::QUICK);
  AddTestCase (new Bug2222TestCase, TestCase::QUICK); //Bug 2222
  AddTestCase (new Bug2483TestCase, TestCase::QUICK); //Bug 2483
  AddTestCase (new Bug2831TestCase, TestCase::QUICK); //Bug 2831
}

static WifiTestSuite g_wifiTestSuite; ///< the test suite

Return to bug 2831