Attachment #3204 for bug #2470

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

(-)a/CHANGES.html (+6 lines)

Lines 56-61 us a note on ns-developers mailing list.</p>	Link Here

<ul>

<ul>

<li>The attributes <b>RegularWifiMac::HtSupported</b>, <b>RegularWifiMac::VhtSupported</b>, <b>RegularWifiMac::HeSupported</b>, <b>RegularWifiMac::RifsSupported</b>, <b>WifiPhy::ShortGuardEnabled</b>, <b>WifiPhy::GuardInterval</b> and <b>WifiPhy::GreenfieldEnabled</b> have been deprecated. Intead, it is advised to use <b>WifiNetDevice::HtConfiguration</b>, <b>WifiNetDevice::VhtConfiguration</b> and <b>WifiNetDevice::HeConfiguration</b>.

<li>The attributes <b>RegularWifiMac::HtSupported</b>, <b>RegularWifiMac::VhtSupported</b>, <b>RegularWifiMac::HeSupported</b>, <b>RegularWifiMac::RifsSupported</b>, <b>WifiPhy::ShortGuardEnabled</b>, <b>WifiPhy::GuardInterval</b> and <b>WifiPhy::GreenfieldEnabled</b> have been deprecated. Intead, it is advised to use <b>WifiNetDevice::HtConfiguration</b>, <b>WifiNetDevice::VhtConfiguration</b> and <b>WifiNetDevice::HeConfiguration</b>.

</li>

</li>

<li>A new attribute <b>WifiPhy::PostReceptionErrorModel</b> has been added to force specific packet drops.

</li>

</li>

<li>New attributes <b>QosTxop::AddBaResponseTimeout</b> and <b>QosTxop::FailedAddBaTimeout</b> have been added to set the timeout to wait for an ADDBA response after the ACK to the ADDBA request is received and to set the timeout after a failed BA agreement, respectively.

</li>

</ul>

</ul>

<h2>Changes to existing API:</h2>

<h2>Changes to existing API:</h2>

<ul>

<ul>

Lines 71-76 us a note on ns-developers mailing list.</p>	Link Here

</ul>

</ul>

<h2>Changed behavior:</h2>

<h2>Changed behavior:</h2>

<ul>

<ul>

  <li>The wifi ADDBA handshake process is now protected with the use of two timeouts who makes sure we do not end up in a blocked situation. If the handshake process is not established, packets that are in the queue are sent as normal MPDUs. Once handshake is successfully established, A-MPDUs can be transmitted.</li>

</ul>

</ul>

<hr>

<hr>

(-)a/src/wifi/model/block-ack-manager.cc (-8 / +34 lines)

Lines 104-111 BlockAckManager::ExistsAgreementInState (Mac48Address recipient, uint8_t tid,	Link Here

104

          return it->second.first.IsEstablished ();

104

          return it->second.first.IsEstablished ();

105

        case OriginatorBlockAckAgreement::PENDING:

105

        case OriginatorBlockAckAgreement::PENDING:

106

          return it->second.first.IsPending ();

106

          return it->second.first.IsPending ();

107

        case OriginatorBlockAckAgreement::UNSUCCESSFUL:

107

        case OriginatorBlockAckAgreement::REJECTED:

108

          return it->second.first.IsUnsuccessful ();

108

          return it->second.first.IsRejected ();

109

        case OriginatorBlockAckAgreement::NO_REPLY:

110

          return it->second.first.IsNoReply ();

111

        case OriginatorBlockAckAgreement::RESET:

112

          return it->second.first.IsReset ();

109

        default:

113

        default:

110

          NS_FATAL_ERROR ("Invalid state for block ack agreement");

114

          NS_FATAL_ERROR ("Invalid state for block ack agreement");

111

115

Lines 138-143 BlockAckManager::CreateAgreement (const MgtAddBaRequestHeader *reqHdr, Mac48Addr	Link Here

138

  agreement.SetState (OriginatorBlockAckAgreement::PENDING);

142

  agreement.SetState (OriginatorBlockAckAgreement::PENDING);

139

  PacketQueue queue;

143

  PacketQueue queue;

140

  std::pair<OriginatorBlockAckAgreement, PacketQueue> value (agreement, queue);

144

  std::pair<OriginatorBlockAckAgreement, PacketQueue> value (agreement, queue);

145

  if (ExistsAgreement (recipient, reqHdr->GetTid ()))

146

147

      // Delete agreement if it exists and in RESET state

148

      NS_ASSERT (ExistsAgreementInState (recipient, reqHdr->GetTid (), OriginatorBlockAckAgreement::RESET));

149

      m_agreements.erase (key);

150

141

  m_agreements.insert (std::make_pair (key, value));

151

  m_agreements.insert (std::make_pair (key, value));

142

  m_blockPackets (recipient, reqHdr->GetTid ());

152

  m_blockPackets (recipient, reqHdr->GetTid ());

143

153

Lines 710-724 BlockAckManager::NotifyAgreementEstablished (Mac48Address recipient, uint8_t tid	Link Here

710

720

711

721

712

void

722

void

713

BlockAckManager::NotifyAgreementUnsuccessful (Mac48Address recipient, uint8_t tid)

723

BlockAckManager::NotifyAgreementRejected (Mac48Address recipient, uint8_t tid)

714

724

715

  NS_LOG_FUNCTION (this << recipient << +tid);

725

  NS_LOG_FUNCTION (this << recipient << +tid);

716

  AgreementsI it = m_agreements.find (std::make_pair (recipient, tid));

726

  AgreementsI it = m_agreements.find (std::make_pair (recipient, tid));

717

  NS_ASSERT (it != m_agreements.end ());

727

  NS_ASSERT (it != m_agreements.end ());

718

  if (it != m_agreements.end ())

728

  it->second.first.SetState (OriginatorBlockAckAgreement::REJECTED);

719

729

720

      it->second.first.SetState (OriginatorBlockAckAgreement::UNSUCCESSFUL);

730

721

731

void

732

BlockAckManager::NotifyAgreementNoReply (Mac48Address recipient, uint8_t tid)

733

734

  NS_LOG_FUNCTION (this << recipient << +tid);

735

  AgreementsI it = m_agreements.find (std::make_pair (recipient, tid));

736

  NS_ASSERT (it != m_agreements.end ());

737

  it->second.first.SetState (OriginatorBlockAckAgreement::NO_REPLY);

738

  m_unblockPackets (recipient, tid);

739

740

741

void

742

BlockAckManager::NotifyAgreementReset (Mac48Address recipient, uint8_t tid)

743

744

  NS_LOG_FUNCTION (this << recipient << +tid);

745

  AgreementsI it = m_agreements.find (std::make_pair (recipient, tid));

746

  NS_ASSERT (it != m_agreements.end ());

747

  it->second.first.SetState (OriginatorBlockAckAgreement::RESET);

722

748

723

749

724

void

750

void

Lines 761-767 BlockAckManager::SwitchToBlockAckIfNeeded (Mac48Address recipient, uint8_t tid,	Link Here

761

787

762

  NS_LOG_FUNCTION (this << recipient << +tid << startingSeq);

788

  NS_LOG_FUNCTION (this << recipient << +tid << startingSeq);

763

  NS_ASSERT (!ExistsAgreementInState (recipient, tid, OriginatorBlockAckAgreement::PENDING));

789

  NS_ASSERT (!ExistsAgreementInState (recipient, tid, OriginatorBlockAckAgreement::PENDING));

764

  if (!ExistsAgreementInState (recipient, tid, OriginatorBlockAckAgreement::UNSUCCESSFUL) && ExistsAgreement (recipient, tid))

790

  if (!ExistsAgreementInState (recipient, tid, OriginatorBlockAckAgreement::REJECTED) && ExistsAgreement (recipient, tid))

765

791

766

      uint32_t packets = m_queue->GetNPacketsByTidAndAddress (tid, recipient) +

792

      uint32_t packets = m_queue->GetNPacketsByTidAndAddress (tid, recipient) +

767

        GetNBufferedPackets (recipient, tid);

793

        GetNBufferedPackets (recipient, tid);




   * \param recipient Address of peer station involved in block ack mechanism.
   * \param tid Traffic ID of transmitted packet.
   *
   * Marks an agreement as rejected. This happens if <i>recipient</i> station reject block ack setup
   * by an ADDBA Response frame with a failure status code. For now we assume that every QoS station accepts
   * a block ack setup.
   */
  void NotifyAgreementRejected (Mac48Address recipient, uint8_t tid);
  /**
   * \param recipient Address of peer station involved in block ack mechanism.
   * \param tid Traffic ID of transmitted packet.
   *
   * Marks an agreement after not receiving response to ADDBA request. During this state
   * any packets in queue will be transmitted using normal MPDU. This also unblock
   * recipient adress.
   */
  void NotifyAgreementNoReply (Mac48Address recipient, uint8_t tid);
  /**
   * \param recipient Address of peer station involved in block ack mechanism.
   * \param tid Traffic ID of transmitted packet.
   *
   * Set BA agreement to a transitory state to reset it after not receiving response to ADDBA request.
   */
  void NotifyAgreementReset (Mac48Address recipient, uint8_t tid);
  /**
   * \param recipient Address of peer station involved in block ack mechanism.
   * \param tid Traffic ID of transmitted packet.

(-)a/src/wifi/model/mac-low.cc (-3 / +3 lines)

Lines 2594-2601 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2594

2595

      if (!hdr.GetAddr1 ().IsBroadcast () && edcaIt->second->GetMpduAggregator () != 0)

2595

      if (!hdr.GetAddr1 ().IsBroadcast () && edcaIt->second->GetMpduAggregator () != 0)

2596

2597

          //Have to make sure that their exist a block Ack agreement before sending an AMPDU (BlockAck Manager)

2597

          //Have to make sure that the block ACK agreement is established before sending an AMPDU (BlockAck Manager)

2598

          if (edcaIt->second->GetBaAgreementExists (hdr.GetAddr1 (), tid))

2598

          if (edcaIt->second->GetBaAgreementEstablished (hdr.GetAddr1 (), tid))

2599

2600

              /* here is performed mpdu aggregation */

2600

              /* here is performed mpdu aggregation */

2601

              /* MSDU aggregation happened in edca if the user asked for it so m_currentPacket may contains a normal packet or a A-MSDU*/

2601

              /* MSDU aggregation happened in edca if the user asked for it so m_currentPacket may contains a normal packet or a A-MSDU*/

Lines 2849-2855 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2849

2850

                  InsertInTxQueue (packet, peekedHdr, tstamp, tid);

2850

                  InsertInTxQueue (packet, peekedHdr, tstamp, tid);

2851

2852

              if (edcaIt->second->GetBaAgreementExists (hdr.GetAddr1 (), tid))

2852

              if (edcaIt->second->GetBaAgreementEstablished (hdr.GetAddr1 (), tid))

2853

2854

                  edcaIt->second->CompleteAmpduTransfer (peekedHdr.GetAddr1 (), tid);

2854

                  edcaIt->second->CompleteAmpduTransfer (peekedHdr.GetAddr1 (), tid);

2855




}

bool
OriginatorBlockAckAgreement::IsRejected (void) const
{
  return (m_state == REJECTED) ? true : false;
}

bool
OriginatorBlockAckAgreement::IsNoReply (void) const
{
  return (m_state == NO_REPLY) ? true : false;
}

bool
OriginatorBlockAckAgreement::IsReset (void) const
{
  return (m_state == RESET) ? true : false;
}

void




/**
 * \ingroup wifi
 * Maintains the state and information about transmitted MPDUs with ack policy block ack
 * for an originator station. The state diagram is as follows:
 *
   \verbatim
                                    --------------
                                    |  REJECTED  |
                                    --------------
                                          ^
                   receive ADDBAResponse  |
                   status code = failure  |
                                          |
                                          |           receive ADDBAResponse
   /------------\ send ADDBARequest ----------------  status code = success  ----------------
   |   START    |------------------>|   PENDING    |------------------------>|  ESTABLISHED |-----
   \------------/                   ----------------                         ----------------     |
         ^                                |                                    /   ^    ^         |
         |              no ADDBAResponse  |                receive BlockAck   /    |    |         | receive BlockAck
         |                                v           retryPkts + queuePkts  /     |    |         | retryPkts + queuePkts
         |                          ----------------            <           /      |    |         |           >=
         |--------------------------|   NO_REPLY   |   blockAckThreshold   /       |    |         | blockAckThreshold
            Reset after timeout     ----------------                      /        |    |         |
                                                                         v         |    ----------|
                                                            ---------------        |
                                                            |  INACTIVE   |        |
                                                            ---------------        |
                                        send a MPDU (Normal Ack)   |               |
                                        retryPkts + queuePkts      |               |
                                                  >=               |               |
                                         blockAckThreshold         |----------------
   \endverbatim
 *
 * See also OriginatorBlockAckAgreement::State
 */
class OriginatorBlockAckAgreement : public BlockAckAgreement
{

   */
  OriginatorBlockAckAgreement (Mac48Address recipient, uint8_t tid);
  ~OriginatorBlockAckAgreement ();
  /*                                      receive ADDBAResponse
   *  send ADDBARequest ---------------   status code = success  ---------------
   *  ----------------->|   PENDING    |------------------------>|  ESTABLISHED |-----
   *                    ---------------                          ---------------      |
   *                          |                                    /   ^    ^         |
   *   receive ADDBAResponse  |                receive BlockAck   /    |    |         | receive BlockAck
   *   status code = failure  |           retryPkts + queuePkts  /     |    |         | retryPkts + queuePkts
   *                          v                     <           /      |    |         |           >=
   *                   ---------------     blockAckThreshold   /       |    |         | blockAckThreshold
   *                   | UNSUCCESSFUL |                       /        |    |         |
   *                   ---------------                       v         |    ----------|
   *                                            --------------         |
   *                                            |  INACTIVE   |        |
   *                                            --------------         |
   *                        send a MPDU (Normal Ack)   |               |
   *                        retryPkts + queuePkts      |               |
   *                                  >=               |               |
   *                         blockAckThreshold         |----------------
   */
  /**
  * Represents the state for this agreement.
  *

  *    m_blockAckThreshold (see ns3::BlockAckManager). In these conditions the agreement becomes
  *    INACTIVE until that the number of packets reaches the value of m_blockAckThreshold again.
  *
  *  NO_REPLY
  *    No reply after an ADDBA request. In this state the originator will send the rest of packets
  *    in queue using normal MPDU.
  *
  *  RESET
  *    A transient state to mark the agreement for reinitialzation after failed ADDBA request.
  *    Since it is a temporary state, it is not included in the state diagram above. In this
  *    state the next transmission will be treated as if the BA agreement is not created yet.
  *      to failure.
  *
  *  REJECTED (not used for now):
  *    The agreement's state becomes REJECTED if an ADDBAResponse frame is received from recipient 
  *    and the Status Code field is set to failure.
  */
  /// State enumeration
  enum State

    PENDING,
    ESTABLISHED,
    INACTIVE,
    NO_REPLY,
    RESET,
    REJECTED
  };
  /**
   * Set the current state.

   */
  bool IsInactive (void) const;
  /**
   * Check if the current state of this agreement is NO_REPLY.
   *
   * \return true if the current state of this agreement is NO_REPLY,
   *         false otherwise
   */
  bool IsNoReply (void) const;
  /**
   * Check if the current state of this agreement is RESET.
   *
   * \return true if the current state of this agreement is RESET,
   *         false otherwise
   */
  bool IsReset (void) const;
  /**
   * Check if the current state of this agreement is REJECTED.
   *
   * \return true if the current state of this agreement is REJECTED,
   *         false otherwise
   */
  bool IsRejected (void) const;
  /**
   * Notifies a packet's transmission with ack policy Block Ack.
   *




    .SetParent<ns3::Txop> ()
    .SetGroupName ("Wifi")
    .AddConstructor<QosTxop> ()
    .AddAttribute ("AddBaResponseTimeout",
                   "The timeout to wait for ADDBA response after the ACK to "
                   "ADDBA request is received.",
                   TimeValue (MilliSeconds (1)),
                   MakeTimeAccessor (&QosTxop::SetAddBaResponseTimeout,
                                     &QosTxop::GetAddBaResponseTimeout),
                   MakeTimeChecker ())
    .AddAttribute ("FailedAddBaTimeout",
                   "The timeout after a failed BA agreement. During this "
                   "timeout, the originator resumes sending packets using normal "
                   "MPDU. After that, BA agreement is reset and the originator "
                   "will retry BA negotiation.",
                   TimeValue (MilliSeconds (200)),
                   MakeTimeAccessor (&QosTxop::SetFailedAddBaTimeout,
                                     &QosTxop::GetFailedAddBaTimeout),
                   MakeTimeChecker ())
    .AddTraceSource ("BackoffTrace",
                     "Trace source for backoff values",
                     MakeTraceSourceAccessor (&QosTxop::m_backoffTrace),

}

bool
QosTxop::GetBaAgreementEstablished (Mac48Address address, uint8_t tid) const
{
  return m_baManager->ExistsAgreementInState (address, tid, OriginatorBlockAckAgreement::ESTABLISHED);
}

void

          m_currentPacketTimestamp = item->GetTimeStamp ();
          if (m_currentHdr.IsQosData () && !m_currentHdr.GetAddr1 ().IsBroadcast ()
              && m_stationManager->GetQosSupported (m_currentHdr.GetAddr1 ())
              && (!m_baManager->ExistsAgreement (m_currentHdr.GetAddr1 (), m_currentHdr.GetQosTid ())
                  || m_baManager->ExistsAgreementInState (m_currentHdr.GetAddr1 (), m_currentHdr.GetQosTid (), OriginatorBlockAckAgreement::RESET))
              && SetupBlockAckIfNeeded ())
            {
              return;

          uint8_t tid = GetTid (m_currentPacket, m_currentHdr);
          m_low->FlushAggregateQueue (tid);

          if (GetBaAgreementEstablished (m_currentHdr.GetAddr1 (), tid))
            {
              NS_LOG_DEBUG ("Transmit Block Ack Request");
              CtrlBAckRequestHeader reqHdr;

          WifiActionHeader actionHdr;
          Ptr<Packet> p = m_currentPacket->Copy ();
          p->RemoveHeader (actionHdr);
          if (actionHdr.GetCategory () == WifiActionHeader::BLOCK_ACK)
              && actionHdr.GetAction ().blockAck == WifiActionHeader::BLOCK_ACK_DELBA)
            {
              if (actionHdr.GetAction ().blockAck == WifiActionHeader::BLOCK_ACK_DELBA)
              p->PeekHeader (delBa);
              if (delBa.IsByOriginator ())
                {
                  MgtDelBaHeader delBa;
                  p->PeekHeader (delBa);
                  if (delBa.IsByOriginator ())
                    {
                      m_baManager->DestroyAgreement (m_currentHdr.GetAddr1 (), delBa.GetTid ());
                    }
                  else
                    {
                      m_low->DestroyBlockAckAgreement (m_currentHdr.GetAddr1 (), delBa.GetTid ());
                    }
                }
              else if (actionHdr.GetAction ().blockAck == WifiActionHeader::BLOCK_ACK_ADDBA_REQUEST)
                {
                  // Setup addba response timeout
                  MgtAddBaRequestHeader addBa;
                  p->PeekHeader (addBa);
                  Simulator::Schedule (m_addBaResponseTimeout,
                                       &QosTxop::AddBaResponseTimeout, this,
                                       m_currentHdr.GetAddr1 (), addBa.GetTid ());
                }
            }
        }

        {
          m_txFailedCallback (m_currentHdr);
        }
      if (m_currentHdr.IsAction ())
        {
          WifiActionHeader actionHdr;
          m_currentPacket->PeekHeader (actionHdr);
          if (actionHdr.GetCategory () == WifiActionHeader::BLOCK_ACK)
            {
              uint8_t tid = GetTid (m_currentPacket, m_currentHdr);
              if (m_baManager->ExistsAgreementInState (m_currentHdr.GetAddr1 (), tid, OriginatorBlockAckAgreement::PENDING))
                {
                  NS_LOG_DEBUG ("No ACK after ADDBA request");
                  m_baManager->NotifyAgreementNoReply (m_currentHdr.GetAddr1 (), tid);
                  Simulator::Schedule (m_failedAddBaTimeout, &QosTxop::ResetBa, this, m_currentHdr.GetAddr1 (), tid);
                }
            }
        }
      if (GetAmpduExist (m_currentHdr.GetAddr1 ()) || m_currentHdr.IsQosData ())
        {
          uint8_t tid = GetTid (m_currentPacket, m_currentHdr);
          if (GetBaAgreementEstablished (m_currentHdr.GetAddr1 (), tid))
          if (GetBaAgreementExists (m_currentHdr.GetAddr1 (), tid))
            {
              //send Block ACK Request in order to shift WinStart at the receiver
              NS_LOG_DEBUG ("Transmit Block Ack Request");

      || GetAmpduExist (m_currentHdr.GetAddr1 ())
      || (m_stationManager->GetHtSupported ()
          && m_currentHdr.IsQosData ()
          && GetBaAgreementEstablished (m_currentHdr.GetAddr1 (), GetTid (m_currentPacket, m_currentHdr))
          && GetMpduAggregator ()->GetMaxAmpduSize () >= m_currentPacket->GetSize ()))
    {
      //MSDU is not fragmented when it is transmitted using an HT-immediate or

      else
        {
          NS_LOG_DEBUG ("discard ADDBA response" << recipient);
          m_baManager->NotifyAgreementRejected (recipient, tid);
        }
    }
  RestartAccessIfNeeded ();

    }
}

void
QosTxop::AddBaResponseTimeout (Mac48Address recipient, uint8_t tid)
{
  NS_LOG_FUNCTION (this << recipient << +tid);
  // If agreement is still pending, ADDBA response is not received
  if (m_baManager->ExistsAgreementInState (recipient, tid, OriginatorBlockAckAgreement::PENDING))
    {
      m_baManager->NotifyAgreementNoReply (recipient, tid);
      Simulator::Schedule (m_failedAddBaTimeout, &QosTxop::ResetBa, this, m_currentHdr.GetAddr1 (), tid);
      m_backoffTrace = m_rng->GetInteger (0, GetCw ());
      StartBackoffNow (m_backoffTrace);
      RestartAccessIfNeeded ();
    }
}

void
QosTxop::ResetBa (Mac48Address recipient, uint8_t tid)
{
  NS_LOG_FUNCTION (this << recipient << +tid);
  NS_ASSERT (m_baManager->ExistsAgreementInState (recipient, tid, OriginatorBlockAckAgreement::NO_REPLY));
  m_baManager->NotifyAgreementReset (recipient, tid);
}

void
QosTxop::SetAddBaResponseTimeout (Time addBaResponseTimeout)
{
  NS_LOG_FUNCTION (this << addBaResponseTimeout);
  m_addBaResponseTimeout = addBaResponseTimeout;
}

Time
QosTxop::GetAddBaResponseTimeout (void) const
{
  return m_addBaResponseTimeout;
}

void
QosTxop::SetFailedAddBaTimeout (Time failedAddBaTimeout)
{
  NS_LOG_FUNCTION (this << failedAddBaTimeout);
  m_failedAddBaTimeout = failedAddBaTimeout;
}

Time
QosTxop::GetFailedAddBaTimeout (void) const
{
  return m_failedAddBaTimeout;
}

bool
QosTxop::IsQosTxop (void) const
{




   * \param address recipient address of the peer station
   * \param tid traffic ID.
   *
   * \return true if a block ack agreement is established, false otherwise.
   *
   * Checks if a block ack agreement is established with station addressed by
   * <i>recipient</i> for tid <i>tid</i>.
   */
  bool GetBaAgreementEstablished (Mac48Address address, uint8_t tid) const;
  /**
   * \param recipient address of peer station involved in block ack mechanism.
   * \param tid Ttraffic ID of transmitted packet.

   * \param enableAmpdu flag whether A-MPDU is used or not.
   */
  void SetAmpduExist (Mac48Address dest, bool enableAmpdu);
  /**
   * Set the timeout to wait for ADDBA response.
   *
   * \param addBaResponseTimeout the timeout to wait for ADDBA response
   */
  void SetAddBaResponseTimeout (Time addBaResponseTimeout);
  /**
   * Get the timeout for ADDBA response.
   *
   * \returns the timeout to wait for ADDBA response
   */
  Time GetAddBaResponseTimeout (void) const;
  /**
   * Set the timeout for failed BA agreement. During the timeout period,
   * all packets will be transmitted using normal MPDU.
   *
   * \param failedAddBaTimeout the timeout for failed BA agreement
   */
  void SetFailedAddBaTimeout (Time failedAddBaTimeout);
  /**
   * Get the timeout for failed BA agreement.
   *
   * \returns the timeout for failed BA agreement
   */
  Time GetFailedAddBaTimeout (void) const;

  /**
   * Return the next sequence number for the given header.

   * \returns the TXOP fragment offset
   */
  uint32_t GetTxopFragmentOffset (uint32_t fragmentNumber) const;
  /**
   * Callback when ADDBA response is not received after timeout.
   *
   * \param recipient MAC address of recipient
   * \param tid traffic ID
   */
  void AddBaResponseTimeout (Mac48Address recipient, uint8_t tid);
  /**
   * Reset BA agreement after BA negotiation failed.
   *
   * \param recipient MAC address of recipient
   * \param tid traffic ID
   */
  void ResetBa (Mac48Address recipient, uint8_t tid);

  void DoDispose (void);
  void DoInitialize (void);

  Time m_startTxop;                                 //!< the start TXOP time
  bool m_isAccessRequestedForRts;                   //!< flag whether access is requested to transmit a RTS frame
  bool m_currentIsFragmented;                       //!< flag whether current packet is fragmented
  Time m_addBaResponseTimeout;                      //!< timeout for ADDBA response
  Time m_failedAddBaTimeout;                        //!< timeout after failed BA agreement

  TracedValue<uint32_t> m_backoffTrace;   //!< backoff trace value
  TracedValue<uint32_t> m_cwTrace;        //!< CW trace value

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

Lines 24-29	Link Here

#include "ns3/pointer.h"

#include "ns3/pointer.h"

#include "ns3/mobility-model.h"

#include "ns3/mobility-model.h"

#include "ns3/random-variable-stream.h"

#include "ns3/random-variable-stream.h"

#include "ns3/error-model.h"

#include "wifi-phy.h"

#include "wifi-phy.h"

#include "wifi-phy-tag.h"

#include "wifi-phy-tag.h"

#include "ampdu-tag.h"

#include "ampdu-tag.h"

Lines 298-303 WifiPhy::GetTypeId (void)	Link Here

298

                   PointerValue (),

299

                   PointerValue (),

299

                   MakePointerAccessor (&WifiPhy::m_frameCaptureModel),

300

                   MakePointerAccessor (&WifiPhy::m_frameCaptureModel),

300

                   MakePointerChecker <FrameCaptureModel> ())

301

                   MakePointerChecker <FrameCaptureModel> ())

302

    .AddAttribute ("PostReceptionErrorModel",

303

                   "An optional packet error model can be added to the receive "

304

                   "packet process after any propagation-based (SNR-based) error "

305

                   "models have been applied. Typically this is used to force "

306

                   "specific packet drops, for testing purposes.",

307

                   PointerValue (),

308

                   MakePointerAccessor (&WifiPhy::m_postReceptionErrorModel),

309

                   MakePointerChecker<ErrorModel> ())

301

    .AddTraceSource ("PhyTxBegin",

310

    .AddTraceSource ("PhyTxBegin",

302

                     "Trace source indicating a packet "

311

                     "Trace source indicating a packet "

303

                     "has begun transmitting over the channel medium",

312

                     "has begun transmitting over the channel medium",

Lines 387-392 WifiPhy::DoDispose (void)	Link Here

387

  m_mobility = 0;

396

  m_mobility = 0;

388

  m_state = 0;

397

  m_state = 0;

389

  m_wifiRadioEnergyModel = 0;

398

  m_wifiRadioEnergyModel = 0;

399

  m_postReceptionErrorModel = 0;

390

  m_deviceRateSet.clear ();

400

  m_deviceRateSet.clear ();

391

  m_deviceMcsSet.clear ();

401

  m_deviceMcsSet.clear ();

392

402

Lines 718-723 WifiPhy::SetErrorRateModel (const Ptr<ErrorRateModel> rate)	Link Here

718

  m_interference.SetNumberOfReceiveAntennas (GetNumberOfAntennas ());

728

  m_interference.SetNumberOfReceiveAntennas (GetNumberOfAntennas ());

719

729

720

730

731

void

732

WifiPhy::SetPostReceptionErrorModel (const Ptr<ErrorModel> em)

733

734

  NS_LOG_FUNCTION (this << em);

735

  m_postReceptionErrorModel = em;

736

737

721

void

738

void

722

WifiPhy::SetFrameCaptureModel (const Ptr<FrameCaptureModel> model)

739

WifiPhy::SetFrameCaptureModel (const Ptr<FrameCaptureModel> model)

723

740

Lines 2588-2594 WifiPhy::EndReceive (Ptr<Packet> packet, WifiPreamble preamble, MpduType mpdutyp	Link Here

2588

      NS_LOG_DEBUG ("mode=" << (event->GetPayloadMode ().GetDataRate (event->GetTxVector ())) <<

2605

      NS_LOG_DEBUG ("mode=" << (event->GetPayloadMode ().GetDataRate (event->GetTxVector ())) <<

2589

                    ", snr(dB)=" << RatioToDb (snrPer.snr) << ", per=" << snrPer.per << ", size=" << packet->GetSize ());

2606

                    ", snr(dB)=" << RatioToDb (snrPer.snr) << ", per=" << snrPer.per << ", size=" << packet->GetSize ());

2590

2607

2591

      if (m_random->GetValue () > snrPer.per)

2608

//

2609

      // There are two error checks: PER and receive error model check.

2610

      // PER check models is typical for Wi-Fi and is based on signal modulation;

2611

      // Receive error model is optional, if we have an error model and

2612

      // it indicates that the packet is corrupt, drop the packet.

2613

//

2614

      if (m_random->GetValue () > snrPer.per &&

2615

          !(m_postReceptionErrorModel && m_postReceptionErrorModel->IsCorrupt (packet)))

2592

2616

2593

          NotifyRxEnd (packet);

2617

          NotifyRxEnd (packet);

2594

          SignalNoiseDbm signalNoise;

2618

          SignalNoiseDbm signalNoise;




class FrameCaptureModel;
class WifiRadioEnergyModel;
class UniformRandomVariable;
class ErrorModel;

/// SignalNoiseDbm structure
struct SignalNoiseDbm

   * \param rate the error rate model
   */
  void SetErrorRateModel (const Ptr<ErrorRateModel> rate);
  /**
   * Attach a receive ErrorModel to the WifiPhy.
   *
   * The WifiPhy may optionally include an ErrorModel in
   * the packet receive chain. The error model is additive
   * to any modulation-based error model based on SNR, and
   * is typically used to force specific packet losses or
   * for testing purposes.
   *
   * \param em Ptr to the ErrorModel.
   */
  void SetPostReceptionErrorModel (const Ptr<ErrorModel> em);
  /**
   * Sets the frame capture model.
   *

  Ptr<Event> m_currentEvent; //!< Hold the current event
  Ptr<FrameCaptureModel> m_frameCaptureModel; //!< Frame capture model
  Ptr<WifiRadioEnergyModel> m_wifiRadioEnergyModel; //!< Wifi radio energy model
  Ptr<ErrorModel> m_postReceptionErrorModel; //!< Error model for receive packet events

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

(-)a/src/wifi/test/wifi-aggregation-test.cc (+1 lines)

Lines 128-133 AmpduAggregationTest::DoRun (void)	Link Here

128

  reqHdr.SetTimeout (0);

128

  reqHdr.SetTimeout (0);

129

  reqHdr.SetStartingSequence (0);

129

  reqHdr.SetStartingSequence (0);

130

  m_mac->GetBEQueue ()->m_baManager->CreateAgreement (&reqHdr, hdr.GetAddr1 ());

130

  m_mac->GetBEQueue ()->m_baManager->CreateAgreement (&reqHdr, hdr.GetAddr1 ());

131

  m_mac->GetBEQueue ()->m_baManager->NotifyAgreementEstablished (hdr.GetAddr1 (), 0, 0);

131

132

  //-----------------------------------------------------------------------------------------------------

133

  //-----------------------------------------------------------------------------------------------------

133

134




#include "ns3/pointer.h"
#include "ns3/rng-seed-manager.h"
#include "ns3/config.h"
#include "ns3/error-model.h"
#include "ns3/packet-socket-server.h"
#include "ns3/packet-socket-client.h"
#include "ns3/packet-socket-helper.h"

{
  m_received = 0;

  Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("2304"));

  NodeContainer wifiStaNode;
  wifiStaNode.Create (1);


    NS_TEST_ASSERT_MSG_EQ (phySta->GetChannelWidth (), 40, "802.11 5GHz configuration");
    NS_TEST_ASSERT_MSG_EQ (phySta->GetFrequency (), 5220, "802.11 5GHz configuration");
  }
  // modify cases 13 and 14 to avoid Config::SetDefault ()
  {
    // case 13
    WifiHelper wifi;

void
Bug2483TestCase::DoRun (void)
{
  Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue ("500")); // so as to force RTS/CTS for data frames
  Config::SetDefault ("ns3::WifiPhy::CcaMode1Threshold", DoubleValue (-62.0));

  uint16_t channelWidth = 40; // at least 40 MHz expected here

  NodeContainer wifiStaNode;

  spectrumPhy.Set ("ChannelWidth", UintegerValue (channelWidth));
  spectrumPhy.Set ("TxPowerStart", DoubleValue (10));
  spectrumPhy.Set ("TxPowerEnd", DoubleValue (10));
  spectrumPhy.Set ("CcaMode1Threshold", DoubleValue (-62.0));

  WifiHelper wifi;
  wifi.SetStandard (WIFI_PHY_STANDARD_80211ac);
  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",
                                "DataMode", StringValue ("VhtMcs8"),
                                "ControlMode", StringValue ("VhtMcs8"),
                                "RtsCtsThreshold", StringValue ("500")); // so as to force RTS/CTS for data frames

  WifiMacHelper mac;
  mac.SetType ("ns3::StaWifiMac");

  }
}

//-----------------------------------------------------------------------------
/**
 * Make sure that the ADDBA handshake process is protected.
 *
 * The scenario considers an access point and a station. It utilizes
 * ReceiveListErrorModel to drop by force ADDBA request on STA or ADDBA
 * response on AP. The AP sends 5 packets of each 1000 bytes (thus generating
 * BA agreement), 2 times during the test at 0.5s and 0.8s. We only drop the
 * first ADDBA request/response of the first BA negotiation. Therefore, we
 * expect that the packets still in queue after the failed BA agreement will be
 * sent with normal MPDU, and packets queued after that should be sent with
 * A-MPDU.
 *
 * This test consider 2 cases:
 *
 *   1. ADDBA request packets are blocked on receive at STA, triggering
 *      transmission failure at AP
 *   2. ADDBA response packets are blocked on receive at AP, STA stops
 *      retransmission of ADDBA response
 *
 * See \bugid{2470}
 */

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

private:
  /**
   * Callback when packet is received
   * \param context node context
   * \param p the received packet
   * \param channelFreqMhz the channel frequency in MHz
   * \param txVector the TX vector
   * \param aMpdu the A-MPDU info
   * \param signalNoise the signal noise in dBm
   */
  void RxCallback (std::string context, Ptr<const Packet> p, uint16_t channelFreqMhz, WifiTxVector txVector, MpduInfo aMpdu, SignalNoiseDbm signalNoise);
  /**
   * Callback when packet is dropped
   * \param context node context
   * \param p the received packet
   */
  void RxDropCallback (std::string context, Ptr<const Packet> p);
  /**
   * Triggers the arrival of a burst of 1000 Byte-long packets in the source device
   * \param numPackets number of packets in burst
   * \param sourceDevice pointer to the source NetDevice
   * \param destination address of the destination device
   */
  void SendPacketBurst (uint32_t numPackets, Ptr<NetDevice> sourceDevice, Address& destination) const;
  /**
   * Run subtest for this test suite
   * \param apErrorModel ErrorModel used for AP
   * \param staErrorModel ErrorModel used for STA
   */
  void RunSubtest (PointerValue apErrorModel, PointerValue staErrorModel);

  uint8_t m_receivedNormalMpduCount; ///< Count received normal MPDU packets on STA
  uint8_t m_receivedAmpduCount;      ///< Count received A-MPDU packets on STA
  uint8_t m_droppedActionCount;      ///< Count dropped ADDBA request/response
};

Bug2470TestCase::Bug2470TestCase ()
  : TestCase ("Test case for Bug 2470"),
    m_receivedNormalMpduCount (0),
    m_receivedAmpduCount (0),
    m_droppedActionCount (0)
{
}

Bug2470TestCase::~Bug2470TestCase ()
{
}

void
Bug2470TestCase::RxCallback (std::string context, Ptr<const Packet> p, uint16_t channelFreqMhz, WifiTxVector txVector, MpduInfo aMpdu, SignalNoiseDbm signalNoise)
{
  Ptr<Packet> packet = p->Copy ();
  if (aMpdu.type != MpduType::NORMAL_MPDU)
    {
      m_receivedAmpduCount++;
    }
  else
    {
      WifiMacHeader hdr;
      packet->RemoveHeader (hdr);
      if (hdr.IsData ())
        {
          m_receivedNormalMpduCount++;
        }
    }
}

void
Bug2470TestCase::RxDropCallback (std::string context, Ptr<const Packet> p)
{
  Ptr<Packet> packet = p->Copy ();
  WifiMacHeader hdr;
  packet->RemoveHeader (hdr);
  if (hdr.IsAction ())
    {
      m_droppedActionCount++;
    }
}

void
Bug2470TestCase::SendPacketBurst (uint32_t numPackets, Ptr<NetDevice> sourceDevice,
                                  Address& destination) const
{
  for (uint32_t i = 0; i < numPackets; i++)
    {
      Ptr<Packet> pkt = Create<Packet> (1000); // 1000 dummy bytes of data
      sourceDevice->Send (pkt, destination, 0);
    }
}

void
Bug2470TestCase::RunSubtest (PointerValue apErrorModel, PointerValue staErrorModel)
{
  RngSeedManager::SetSeed (1);
  RngSeedManager::SetRun (1);

  NodeContainer wifiApNode, wifiStaNode;
  wifiApNode.Create (1);
  wifiStaNode.Create (1);

  YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();
  YansWifiChannelHelper channel = YansWifiChannelHelper::Default ();
  phy.SetChannel (channel.Create ());

  WifiHelper wifi;
  wifi.SetStandard (WIFI_PHY_STANDARD_80211n_5GHZ);
  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",
                                "DataMode", StringValue ("HtMcs7"),
                                "ControlMode", StringValue ("HtMcs7"));

  WifiMacHelper mac;
  NetDeviceContainer apDevice;
  phy.Set ("PostReceptionErrorModel", apErrorModel);
  mac.SetType ("ns3::ApWifiMac", "EnableBeaconJitter", BooleanValue (false));
  apDevice = wifi.Install (phy, mac, wifiApNode);

  NetDeviceContainer staDevice;
  phy.Set ("PostReceptionErrorModel", staErrorModel);
  mac.SetType ("ns3::StaWifiMac");
  staDevice = wifi.Install (phy, mac, wifiStaNode);

  MobilityHelper mobility;
  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
  positionAlloc->Add (Vector (0.0, 0.0, 0.0));
  positionAlloc->Add (Vector (1.0, 0.0, 0.0));
  mobility.SetPositionAllocator (positionAlloc);

  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
  mobility.Install (wifiApNode);
  mobility.Install (wifiStaNode);

  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/MonitorSnifferRx", MakeCallback (&Bug2470TestCase::RxCallback, this));
  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/PhyRxDrop", MakeCallback (&Bug2470TestCase::RxDropCallback, this));

  Simulator::Schedule (Seconds (0.5), &Bug2470TestCase::SendPacketBurst, this, 5, apDevice.Get (0), staDevice.Get (0)->GetAddress ());
  Simulator::Schedule (Seconds (0.8), &Bug2470TestCase::SendPacketBurst, this, 5, apDevice.Get (0), staDevice.Get (0)->GetAddress ());

  Simulator::Stop (Seconds (1.0));
  Simulator::Run ();
  Simulator::Destroy ();
}

void
Bug2470TestCase::DoRun (void)
{
  // Create ReceiveListErrorModel to corrupt ADDBA req packet. We use ReceiveListErrorModel
  // instead of ListErrorModel since packet UID is incremented between simulations. But
  // problem may occur because of random stream, therefore we suppress usage of RNG as
  // much as possible (i.e., removing beacon jitter).
  Ptr<ReceiveListErrorModel> staPem = CreateObject<ReceiveListErrorModel> ();
  std::list<uint32_t> blackList;
  // Block ADDBA request 6 times (== maximum number of MAC frame transmissions in the addba response timeout interval)
  blackList.push_back (8);
  blackList.push_back (9);
  blackList.push_back (10);
  blackList.push_back (11);
  blackList.push_back (12);
  blackList.push_back (13);
  staPem->SetList (blackList);

  {
    RunSubtest (PointerValue (), PointerValue (staPem));
    NS_TEST_ASSERT_MSG_EQ (m_droppedActionCount, 6, "ADDBA request packet is not dropped correctly");
    // There are two sets of 5 packets to be transmitted. The first 5 packets should be sent by normal
    // MPDU because of failed ADDBA handshake. For the second set, the first packet should be sent by
    // normal MPDU, and the rest with A-MPDU. In total we expect to receive 2 normal MPDU packets and
    // 8 A-MPDU packets.
    NS_TEST_ASSERT_MSG_EQ (m_receivedNormalMpduCount, 2, "Receiving incorrect number of normal MPDU packet on subtest 1");
    NS_TEST_ASSERT_MSG_EQ (m_receivedAmpduCount, 8, "Receiving incorrect number of A-MPDU packet on subtest 1");
  }

  m_receivedNormalMpduCount = 0;
  m_receivedAmpduCount = 0;
  m_droppedActionCount = 0;
  Ptr<ReceiveListErrorModel> apPem = CreateObject<ReceiveListErrorModel> ();
  blackList.clear ();
  // Block ADDBA request 3 times (== maximum number of MAC frame transmissions in the addba response timeout interval)
  blackList.push_back (4);
  blackList.push_back (5);
  blackList.push_back (6);
  apPem->SetList (blackList);

  {
    RunSubtest (PointerValue (apPem), PointerValue ());
    NS_TEST_ASSERT_MSG_EQ (m_droppedActionCount, 3, "ADDBA response packet is not dropped correctly");
    // Similar to subtest 1, we also expect to receive 6 normal MPDU packets and 4 A-MPDU packets.
    NS_TEST_ASSERT_MSG_EQ (m_receivedNormalMpduCount, 6, "Receiving incorrect number of normal MPDU packet on subtest 2");
    NS_TEST_ASSERT_MSG_EQ (m_receivedAmpduCount, 4, "Receiving incorrect number of A-MPDU packet on subtest 2");
  }
}

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

  AddTestCase (new Bug2483TestCase, TestCase::QUICK); //Bug 2483
  AddTestCase (new Bug2831TestCase, TestCase::QUICK); //Bug 2831
  AddTestCase (new StaWifiMacScanningTestCase, TestCase::QUICK); //Bug 2399
  AddTestCase (new Bug2470TestCase, TestCase::QUICK); //Bug 2470
}

static WifiTestSuite g_wifiTestSuite; ///< the test suite

Return to bug 2470