ht-frame-exchange-manager.cc

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2020 Universita' degli Studi di Napoli Federico II
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Stefano Avallone <stavallo@unina.it>
 */

#include "ns3/log.h"
#include "ns3/abort.h"
#include "ht-frame-exchange-manager.h"
#include "ns3/wifi-mac-queue.h"
#include "ns3/mgt-headers.h"
#include "ns3/recipient-block-ack-agreement.h"
#include "ns3/wifi-utils.h"
#include "ns3/snr-tag.h"
#include "ns3/ctrl-headers.h"

#undef NS_LOG_APPEND_CONTEXT
#define NS_LOG_APPEND_CONTEXT std::clog << "[mac=" << m_self << "] "

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("HtFrameExchangeManager");

NS_OBJECT_ENSURE_REGISTERED (HtFrameExchangeManager);

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

HtFrameExchangeManager::HtFrameExchangeManager ()
{
  NS_LOG_FUNCTION (this);
  m_msduAggregator = CreateObject<MsduAggregator> ();
  m_mpduAggregator = CreateObject<MpduAggregator> ();
}

HtFrameExchangeManager::~HtFrameExchangeManager ()
{
  NS_LOG_FUNCTION_NOARGS ();
}

void
HtFrameExchangeManager::DoDispose (void)
{
  NS_LOG_FUNCTION (this);
  m_agreements.clear ();
  m_msduAggregator = 0;
  m_mpduAggregator = 0;
  m_psdu = 0;
  m_txParams.Clear ();
  QosFrameExchangeManager::DoDispose ();
}

void
HtFrameExchangeManager::SetWifiMac (const Ptr<RegularWifiMac> mac)
{
  m_msduAggregator->SetWifiMac (mac);
  m_mpduAggregator->SetWifiMac (mac);
  QosFrameExchangeManager::SetWifiMac (mac);
}

Ptr<MsduAggregator>
HtFrameExchangeManager::GetMsduAggregator (void) const
{
  return m_msduAggregator;
}

Ptr<MpduAggregator>
HtFrameExchangeManager::GetMpduAggregator (void) const
{
  return m_mpduAggregator;
}

Ptr<BlockAckManager>
HtFrameExchangeManager::GetBaManager (uint8_t tid) const
{
  return m_mac->GetQosTxop (tid)->GetBaManager ();
}

bool
HtFrameExchangeManager::NeedSetupBlockAck (Mac48Address recipient, uint8_t tid)
{
  Ptr<QosTxop> qosTxop = m_mac->GetQosTxop (tid);
  bool establish;

  if (!m_mac->GetWifiRemoteStationManager ()->GetHtSupported (recipient))
    {
      establish = false;
    }
  else if (qosTxop->GetBaManager ()->ExistsAgreement (recipient, tid)
           && !qosTxop->GetBaManager ()->ExistsAgreementInState (recipient, tid, OriginatorBlockAckAgreement::RESET))
    {
      establish = false;
    }
  else
    {
      uint32_t packets = qosTxop->GetWifiMacQueue ()->GetNPacketsByTidAndAddress (tid, recipient);
      establish = ((qosTxop->GetBlockAckThreshold () > 0 && packets >= qosTxop->GetBlockAckThreshold ())
                   || (m_mpduAggregator->GetMaxAmpduSize (recipient, tid, WIFI_MOD_CLASS_HT) > 0 && packets > 1)
                   || m_mac->GetWifiRemoteStationManager ()->GetVhtSupported ());
    }

  NS_LOG_FUNCTION (this << recipient << +tid << establish);
  return establish;
}

void
HtFrameExchangeManager::SendAddBaRequest (Mac48Address dest, uint8_t tid, uint16_t startingSeq,
                                          uint16_t timeout, bool immediateBAck)
{
  NS_LOG_FUNCTION (this << dest << +tid << startingSeq << timeout << immediateBAck);
  NS_LOG_DEBUG ("Send ADDBA request to " << dest);

  WifiMacHeader hdr;
  hdr.SetType (WIFI_MAC_MGT_ACTION);
  hdr.SetAddr1 (dest);
  hdr.SetAddr2 (m_self);
  hdr.SetAddr3 (m_bssid);
  hdr.SetDsNotTo ();
  hdr.SetDsNotFrom ();

  WifiActionHeader actionHdr;
  WifiActionHeader::ActionValue action;
  action.blockAck = WifiActionHeader::BLOCK_ACK_ADDBA_REQUEST;
  actionHdr.SetAction (WifiActionHeader::BLOCK_ACK, action);

  Ptr<Packet> packet = Create<Packet> ();
  // Setting ADDBARequest header
  MgtAddBaRequestHeader reqHdr;
  reqHdr.SetAmsduSupport (true);
  if (immediateBAck)
    {
      reqHdr.SetImmediateBlockAck ();
    }
  else
    {
      reqHdr.SetDelayedBlockAck ();
    }
  reqHdr.SetTid (tid);
  /* For now we don't use buffer size field in the ADDBA request frame. The recipient
   * will choose how many packets it can receive under block ack.
   */
  reqHdr.SetBufferSize (0);
  reqHdr.SetTimeout (timeout);
  // set the starting sequence number for the BA agreement
  reqHdr.SetStartingSequence (startingSeq);

  GetBaManager (tid)->CreateAgreement (&reqHdr, dest);

  packet->AddHeader (reqHdr);
  packet->AddHeader (actionHdr);

  Ptr<WifiMacQueueItem> mpdu = Create<WifiMacQueueItem> (packet, hdr);

  // get the sequence number for the ADDBA Request management frame
  uint16_t sequence = m_txMiddle->GetNextSequenceNumberFor (&mpdu->GetHeader ());
  mpdu->GetHeader ().SetSequenceNumber (sequence);

  WifiTxParameters txParams;
  txParams.m_txVector = m_mac->GetWifiRemoteStationManager ()->GetDataTxVector (mpdu->GetHeader ());
  txParams.m_protection = std::unique_ptr<WifiProtection> (new WifiNoProtection);
  txParams.m_acknowledgment = GetAckManager ()->TryAddMpdu (mpdu, txParams);

  SendMpduWithProtection (mpdu, txParams);
}

void
HtFrameExchangeManager::SendAddBaResponse (const MgtAddBaRequestHeader *reqHdr,
                                           Mac48Address originator)
{
  NS_LOG_FUNCTION (this << originator);
  WifiMacHeader hdr;
  hdr.SetType (WIFI_MAC_MGT_ACTION);
  hdr.SetAddr1 (originator);
  hdr.SetAddr2 (m_self);
  hdr.SetAddr3 (m_bssid);
  hdr.SetDsNotFrom ();
  hdr.SetDsNotTo ();

  MgtAddBaResponseHeader respHdr;
  StatusCode code;
  code.SetSuccess ();
  respHdr.SetStatusCode (code);
  //Here a control about queues type?
  respHdr.SetAmsduSupport (reqHdr->IsAmsduSupported ());

  if (reqHdr->IsImmediateBlockAck ())
    {
      respHdr.SetImmediateBlockAck ();
    }
  else
    {
      respHdr.SetDelayedBlockAck ();
    }
  respHdr.SetTid (reqHdr->GetTid ());

  respHdr.SetBufferSize (GetSupportedBaBufferSize () - 1);
  respHdr.SetTimeout (reqHdr->GetTimeout ());

  WifiActionHeader actionHdr;
  WifiActionHeader::ActionValue action;
  action.blockAck = WifiActionHeader::BLOCK_ACK_ADDBA_RESPONSE;
  actionHdr.SetAction (WifiActionHeader::BLOCK_ACK, action);

  Ptr<Packet> packet = Create<Packet> ();
  packet->AddHeader (respHdr);
  packet->AddHeader (actionHdr);

  CreateBlockAckAgreement (&respHdr, originator, reqHdr->GetStartingSequence ());

  //It is unclear which queue this frame should go into. For now we
  //bung it into the queue corresponding to the TID for which we are
  //establishing an agreement, and push it to the head.
  m_mac->GetQosTxop (reqHdr->GetTid ())->PushFront (packet, hdr);
}

uint16_t
HtFrameExchangeManager::GetSupportedBaBufferSize (void) const
{
  return 64;
}

void
HtFrameExchangeManager::SendDelbaFrame (Mac48Address addr, uint8_t tid, bool byOriginator)
{
  NS_LOG_FUNCTION (this << addr << +tid << byOriginator);
  WifiMacHeader hdr;
  hdr.SetType (WIFI_MAC_MGT_ACTION);
  hdr.SetAddr1 (addr);
  hdr.SetAddr2 (m_self);
  hdr.SetAddr3 (m_bssid);
  hdr.SetDsNotTo ();
  hdr.SetDsNotFrom ();

  MgtDelBaHeader delbaHdr;
  delbaHdr.SetTid (tid);
  if (byOriginator)
    {
      delbaHdr.SetByOriginator ();
      GetBaManager (tid)->DestroyAgreement (addr, tid);
    }
  else
    {
      delbaHdr.SetByRecipient ();
      DestroyBlockAckAgreement (addr, tid);
    }

  WifiActionHeader actionHdr;
  WifiActionHeader::ActionValue action;
  action.blockAck = WifiActionHeader::BLOCK_ACK_DELBA;
  actionHdr.SetAction (WifiActionHeader::BLOCK_ACK, action);

  Ptr<Packet> packet = Create<Packet> ();
  packet->AddHeader (delbaHdr);
  packet->AddHeader (actionHdr);

  m_mac->GetQosTxop (tid)->GetWifiMacQueue ()->PushFront (Create<WifiMacQueueItem> (packet, hdr));
}

void
HtFrameExchangeManager::CreateBlockAckAgreement (const MgtAddBaResponseHeader *respHdr, Mac48Address originator,
                                                 uint16_t startingSeq)
{
  NS_LOG_FUNCTION (this << *respHdr << originator << startingSeq);
  uint8_t tid = respHdr->GetTid ();
  
  RecipientBlockAckAgreement agreement (originator, respHdr->IsAmsduSupported (), tid,
                                        respHdr->GetBufferSize () + 1, respHdr->GetTimeout (),
                                        startingSeq,
                                        m_mac->GetWifiRemoteStationManager ()->GetHtSupported ()
                                        && m_mac->GetWifiRemoteStationManager ()->GetHtSupported (originator));
  agreement.SetMacRxMiddle (m_rxMiddle);
  if (respHdr->IsImmediateBlockAck ())
    {
      agreement.SetImmediateBlockAck ();
    }
  else
    {
      agreement.SetDelayedBlockAck ();
    }

  if (respHdr->GetTimeout () != 0)
    {
      Time timeout = MicroSeconds (1024 * agreement.GetTimeout ());

      agreement.m_inactivityEvent = Simulator::Schedule (timeout, &HtFrameExchangeManager::SendDelbaFrame,
                                                         this, originator, tid, false);
    }

  m_agreements.insert ({{originator, tid}, agreement});
  GetBaManager (tid)->SetBlockAckInactivityCallback (MakeCallback (&HtFrameExchangeManager::SendDelbaFrame, this));
}

void
HtFrameExchangeManager::DestroyBlockAckAgreement  (Mac48Address originator, uint8_t tid)
{
  NS_LOG_FUNCTION (this << originator << +tid);

  auto agreementIt = m_agreements.find ({originator, tid});
  if (agreementIt != m_agreements.end ())
    {
      // forward up the buffered MPDUs before destroying the agreement
      agreementIt->second.Flush ();
      m_agreements.erase (agreementIt);
    }
}

bool
HtFrameExchangeManager::StartFrameExchange (Ptr<QosTxop> edca, Time availableTime, bool initialFrame)
{
  NS_LOG_FUNCTION (this << edca << availableTime << initialFrame);

  // First, check if there is a BAR to be transmitted
  if (SendMpduFromBaManager (edca, availableTime, initialFrame))
    {
      return true;
    }

  Ptr<const WifiMacQueueItem> peekedItem = edca->PeekNextMpdu ();

  // Even though channel access is requested when the queue is not empty, at
  // the time channel access is granted the lifetime of the packet might be
  // expired and the queue might be empty.
  if (peekedItem == 0)
    {
      NS_LOG_DEBUG ("No frames available for transmission");
      return false;
    }

  const WifiMacHeader& hdr = peekedItem->GetHeader ();
  // setup a Block Ack agreement if needed
  if (hdr.IsQosData () && !hdr.GetAddr1 ().IsGroup ()
      && NeedSetupBlockAck (hdr.GetAddr1 (), hdr.GetQosTid ()))
    {
      // if the peeked MPDU has been already transmitted, use its sequence number
      // as the starting sequence number for the BA agreement, otherwise use the
      // next available sequence number
      uint16_t startingSeq = (hdr.IsRetry () ? hdr.GetSequenceNumber ()
                                             : m_txMiddle->GetNextSeqNumberByTidAndAddress (hdr.GetQosTid (),
                                                                                            hdr.GetAddr1 ()));
      SendAddBaRequest (hdr.GetAddr1 (), hdr.GetQosTid (), startingSeq,
                        edca->GetBlockAckInactivityTimeout (), true);
      return true;
    }

  // Use SendDataFrame if we can try aggregation
  if (hdr.IsQosData () && !hdr.GetAddr1 ().IsGroup () && !peekedItem->IsFragment ()
      && !m_mac->GetWifiRemoteStationManager ()->NeedFragmentation (peekedItem))
    {
      return SendDataFrame (peekedItem, availableTime, initialFrame);
    }

  // Use the QoS FEM to transmit the frame in all the other cases, i.e.:
  // - the frame is not a QoS data frame
  // - the frame is a broadcast QoS data frame
  // - the frame is a fragment
  // - the frame must be fragmented
  return QosFrameExchangeManager::StartFrameExchange (edca, availableTime, initialFrame);
}

bool
HtFrameExchangeManager::SendMpduFromBaManager (Ptr<QosTxop> edca, Time availableTime, bool initialFrame)
{
  NS_LOG_FUNCTION (this << edca << availableTime << initialFrame);

  // First, check if there is a BAR to be transmitted
  Ptr<const WifiMacQueueItem> peekedItem = edca->GetBaManager ()->GetBar (false);

  if (peekedItem == 0)
    {
      NS_LOG_DEBUG ("Block Ack Manager returned no frame to send");
      return false;
    }

  NS_ASSERT (peekedItem->GetHeader ().IsBlockAckReq ());

  // Prepare the TX parameters. Note that the default ack manager expects the
  // data TxVector in the m_txVector field to compute the BlockAck TxVector.
  // The m_txVector field of the TX parameters is set to the BlockAckReq TxVector
  // a few lines below.
  WifiTxParameters txParams;
  txParams.m_txVector = m_mac->GetWifiRemoteStationManager ()->GetDataTxVector (peekedItem->GetHeader ());
  txParams.m_protection = std::unique_ptr<WifiProtection> (new WifiNoProtection);
  txParams.m_acknowledgment = GetAckManager ()->TryAddMpdu (peekedItem, txParams);

  NS_ABORT_IF (txParams.m_acknowledgment->method != WifiAcknowledgment::BLOCK_ACK);

  WifiBlockAck* blockAcknowledgment = static_cast<WifiBlockAck*> (txParams.m_acknowledgment.get ());
  CalculateAcknowledgmentTime (blockAcknowledgment);
  // the BlockAckReq frame is sent using the same TXVECTOR as the BlockAck frame
  txParams.m_txVector = blockAcknowledgment->blockAckTxVector;

  Time barTxDuration = m_phy->CalculateTxDuration (peekedItem->GetSize (),
                                                   blockAcknowledgment->blockAckTxVector,
                                                   m_phy->GetPhyBand ());

  // if the available time is limited and we are not transmitting the initial
  // frame of the TXOP, we have to check that this frame and its response fit
  // within the given time limits
  if (availableTime != Time::Min () && !initialFrame
      && barTxDuration + m_phy->GetSifs () + blockAcknowledgment->acknowledgmentTime > availableTime)
    {
      NS_LOG_DEBUG ("Not enough time to send the BAR frame returned by the Block Ack Manager");
      return false;
    }

  // we can transmit the BlockAckReq frame
  Ptr<const WifiMacQueueItem> mpdu = edca->GetBaManager ()->GetBar ();
  SendPsduWithProtection (Create<WifiPsdu> (mpdu, false), txParams);
  return true;
}

bool
HtFrameExchangeManager::SendDataFrame (Ptr<const WifiMacQueueItem> peekedItem,
                                       Time availableTime, bool initialFrame)
{
  NS_ASSERT (peekedItem != 0 && peekedItem->GetHeader ().IsQosData ()
             && !peekedItem->GetHeader ().GetAddr1 ().IsBroadcast ()
             && !peekedItem->IsFragment ());
  NS_LOG_FUNCTION (this << *peekedItem << availableTime << initialFrame);

  Ptr<QosTxop> edca = m_mac->GetQosTxop (peekedItem->GetHeader ().GetQosTid ());
  WifiTxParameters txParams;
  txParams.m_txVector = m_mac->GetWifiRemoteStationManager ()->GetDataTxVector (peekedItem->GetHeader ());
  WifiMacQueueItem::QueueIteratorPair queueIt;
  Ptr<WifiMacQueueItem> mpdu = edca->GetNextMpdu (peekedItem, txParams, availableTime, initialFrame, queueIt);

  if (mpdu == nullptr)
    {
      NS_LOG_DEBUG ("Not enough time to transmit a frame");
      return false;
    }

  // try A-MPDU aggregation
  std::vector<Ptr<WifiMacQueueItem>> mpduList = m_mpduAggregator->GetNextAmpdu (mpdu, txParams,
                                                                                availableTime, queueIt);
  NS_ASSERT (txParams.m_acknowledgment);

  if (mpduList.size () > 1)
    {
      // A-MPDU aggregation succeeded
      SendPsduWithProtection (Create<WifiPsdu> (std::move (mpduList)), txParams);
    }
  else if (txParams.m_acknowledgment->method == WifiAcknowledgment::BAR_BLOCK_ACK)
    {
      // a QoS data frame using the Block Ack policy can be followed by a BlockAckReq
      // frame and a BlockAck frame. Such a sequence is handled by the HT FEM
      SendPsduWithProtection (Create<WifiPsdu> (mpdu, false), txParams);
    }
  else
    {
      // transmission can be handled by the base FEM
      SendMpduWithProtection (mpdu, txParams);
    }

  return true;
}

void
HtFrameExchangeManager::CalculateAcknowledgmentTime (WifiAcknowledgment* acknowledgment) const
{
  NS_LOG_FUNCTION (this << acknowledgment);
  NS_ASSERT (acknowledgment != nullptr);

  if (acknowledgment->method == WifiAcknowledgment::BLOCK_ACK)
    {
      WifiBlockAck* blockAcknowledgment = static_cast<WifiBlockAck*> (acknowledgment);
      Time baTxDuration = m_phy->CalculateTxDuration (GetBlockAckSize (blockAcknowledgment->baType),
                                                      blockAcknowledgment->blockAckTxVector,
                                                      m_phy->GetPhyBand ());
      blockAcknowledgment->acknowledgmentTime = m_phy->GetSifs () + baTxDuration;
    }
  else if (acknowledgment->method == WifiAcknowledgment::BAR_BLOCK_ACK)
    {
      WifiBarBlockAck* barBlockAcknowledgment = static_cast<WifiBarBlockAck*> (acknowledgment);
      Time barTxDuration = m_phy->CalculateTxDuration (GetBlockAckRequestSize (barBlockAcknowledgment->barType),
                                                      barBlockAcknowledgment->blockAckReqTxVector,
                                                      m_phy->GetPhyBand ());
      Time baTxDuration = m_phy->CalculateTxDuration (GetBlockAckSize (barBlockAcknowledgment->baType),
                                                      barBlockAcknowledgment->blockAckTxVector,
                                                      m_phy->GetPhyBand ());
      barBlockAcknowledgment->acknowledgmentTime = 2 * m_phy->GetSifs () + barTxDuration + baTxDuration;
    }
  else
    {
      QosFrameExchangeManager::CalculateAcknowledgmentTime (acknowledgment);
    }
}

void
HtFrameExchangeManager::ForwardMpduDown (Ptr<WifiMacQueueItem> mpdu, WifiTxVector& txVector)
{
  ForwardPsduDown (GetWifiPsdu (mpdu, txVector), txVector);
}

Ptr<WifiPsdu>
HtFrameExchangeManager::GetWifiPsdu (Ptr<WifiMacQueueItem> mpdu, const WifiTxVector& txVector) const
{
  return Create<WifiPsdu> (mpdu, false);
}

void
HtFrameExchangeManager::NotifyReceivedNormalAck (Ptr<WifiMacQueueItem> mpdu)
{
  NS_LOG_FUNCTION (this << *mpdu);

  if (mpdu->GetHeader ().IsQosData ())
    {
      uint8_t tid = mpdu->GetHeader ().GetQosTid ();
      Ptr<QosTxop> edca = m_mac->GetQosTxop (tid);

      if (edca->GetBaAgreementEstablished (mpdu->GetHeader ().GetAddr1 (), tid))
        {
          // notify the BA manager that the MPDU was acknowledged
          edca->GetBaManager ()->NotifyGotAck (mpdu);
        }
    }
  else if (mpdu->GetHeader ().IsAction ())
    {
      WifiActionHeader actionHdr;
      Ptr<Packet> p = mpdu->GetPacket ()->Copy ();
      p->RemoveHeader (actionHdr);
      if (actionHdr.GetCategory () == WifiActionHeader::BLOCK_ACK)
        {
          if (actionHdr.GetAction ().blockAck == WifiActionHeader::BLOCK_ACK_DELBA)
            {
              MgtDelBaHeader delBa;
              p->PeekHeader (delBa);
              if (delBa.IsByOriginator ())
                {
                  GetBaManager (delBa.GetTid ())->DestroyAgreement (mpdu->GetHeader ().GetAddr1 (),
                                                                    delBa.GetTid ());
                }
              else
                {
                  DestroyBlockAckAgreement (mpdu->GetHeader ().GetAddr1 (), delBa.GetTid ());
                }
            }
          else if (actionHdr.GetAction ().blockAck == WifiActionHeader::BLOCK_ACK_ADDBA_REQUEST)
            {
              // Setup ADDBA response timeout
              MgtAddBaRequestHeader addBa;
              p->PeekHeader (addBa);
              Ptr<QosTxop> edca = m_mac->GetQosTxop (addBa.GetTid ());
              Simulator::Schedule (edca->GetAddBaResponseTimeout (),
                                   &QosTxop::AddBaResponseTimeout, edca,
                                   mpdu->GetHeader ().GetAddr1 (), addBa.GetTid ());
            }
        }
    }
  QosFrameExchangeManager::NotifyReceivedNormalAck (mpdu);
}

void
HtFrameExchangeManager::TransmissionSucceeded (void)
{
  NS_LOG_DEBUG (this);

  if (m_edca != 0 && m_edca->GetTxopLimit ().IsZero () && m_edca->GetBaManager ()->GetBar (false) != 0)
    {
      // A TXOP limit of 0 indicates that the TXOP holder may transmit or cause to
      // be transmitted (as responses) the following within the current TXOP:
      // f) Any number of BlockAckReq frames
      // (Sec. 10.22.2.8 of 802.11-2016)
      NS_LOG_DEBUG ("Schedule a transmission from Block Ack Manager in a SIFS");
      bool (HtFrameExchangeManager::*fp) (Ptr<QosTxop>, Time) = &HtFrameExchangeManager::StartTransmission;

      // TXOP limit is null, hence the txopDuration parameter is unused
      Simulator::Schedule (m_phy->GetSifs (), fp, this, m_edca, Seconds (0));
    }
  else
    {
      QosFrameExchangeManager::TransmissionSucceeded ();
    }
}

void
HtFrameExchangeManager::NotifyPacketDiscarded (Ptr<const WifiMacQueueItem> mpdu)
{
  NS_LOG_FUNCTION (this << *mpdu);

  if (mpdu->GetHeader ().IsQosData ())
    {
      GetBaManager (mpdu->GetHeader ().GetQosTid ())->NotifyDiscardedMpdu (mpdu);
    }
  else if (mpdu->GetHeader ().IsAction ())
    {
      WifiActionHeader actionHdr;
      mpdu->GetPacket ()->PeekHeader (actionHdr);
      if (actionHdr.GetCategory () == WifiActionHeader::BLOCK_ACK)
        {
          uint8_t tid = GetTid (mpdu->GetPacket (), mpdu->GetHeader ());
          if (GetBaManager (tid)->ExistsAgreementInState (mpdu->GetHeader ().GetAddr1 (), tid,
                                                          OriginatorBlockAckAgreement::PENDING))
            {
              NS_LOG_DEBUG ("No ACK after ADDBA request");
              GetBaManager (tid)->NotifyAgreementNoReply (mpdu->GetHeader ().GetAddr1 (), tid);
              Ptr<QosTxop> qosTxop = m_mac->GetQosTxop (tid);
              Simulator::Schedule (qosTxop->GetFailedAddBaTimeout (), &QosTxop::ResetBa, qosTxop,
                                   mpdu->GetHeader ().GetAddr1 (), tid);
            }
        }
    }
  QosFrameExchangeManager::NotifyPacketDiscarded (mpdu);
}

void
HtFrameExchangeManager::RetransmitMpduAfterMissedAck (Ptr<WifiMacQueueItem> mpdu) const
{
  NS_LOG_FUNCTION (this << *mpdu);

  if (mpdu->GetHeader ().IsQosData ())
    {
      uint8_t tid = mpdu->GetHeader ().GetQosTid ();
      Ptr<QosTxop> edca = m_mac->GetQosTxop (tid);

      if (edca->GetBaAgreementEstablished (mpdu->GetHeader ().GetAddr1 (), tid))
        {
          // notify the BA manager that the MPDU was not acknowledged
          edca->GetBaManager ()->NotifyMissedAck (mpdu);
          return;
        }
    }
  QosFrameExchangeManager::RetransmitMpduAfterMissedAck (mpdu);
}

void
HtFrameExchangeManager::RetransmitMpduAfterMissedCts (Ptr<WifiMacQueueItem> mpdu) const
{
  NS_LOG_FUNCTION (this << *mpdu);

  // the MPDU should be still in the queue, unless it expired.
  const WifiMacHeader& hdr = mpdu->GetHeader ();
  if (hdr.IsQosData ())
    {
      uint8_t tid = hdr.GetQosTid ();
      Ptr<QosTxop> edca = m_mac->GetQosTxop (tid);

      if (edca->GetBaAgreementEstablished (hdr.GetAddr1 (), tid)
          && !hdr.IsRetry ())
        {
          // The MPDU has never been transmitted, so we can make its sequence
          // number available again if it is lower than the sequence number
          // maintained by the MAC TX middle
          uint16_t currentNextSeq = m_txMiddle->PeekNextSequenceNumberFor (&hdr);
          uint16_t startingSeq = edca->GetBaStartingSequence (hdr.GetAddr1 (), tid);

          if (BlockAckAgreement::GetDistance (hdr.GetSequenceNumber (), startingSeq)
              < BlockAckAgreement::GetDistance (currentNextSeq, startingSeq))
            {
              m_txMiddle->SetSequenceNumberFor (&hdr);
            }

          return;
        }
    }
  QosFrameExchangeManager::RetransmitMpduAfterMissedCts (mpdu);
}

Time
HtFrameExchangeManager::GetPsduDurationId (Time txDuration, const WifiTxParameters& txParams) const
{
  NS_LOG_FUNCTION (this << txDuration << &txParams);

  NS_ASSERT (m_edca != 0);

  if (m_edca->GetTxopLimit ().IsZero ())
    {
      NS_ASSERT (txParams.m_acknowledgment && txParams.m_acknowledgment->acknowledgmentTime != Time::Min ());
      return txParams.m_acknowledgment->acknowledgmentTime;
    }

  // under multiple protection settings, if the TXOP limit is not null, Duration/ID
  // is set to cover the remaining TXOP time (Sec. 9.2.5.2 of 802.11-2016).
  // The TXOP holder may exceed the TXOP limit in some situations (Sec. 10.22.2.8
  // of 802.11-2016)
  return std::max (m_edca->GetRemainingTxop () - txDuration, Seconds (0));
}

void
HtFrameExchangeManager::SendPsduWithProtection (Ptr<WifiPsdu> psdu, WifiTxParameters& txParams)
{
  NS_LOG_FUNCTION (this << psdu << &txParams);

  m_psdu = psdu;
  m_txParams = std::move (txParams);

#ifdef NS3_BUILD_PROFILE_DEBUG
  // If protection is required, the MPDUs must be stored in some queue because
  // they are not put back in a queue if the RTS/CTS exchange fails
  if (m_txParams.m_protection->method != WifiProtection::NONE)
    {
      for (const auto& mpdu : *PeekPointer (m_psdu))
        {
          NS_ASSERT (mpdu->GetHeader ().IsCtl () || mpdu->IsQueued ());
        }
    }
#endif

  // Make sure that the acknowledgment time has been computed, so that SendRts()
  // and SendCtsToSelf() can reuse this value.
  NS_ASSERT (m_txParams.m_acknowledgment);

  if (m_txParams.m_acknowledgment->acknowledgmentTime == Time::Min ())
    {
      CalculateAcknowledgmentTime (m_txParams.m_acknowledgment.get ());
    }

  // Set QoS Ack policy
  WifiAckManager::SetQosAckPolicy (m_psdu, m_txParams.m_acknowledgment.get ());

  if (m_txParams.m_protection->method == WifiProtection::RTS_CTS)
    {
      SendRts (m_txParams);
    }
  else if (m_txParams.m_protection->method == WifiProtection::CTS_TO_SELF)
    {
      SendCtsToSelf (m_txParams);
    }
  else if (m_txParams.m_protection->method == WifiProtection::NONE)
    {
      SendPsdu ();
    }
  else
    {
      NS_ABORT_MSG ("Unknown protection type");
    }
}

void
HtFrameExchangeManager::CtsTimeout (Ptr<WifiMacQueueItem> rts, const WifiTxVector& txVector)
{
  NS_LOG_FUNCTION (this << *rts << txVector);

  if (m_psdu == 0)
    {
      // A CTS Timeout occurred when protecting a single MPDU is handled by the
      // parent classes
      QosFrameExchangeManager::CtsTimeout (rts, txVector);
      return;
    }

  NS_ASSERT (m_psdu->GetNMpdus () > 1);
  m_mac->GetWifiRemoteStationManager ()->ReportRtsFailed (m_psdu->GetHeader (0));

  if (!m_mac->GetWifiRemoteStationManager ()->NeedRetransmission (*m_psdu->begin ()))
    {
      NS_LOG_DEBUG ("Missed CTS, discard MPDUs");
      m_mac->GetWifiRemoteStationManager ()->ReportFinalRtsFailed (m_psdu->GetHeader (0));
      // Dequeue the MPDUs if they are stored in a queue
      DequeuePsdu (m_psdu);
      for (const auto& mpdu : *PeekPointer (m_psdu))
        {
          NotifyPacketDiscarded (mpdu);
        }
      m_edca->ResetCw ();
    }
  else
    {
      NS_LOG_DEBUG ("Missed CTS, retransmit MPDUs");
      for (const auto& mpdu : *PeekPointer (m_psdu))
        {
          RetransmitMpduAfterMissedCts (mpdu);
        }
      m_edca->UpdateFailedCw ();
    }
  m_psdu = 0;
  TransmissionFailed ();
}

void
HtFrameExchangeManager::SendPsdu (void)
{
  NS_LOG_FUNCTION (this);

  Time txDuration = m_phy->CalculateTxDuration (m_psdu->GetSize (), m_txParams.m_txVector, m_phy->GetPhyBand ());

  NS_ASSERT (m_txParams.m_acknowledgment);

  if (m_txParams.m_acknowledgment->method == WifiAcknowledgment::NONE)
    {
      Simulator::Schedule (txDuration, &HtFrameExchangeManager::TransmissionSucceeded, this);
    }
  else if (m_txParams.m_acknowledgment->method == WifiAcknowledgment::BLOCK_ACK)
    {
      m_psdu->SetDuration (GetPsduDurationId (txDuration, m_txParams));

      // the timeout duration is "aSIFSTime + aSlotTime + aRxPHYStartDelay, starting
      // at the PHY-TXEND.confirm primitive" (section 10.3.2.9 or 10.22.2.2 of 802.11-2016).
      // aRxPHYStartDelay equals the time to transmit the PHY header.
      WifiBlockAck* blockAcknowledgment = static_cast<WifiBlockAck*> (m_txParams.m_acknowledgment.get ());

      Time timeout = txDuration
                    + m_phy->GetSifs ()
                    + m_phy->GetSlot ()
                    + m_phy->CalculatePhyPreambleAndHeaderDuration (blockAcknowledgment->blockAckTxVector);
      NS_ASSERT (!m_txTimer.IsRunning ());
      m_txTimer.Set (WifiTxTimer::WAIT_BLOCK_ACK, timeout, &HtFrameExchangeManager::BlockAckTimeout,
                     this, m_psdu, m_txParams.m_txVector);
      m_channelAccessManager->NotifyAckTimeoutStartNow (timeout);
    }
  else if (m_txParams.m_acknowledgment->method == WifiAcknowledgment::BAR_BLOCK_ACK)
    {
      m_psdu->SetDuration (GetPsduDurationId (txDuration, m_txParams));

      // schedule the transmission of a BAR in a SIFS
      std::set<uint8_t> tids = m_psdu->GetTids ();
      NS_ABORT_MSG_IF (tids.size () > 1, "Acknowledgment method incompatible with a Multi-TID A-MPDU");
      uint8_t tid = *tids.begin ();

      Ptr<QosTxop> edca = m_mac->GetQosTxop (tid);
      edca->ScheduleBar (edca->PrepareBlockAckRequest (m_psdu->GetAddr1 (), tid));

      Simulator::Schedule (txDuration, &HtFrameExchangeManager::TransmissionSucceeded, this);
    }
  else
    {
      NS_ABORT_MSG ("Unable to handle the selected acknowledgment method ("
                    << m_txParams.m_acknowledgment.get () << ")");
    }

  // transmit the PSDU
  if (m_psdu->GetNMpdus () > 1)
    {
      ForwardPsduDown (m_psdu, m_txParams.m_txVector);
    }
  else
    {
      ForwardMpduDown (*m_psdu->begin (), m_txParams.m_txVector);
    }

  if (m_txParams.m_acknowledgment->method == WifiAcknowledgment::NONE)
    {
      // we are done in case the A-MPDU does not require acknowledgment
      m_psdu = 0;
    }
}

void
HtFrameExchangeManager::NotifyTxToEdca (Ptr<const WifiPsdu> psdu) const
{
  NS_LOG_FUNCTION (this << psdu);

  for (const auto& mpdu : *PeekPointer (psdu))
    {
      if (mpdu->GetHeader ().IsQosData ())
        {
          Ptr<QosTxop> edca = m_mac->GetQosTxop (mpdu->GetHeader ().GetQosTid ());

          if (mpdu->GetHeader ().IsQosEosp ())
            {
              edca->SetQosQueueSize (mpdu);
            }
          if (mpdu->GetHeader ().HasData ())
            {
              edca->CompleteMpduTx (mpdu);
            }
        }
    }
}

void
HtFrameExchangeManager::DequeueMpdu (Ptr<WifiMacQueueItem> mpdu)
{
  DequeuePsdu (Create<const WifiPsdu> (mpdu, true));
}

void
HtFrameExchangeManager::DequeuePsdu (Ptr<const WifiPsdu> psdu)
{
  NS_LOG_DEBUG (this << psdu);

  for (const auto& mpdu : *PeekPointer (psdu))
    {
      if (mpdu->GetQueueIteratorPairs ().size () > 1)
        {
          // this MPDU contains an A-MSDU
          for (const auto& queueIt : mpdu->GetQueueIteratorPairs ())
            {
              NS_ASSERT (*queueIt.it != mpdu);
              queueIt.queue->Dequeue (queueIt.it);
            }
        }
      else if (mpdu->IsQueued ())
        {
          WifiMacQueueItem::QueueIteratorPair queueIt = mpdu->GetQueueIteratorPairs ().front ();
          NS_ASSERT (*queueIt.it == mpdu);
          queueIt.queue->Dequeue (queueIt.it);
        }
    }
}

void
HtFrameExchangeManager::ForwardPsduDown (Ptr<const WifiPsdu> psdu, WifiTxVector& txVector)
{
  NS_LOG_FUNCTION (this << psdu << txVector);

  NS_LOG_DEBUG ("Transmitting a PSDU: " << *psdu << " TXVECTOR: " << txVector);
  NotifyTxToEdca (psdu);

  if (psdu->IsAggregate ())
    {
      txVector.SetAggregation (true);
    }

  // The PSDU is about to be transmitted, we can now dequeue the MPDUs
  DequeuePsdu (psdu);

  m_phy->Send (psdu, txVector);
}

bool
HtFrameExchangeManager::IsWithinLimitsIfAddMpdu (Ptr<const WifiMacQueueItem> mpdu,
                                                 const WifiTxParameters& txParams,
                                                 Time ppduDurationLimit) const
{
  NS_ASSERT (mpdu != 0);
  NS_LOG_FUNCTION (this << *mpdu << &txParams << ppduDurationLimit);
  
  Mac48Address receiver = mpdu->GetHeader ().GetAddr1 ();
  uint32_t ampduSize = txParams.GetSizeIfAddMpdu (mpdu);

  if (txParams.GetSize (receiver) > 0)
    {
      // we are attempting to perform A-MPDU aggregation, hence we have to check
      // that we meet the limit on the max A-MPDU size
      uint8_t tid;
      const WifiTxParameters::PsduInfo* info;

      if (mpdu->GetHeader ().IsQosData ())
        {
          tid = mpdu->GetHeader ().GetQosTid ();
        }
      else if ((info = txParams.GetPsduInfo (receiver)) && !info->seqNumbers.empty ())
        {
          tid = info->seqNumbers.begin ()->first;
        }
      else
        {
          NS_ABORT_MSG ("Cannot aggregate a non-QoS data frame to an A-MPDU that does"
                        " not contain any QoS data frame");
        }

      WifiModulationClass modulation = txParams.m_txVector.GetModulationClass ();

      if (!IsWithinAmpduSizeLimit (ampduSize, receiver, tid, modulation))
        {
          return false;
        }
    }

  return IsWithinSizeAndTimeLimits (ampduSize, receiver, txParams, ppduDurationLimit);
}

bool
HtFrameExchangeManager::IsWithinAmpduSizeLimit (uint32_t ampduSize, Mac48Address receiver, uint8_t tid,
                                                WifiModulationClass modulation) const
{
  NS_LOG_FUNCTION (this << ampduSize << receiver << +tid << modulation);

  uint32_t maxAmpduSize = m_mpduAggregator->GetMaxAmpduSize (receiver, tid, modulation);

  if (maxAmpduSize == 0)
    {
      NS_LOG_DEBUG ("A-MPDU aggregation disabled");
      return false;
    }

  if (ampduSize > maxAmpduSize)
    {
      NS_LOG_DEBUG ("the frame does not meet the constraint on max A-MPDU size ("
                    << maxAmpduSize << ")");
      return false;
    }
  return true;
}

bool
HtFrameExchangeManager::TryAggregateMsdu (Ptr<const WifiMacQueueItem> msdu, WifiTxParameters& txParams,
                                          Time availableTime) const
{
  NS_ASSERT (msdu != 0 && msdu->GetHeader ().IsQosData ());
  NS_LOG_FUNCTION (this << *msdu << &txParams << availableTime);

  // check if aggregating the given MSDU requires a different protection method
  NS_ASSERT (txParams.m_protection);
  Time protectionTime = txParams.m_protection->protectionTime;

  std::unique_ptr<WifiProtection> protection;
  protection = GetProtectionManager ()->TryAggregateMsdu (msdu, txParams);
  bool protectionSwapped = false;

  if (protection)
    {
      // the protection method has changed, calculate the new protection time
      CalculateProtectionTime (protection.get ());
      protectionTime = protection->protectionTime;
      // swap unique pointers, so that the txParams that is passed to the next
      // call to IsWithinLimitsIfAggregateMsdu is the most updated one
      txParams.m_protection.swap (protection);
      protectionSwapped = true;
    }
  NS_ASSERT (protectionTime != Time::Min ());

  // check if aggregating the given MSDU requires a different acknowledgment method
  NS_ASSERT (txParams.m_acknowledgment);
  Time acknowledgmentTime = txParams.m_acknowledgment->acknowledgmentTime;

  std::unique_ptr<WifiAcknowledgment> acknowledgment;
  acknowledgment = GetAckManager ()->TryAggregateMsdu (msdu, txParams);
  bool acknowledgmentSwapped = false;

  if (acknowledgment)
    {
      // the acknowledgment method has changed, calculate the new acknowledgment time
      CalculateAcknowledgmentTime (acknowledgment.get ());
      acknowledgmentTime = acknowledgment->acknowledgmentTime;
      // swap unique pointers, so that the txParams that is passed to the next
      // call to IsWithinLimitsIfAggregateMsdu is the most updated one
      txParams.m_acknowledgment.swap (acknowledgment);
      acknowledgmentSwapped = true;
    }
  NS_ASSERT (acknowledgmentTime != Time::Min ());

  Time ppduDurationLimit = Time::Min ();
  if (availableTime != Time::Min ())
    {
      ppduDurationLimit = availableTime - protectionTime - acknowledgmentTime;
    }

  if (!IsWithinLimitsIfAggregateMsdu (msdu, txParams, ppduDurationLimit))
    {
      // adding MPDU failed, restore protection and acknowledgment methods
      // if they were swapped
      if (protectionSwapped)
        {
          txParams.m_protection.swap (protection);
        }
      if (acknowledgmentSwapped)
        {
          txParams.m_acknowledgment.swap (acknowledgment);
        }
      return false;
    }

  // the given MPDU can be added, hence update the txParams
  txParams.AggregateMsdu (msdu);
  UpdateTxDuration (msdu->GetHeader ().GetAddr1 (), txParams);

  return true;
}

bool
HtFrameExchangeManager::IsWithinLimitsIfAggregateMsdu (Ptr<const WifiMacQueueItem> msdu,
                                                       const WifiTxParameters& txParams,
                                                       Time ppduDurationLimit) const
{
  NS_ASSERT (msdu != 0 && msdu->GetHeader ().IsQosData ());
  NS_LOG_FUNCTION (this << *msdu << &txParams << ppduDurationLimit);

  std::pair<uint16_t, uint32_t> ret = txParams.GetSizeIfAggregateMsdu (msdu);
  Mac48Address receiver = msdu->GetHeader ().GetAddr1 ();
  uint8_t tid = msdu->GetHeader ().GetQosTid ();
  WifiModulationClass modulation = txParams.m_txVector.GetModulationClass ();

  // Check that the limit on A-MSDU size is met
  uint16_t maxAmsduSize = m_msduAggregator->GetMaxAmsduSize (receiver, tid, modulation);

  if (maxAmsduSize == 0)
    {
      NS_LOG_DEBUG ("A-MSDU aggregation disabled");
      return false;
    }

  if (ret.first > maxAmsduSize)
    {
      NS_LOG_DEBUG ("No other MSDU can be aggregated: maximum A-MSDU size ("
                    << maxAmsduSize << ") reached ");
      return false;
    }

  const WifiTxParameters::PsduInfo* info = txParams.GetPsduInfo (msdu->GetHeader ().GetAddr1 ());
  NS_ASSERT (info != nullptr);

  if (info->ampduSize > 0)
    {
      // the A-MSDU being built is aggregated to other MPDUs in an A-MPDU.
      // Check that the limit on A-MPDU size is met.
      if (!IsWithinAmpduSizeLimit (ret.second, receiver, tid, modulation))
        {
          return false;
        }
    }

  return IsWithinSizeAndTimeLimits (ret.second, receiver, txParams, ppduDurationLimit);
}

void
HtFrameExchangeManager::BlockAckTimeout (Ptr<WifiPsdu> psdu, const WifiTxVector& txVector)
{
  NS_LOG_FUNCTION (this << *psdu << txVector);

  m_mac->GetWifiRemoteStationManager ()->ReportDataFailed (*psdu->begin ());

  bool resetCw;
  MissedBlockAck (psdu, txVector, resetCw);

  NS_ASSERT (m_edca != 0);

  if (resetCw)
    {
      m_edca->ResetCw ();
    }
  else
    {
      m_edca->UpdateFailedCw ();
    }

  m_psdu = 0;
  TransmissionFailed ();
}

void
HtFrameExchangeManager::MissedBlockAck (Ptr<WifiPsdu> psdu, const WifiTxVector& txVector, bool& resetCw)
{
  NS_LOG_FUNCTION (this << psdu << txVector << resetCw);

  Mac48Address recipient = psdu->GetAddr1 ();
  bool isBar;
  uint8_t tid;

  if (psdu->GetNMpdus () == 1 && psdu->GetHeader (0).IsBlockAckReq ())
    {
      isBar = true;
      CtrlBAckRequestHeader baReqHdr;
      psdu->GetPayload (0)->PeekHeader (baReqHdr);
      tid = baReqHdr.GetTidInfo ();
    }
  else
    {
      isBar = false;
      m_mac->GetWifiRemoteStationManager ()->ReportAmpduTxStatus (recipient, 0, psdu->GetNMpdus (),
                                                                  0, 0, txVector);
      std::set<uint8_t> tids = psdu->GetTids ();
      NS_ABORT_MSG_IF (tids.size () > 1, "Multi-TID A-MPDUs not handled here");
      NS_ASSERT (!tids.empty ());
      tid = *tids.begin ();
    }

  Ptr<QosTxop> edca = m_mac->GetQosTxop (tid);

  if (edca->UseExplicitBarAfterMissedBlockAck () || isBar)
    {
      // we have to send a BlockAckReq, if needed
      if (GetBaManager (tid)->NeedBarRetransmission (tid, recipient))
        {
          NS_LOG_DEBUG ("Missed Block Ack, transmit a BlockAckReq");
          if (isBar)
            {
              psdu->GetHeader (0).SetRetry ();
              edca->ScheduleBar (*psdu->begin ());
            }
          else
            {
              // missed block ack after data frame with Implicit BAR Ack policy
              edca->ScheduleBar (edca->PrepareBlockAckRequest (recipient, tid));
            }
          resetCw = false;
        }
      else
        {
          NS_LOG_DEBUG ("Missed Block Ack, do not transmit a BlockAckReq");
          // if a BA agreement exists, we can get here if there is no outstanding
          // MPDU whose lifetime has not expired yet.
          m_mac->GetWifiRemoteStationManager ()->ReportFinalDataFailed (*psdu->begin ());
          if (GetBaManager (tid)->ExistsAgreementInState (recipient, tid,
                                                          OriginatorBlockAckAgreement::ESTABLISHED))
            {
              // If there is any (expired) outstanding MPDU, request the BA manager to discard
              // it, which involves the scheduling of a BAR to advance the recipient's window
              if (GetBaManager (tid)->GetNBufferedPackets (recipient, tid) > 0)
                {
                  GetBaManager (tid)->DiscardOutstandingMpdus (recipient, tid);
                }
              // otherwise, it means that we have not received a Block Ack in response to a
              // BlockAckRequest sent while no frame was outstanding, whose purpose was therefore
              // to advance the recipient's window. Schedule a BlockAckRequest with
              // skipIfNoDataQueued set to true, so that the BlockAckRequest is only sent
              // if there are data frames queued for this recipient.
              else
                {
                  edca->ScheduleBar (edca->PrepareBlockAckRequest (recipient, tid), true);
                }
            }
          resetCw = true;
        }
    }
  else
    {
      // we have to retransmit the data frames, if needed
      if (!m_mac->GetWifiRemoteStationManager ()->NeedRetransmission (*psdu->begin ()))
        {
          NS_LOG_DEBUG ("Missed Block Ack, do not retransmit the data frames");
          m_mac->GetWifiRemoteStationManager ()->ReportFinalDataFailed (*psdu->begin ());
          for (const auto& mpdu : *PeekPointer (psdu))
            {
              FrameExchangeManager::NotifyPacketDiscarded (mpdu);
            }
          GetBaManager (tid)->DiscardOutstandingMpdus (recipient, tid);
          resetCw = true;
        }
      else
        {
          NS_LOG_DEBUG ("Missed Block Ack, retransmit data frames");
          GetBaManager (tid)->NotifyMissedBlockAck (recipient, tid);
          resetCw = false;
        }
    }
}

void
HtFrameExchangeManager::SendBlockAck (const RecipientBlockAckAgreement& agreement, Time durationId,
                                      WifiTxVector& blockAckTxVector, double rxSnr)
{
  NS_LOG_FUNCTION (this << durationId << blockAckTxVector << rxSnr);

  WifiMacHeader hdr;
  hdr.SetType (WIFI_MAC_CTL_BACKRESP);
  hdr.SetAddr1 (agreement.GetPeer ());
  hdr.SetAddr2 (m_self);
  hdr.SetDsNotFrom ();
  hdr.SetDsNotTo ();

  CtrlBAckResponseHeader blockAck;
  blockAck.SetType (agreement.GetBlockAckType ());
  blockAck.SetTidInfo (agreement.GetTid ());
  agreement.FillBlockAckBitmap (&blockAck);

  Ptr<Packet> packet = Create<Packet> ();
  packet->AddHeader (blockAck);
  Ptr<WifiPsdu> psdu = GetWifiPsdu (Create<WifiMacQueueItem> (packet, hdr), blockAckTxVector);

  // 802.11-2016, Section 9.2.5.7: In a BlockAck frame transmitted in response
  // to a BlockAckReq frame or transmitted in response to a frame containing an
  // implicit block ack request, the Duration/ID field is set to the value obtained
  // from the Duration/ ID field of the frame that elicited the response minus the
  // time, in microseconds between the end of the PPDU carrying the frame that
  // elicited the response and the end of the PPDU carrying the BlockAck frame.
  Time baDurationId = durationId - m_phy->GetSifs ()
                      - m_phy->CalculateTxDuration (psdu, blockAckTxVector, m_phy->GetPhyBand ());
  // The TXOP holder may exceed the TXOP limit in some situations (Sec. 10.22.2.8 of 802.11-2016)
  if (baDurationId.IsStrictlyNegative ())
    {
      baDurationId = Seconds (0);
    }
  psdu->GetHeader (0).SetDuration (baDurationId);

  SnrTag tag;
  tag.Set (rxSnr);
  psdu->GetPayload (0)->AddPacketTag (tag);

  ForwardPsduDown (psdu, blockAckTxVector);
}

bool
HtFrameExchangeManager::GetBaAgreementEstablished (Mac48Address originator, uint8_t tid) const
{
  return (m_agreements.find ({originator, tid}) != m_agreements.end ());
}

BlockAckType
HtFrameExchangeManager::GetBlockAckType (Mac48Address originator, uint8_t tid) const
{
  auto it = m_agreements.find ({originator, tid});
  NS_ABORT_MSG_IF (it == m_agreements.end (), "No established Block Ack agreement");
  return it->second.GetBlockAckType ();
}

void
HtFrameExchangeManager::ReceiveMpdu (Ptr<WifiMacQueueItem> mpdu, RxSignalInfo rxSignalInfo,
                                     const WifiTxVector& txVector, bool inAmpdu)
{
  // The received MPDU is either broadcast or addressed to this station
  NS_ASSERT (mpdu->GetHeader ().GetAddr1 ().IsGroup ()
             || mpdu->GetHeader ().GetAddr1 () == m_self);

  double rxSnr = rxSignalInfo.snr;
  const WifiMacHeader& hdr = mpdu->GetHeader ();

  if (hdr.IsCtl ())
    {
      if (hdr.IsCts () && m_txTimer.IsRunning () && m_txTimer.GetReason () == WifiTxTimer::WAIT_CTS
          && m_psdu != 0)
        {
          NS_ABORT_MSG_IF (inAmpdu, "Received CTS as part of an A-MPDU");
          NS_ASSERT (hdr.GetAddr1 () == m_self);

          Mac48Address sender = m_psdu->GetAddr1 ();
          NS_LOG_DEBUG ("Received CTS from=" << sender);

          SnrTag tag;
          mpdu->GetPacket ()->PeekPacketTag (tag);
          m_mac->GetWifiRemoteStationManager ()->ReportRxOk (sender, rxSignalInfo, txVector);
          m_mac->GetWifiRemoteStationManager ()->ReportRtsOk (m_psdu->GetHeader (0),
                                                              rxSnr, txVector.GetMode (), tag.Get ());

          m_txTimer.Cancel ();
          m_channelAccessManager->NotifyCtsTimeoutResetNow ();
          Simulator::Schedule (m_phy->GetSifs (), &HtFrameExchangeManager::SendPsdu, this);
        }
      else if (hdr.IsBlockAck () && m_txTimer.IsRunning ()
               && m_txTimer.GetReason () == WifiTxTimer::WAIT_BLOCK_ACK
               && hdr.GetAddr1 () == m_self)
        {
          Mac48Address sender = hdr.GetAddr2 ();
          NS_LOG_DEBUG ("Received BlockAck from=" << sender);

          SnrTag tag;
          mpdu->GetPacket ()->PeekPacketTag (tag);

          // notify the Block Ack Manager
          CtrlBAckResponseHeader blockAck;
          mpdu->GetPacket ()->PeekHeader (blockAck);
          uint8_t tid = blockAck.GetTidInfo ();
          GetBaManager (tid)->NotifyGotBlockAck (blockAck, hdr.GetAddr2 (), {tid}, rxSnr,
                                                 tag.Get (), m_txParams.m_txVector);

          // cancel the timer
          m_txTimer.Cancel ();
          m_channelAccessManager->NotifyAckTimeoutResetNow ();

          // Reset the CW
          m_edca->ResetCw ();

          m_psdu = 0;
          TransmissionSucceeded ();
        }
      else if (hdr.IsBlockAckReq ())
        {
          NS_ASSERT (hdr.GetAddr1 () == m_self);
          NS_ABORT_MSG_IF (inAmpdu, "BlockAckReq in A-MPDU is not supported");

          Mac48Address sender = hdr.GetAddr2 ();
          NS_LOG_DEBUG ("Received BlockAckReq from=" << sender);

          CtrlBAckRequestHeader blockAckReq;
          mpdu->GetPacket ()->PeekHeader (blockAckReq);
          NS_ABORT_MSG_IF (blockAckReq.IsMultiTid (), "Multi-TID BlockAckReq not supported");
          uint8_t tid = blockAckReq.GetTidInfo ();
          
          auto agreementIt = m_agreements.find ({sender, tid});

          if (agreementIt == m_agreements.end ())
            {
              NS_LOG_DEBUG ("There's not a valid agreement for this BlockAckReq");
              return;
            }

          agreementIt->second.NotifyReceivedBar (blockAckReq.GetStartingSequence ());

          NS_LOG_DEBUG ("Schedule Block Ack");
          Simulator::Schedule (m_phy->GetSifs (), &HtFrameExchangeManager::SendBlockAck, this,
                               agreementIt->second, hdr.GetDuration (),
                               m_mac->GetWifiRemoteStationManager ()->GetBlockAckTxVector (sender, txVector),
                               rxSnr);
        }
      else
        {
          // the received control frame cannot be handled here
          QosFrameExchangeManager::ReceiveMpdu (mpdu, rxSignalInfo, txVector, inAmpdu);
        }
      return;
    }

  if (hdr.IsQosData () && hdr.HasData () && hdr.GetAddr1 () == m_self)
    {
      uint8_t tid = hdr.GetQosTid ();

      auto agreementIt = m_agreements.find ({hdr.GetAddr2 (), tid});
      if (agreementIt != m_agreements.end ())
        {
          // a Block Ack agreement has been established
          NS_LOG_DEBUG ("Received from=" << hdr.GetAddr2 ()
                        << " (" << *mpdu << ")");

          agreementIt->second.NotifyReceivedMpdu (mpdu);

          if (!inAmpdu && hdr.GetQosAckPolicy () == WifiMacHeader::NORMAL_ACK)
            {
              NS_LOG_DEBUG ("Schedule Normal Ack");
              Simulator::Schedule (m_phy->GetSifs (), &HtFrameExchangeManager::SendNormalAck,
                                   this, hdr, txVector, rxSnr);
            }
          return;
        }
      // We let the QosFrameExchangeManager handle QoS data frame not belonging
      // to a Block Ack agreement
    }

  QosFrameExchangeManager::ReceiveMpdu (mpdu, rxSignalInfo, txVector, inAmpdu);
}

void
HtFrameExchangeManager::EndReceiveAmpdu (Ptr<const WifiPsdu> psdu, const RxSignalInfo& rxSignalInfo,
                                         const WifiTxVector& txVector, const std::vector<bool>& perMpduStatus)
{
  std::set<uint8_t> tids = psdu->GetTids ();

  // Multi-TID A-MPDUs are not supported yet
  if (tids.size () == 1)
    {
      uint8_t tid = *tids.begin ();
      WifiMacHeader::QosAckPolicy ackPolicy = psdu->GetAckPolicyForTid (tid);
      NS_ASSERT (psdu->GetNMpdus () > 1);

      if (ackPolicy == WifiMacHeader::NORMAL_ACK)
        {
          // Normal Ack or Implicit Block Ack Request
          NS_LOG_DEBUG ("Schedule Block Ack");
          auto agreementIt = m_agreements.find ({psdu->GetAddr2 (), tid});
          NS_ASSERT (agreementIt != m_agreements.end ());

          Simulator::Schedule (m_phy->GetSifs (), &HtFrameExchangeManager::SendBlockAck, this,
                               agreementIt->second, psdu->GetDuration (),
                               m_mac->GetWifiRemoteStationManager ()->GetBlockAckTxVector (psdu->GetAddr2 (), txVector),
                               rxSignalInfo.snr);
        }
    }
}

} //namespace ns3