diff options
Diffstat (limited to 'emu-radio/ns3-patch/wifi/model/mac-low.cc')
| -rw-r--r-- | emu-radio/ns3-patch/wifi/model/mac-low.cc | 3347 |
1 files changed, 3347 insertions, 0 deletions
diff --git a/emu-radio/ns3-patch/wifi/model/mac-low.cc b/emu-radio/ns3-patch/wifi/model/mac-low.cc new file mode 100644 index 00000000..aa86bad2 --- /dev/null +++ b/emu-radio/ns3-patch/wifi/model/mac-low.cc @@ -0,0 +1,3347 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2005,2006 INRIA + * Copyright (c) 2009 MIRKO BANCHI + * + * 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 + * + * Authors: Mathieu Lacage <mathieu.lacage@sophia.inria.fr> + * Mirko Banchi <mk.banchi@gmail.com> + */ + +#include "ns3/assert.h" +#include "ns3/packet.h" +#include "ns3/simulator.h" +#include "ns3/tag.h" +#include "ns3/log.h" +#include "ns3/node.h" +#include "ns3/double.h" +#include "mac-low.h" +#include "wifi-phy.h" +#include "wifi-mac-trailer.h" +#include "qos-utils.h" +#include "edca-txop-n.h" +#include "snr-tag.h" +#include "yans-wifi-phy.h" +#include "ampdu-tag.h" +#include "wifi-mac-queue.h" +#include "mpdu-standard-aggregator.h" + +#undef NS_LOG_APPEND_CONTEXT +#define NS_LOG_APPEND_CONTEXT std::clog << "[mac=" << m_self << "] " + +#define WITH_FIX_RECEIVE_BAR_BEFORE_CTS_TIMEOUT 1 + +namespace ns3 { + +NS_LOG_COMPONENT_DEFINE ("MacLow"); + +MacLowTransmissionListener::MacLowTransmissionListener () +{ +} +MacLowTransmissionListener::~MacLowTransmissionListener () +{ +} +void +MacLowTransmissionListener::GotBlockAck (const CtrlBAckResponseHeader *blockAck, Mac48Address source, WifiMode mode) +{ +} +void +MacLowTransmissionListener::MissedBlockAck (void) +{ +} + +MacLowDcfListener::MacLowDcfListener () +{ +} +MacLowDcfListener::~MacLowDcfListener () +{ +} + +MacLowAggregationCapableTransmissionListener::MacLowAggregationCapableTransmissionListener () +{ +} +MacLowAggregationCapableTransmissionListener::~MacLowAggregationCapableTransmissionListener () +{ +} +void MacLowAggregationCapableTransmissionListener::SetAmpdu (bool ampdu) +{ +} +void MacLowAggregationCapableTransmissionListener::CompleteTransfer (Mac48Address address, uint8_t tid) +{ +} +void +MacLowAggregationCapableTransmissionListener::CompleteMpduTx (Ptr<const Packet> packet, WifiMacHeader hdr, Time tstamp) +{ +} +uint16_t +MacLowAggregationCapableTransmissionListener::GetNextSequenceNumberfor (WifiMacHeader *hdr) +{ + return 0; +} +uint16_t +MacLowAggregationCapableTransmissionListener::PeekNextSequenceNumberfor (WifiMacHeader *hdr) +{ + return 0; +} +Ptr<const Packet> +MacLowAggregationCapableTransmissionListener::PeekNextPacketInBaQueue (WifiMacHeader &header, Mac48Address recipient, uint8_t tid, Time *timestamp) +{ + return 0; +} +void +MacLowAggregationCapableTransmissionListener::RemoveFromBaQueue (uint8_t tid, Mac48Address recipient, uint16_t seqnumber) +{ +} +uint32_t +MacLowAggregationCapableTransmissionListener::GetNOutstandingPackets (Mac48Address recipient, uint8_t tid) +{ + return 0; +} +uint32_t +MacLowAggregationCapableTransmissionListener::GetNRetryNeededPackets (Mac48Address recipient, uint8_t tid) const +{ + return 0; +} +Ptr<MsduAggregator> +MacLowAggregationCapableTransmissionListener::GetMsduAggregator (void) const +{ + return 0; +} +Mac48Address +MacLowAggregationCapableTransmissionListener::GetSrcAddressForAggregation (const WifiMacHeader &hdr) +{ + return 0; +} +Mac48Address +MacLowAggregationCapableTransmissionListener::GetDestAddressForAggregation (const WifiMacHeader &hdr) +{ + return 0; +} + +MacLowTransmissionParameters::MacLowTransmissionParameters () + : m_nextSize (0), + m_waitAck (ACK_NONE), + m_sendRts (false), + m_overrideDurationId (Seconds (0)) +{ +} +void +MacLowTransmissionParameters::EnableNextData (uint32_t size) +{ + m_nextSize = size; +} +void +MacLowTransmissionParameters::DisableNextData (void) +{ + m_nextSize = 0; +} +void +MacLowTransmissionParameters::EnableOverrideDurationId (Time durationId) +{ + m_overrideDurationId = durationId; +} +void +MacLowTransmissionParameters::DisableOverrideDurationId (void) +{ + m_overrideDurationId = Seconds (0); +} +void +MacLowTransmissionParameters::EnableSuperFastAck (void) +{ + m_waitAck = ACK_SUPER_FAST; +} +void +MacLowTransmissionParameters::EnableBasicBlockAck (void) +{ + m_waitAck = BLOCK_ACK_BASIC; +} +void +MacLowTransmissionParameters::EnableCompressedBlockAck (void) +{ + m_waitAck = BLOCK_ACK_COMPRESSED; +} +void +MacLowTransmissionParameters::EnableMultiTidBlockAck (void) +{ + m_waitAck = BLOCK_ACK_MULTI_TID; +} +void +MacLowTransmissionParameters::EnableFastAck (void) +{ + m_waitAck = ACK_FAST; +} +void +MacLowTransmissionParameters::EnableAck (void) +{ + m_waitAck = ACK_NORMAL; +} +void +MacLowTransmissionParameters::DisableAck (void) +{ + m_waitAck = ACK_NONE; +} +void +MacLowTransmissionParameters::EnableRts (void) +{ + m_sendRts = true; +} +void +MacLowTransmissionParameters::DisableRts (void) +{ + m_sendRts = false; +} +bool +MacLowTransmissionParameters::MustWaitAck (void) const +{ + return (m_waitAck != ACK_NONE); +} +bool +MacLowTransmissionParameters::MustWaitNormalAck (void) const +{ + return (m_waitAck == ACK_NORMAL); +} +bool +MacLowTransmissionParameters::MustWaitFastAck (void) const +{ + return (m_waitAck == ACK_FAST); +} +bool +MacLowTransmissionParameters::MustWaitSuperFastAck (void) const +{ + return (m_waitAck == ACK_SUPER_FAST); +} +bool +MacLowTransmissionParameters::MustWaitBasicBlockAck (void) const +{ + return (m_waitAck == BLOCK_ACK_BASIC) ? true : false; +} +bool +MacLowTransmissionParameters::MustWaitCompressedBlockAck (void) const +{ + return (m_waitAck == BLOCK_ACK_COMPRESSED) ? true : false; +} +bool +MacLowTransmissionParameters::MustWaitMultiTidBlockAck (void) const +{ + return (m_waitAck == BLOCK_ACK_MULTI_TID) ? true : false; +} +bool +MacLowTransmissionParameters::MustSendRts (void) const +{ + return m_sendRts; +} +bool +MacLowTransmissionParameters::HasDurationId (void) const +{ + return (m_overrideDurationId != Seconds (0)); +} +Time +MacLowTransmissionParameters::GetDurationId (void) const +{ + NS_ASSERT (m_overrideDurationId != Seconds (0)); + return m_overrideDurationId; +} +bool +MacLowTransmissionParameters::HasNextPacket (void) const +{ + return (m_nextSize != 0); +} +uint32_t +MacLowTransmissionParameters::GetNextPacketSize (void) const +{ + NS_ASSERT (HasNextPacket ()); + return m_nextSize; +} + +std::ostream &operator << (std::ostream &os, const MacLowTransmissionParameters ¶ms) +{ + os << "[" + << "send rts=" << params.m_sendRts << ", " + << "next size=" << params.m_nextSize << ", " + << "dur=" << params.m_overrideDurationId << ", " + << "ack="; + switch (params.m_waitAck) + { + case MacLowTransmissionParameters::ACK_NONE: + os << "none"; + break; + case MacLowTransmissionParameters::ACK_NORMAL: + os << "normal"; + break; + case MacLowTransmissionParameters::ACK_FAST: + os << "fast"; + break; + case MacLowTransmissionParameters::ACK_SUPER_FAST: + os << "super-fast"; + break; + case MacLowTransmissionParameters::BLOCK_ACK_BASIC: + os << "basic-block-ack"; + break; + case MacLowTransmissionParameters::BLOCK_ACK_COMPRESSED: + os << "compressed-block-ack"; + break; + case MacLowTransmissionParameters::BLOCK_ACK_MULTI_TID: + os << "multi-tid-block-ack"; + break; + } + os << "]"; + return os; +} + + +/** + * Listener for PHY events. Forwards to MacLow + */ +class PhyMacLowListener : public ns3::WifiPhyListener +{ +public: + /** + * Create a PhyMacLowListener for the given MacLow. + * + * \param macLow + */ + PhyMacLowListener (ns3::MacLow *macLow) + : m_macLow (macLow) + { + } + virtual ~PhyMacLowListener () + { + } + virtual void NotifyRxStart (Time duration) + { + } + virtual void NotifyRxEndOk (void) + { + } + virtual void NotifyRxEndError (void) + { + } + virtual void NotifyTxStart (Time duration, double txPowerDbm) + { + } + virtual void NotifyMaybeCcaBusyStart (Time duration) + { + } + virtual void NotifySwitchingStart (Time duration) + { + m_macLow->NotifySwitchingStartNow (duration); + } + virtual void NotifySleep (void) + { + m_macLow->NotifySleepNow (); + } + virtual void NotifyWakeup (void) + { + } +private: + ns3::MacLow *m_macLow; +}; + + +MacLow::MacLow () + : m_normalAckTimeoutEvent (), + m_fastAckTimeoutEvent (), + m_superFastAckTimeoutEvent (), + m_fastAckFailedTimeoutEvent (), + m_blockAckTimeoutEvent (), + m_ctsTimeoutEvent (), + m_sendCtsEvent (), + m_sendAckEvent (), + m_sendDataEvent (), + m_waitSifsEvent (), + m_endTxNoAckEvent (), + m_mpduAggregator (0), + m_currentPacket (0), + m_listener (0), + m_phyMacLowListener (0), + m_ctsToSelfSupported (false), + m_receivedAtLeastOneMpdu (false), + m_mpduReferenceNumber (0) +{ + NS_LOG_FUNCTION (this); + m_lastNavDuration = Seconds (0); + m_lastNavStart = Seconds (0); + m_promisc = false; + m_ampdu = false; + m_sentMpdus = 0; + m_aggregateQueue = CreateObject<WifiMacQueue> (); +} + +MacLow::~MacLow () +{ + NS_LOG_FUNCTION (this); +} + +/* static */ +TypeId +MacLow::GetTypeId (void) +{ + static TypeId tid = TypeId ("ns3::MacLow") + .SetParent<Object> () + .SetGroupName ("Wifi") + .AddConstructor<MacLow> () + ; + return tid; +} + +void +MacLow::SetupPhyMacLowListener (Ptr<WifiPhy> phy) +{ + m_phyMacLowListener = new PhyMacLowListener (this); + phy->RegisterListener (m_phyMacLowListener); +} + +void +MacLow::RemovePhyMacLowListener (Ptr<WifiPhy> phy) +{ + if (m_phyMacLowListener != 0 ) + { + phy->UnregisterListener (m_phyMacLowListener); + delete m_phyMacLowListener; + m_phyMacLowListener = 0; + } +} + +void +MacLow::DoDispose (void) +{ + NS_LOG_FUNCTION (this); + m_normalAckTimeoutEvent.Cancel (); + m_fastAckTimeoutEvent.Cancel (); + m_superFastAckTimeoutEvent.Cancel (); + m_fastAckFailedTimeoutEvent.Cancel (); + m_blockAckTimeoutEvent.Cancel (); + m_ctsTimeoutEvent.Cancel (); + m_sendCtsEvent.Cancel (); + m_sendAckEvent.Cancel (); + m_sendDataEvent.Cancel (); + m_waitSifsEvent.Cancel (); + m_endTxNoAckEvent.Cancel (); + m_waitRifsEvent.Cancel (); + m_phy = 0; + m_stationManager = 0; + if (m_phyMacLowListener != 0) + { + delete m_phyMacLowListener; + m_phyMacLowListener = 0; + } + m_mpduAggregator = 0; + m_sentMpdus = 0; + m_aggregateQueue = 0; + m_ampdu = false; +} + +void +MacLow::CancelAllEvents (void) +{ + NS_LOG_FUNCTION (this); + bool oneRunning = false; + if (m_normalAckTimeoutEvent.IsRunning ()) + { + m_normalAckTimeoutEvent.Cancel (); + oneRunning = true; + } + if (m_fastAckTimeoutEvent.IsRunning ()) + { + m_fastAckTimeoutEvent.Cancel (); + oneRunning = true; + } + if (m_superFastAckTimeoutEvent.IsRunning ()) + { + m_superFastAckTimeoutEvent.Cancel (); + oneRunning = true; + } + if (m_fastAckFailedTimeoutEvent.IsRunning ()) + { + m_fastAckFailedTimeoutEvent.Cancel (); + oneRunning = true; + } + if (m_blockAckTimeoutEvent.IsRunning ()) + { + m_blockAckTimeoutEvent.Cancel (); + oneRunning = true; + } + if (m_ctsTimeoutEvent.IsRunning ()) + { + m_ctsTimeoutEvent.Cancel (); + oneRunning = true; + } + if (m_sendCtsEvent.IsRunning ()) + { + m_sendCtsEvent.Cancel (); + oneRunning = true; + } + if (m_sendAckEvent.IsRunning ()) + { + m_sendAckEvent.Cancel (); + oneRunning = true; + } + if (m_sendDataEvent.IsRunning ()) + { + m_sendDataEvent.Cancel (); + oneRunning = true; + } + if (m_waitSifsEvent.IsRunning ()) + { + m_waitSifsEvent.Cancel (); + oneRunning = true; + } + if (m_waitRifsEvent.IsRunning ()) + { + m_waitRifsEvent.Cancel (); + oneRunning = true; + } + if (m_endTxNoAckEvent.IsRunning ()) + { + m_endTxNoAckEvent.Cancel (); + oneRunning = true; + } + if (oneRunning && m_listener != 0) + { + m_listener->Cancel (); + m_listener = 0; + } +} + +void +MacLow::SetPhy (Ptr<WifiPhy> phy) +{ + m_phy = phy; + m_phy->SetReceiveOkCallback (MakeCallback (&MacLow::DeaggregateAmpduAndReceive, this)); + m_phy->SetReceiveErrorCallback (MakeCallback (&MacLow::ReceiveError, this)); + SetupPhyMacLowListener (phy); +} + +Ptr<WifiPhy> +MacLow::GetPhy (void) const +{ + return m_phy; +} + +void +MacLow::ResetPhy (void) +{ + m_phy->SetReceiveOkCallback (MakeNullCallback<void, Ptr<Packet>, double, WifiTxVector, enum WifiPreamble> ()); + m_phy->SetReceiveErrorCallback (MakeNullCallback<void, Ptr<const Packet>, double> ()); + RemovePhyMacLowListener (m_phy); + m_phy = 0; +} + +void +MacLow::SetWifiRemoteStationManager (Ptr<WifiRemoteStationManager> manager) +{ + m_stationManager = manager; +} + +void +MacLow::SetAddress (Mac48Address ad) +{ + m_self = ad; +} + +void +MacLow::SetAckTimeout (Time ackTimeout) +{ + m_ackTimeout = ackTimeout; +} + +void +MacLow::SetBasicBlockAckTimeout (Time blockAckTimeout) +{ + m_basicBlockAckTimeout = blockAckTimeout; +} + +void +MacLow::SetCompressedBlockAckTimeout (Time blockAckTimeout) +{ + m_compressedBlockAckTimeout = blockAckTimeout; +} + +void +MacLow::SetCtsToSelfSupported (bool enable) +{ + m_ctsToSelfSupported = enable; +} + +bool +MacLow::GetCtsToSelfSupported () const +{ + return m_ctsToSelfSupported; +} + +void +MacLow::SetCtsTimeout (Time ctsTimeout) +{ + m_ctsTimeout = ctsTimeout; +} + +void +MacLow::SetSifs (Time sifs) +{ + m_sifs = sifs; +} + +void +MacLow::SetSlotTime (Time slotTime) +{ + m_slotTime = slotTime; +} + +void +MacLow::SetPifs (Time pifs) +{ + m_pifs = pifs; +} + +void +MacLow::SetRifs (Time rifs) +{ + m_rifs = rifs; +} + +void +MacLow::SetBssid (Mac48Address bssid) +{ + m_bssid = bssid; +} + +void +MacLow::SetPromisc (void) +{ + m_promisc = true; +} + +Mac48Address +MacLow::GetAddress (void) const +{ + return m_self; +} + +Time +MacLow::GetAckTimeout (void) const +{ + return m_ackTimeout; +} + +Time +MacLow::GetBasicBlockAckTimeout () const +{ + return m_basicBlockAckTimeout; +} + +Time +MacLow::GetCompressedBlockAckTimeout () const +{ + return m_compressedBlockAckTimeout; +} + +Time +MacLow::GetCtsTimeout (void) const +{ + return m_ctsTimeout; +} + +Time +MacLow::GetSifs (void) const +{ + return m_sifs; +} + +Time +MacLow::GetRifs (void) const +{ + return m_rifs; +} + +Time +MacLow::GetSlotTime (void) const +{ + return m_slotTime; +} + +Time +MacLow::GetPifs (void) const +{ + return m_pifs; +} + +Mac48Address +MacLow::GetBssid (void) const +{ + return m_bssid; +} + +bool +MacLow::IsPromisc (void) const +{ + return m_promisc; +} + +void +MacLow::SetRxCallback (Callback<void, Ptr<Packet>, const WifiMacHeader *> callback) +{ + m_rxCallback = callback; +} + +void +MacLow::RegisterDcfListener (MacLowDcfListener *listener) +{ + m_dcfListeners.push_back (listener); +} + +bool +MacLow::IsAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr) +{ + uint32_t size, actualSize; + WifiMacTrailer fcs; + size = packet->GetSize () + hdr.GetSize () + fcs.GetSerializedSize (); + Ptr<Packet> p = AggregateToAmpdu (packet, hdr); + actualSize = p->GetSize (); + if (actualSize > size) + { + m_currentPacket = p; + return true; + } + else + { + return false; + } +} + +void +MacLow::StartTransmission (Ptr<const Packet> packet, + const WifiMacHeader* hdr, + MacLowTransmissionParameters params, + MacLowTransmissionListener *listener) +{ + NS_LOG_FUNCTION (this << packet << hdr << params << listener); + /* m_currentPacket is not NULL because someone started + * a transmission and was interrupted before one of: + * - ctsTimeout + * - sendDataAfterCTS + * expired. This means that one of these timers is still + * running. They are all cancelled below anyway by the + * call to CancelAllEvents (because of at least one + * of these two timers) which will trigger a call to the + * previous listener's cancel method. + * + * This typically happens because the high-priority + * QapScheduler has taken access to the channel from + * one of the Edca of the QAP. + */ + m_currentPacket = packet->Copy (); + m_currentHdr = *hdr; + CancelAllEvents (); + m_listener = listener; + m_txParams = params; + + if (!m_currentHdr.IsQosData () && !m_currentHdr.IsBlockAck () && !m_currentHdr.IsBlockAckReq ()) + { + //This is mainly encountered when a higher priority control frame (such as beacons) + //is sent between A-MPDU transmissions. It avoids to unexpectedly flush the aggregate + //queue when previous RTS request has failed. + m_ampdu = false; + } + else if (m_aggregateQueue->GetSize () > 0) + { + //m_aggregateQueue > 0 occurs when a RTS/CTS exchange failed before an A-MPDU transmission. + //In that case, we transmit the same A-MPDU as previously. + m_sentMpdus = m_aggregateQueue->GetSize (); + m_ampdu = true; + if (m_sentMpdus > 1) + { + m_txParams.EnableCompressedBlockAck (); + } + else if (m_currentHdr.IsQosData ()) + { + //VHT single MPDUs are followed by normal ACKs + m_txParams.EnableAck (); + } + } + else + { + //Perform MPDU aggregation if possible + m_ampdu = IsAmpdu (m_currentPacket, m_currentHdr); + if (m_ampdu) + { + AmpduTag ampdu; + m_currentPacket->PeekPacketTag (ampdu); + if (ampdu.GetNoOfMpdus () > 1) + { + m_txParams.EnableCompressedBlockAck (); + } + else if (m_currentHdr.IsQosData ()) + { + //VHT single MPDUs are followed by normal ACKs + m_txParams.EnableAck (); + } + } + } + +// if (NeedRts ()) +// { +// m_txParams.EnableRts (); +// } +// else +// { +// m_txParams.DisableRts (); +// } + + NS_LOG_DEBUG ("startTx size=" << GetSize (m_currentPacket, &m_currentHdr) << + ", to=" << m_currentHdr.GetAddr1 () << ", listener=" << m_listener); + + if (m_txParams.MustSendRts ()) + { + SendRtsForPacket (); + } + else + { + if (NeedCtsToSelf () && m_ctsToSelfSupported) + { + SendCtsToSelf (); + } + else + { + SendDataPacket (); + } + } + + /* When this method completes, we have taken ownership of the medium. */ + NS_ASSERT (m_phy->IsStateTx ()); +} + +bool +MacLow::NeedRts (void) +{ + return m_stationManager->NeedRts (m_currentHdr.GetAddr1 (), + &m_currentHdr, + m_currentPacket); +} + +bool +MacLow::NeedCtsToSelf (void) +{ + WifiTxVector dataTxVector = GetDataTxVector (m_currentPacket, &m_currentHdr); + return m_stationManager->NeedCtsToSelf (dataTxVector); +} + +void +MacLow::ReceiveError (Ptr<const Packet> packet, double rxSnr) +{ + NS_LOG_FUNCTION (this << packet << rxSnr); + NS_LOG_DEBUG ("rx failed "); + AmpduTag ampdu; + Ptr<Packet> pkt = packet->Copy (); + bool isInAmpdu = pkt->RemovePacketTag (ampdu); + + if (isInAmpdu && m_receivedAtLeastOneMpdu && (ampdu.GetNoOfMpdus () == 1)) + { + MpduAggregator::DeaggregatedMpdus packets = MpduAggregator::Deaggregate (pkt); + MpduAggregator::DeaggregatedMpdusCI n = packets.begin (); + WifiMacHeader hdr; + (*n).first->PeekHeader (hdr); +#ifdef WITH_MORE_FIX_TO_BA_IN_MAC_LOW + //further check if last mpdu is received from the same source + if(m_lastmpduFrom==hdr.GetAddr2()) + { +#endif + if (hdr.IsQosData ()) + { + uint8_t tid = hdr.GetQosTid (); + AgreementsI it = m_bAckAgreements.find (std::make_pair (hdr.GetAddr2 (), tid)); + if (it != m_bAckAgreements.end ()) + { +#ifndef WITHOUT_BA_RESPONSE_WHEN_LAST_AMPDU_FAIL + NS_LOG_DEBUG ("last a-mpdu subframe detected/sendImmediateBlockAck from=" << hdr.GetAddr2 ()); + m_sendAckEvent = Simulator::Schedule (GetSifs (), + &MacLow::SendBlockAckAfterAmpdu, this, + hdr.GetQosTid (), + hdr.GetAddr2 (), + hdr.GetDuration (), + m_currentTxVector); +#endif + m_receivedAtLeastOneMpdu = false; + } + } + else if (hdr.IsBlockAckReq ()) + { + NS_LOG_DEBUG ("last a-mpdu subframe is BAR"); + m_receivedAtLeastOneMpdu = false; + } +#ifdef WITH_MORE_FIX_TO_BA_IN_MAC_LOW + } +#endif + } + else if (m_txParams.MustWaitFastAck ()) + { + NS_ASSERT (m_fastAckFailedTimeoutEvent.IsExpired ()); + m_fastAckFailedTimeoutEvent = Simulator::Schedule (GetSifs (), + &MacLow::FastAckFailedTimeout, this); + } + return; +} + +void +MacLow::NotifySwitchingStartNow (Time duration) +{ + NS_LOG_DEBUG ("switching channel. Cancelling MAC pending events"); + m_stationManager->Reset (); + CancelAllEvents (); + if (m_navCounterResetCtsMissed.IsRunning ()) + { + m_navCounterResetCtsMissed.Cancel (); + } + m_lastNavStart = Simulator::Now (); + m_lastNavDuration = Seconds (0); + m_currentPacket = 0; + m_listener = 0; +} + +void +MacLow::NotifySleepNow (void) +{ + NS_LOG_DEBUG ("Device in sleep mode. Cancelling MAC pending events"); + CancelAllEvents (); + if (m_navCounterResetCtsMissed.IsRunning ()) + { + m_navCounterResetCtsMissed.Cancel (); + } + m_lastNavStart = Simulator::Now (); + m_lastNavDuration = Seconds (0); + m_currentPacket = 0; + m_listener = 0; +} + +void +MacLow::ReceiveOk (Ptr<Packet> packet, double rxSnr, WifiTxVector txVector, WifiPreamble preamble, bool ampduSubframe) +{ + NS_LOG_FUNCTION (this << packet << rxSnr << txVector.GetMode () << preamble); + /* A packet is received from the PHY. + * When we have handled this packet, + * we handle any packet present in the + * packet queue. + */ + WifiMacHeader hdr; + packet->RemoveHeader (hdr); + + bool isPrevNavZero = IsNavZero (); + NS_LOG_DEBUG ("duration/id=" << hdr.GetDuration ()); + NotifyNav (packet, hdr, preamble); + if (hdr.IsRts ()) + { + /* see section 9.2.5.7 802.11-1999 + * A STA that is addressed by an RTS frame shall transmit a CTS frame after a SIFS + * period if the NAV at the STA receiving the RTS frame indicates that the medium is + * idle. If the NAV at the STA receiving the RTS indicates the medium is not idle, + * that STA shall not respond to the RTS frame. + */ + if (ampduSubframe) + { + NS_FATAL_ERROR ("Received RTS as part of an A-MPDU"); + } + else + { + if (isPrevNavZero + && hdr.GetAddr1 () == m_self) + { + NS_LOG_DEBUG ("rx RTS from=" << hdr.GetAddr2 () << ", schedule CTS"); + NS_ASSERT (m_sendCtsEvent.IsExpired ()); + m_stationManager->ReportRxOk (hdr.GetAddr2 (), &hdr, + rxSnr, txVector.GetMode ()); + m_sendCtsEvent = Simulator::Schedule (GetSifs (), + &MacLow::SendCtsAfterRts, this, + hdr.GetAddr2 (), + hdr.GetDuration (), + txVector, + rxSnr); + } + else + { + NS_LOG_DEBUG ("rx RTS from=" << hdr.GetAddr2 () << ", cannot schedule CTS"); + } + } + } + else if (hdr.IsCts () + && hdr.GetAddr1 () == m_self + && m_ctsTimeoutEvent.IsRunning () + && m_currentPacket != 0) + { + if (ampduSubframe) + { + NS_FATAL_ERROR ("Received CTS as part of an A-MPDU"); + } + + NS_LOG_DEBUG ("receive cts from=" << m_currentHdr.GetAddr1 ()); + + SnrTag tag; + packet->RemovePacketTag (tag); + m_stationManager->ReportRxOk (m_currentHdr.GetAddr1 (), &m_currentHdr, + rxSnr, txVector.GetMode ()); + m_stationManager->ReportRtsOk (m_currentHdr.GetAddr1 (), &m_currentHdr, + rxSnr, txVector.GetMode (), tag.Get ()); + + m_ctsTimeoutEvent.Cancel (); + NotifyCtsTimeoutResetNow (); + m_listener->GotCts (rxSnr, txVector.GetMode ()); + NS_ASSERT (m_sendDataEvent.IsExpired ()); + m_sendDataEvent = Simulator::Schedule (GetSifs (), + &MacLow::SendDataAfterCts, this, + hdr.GetAddr1 (), + hdr.GetDuration ()); + } + else if (hdr.IsAck () + && hdr.GetAddr1 () == m_self + && (m_normalAckTimeoutEvent.IsRunning () + || m_fastAckTimeoutEvent.IsRunning () + || m_superFastAckTimeoutEvent.IsRunning ()) + && m_txParams.MustWaitAck ()) + { + NS_LOG_DEBUG ("receive ack from=" << m_currentHdr.GetAddr1 ()); + SnrTag tag; + packet->RemovePacketTag (tag); + m_stationManager->ReportRxOk (m_currentHdr.GetAddr1 (), &m_currentHdr, + rxSnr, txVector.GetMode ()); + m_stationManager->ReportDataOk (m_currentHdr.GetAddr1 (), &m_currentHdr, + rxSnr, txVector.GetMode (), tag.Get ()); + + FlushAggregateQueue (); + m_ampdu = false; + bool gotAck = false; + + if (m_txParams.MustWaitNormalAck () + && m_normalAckTimeoutEvent.IsRunning ()) + { + m_normalAckTimeoutEvent.Cancel (); + NotifyAckTimeoutResetNow (); + gotAck = true; + } + if (m_txParams.MustWaitFastAck () + && m_fastAckTimeoutEvent.IsRunning ()) + { + m_fastAckTimeoutEvent.Cancel (); + NotifyAckTimeoutResetNow (); + gotAck = true; + } + if (gotAck) + { + m_listener->GotAck (rxSnr, txVector.GetMode ()); + } + if (m_txParams.HasNextPacket ()) + { + m_waitSifsEvent = Simulator::Schedule (GetSifs (), + &MacLow::WaitSifsAfterEndTx, this); + } + } + else if (hdr.IsBlockAck () && hdr.GetAddr1 () == m_self + && (m_txParams.MustWaitBasicBlockAck () || m_txParams.MustWaitCompressedBlockAck ()) + && m_blockAckTimeoutEvent.IsRunning ()) + { + NS_LOG_DEBUG ("got block ack from " << hdr.GetAddr2 ()); + CtrlBAckResponseHeader blockAck; + packet->RemoveHeader (blockAck); + m_blockAckTimeoutEvent.Cancel (); + NotifyAckTimeoutResetNow (); + m_listener->GotBlockAck (&blockAck, hdr.GetAddr2 (), txVector.GetMode ()); + m_sentMpdus = 0; + m_ampdu = false; + FlushAggregateQueue (); + } + else if (hdr.IsBlockAckReq () && hdr.GetAddr1 () == m_self) + { +#ifdef WITH_FIX_RECEIVE_BAR_BEFORE_CTS_TIMEOUT + if(m_ctsTimeoutEvent.IsRunning()) + return; +#endif + CtrlBAckRequestHeader blockAckReq; + packet->RemoveHeader (blockAckReq); + if (!blockAckReq.IsMultiTid ()) + { + uint8_t tid = blockAckReq.GetTidInfo (); + AgreementsI it = m_bAckAgreements.find (std::make_pair (hdr.GetAddr2 (), tid)); + if (it != m_bAckAgreements.end ()) + { + //Update block ack cache + BlockAckCachesI i = m_bAckCaches.find (std::make_pair (hdr.GetAddr2 (), tid)); + NS_ASSERT (i != m_bAckCaches.end ()); + (*i).second.UpdateWithBlockAckReq (blockAckReq.GetStartingSequence ()); + + NS_ASSERT (m_sendAckEvent.IsExpired ()); + /* See section 11.5.3 in IEEE 802.11 for mean of this timer */ + ResetBlockAckInactivityTimerIfNeeded (it->second.first); + if ((*it).second.first.IsImmediateBlockAck ()) + { + NS_LOG_DEBUG ("rx blockAckRequest/sendImmediateBlockAck from=" << hdr.GetAddr2 ()); + m_sendAckEvent = Simulator::Schedule (GetSifs (), + &MacLow::SendBlockAckAfterBlockAckRequest, this, + blockAckReq, + hdr.GetAddr2 (), + hdr.GetDuration (), + txVector.GetMode ()); + } + else + { + NS_FATAL_ERROR ("Delayed block ack not supported."); + } + m_receivedAtLeastOneMpdu = false; + } + else + { + NS_LOG_DEBUG ("There's not a valid agreement for this block ack request."); + } + } + else + { + NS_FATAL_ERROR ("Multi-tid block ack is not supported."); + } + } + else if (hdr.IsCtl ()) + { + NS_LOG_DEBUG ("rx drop " << hdr.GetTypeString ()); + m_receivedAtLeastOneMpdu = false; + } + else if (hdr.GetAddr1 () == m_self) + { + m_stationManager->ReportRxOk (hdr.GetAddr2 (), &hdr, + rxSnr, txVector.GetMode ()); + if (hdr.IsQosData () && ReceiveMpdu (packet, hdr)) + { + /* From section 9.10.4 in IEEE 802.11: + Upon the receipt of a QoS data frame from the originator for which + the Block Ack agreement exists, the recipient shall buffer the MSDU + regardless of the value of the Ack Policy subfield within the + QoS Control field of the QoS data frame. */ + if (hdr.IsQosAck () && !ampduSubframe) + { + NS_LOG_DEBUG ("rx QoS unicast/sendAck from=" << hdr.GetAddr2 ()); + AgreementsI it = m_bAckAgreements.find (std::make_pair (hdr.GetAddr2 (), hdr.GetQosTid ())); + + RxCompleteBufferedPacketsWithSmallerSequence (it->second.first.GetStartingSequenceControl (), + hdr.GetAddr2 (), hdr.GetQosTid ()); + RxCompleteBufferedPacketsUntilFirstLost (hdr.GetAddr2 (), hdr.GetQosTid ()); + NS_ASSERT (m_sendAckEvent.IsExpired ()); + m_sendAckEvent = Simulator::Schedule (GetSifs (), + &MacLow::SendAckAfterData, this, + hdr.GetAddr2 (), + hdr.GetDuration (), + txVector.GetMode (), + rxSnr); + m_receivedAtLeastOneMpdu = false; + } + else if (hdr.IsQosBlockAck ()) + { + AgreementsI it = m_bAckAgreements.find (std::make_pair (hdr.GetAddr2 (), hdr.GetQosTid ())); + /* See section 11.5.3 in IEEE 802.11 for mean of this timer */ + ResetBlockAckInactivityTimerIfNeeded (it->second.first); + } + return; + } + else if (hdr.IsQosData () && hdr.IsQosBlockAck ()) + { + /* This happens if a packet with ack policy Block Ack is received and a block ack + agreement for that packet doesn't exist. + + From section 11.5.3 in IEEE 802.11e: + When a recipient does not have an active Block ack for a TID, but receives + data MPDUs with the Ack Policy subfield set to Block Ack, it shall discard + them and shall send a DELBA frame using the normal access + mechanisms. */ + AcIndex ac = QosUtilsMapTidToAc (hdr.GetQosTid ()); + m_edcaListeners[ac]->BlockAckInactivityTimeout (hdr.GetAddr2 (), hdr.GetQosTid ()); + return; + } + else if (hdr.IsQosData () && hdr.IsQosNoAck ()) + { + if (ampduSubframe) + { + NS_LOG_DEBUG ("rx Ampdu with No Ack Policy from=" << hdr.GetAddr2 ()); + } + else + { + NS_LOG_DEBUG ("rx unicast/noAck from=" << hdr.GetAddr2 ()); + } + } + else if (hdr.IsData () || hdr.IsMgt ()) + { + if (hdr.IsMgt () && ampduSubframe) + { + NS_FATAL_ERROR ("Received management packet as part of an A-MPDU"); + } + else + { +#ifdef WITH_MORE_FIX_TO_BA_IN_MAC_LOW + if(hdr.IsData () && ampduSubframe) + { + AcIndex ac = QosUtilsMapTidToAc (hdr.GetQosTid ()); + m_edcaListeners[ac]->BlockAckInactivityTimeout (hdr.GetAddr2 (), hdr.GetQosTid ()); + return; + } +#endif + NS_LOG_DEBUG ("rx unicast/sendAck from=" << hdr.GetAddr2 ()); + NS_ASSERT (m_sendAckEvent.IsExpired ()); + m_sendAckEvent = Simulator::Schedule (GetSifs (), + &MacLow::SendAckAfterData, this, + hdr.GetAddr2 (), + hdr.GetDuration (), + txVector.GetMode (), + rxSnr); + m_receivedAtLeastOneMpdu = false; + } + } + goto rxPacket; + } + else if (hdr.GetAddr1 ().IsGroup ()) + { + if (ampduSubframe) + { + NS_FATAL_ERROR ("Received group addressed packet as part of an A-MPDU"); + } + else + { + if (hdr.IsData () || hdr.IsMgt ()) + { + NS_LOG_DEBUG ("rx group from=" << hdr.GetAddr2 ()); + m_receivedAtLeastOneMpdu = false; + goto rxPacket; + } + else + { + // DROP + } + } + } + else if (m_promisc) + { + NS_ASSERT (hdr.GetAddr1 () != m_self); + if (hdr.IsData ()) + { + goto rxPacket; + } + } + else + { + //NS_LOG_DEBUG_VERBOSE ("rx not-for-me from %d", GetSource (packet)); + } + return; +rxPacket: + WifiMacTrailer fcs; + packet->RemoveTrailer (fcs); + m_rxCallback (packet, &hdr); + return; +} + +uint8_t +MacLow::GetTid (Ptr<const Packet> packet, const WifiMacHeader hdr) const +{ + uint8_t tid = 0; + if (hdr.IsQosData ()) + { + tid = hdr.GetQosTid (); + } + else if (hdr.IsBlockAckReq ()) + { + CtrlBAckRequestHeader baReqHdr; + packet->PeekHeader (baReqHdr); + tid = baReqHdr.GetTidInfo (); + } + else if (hdr.IsBlockAck ()) + { + CtrlBAckResponseHeader baRespHdr; + packet->PeekHeader (baRespHdr); + tid = baRespHdr.GetTidInfo (); + } + return tid; +} + +uint32_t +MacLow::GetAckSize (void) const +{ + WifiMacHeader ack; + ack.SetType (WIFI_MAC_CTL_ACK); + return ack.GetSize () + 4; +} + +uint32_t +MacLow::GetBlockAckSize (enum BlockAckType type) const +{ + WifiMacHeader hdr; + hdr.SetType (WIFI_MAC_CTL_BACKRESP); + CtrlBAckResponseHeader blockAck; + if (type == BASIC_BLOCK_ACK) + { + blockAck.SetType (BASIC_BLOCK_ACK); + } + else if (type == COMPRESSED_BLOCK_ACK) + { + blockAck.SetType (COMPRESSED_BLOCK_ACK); + } + else if (type == MULTI_TID_BLOCK_ACK) + { + //Not implemented + NS_ASSERT (false); + } + return hdr.GetSize () + blockAck.GetSerializedSize () + 4; +} + +uint32_t +MacLow::GetRtsSize (void) const +{ + WifiMacHeader rts; + rts.SetType (WIFI_MAC_CTL_RTS); + return rts.GetSize () + 4; +} + +Time +MacLow::GetAckDuration (Mac48Address to, WifiTxVector dataTxVector) const +{ + WifiTxVector ackTxVector = GetAckTxVectorForData (to, dataTxVector.GetMode ()); + return GetAckDuration (ackTxVector); +} + +Time +MacLow::GetAckDuration (WifiTxVector ackTxVector) const +{ + NS_ASSERT (ackTxVector.GetMode ().GetModulationClass () != WIFI_MOD_CLASS_HT); //ACK should always use non-HT PPDU (HT PPDU cases not supported yet) + return m_phy->CalculateTxDuration (GetAckSize (), ackTxVector, WIFI_PREAMBLE_LONG, m_phy->GetFrequency (), 0, 0); +} + +Time +MacLow::GetBlockAckDuration (Mac48Address to, WifiTxVector blockAckReqTxVector, enum BlockAckType type) const +{ + /* + * For immediate Basic BlockAck we should transmit the frame with the same WifiMode + * as the BlockAckReq. + */ + WifiPreamble preamble; + if (blockAckReqTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT && type == BASIC_BLOCK_ACK) + { + preamble = WIFI_PREAMBLE_HT_MF; + } + else + { + preamble = WIFI_PREAMBLE_LONG; + } + return m_phy->CalculateTxDuration (GetBlockAckSize (type), blockAckReqTxVector, preamble, m_phy->GetFrequency (), 0, 0); +} + +Time +MacLow::GetCtsDuration (Mac48Address to, WifiTxVector rtsTxVector) const +{ + WifiTxVector ctsTxVector = GetCtsTxVectorForRts (to, rtsTxVector.GetMode ()); + return GetCtsDuration (ctsTxVector); +} + +Time +MacLow::GetCtsDuration (WifiTxVector ctsTxVector) const +{ + NS_ASSERT (ctsTxVector.GetMode ().GetModulationClass () != WIFI_MOD_CLASS_HT); //CTS should always use non-HT PPDU (HT PPDU cases not supported yet) + return m_phy->CalculateTxDuration (GetCtsSize (), ctsTxVector, WIFI_PREAMBLE_LONG, m_phy->GetFrequency (), 0, 0); +} + +uint32_t +MacLow::GetCtsSize (void) const +{ + WifiMacHeader cts; + cts.SetType (WIFI_MAC_CTL_CTS); + return cts.GetSize () + 4; +} + +uint32_t +MacLow::GetSize (Ptr<const Packet> packet, const WifiMacHeader *hdr) const +{ + uint32_t size; + WifiMacTrailer fcs; + if (m_ampdu) + { + size = packet->GetSize (); + } + else + { + size = packet->GetSize () + hdr->GetSize () + fcs.GetSerializedSize (); + } + return size; +} + +WifiTxVector +MacLow::GetCtsToSelfTxVector (Ptr<const Packet> packet, const WifiMacHeader *hdr) const +{ + return m_stationManager->GetCtsToSelfTxVector (hdr, packet); +} + +WifiTxVector +MacLow::GetRtsTxVector (Ptr<const Packet> packet, const WifiMacHeader *hdr) const +{ + Mac48Address to = hdr->GetAddr1 (); + return m_stationManager->GetRtsTxVector (to, hdr, packet); +} + +WifiTxVector +MacLow::GetDataTxVector (Ptr<const Packet> packet, const WifiMacHeader *hdr) const +{ + Mac48Address to = hdr->GetAddr1 (); + WifiMacTrailer fcs; + uint32_t size = packet->GetSize () + hdr->GetSize () + fcs.GetSerializedSize (); + //size is not used in anything!! will not worry about aggregation + return m_stationManager->GetDataTxVector (to, hdr, packet, size); +} + +WifiTxVector +MacLow::GetCtsTxVector (Mac48Address to, WifiMode rtsTxMode) const +{ + return m_stationManager->GetCtsTxVector (to, rtsTxMode); +} + +WifiTxVector +MacLow::GetAckTxVector (Mac48Address to, WifiMode dataTxMode) const +{ + return m_stationManager->GetAckTxVector (to, dataTxMode); +} + +WifiTxVector +MacLow::GetBlockAckTxVector (Mac48Address to, WifiMode dataTxMode) const +{ + return m_stationManager->GetBlockAckTxVector (to, dataTxMode); +} + +WifiTxVector +MacLow::GetCtsTxVectorForRts (Mac48Address to, WifiMode rtsTxMode) const +{ + return GetCtsTxVector (to, rtsTxMode); +} + +WifiTxVector +MacLow::GetAckTxVectorForData (Mac48Address to, WifiMode dataTxMode) const +{ + return GetAckTxVector (to, dataTxMode); +} + +Time +MacLow::CalculateOverallTxTime (Ptr<const Packet> packet, + const WifiMacHeader* hdr, + const MacLowTransmissionParameters& params) const +{ + WifiPreamble preamble; + Time txTime = Seconds (0); + if (params.MustSendRts ()) + { + WifiTxVector rtsTxVector = GetRtsTxVector (packet, hdr); + //standard says RTS packets can have GF format sec 9.6.0e.1 page 110 bullet b 2 + if (m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ())) + { + preamble = WIFI_PREAMBLE_HT_GF; + } + else + { + //Otherwise, RTS should always use non-HT PPDU (HT PPDU cases not supported yet) + preamble = WIFI_PREAMBLE_LONG; + } + txTime += m_phy->CalculateTxDuration (GetRtsSize (), rtsTxVector, preamble, m_phy->GetFrequency (), 0, 0); + txTime += GetCtsDuration (hdr->GetAddr1 (), rtsTxVector); + txTime += Time (GetSifs () * 2); + } + WifiTxVector dataTxVector = GetDataTxVector (packet, hdr); + if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT) + { + preamble = WIFI_PREAMBLE_VHT; + } + else if (m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ())) + { + preamble = WIFI_PREAMBLE_HT_GF; + } + else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT) + { + preamble = WIFI_PREAMBLE_HT_MF; + } + else + { + preamble = WIFI_PREAMBLE_LONG; + } + uint32_t dataSize = GetSize (packet, hdr); + txTime += m_phy->CalculateTxDuration (dataSize, dataTxVector, preamble, m_phy->GetFrequency (), 0, 0); + if (params.MustWaitAck ()) + { + txTime += GetSifs (); + txTime += GetAckDuration (hdr->GetAddr1 (), dataTxVector); + } + return txTime; +} + +Time +MacLow::CalculateTransmissionTime (Ptr<const Packet> packet, + const WifiMacHeader* hdr, + const MacLowTransmissionParameters& params) const +{ + Time txTime = CalculateOverallTxTime (packet, hdr, params); + if (params.HasNextPacket ()) + { + WifiTxVector dataTxVector = GetDataTxVector (packet, hdr); + WifiPreamble preamble; + if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT) + { + preamble = WIFI_PREAMBLE_VHT; + } + if (m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ())) + { + preamble = WIFI_PREAMBLE_HT_GF; + } + else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT) + { + preamble = WIFI_PREAMBLE_HT_MF; + } + else + { + preamble = WIFI_PREAMBLE_LONG; + } + txTime += GetSifs (); + txTime += m_phy->CalculateTxDuration (params.GetNextPacketSize (), dataTxVector, preamble, m_phy->GetFrequency (), 0, 0); + } + return txTime; +} + +void +MacLow::NotifyNav (Ptr<const Packet> packet,const WifiMacHeader &hdr, WifiPreamble preamble) +{ + NS_ASSERT (m_lastNavStart <= Simulator::Now ()); + Time duration = hdr.GetDuration (); + + if (hdr.IsCfpoll () + && hdr.GetAddr2 () == m_bssid) + { + //see section 9.3.2.2 802.11-1999 + DoNavResetNow (duration); + return; + } + /// \todo We should also handle CF_END specially here + /// but we don't for now because we do not generate them. + else if (hdr.GetAddr1 () != m_self) + { + // see section 9.2.5.4 802.11-1999 + bool navUpdated = DoNavStartNow (duration); + if (hdr.IsRts () && navUpdated) + { + /** + * A STA that used information from an RTS frame as the most recent basis to update its NAV setting + * is permitted to reset its NAV if no PHY-RXSTART.indication is detected from the PHY during a + * period with a duration of (2 * aSIFSTime) + (CTS_Time) + (2 * aSlotTime) starting at the + * PHY-RXEND.indication corresponding to the detection of the RTS frame. The “CTS_Time” shall + * be calculated using the length of the CTS frame and the data rate at which the RTS frame + * used for the most recent NAV update was received. + */ + WifiMacHeader cts; + cts.SetType (WIFI_MAC_CTL_CTS); + WifiTxVector txVector = GetRtsTxVector (packet, &hdr); + Time navCounterResetCtsMissedDelay = + m_phy->CalculateTxDuration (cts.GetSerializedSize (), txVector, preamble, m_phy->GetFrequency (), 0, 0) + + Time (2 * GetSifs ()) + Time (2 * GetSlotTime ()); + m_navCounterResetCtsMissed = Simulator::Schedule (navCounterResetCtsMissedDelay, + &MacLow::NavCounterResetCtsMissed, this, + Simulator::Now ()); + } + } +} + +void +MacLow::NavCounterResetCtsMissed (Time rtsEndRxTime) +{ + if (m_phy->GetLastRxStartTime () < rtsEndRxTime) + { + DoNavResetNow (Seconds (0.0)); + } +} + +void +MacLow::DoNavResetNow (Time duration) +{ + for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++) + { + (*i)->NavReset (duration); + } + m_lastNavStart = Simulator::Now (); + m_lastNavDuration = duration; +} + +bool +MacLow::DoNavStartNow (Time duration) +{ + for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++) + { + (*i)->NavStart (duration); + } + Time newNavEnd = Simulator::Now () + duration; + Time oldNavEnd = m_lastNavStart + m_lastNavDuration; + if (newNavEnd > oldNavEnd) + { + m_lastNavStart = Simulator::Now (); + m_lastNavDuration = duration; + return true; + } + return false; +} + +void +MacLow::NotifyAckTimeoutStartNow (Time duration) +{ + for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++) + { + (*i)->AckTimeoutStart (duration); + } +} + +void +MacLow::NotifyAckTimeoutResetNow () +{ + for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++) + { + (*i)->AckTimeoutReset (); + } +} + +void +MacLow::NotifyCtsTimeoutStartNow (Time duration) +{ + for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++) + { + (*i)->CtsTimeoutStart (duration); + } +} + +void +MacLow::NotifyCtsTimeoutResetNow () +{ + for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++) + { + (*i)->CtsTimeoutReset (); + } +} + +void +MacLow::ForwardDown (Ptr<const Packet> packet, const WifiMacHeader* hdr, + WifiTxVector txVector, WifiPreamble preamble) +{ + NS_LOG_FUNCTION (this << packet << hdr << txVector); + NS_LOG_DEBUG ("send " << hdr->GetTypeString () << + ", to=" << hdr->GetAddr1 () << + ", size=" << packet->GetSize () << + ", mode=" << txVector.GetMode () << + ", duration=" << hdr->GetDuration () << + ", seq=0x" << std::hex << m_currentHdr.GetSequenceControl () << std::dec); + +/*std::cout<<"send " << hdr->GetTypeString () << + ", size=" << packet->GetSize () << + ", mode=" << txVector.GetMode () <<"\n"; + */ + if (!m_ampdu || hdr->IsRts ()) + { + m_phy->SendPacket (packet, txVector, preamble, 0, 0); + } + else + { + Ptr<Packet> newPacket; + Ptr <const Packet> dequeuedPacket; + WifiMacHeader newHdr; + WifiMacTrailer fcs; + uint32_t queueSize = m_aggregateQueue->GetSize (); + bool vhtSingleMpdu = false; + bool last = false; + uint8_t packetType = 0; + + if (queueSize == 1) + { + vhtSingleMpdu = true; + } + + //Add packet tag + AmpduTag ampdutag; + ampdutag.SetAmpdu (true); + Time delay = Seconds (0); + if (queueSize > 1 || vhtSingleMpdu) + { + txVector.SetAggregation (true); + } + for (; queueSize > 0; queueSize--) + { + dequeuedPacket = m_aggregateQueue->Dequeue (&newHdr); + newPacket = dequeuedPacket->Copy (); + newHdr.SetDuration (hdr->GetDuration ()); + newPacket->AddHeader (newHdr); + newPacket->AddTrailer (fcs); + if (queueSize == 1) + { + last = true; + packetType = 2; + } + m_mpduAggregator->AddHeaderAndPad (newPacket, last, vhtSingleMpdu); + + ampdutag.SetNoOfMpdus (queueSize); + newPacket->AddPacketTag (ampdutag); + if (delay == Seconds (0)) + { + if (!vhtSingleMpdu) + { + NS_LOG_DEBUG ("Sending MPDU as part of A-MPDU"); + packetType = 1; + } + else + { + packetType = 0; + } + m_phy->SendPacket (newPacket, txVector, preamble, packetType, m_mpduReferenceNumber); + } + else + { + Simulator::Schedule (delay, &MacLow::SendPacket, this, newPacket, txVector, preamble, packetType, m_mpduReferenceNumber); + } + if (queueSize > 1) + { + delay = delay + m_phy->CalculateTxDuration (GetSize (newPacket, &newHdr), txVector, preamble, m_phy->GetFrequency (), packetType, 0); + } + preamble = WIFI_PREAMBLE_NONE; + } + m_mpduReferenceNumber = ((m_mpduReferenceNumber + 1) % 4294967296); + } +} + +void +MacLow::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, WifiPreamble preamble, uint8_t packetType, uint32_t mpduReferenceNumber) +{ + NS_LOG_DEBUG ("Sending MPDU as part of A-MPDU"); + m_phy->SendPacket (packet, txVector, preamble, packetType, mpduReferenceNumber); +} + +void +MacLow::CtsTimeout (void) +{ + NS_LOG_FUNCTION (this); + NS_LOG_DEBUG ("cts timeout"); + /// \todo should check that there was no rx start before now. + /// we should restart a new cts timeout now until the expected + /// end of rx if there was a rx start before now. + m_stationManager->ReportRtsFailed (m_currentHdr.GetAddr1 (), &m_currentHdr); + if (m_sentMpdus == 0) + { + m_currentPacket = 0; + } + MacLowTransmissionListener *listener = m_listener; + m_listener = 0; + m_sentMpdus = 0; + m_ampdu = false; + listener->MissedCts (); +} + +void +MacLow::NormalAckTimeout (void) +{ + NS_LOG_FUNCTION (this); + NS_LOG_DEBUG ("normal ack timeout"); + /// \todo should check that there was no rx start before now. + /// we should restart a new ack timeout now until the expected + /// end of rx if there was a rx start before now. + m_stationManager->ReportDataFailed (m_currentHdr.GetAddr1 (), &m_currentHdr); + MacLowTransmissionListener *listener = m_listener; + m_listener = 0; + m_sentMpdus = 0; + m_ampdu = false; + FlushAggregateQueue (); + listener->MissedAck (); +} + +void +MacLow::FastAckTimeout (void) +{ + NS_LOG_FUNCTION (this); + m_stationManager->ReportDataFailed (m_currentHdr.GetAddr1 (), &m_currentHdr); + MacLowTransmissionListener *listener = m_listener; + m_listener = 0; + if (m_phy->IsStateIdle ()) + { + NS_LOG_DEBUG ("fast Ack idle missed"); + listener->MissedAck (); + } + else + { + NS_LOG_DEBUG ("fast Ack ok"); + } +} + +void +MacLow::BlockAckTimeout (void) +{ + NS_LOG_FUNCTION (this); + NS_LOG_DEBUG ("block ack timeout"); + + m_stationManager->ReportDataFailed (m_currentHdr.GetAddr1 (), &m_currentHdr); + MacLowTransmissionListener *listener = m_listener; + m_listener = 0; + m_sentMpdus = 0; + m_ampdu = false; + FlushAggregateQueue (); + listener->MissedBlockAck (); +} + +void +MacLow::SuperFastAckTimeout () +{ + NS_LOG_FUNCTION (this); + m_stationManager->ReportDataFailed (m_currentHdr.GetAddr1 (), &m_currentHdr); + MacLowTransmissionListener *listener = m_listener; + m_listener = 0; + if (m_phy->IsStateIdle ()) + { + NS_LOG_DEBUG ("super fast Ack failed"); + listener->MissedAck (); + } + else + { + NS_LOG_DEBUG ("super fast Ack ok"); + listener->GotAck (0.0, WifiMode ()); + } +} + +void +MacLow::SendRtsForPacket (void) +{ + NS_LOG_FUNCTION (this); + /* send an RTS for this packet. */ + WifiMacHeader rts; + rts.SetType (WIFI_MAC_CTL_RTS); + rts.SetDsNotFrom (); + rts.SetDsNotTo (); + rts.SetNoRetry (); + rts.SetNoMoreFragments (); + rts.SetAddr1 (m_currentHdr.GetAddr1 ()); + rts.SetAddr2 (m_self); + WifiTxVector rtsTxVector = GetRtsTxVector (m_currentPacket, &m_currentHdr); + Time duration = Seconds (0); + + WifiPreamble preamble; + //standard says RTS packets can have GF format sec 9.6.0e.1 page 110 bullet b 2 + if (m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ())) + { + preamble = WIFI_PREAMBLE_HT_GF; + } + else //Otherwise, RTS should always use non-HT PPDU (HT PPDU cases not supported yet) + { + preamble = WIFI_PREAMBLE_LONG; + } + + if (m_txParams.HasDurationId ()) + { + duration += m_txParams.GetDurationId (); + } + else + { + WifiTxVector dataTxVector = GetDataTxVector (m_currentPacket, &m_currentHdr); + duration += GetSifs (); + duration += GetCtsDuration (m_currentHdr.GetAddr1 (), rtsTxVector); + duration += GetSifs (); + duration += m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr), + dataTxVector, preamble, m_phy->GetFrequency (), 0, 0); + duration += GetSifs (); + if (m_txParams.MustWaitBasicBlockAck ()) + { + WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode ()); + duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, BASIC_BLOCK_ACK); + } + else if (m_txParams.MustWaitCompressedBlockAck ()) + { + WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode ()); + duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK); + } + else if (m_txParams.MustWaitAck ()) + { + duration += GetAckDuration (m_currentHdr.GetAddr1 (), dataTxVector); + } + if (m_txParams.HasNextPacket ()) + { + duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (), + dataTxVector, preamble, m_phy->GetFrequency (), 0, 0); + if (m_txParams.MustWaitAck ()) + { + duration += GetSifs (); + duration += GetAckDuration (m_currentHdr.GetAddr1 (), dataTxVector); + } + } + } + rts.SetDuration (duration); + + Time txDuration = m_phy->CalculateTxDuration (GetRtsSize (), rtsTxVector, preamble, m_phy->GetFrequency (), 0, 0); + Time timerDelay = txDuration + GetCtsTimeout (); + + NS_ASSERT (m_ctsTimeoutEvent.IsExpired ()); + NotifyCtsTimeoutStartNow (timerDelay); + m_ctsTimeoutEvent = Simulator::Schedule (timerDelay, &MacLow::CtsTimeout, this); + + Ptr<Packet> packet = Create<Packet> (); + packet->AddHeader (rts); + WifiMacTrailer fcs; + packet->AddTrailer (fcs); + + ForwardDown (packet, &rts, rtsTxVector,preamble); +} + +void +MacLow::StartDataTxTimers (WifiTxVector dataTxVector) +{ + WifiPreamble preamble; + + if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT) + { + preamble = WIFI_PREAMBLE_VHT; + } + //Since it is data then it can have format = GF + else if (m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ())) + { + preamble = WIFI_PREAMBLE_HT_GF; + } + else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT) + { + preamble = WIFI_PREAMBLE_HT_MF; + } + else + { + preamble = WIFI_PREAMBLE_LONG; + } + + Time txDuration = m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr), dataTxVector, preamble, m_phy->GetFrequency (), 0, 0); + if (m_txParams.MustWaitNormalAck ()) + { + Time timerDelay = txDuration + GetAckTimeout (); + NS_ASSERT (m_normalAckTimeoutEvent.IsExpired ()); + NotifyAckTimeoutStartNow (timerDelay); + m_normalAckTimeoutEvent = Simulator::Schedule (timerDelay, &MacLow::NormalAckTimeout, this); + } + else if (m_txParams.MustWaitFastAck ()) + { + Time timerDelay = txDuration + GetPifs (); + NS_ASSERT (m_fastAckTimeoutEvent.IsExpired ()); + NotifyAckTimeoutStartNow (timerDelay); + m_fastAckTimeoutEvent = Simulator::Schedule (timerDelay, &MacLow::FastAckTimeout, this); + } + else if (m_txParams.MustWaitSuperFastAck ()) + { + Time timerDelay = txDuration + GetPifs (); + NS_ASSERT (m_superFastAckTimeoutEvent.IsExpired ()); + NotifyAckTimeoutStartNow (timerDelay); + m_superFastAckTimeoutEvent = Simulator::Schedule (timerDelay, + &MacLow::SuperFastAckTimeout, this); + } + else if (m_txParams.MustWaitBasicBlockAck ()) + { + Time timerDelay = txDuration + GetBasicBlockAckTimeout (); + NS_ASSERT (m_blockAckTimeoutEvent.IsExpired ()); + NotifyAckTimeoutStartNow (timerDelay); + m_blockAckTimeoutEvent = Simulator::Schedule (timerDelay, &MacLow::BlockAckTimeout, this); + } + else if (m_txParams.MustWaitCompressedBlockAck ()) + { + Time timerDelay = txDuration + GetCompressedBlockAckTimeout (); + NS_ASSERT (m_blockAckTimeoutEvent.IsExpired ()); + NotifyAckTimeoutStartNow (timerDelay); + m_blockAckTimeoutEvent = Simulator::Schedule (timerDelay, &MacLow::BlockAckTimeout, this); + } + else if (m_txParams.HasNextPacket ()) + { + if (m_stationManager->HasHtSupported ()) + { + Time delay = txDuration + GetRifs (); + NS_ASSERT (m_waitRifsEvent.IsExpired ()); + m_waitRifsEvent = Simulator::Schedule (delay, &MacLow::WaitSifsAfterEndTx, this); + } + else + { + Time delay = txDuration + GetSifs (); + NS_ASSERT (m_waitSifsEvent.IsExpired ()); + m_waitSifsEvent = Simulator::Schedule (delay, &MacLow::WaitSifsAfterEndTx, this); + } + } + else + { + // since we do not expect any timer to be triggered. + Simulator::Schedule (txDuration, &MacLow::EndTxNoAck, this); + } +} + +void +MacLow::SendDataPacket (void) +{ + NS_LOG_FUNCTION (this); + /* send this packet directly. No RTS is needed. */ + WifiTxVector dataTxVector = GetDataTxVector (m_currentPacket, &m_currentHdr); + WifiPreamble preamble; + if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT) + { + preamble = WIFI_PREAMBLE_VHT; + } + else if (m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ())) + { + //In the future has to make sure that receiver has greenfield enabled + preamble = WIFI_PREAMBLE_HT_GF; + } + else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT) + { + preamble = WIFI_PREAMBLE_HT_MF; + } + else + { + preamble = WIFI_PREAMBLE_LONG; + } + + StartDataTxTimers (dataTxVector); + + Time duration = Seconds (0.0); + if (m_txParams.HasDurationId ()) + { + duration += m_txParams.GetDurationId (); + NS_LOG_DEBUG("duration add durationId="<<m_txParams.GetDurationId ()); + + } + else + { + if (m_txParams.MustWaitBasicBlockAck ()) + { + duration += GetSifs (); + WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode ()); + NS_LOG_DEBUG("expected BA tx vector="<<blockAckReqTxVector.GetMode()); + duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, BASIC_BLOCK_ACK); + NS_LOG_DEBUG("add basic BA duration="<<GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, BASIC_BLOCK_ACK)); + } + else if (m_txParams.MustWaitCompressedBlockAck ()) + { + duration += GetSifs (); + WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode ()); + NS_LOG_DEBUG("expected BA tx vector="<<blockAckReqTxVector.GetMode()); + duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK); + NS_LOG_DEBUG("add compressed BA duration="<<GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK)); + + } + else if (m_txParams.MustWaitAck ()) + { + duration += GetSifs (); + duration += GetAckDuration (m_currentHdr.GetAddr1 (), dataTxVector); + } + if (m_txParams.HasNextPacket ()) + { + duration += GetSifs (); + duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (), + dataTxVector, preamble, m_phy->GetFrequency (), 0, 0); + NS_LOG_DEBUG("add next packet duration="<<GetSifs ()<<" " <<m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (), + dataTxVector, preamble, m_phy->GetFrequency (), 0, 0)); + + if (m_txParams.MustWaitAck ()) + { + duration += GetSifs (); + duration += GetAckDuration (m_currentHdr.GetAddr1 (), dataTxVector); + } + NS_LOG_DEBUG("add must wait ack of next, duration="<<GetSifs ()<<" " <<GetAckDuration (m_currentHdr.GetAddr1 (), dataTxVector)); + } + } + m_currentHdr.SetDuration (duration); + NS_LOG_DEBUG("final duration="<<duration); + + if (!m_ampdu) + { + m_currentPacket->AddHeader (m_currentHdr); + WifiMacTrailer fcs; + m_currentPacket->AddTrailer (fcs); + } + + ForwardDown (m_currentPacket, &m_currentHdr, dataTxVector, preamble); + m_currentPacket = 0; +} + +bool +MacLow::IsNavZero (void) const +{ + if (m_lastNavStart + m_lastNavDuration < Simulator::Now ()) + { + return true; + } + else + { + return false; + } +} + +void +MacLow::SendCtsToSelf (void) +{ + WifiMacHeader cts; + cts.SetType (WIFI_MAC_CTL_CTS); + cts.SetDsNotFrom (); + cts.SetDsNotTo (); + cts.SetNoMoreFragments (); + cts.SetNoRetry (); + cts.SetAddr1 (m_self); + + WifiTxVector ctsTxVector = GetCtsToSelfTxVector (m_currentPacket, &m_currentHdr); + + WifiPreamble preamble; + if (ctsTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT) + { + preamble = WIFI_PREAMBLE_HT_MF; + } + else + { + preamble = WIFI_PREAMBLE_LONG; + } + + Time duration = Seconds (0); + + if (m_txParams.HasDurationId ()) + { + duration += m_txParams.GetDurationId (); + } + else + { + WifiTxVector dataTxVector = GetDataTxVector (m_currentPacket, &m_currentHdr); + duration += GetSifs (); + duration += m_phy->CalculateTxDuration (GetSize (m_currentPacket,&m_currentHdr), + dataTxVector, preamble, m_phy->GetFrequency (), 0, 0); + if (m_txParams.MustWaitBasicBlockAck ()) + { + + duration += GetSifs (); + WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode ()); + duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, BASIC_BLOCK_ACK); + } + else if (m_txParams.MustWaitCompressedBlockAck ()) + { + duration += GetSifs (); + WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode ()); + duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK); + } + else if (m_txParams.MustWaitAck ()) + { + duration += GetSifs (); + duration += GetAckDuration (m_currentHdr.GetAddr1 (), dataTxVector); + } + if (m_txParams.HasNextPacket ()) + { + duration += GetSifs (); + duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (), + dataTxVector, preamble, m_phy->GetFrequency (), 0, 0); + if (m_txParams.MustWaitCompressedBlockAck ()) + { + duration += GetSifs (); + WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode ()); + duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK); + } + else if (m_txParams.MustWaitAck ()) + { + duration += GetSifs (); + duration += GetAckDuration (m_currentHdr.GetAddr1 (), dataTxVector); + } + } + } + + cts.SetDuration (duration); + + Ptr<Packet> packet = Create<Packet> (); + packet->AddHeader (cts); + WifiMacTrailer fcs; + packet->AddTrailer (fcs); + + ForwardDown (packet, &cts, ctsTxVector,preamble); + + Time txDuration = m_phy->CalculateTxDuration (GetCtsSize (), ctsTxVector, preamble, m_phy->GetFrequency (), 0, 0); + txDuration += GetSifs (); + NS_ASSERT (m_sendDataEvent.IsExpired ()); + + m_sendDataEvent = Simulator::Schedule (txDuration, + &MacLow::SendDataAfterCts, this, + cts.GetAddr1 (), + duration); + +} + +void +MacLow::SendCtsAfterRts (Mac48Address source, Time duration, WifiTxVector rtsTxVector, double rtsSnr) +{ + NS_LOG_FUNCTION (this << source << duration << rtsTxVector.GetMode () << rtsSnr); + /* send a CTS when you receive a RTS + * right after SIFS. + */ + WifiTxVector ctsTxVector = GetCtsTxVector (source, rtsTxVector.GetMode ()); + WifiMacHeader cts; + cts.SetType (WIFI_MAC_CTL_CTS); + cts.SetDsNotFrom (); + cts.SetDsNotTo (); + cts.SetNoMoreFragments (); + cts.SetNoRetry (); + cts.SetAddr1 (source); + duration -= GetCtsDuration (source, rtsTxVector); + duration -= GetSifs (); + NS_ASSERT (duration >= MicroSeconds (0)); + cts.SetDuration (duration); + + Ptr<Packet> packet = Create<Packet> (); + packet->AddHeader (cts); + WifiMacTrailer fcs; + packet->AddTrailer (fcs); + + SnrTag tag; + tag.Set (rtsSnr); + packet->AddPacketTag (tag); + + ForwardDown (packet, &cts, ctsTxVector, WIFI_PREAMBLE_LONG); +} + +void +MacLow::SendDataAfterCts (Mac48Address source, Time duration) +{ + NS_LOG_FUNCTION (this); + /* send the third step in a + * RTS/CTS/DATA/ACK hanshake + */ + NS_ASSERT (m_currentPacket != 0); + WifiTxVector dataTxVector = GetDataTxVector (m_currentPacket, &m_currentHdr); + + if (m_aggregateQueue->GetSize () != 0) + { + for (std::vector<Item>::size_type i = 0; i != m_txPackets.size (); i++) + { + uint8_t tid = GetTid (m_txPackets.at (i).packet, m_txPackets.at (i).hdr); + AcIndex ac = QosUtilsMapTidToAc (tid); + std::map<AcIndex, MacLowAggregationCapableTransmissionListener*>::const_iterator listenerIt = m_edcaListeners.find (ac); + + listenerIt->second->CompleteMpduTx (m_txPackets.at (i).packet, m_txPackets.at (i).hdr, m_txPackets.at (i).timestamp); + } + m_txPackets.clear (); + } + + WifiPreamble preamble; + if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT) + { + preamble = WIFI_PREAMBLE_VHT; + } + else if (m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ())) + { + //In the future has to make sure that receiver has greenfield enabled + preamble = WIFI_PREAMBLE_HT_GF; + } + else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT) + { + preamble = WIFI_PREAMBLE_HT_MF; + } + else + { + preamble = WIFI_PREAMBLE_LONG; + } + + StartDataTxTimers (dataTxVector); + Time newDuration = Seconds (0); + if (m_txParams.MustWaitBasicBlockAck ()) + { + newDuration += GetSifs (); + WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode ()); + newDuration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, BASIC_BLOCK_ACK); + } + else if (m_txParams.MustWaitCompressedBlockAck ()) + { + newDuration += GetSifs (); + WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode ()); + newDuration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK); + } + else if (m_txParams.MustWaitAck ()) + { + newDuration += GetSifs (); + newDuration += GetAckDuration (m_currentHdr.GetAddr1 (), dataTxVector); + } + if (m_txParams.HasNextPacket ()) + { + newDuration += GetSifs (); + newDuration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (), dataTxVector, preamble, m_phy->GetFrequency (), 0, 0); + if (m_txParams.MustWaitCompressedBlockAck ()) + { + newDuration += GetSifs (); + WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode ()); + newDuration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK); + } + else if (m_txParams.MustWaitAck ()) + { + newDuration += GetSifs (); + newDuration += GetAckDuration (m_currentHdr.GetAddr1 (), dataTxVector); + } + } + + Time txDuration = m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr), dataTxVector, preamble, m_phy->GetFrequency (), 0, 0); + duration -= txDuration; + duration -= GetSifs (); + + duration = std::max (duration, newDuration); + NS_ASSERT (duration >= MicroSeconds (0)); + m_currentHdr.SetDuration (duration); + + if (!m_ampdu) + { + m_currentPacket->AddHeader (m_currentHdr); + WifiMacTrailer fcs; + m_currentPacket->AddTrailer (fcs); + } + + ForwardDown (m_currentPacket, &m_currentHdr, dataTxVector, preamble); + m_currentPacket = 0; +} + +void +MacLow::WaitSifsAfterEndTx (void) +{ + m_listener->StartNext (); +} + +void +MacLow::EndTxNoAck (void) +{ + MacLowTransmissionListener *listener = m_listener; + m_listener = 0; + listener->EndTxNoAck (); +} + +void +MacLow::FastAckFailedTimeout (void) +{ + NS_LOG_FUNCTION (this); + MacLowTransmissionListener *listener = m_listener; + m_listener = 0; + listener->MissedAck (); + NS_LOG_DEBUG ("fast Ack busy but missed"); +} + +void +MacLow::SendAckAfterData (Mac48Address source, Time duration, WifiMode dataTxMode, double dataSnr) +{ + NS_LOG_FUNCTION (this); + /* send an ACK when you receive + * a packet after SIFS. + */ + WifiTxVector ackTxVector = GetAckTxVector (source, dataTxMode); + WifiMacHeader ack; + ack.SetType (WIFI_MAC_CTL_ACK); + ack.SetDsNotFrom (); + ack.SetDsNotTo (); + ack.SetNoRetry (); + ack.SetNoMoreFragments (); + ack.SetAddr1 (source); + duration -= GetAckDuration (ackTxVector); + duration -= GetSifs (); + NS_ASSERT (duration >= MicroSeconds (0)); + ack.SetDuration (duration); + + Ptr<Packet> packet = Create<Packet> (); + packet->AddHeader (ack); + WifiMacTrailer fcs; + packet->AddTrailer (fcs); + + SnrTag tag; + tag.Set (dataSnr); + packet->AddPacketTag (tag); + + //ACK should always use non-HT PPDU (HT PPDU cases not supported yet) + ForwardDown (packet, &ack, ackTxVector, WIFI_PREAMBLE_LONG); +} + +bool +MacLow::IsInWindow (uint16_t seq, uint16_t winstart, uint16_t winsize) +{ + return ((seq - winstart + 4096) % 4096) < winsize; +} + +bool +MacLow::ReceiveMpdu (Ptr<Packet> packet, WifiMacHeader hdr) +{ + if (m_stationManager->HasHtSupported () || m_stationManager->HasVhtSupported ()) + { + Mac48Address originator = hdr.GetAddr2 (); + uint8_t tid = 0; + if (hdr.IsQosData ()) + { + tid = hdr.GetQosTid (); + } + uint16_t seqNumber = hdr.GetSequenceNumber (); + AgreementsI it = m_bAckAgreements.find (std::make_pair (originator, tid)); + if (it != m_bAckAgreements.end ()) + { + //Implement HT immediate Block Ack support for HT Delayed Block Ack is not added yet + if (!QosUtilsIsOldPacket ((*it).second.first.GetStartingSequence (), seqNumber)) + { + StoreMpduIfNeeded (packet, hdr); + if (!IsInWindow (hdr.GetSequenceNumber (), (*it).second.first.GetStartingSequence (), (*it).second.first.GetBufferSize ())) + { + uint16_t delta = (seqNumber - (*it).second.first.GetWinEnd () + 4096) % 4096; + if (delta > 1) + { + (*it).second.first.SetWinEnd (seqNumber); + int16_t winEnd = (*it).second.first.GetWinEnd (); + int16_t bufferSize = (*it).second.first.GetBufferSize (); + uint16_t sum = ((uint16_t)(std::abs (winEnd - bufferSize + 1))) % 4096; + (*it).second.first.SetStartingSequence (sum); + RxCompleteBufferedPacketsWithSmallerSequence ((*it).second.first.GetStartingSequenceControl (), originator, tid); + } + } + RxCompleteBufferedPacketsUntilFirstLost (originator, tid); //forwards up packets starting from winstart and set winstart to last +1 + (*it).second.first.SetWinEnd (((*it).second.first.GetStartingSequence () + (*it).second.first.GetBufferSize () - 1) % 4096); + } + return true; + } + return false; + } + else + { + return StoreMpduIfNeeded (packet, hdr); + } +} + +bool +MacLow::StoreMpduIfNeeded (Ptr<Packet> packet, WifiMacHeader hdr) +{ + AgreementsI it = m_bAckAgreements.find (std::make_pair (hdr.GetAddr2 (), hdr.GetQosTid ())); + if (it != m_bAckAgreements.end ()) + { + WifiMacTrailer fcs; + packet->RemoveTrailer (fcs); + BufferedPacket bufferedPacket (packet, hdr); + + uint16_t endSequence = ((*it).second.first.GetStartingSequence () + 2047) % 4096; + uint16_t mappedSeqControl = QosUtilsMapSeqControlToUniqueInteger (hdr.GetSequenceControl (), endSequence); + + BufferedPacketI i = (*it).second.second.begin (); + for (; i != (*it).second.second.end () + && QosUtilsMapSeqControlToUniqueInteger ((*i).second.GetSequenceControl (), endSequence) < mappedSeqControl; i++) + { + } + (*it).second.second.insert (i, bufferedPacket); + + //Update block ack cache + BlockAckCachesI j = m_bAckCaches.find (std::make_pair (hdr.GetAddr2 (), hdr.GetQosTid ())); + NS_ASSERT (j != m_bAckCaches.end ()); + (*j).second.UpdateWithMpdu (&hdr); + return true; + } + return false; +} + +void +MacLow::CreateBlockAckAgreement (const MgtAddBaResponseHeader *respHdr, Mac48Address originator, + uint16_t startingSeq) +{ + NS_LOG_FUNCTION(originator<<startingSeq); + uint8_t tid = respHdr->GetTid (); + BlockAckAgreement agreement (originator, tid); + if (respHdr->IsImmediateBlockAck ()) + { + agreement.SetImmediateBlockAck (); + } + else + { + agreement.SetDelayedBlockAck (); + } + agreement.SetAmsduSupport (respHdr->IsAmsduSupported ()); + agreement.SetBufferSize (respHdr->GetBufferSize () + 1); + agreement.SetTimeout (respHdr->GetTimeout ()); + agreement.SetStartingSequence (startingSeq); + + std::list<BufferedPacket> buffer (0); + AgreementKey key (originator, respHdr->GetTid ()); + AgreementValue value (agreement, buffer); + m_bAckAgreements.insert (std::make_pair (key, value)); + + BlockAckCache cache; + cache.Init (startingSeq, respHdr->GetBufferSize () + 1); + m_bAckCaches.insert (std::make_pair (key, cache)); + + if (respHdr->GetTimeout () != 0) + { + AgreementsI it = m_bAckAgreements.find (std::make_pair (originator, respHdr->GetTid ())); + Time timeout = MicroSeconds (1024 * agreement.GetTimeout ()); + + AcIndex ac = QosUtilsMapTidToAc (agreement.GetTid ()); + + it->second.first.m_inactivityEvent = Simulator::Schedule (timeout, + &MacLowAggregationCapableTransmissionListener::BlockAckInactivityTimeout, + m_edcaListeners[ac], + originator, tid); + } +} + +void +MacLow::DestroyBlockAckAgreement (Mac48Address originator, uint8_t tid) +{ + NS_LOG_FUNCTION(originator<<tid); + AgreementsI it = m_bAckAgreements.find (std::make_pair (originator, tid)); + if (it != m_bAckAgreements.end ()) + { + RxCompleteBufferedPacketsWithSmallerSequence (it->second.first.GetStartingSequenceControl (), originator, tid); + RxCompleteBufferedPacketsUntilFirstLost (originator, tid); + m_bAckAgreements.erase (it); + + BlockAckCachesI i = m_bAckCaches.find (std::make_pair (originator, tid)); + NS_ASSERT (i != m_bAckCaches.end ()); + m_bAckCaches.erase (i); + } +#ifdef WITH_MORE_FIX_TO_BA_IN_MAC_LOW + //added+++++++++ when agreement with the originator is destroyed + //we should reset the status of m_receivedAtLeastOneMpdu if last mpdu is received from originator + if(m_lastmpduFrom==originator && m_receivedAtLeastOneMpdu) + m_receivedAtLeastOneMpdu=false; +#endif +} + +void +MacLow::RxCompleteBufferedPacketsWithSmallerSequence (uint16_t seq, Mac48Address originator, uint8_t tid) +{ + AgreementsI it = m_bAckAgreements.find (std::make_pair (originator, tid)); + if (it != m_bAckAgreements.end ()) + { + uint16_t endSequence = ((*it).second.first.GetStartingSequence () + 2047) % 4096; + uint16_t mappedStart = QosUtilsMapSeqControlToUniqueInteger (seq, endSequence); + BufferedPacketI last = (*it).second.second.begin (); + uint16_t guard = 0; + if (last != (*it).second.second.end ()) + { + guard = (*it).second.second.begin ()->second.GetSequenceControl (); + } + BufferedPacketI i = (*it).second.second.begin (); + for (; i != (*it).second.second.end () + && QosUtilsMapSeqControlToUniqueInteger ((*i).second.GetSequenceControl (), endSequence) < mappedStart; ) + { + if (guard == (*i).second.GetSequenceControl ()) + { + if (!(*i).second.IsMoreFragments ()) + { + while (last != i) + { + m_rxCallback ((*last).first, &(*last).second); + last++; + } + m_rxCallback ((*last).first, &(*last).second); + last++; + /* go to next packet */ + while (i != (*it).second.second.end () && guard == (*i).second.GetSequenceControl ()) + { + i++; + } + if (i != (*it).second.second.end ()) + { + guard = (*i).second.GetSequenceControl (); + last = i; + } + } + else + { + guard++; + } + } + else + { + /* go to next packet */ + while (i != (*it).second.second.end () && guard == (*i).second.GetSequenceControl ()) + { + i++; + } + if (i != (*it).second.second.end ()) + { + guard = (*i).second.GetSequenceControl (); + last = i; + } + } + } + (*it).second.second.erase ((*it).second.second.begin (), i); + } +} + +void +MacLow::RxCompleteBufferedPacketsUntilFirstLost (Mac48Address originator, uint8_t tid) +{ + AgreementsI it = m_bAckAgreements.find (std::make_pair (originator, tid)); + if (it != m_bAckAgreements.end ()) + { + uint16_t guard = (*it).second.first.GetStartingSequenceControl (); + BufferedPacketI lastComplete = (*it).second.second.begin (); + BufferedPacketI i = (*it).second.second.begin (); + for (; i != (*it).second.second.end () && guard == (*i).second.GetSequenceControl (); i++) + { + if (!(*i).second.IsMoreFragments ()) + { + while (lastComplete != i) + { + m_rxCallback ((*lastComplete).first, &(*lastComplete).second); + lastComplete++; + } + m_rxCallback ((*lastComplete).first, &(*lastComplete).second); + lastComplete++; + } + guard = (*i).second.IsMoreFragments () ? (guard + 1) : ((guard + 16) & 0xfff0); + } + (*it).second.first.SetStartingSequenceControl (guard); + /* All packets already forwarded to WifiMac must be removed from buffer: + [begin (), lastComplete) */ + (*it).second.second.erase ((*it).second.second.begin (), lastComplete); + } +} +void +MacLow::SendBlockAckResponse (const CtrlBAckResponseHeader* blockAck, Mac48Address originator, bool immediate, + Time duration, WifiMode blockAckReqTxMode) +{ + Ptr<Packet> packet = Create<Packet> (); + packet->AddHeader (*blockAck); + + WifiMacHeader hdr; + hdr.SetType (WIFI_MAC_CTL_BACKRESP); + hdr.SetAddr1 (originator); + hdr.SetAddr2 (GetAddress ()); + hdr.SetDsNotFrom (); + hdr.SetDsNotTo (); + hdr.SetNoRetry (); + hdr.SetNoMoreFragments (); + + WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (originator, blockAckReqTxMode); + + NS_LOG_DEBUG("actual block ack tx vector used="<<blockAckReqTxVector.GetMode()); + m_currentPacket = packet; + m_currentHdr = hdr; + if (immediate) + { + m_txParams.DisableAck (); + NS_LOG_DEBUG("duration="<<duration); + duration -= GetSifs (); + NS_LOG_DEBUG("from duration, extract sifi="<<GetSifs ()); + if (blockAck->IsBasic ()) + { + duration -= GetBlockAckDuration (originator, blockAckReqTxVector, BASIC_BLOCK_ACK); + NS_LOG_DEBUG("from duration,extract baisc block ack duration="<<GetBlockAckDuration (originator, blockAckReqTxVector, BASIC_BLOCK_ACK)); + } + else if (blockAck->IsCompressed ()) + { + duration -= GetBlockAckDuration (originator, blockAckReqTxVector, COMPRESSED_BLOCK_ACK); + NS_LOG_DEBUG("from duration,extract compressed block ack duration="<<GetBlockAckDuration (originator, blockAckReqTxVector, BASIC_BLOCK_ACK)); + + } + else if (blockAck->IsMultiTid ()) + { + NS_FATAL_ERROR ("Multi-tid block ack is not supported."); + } + } + else + { + m_txParams.EnableAck (); + duration += GetSifs (); + duration += GetAckDuration (originator, blockAckReqTxVector); + } + m_txParams.DisableNextData (); + + if (!immediate) + { + StartDataTxTimers (blockAckReqTxVector); + } + + NS_ASSERT (duration >= MicroSeconds (0)); + hdr.SetDuration (duration); + //here should be present a control about immediate or delayed block ack + //for now we assume immediate + packet->AddHeader (hdr); + WifiMacTrailer fcs; + packet->AddTrailer (fcs); + WifiPreamble preamble; + if (blockAckReqTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT) + { + preamble = WIFI_PREAMBLE_HT_MF; + } + else + { + preamble = WIFI_PREAMBLE_LONG; + } + ForwardDown (packet, &hdr, blockAckReqTxVector, preamble); + m_currentPacket = 0; +} + +void +MacLow::SendBlockAckAfterAmpdu (uint8_t tid, Mac48Address originator, Time duration, WifiTxVector blockAckReqTxVector) +{ + NS_LOG_FUNCTION (this); + CtrlBAckResponseHeader blockAck; + uint16_t seqNumber = 0; + BlockAckCachesI i = m_bAckCaches.find (std::make_pair (originator, tid)); + NS_ASSERT (i != m_bAckCaches.end ()); + seqNumber = (*i).second.GetWinStart (); + + bool immediate = true; + AgreementsI it = m_bAckAgreements.find (std::make_pair (originator, tid)); + blockAck.SetStartingSequence (seqNumber); + blockAck.SetTidInfo (tid); + immediate = (*it).second.first.IsImmediateBlockAck (); + blockAck.SetType (COMPRESSED_BLOCK_ACK); + NS_LOG_DEBUG ("Got Implicit block Ack Req with seq " << seqNumber); + (*i).second.FillBlockAckBitmap (&blockAck); + + SendBlockAckResponse (&blockAck, originator, immediate, duration, blockAckReqTxVector.GetMode ()); +} + +void +MacLow::SendBlockAckAfterBlockAckRequest (const CtrlBAckRequestHeader reqHdr, Mac48Address originator, + Time duration, WifiMode blockAckReqTxMode) +{ + NS_LOG_FUNCTION (this); + CtrlBAckResponseHeader blockAck; + uint8_t tid = 0; + bool immediate = false; + if (!reqHdr.IsMultiTid ()) + { + tid = reqHdr.GetTidInfo (); + AgreementsI it = m_bAckAgreements.find (std::make_pair (originator, tid)); + if (it != m_bAckAgreements.end ()) + { + blockAck.SetStartingSequence (reqHdr.GetStartingSequence ()); + blockAck.SetTidInfo (tid); + immediate = (*it).second.first.IsImmediateBlockAck (); + if (reqHdr.IsBasic ()) + { + blockAck.SetType (BASIC_BLOCK_ACK); + } + else if (reqHdr.IsCompressed ()) + { + blockAck.SetType (COMPRESSED_BLOCK_ACK); + } + BlockAckCachesI i = m_bAckCaches.find (std::make_pair (originator, tid)); + NS_ASSERT (i != m_bAckCaches.end ()); + (*i).second.FillBlockAckBitmap (&blockAck); + NS_LOG_DEBUG ("Got block Ack Req with seq " << reqHdr.GetStartingSequence ()); + + if (!m_stationManager->HasHtSupported () && !m_stationManager->HasVhtSupported ()) + { + /* All packets with smaller sequence than starting sequence control must be passed up to Wifimac + * See 9.10.3 in IEEE 802.11e standard. + */ + RxCompleteBufferedPacketsWithSmallerSequence (reqHdr.GetStartingSequenceControl (), originator, tid); + RxCompleteBufferedPacketsUntilFirstLost (originator, tid); + } + else + { + if (!QosUtilsIsOldPacket ((*it).second.first.GetStartingSequence (), reqHdr.GetStartingSequence ())) + { + (*it).second.first.SetStartingSequence (reqHdr.GetStartingSequence ()); + (*it).second.first.SetWinEnd (((*it).second.first.GetStartingSequence () + (*it).second.first.GetBufferSize () - 1) % 4096); + RxCompleteBufferedPacketsWithSmallerSequence (reqHdr.GetStartingSequenceControl (), originator, tid); + RxCompleteBufferedPacketsUntilFirstLost (originator, tid); + (*it).second.first.SetWinEnd (((*it).second.first.GetStartingSequence () + (*it).second.first.GetBufferSize () - 1) % 4096); + } + } + } + else + { + NS_LOG_DEBUG ("there's not a valid block ack agreement with " << originator); + } + } + else + { + NS_FATAL_ERROR ("Multi-tid block ack is not supported."); + } + + SendBlockAckResponse (&blockAck, originator, immediate, duration, blockAckReqTxMode); +} + +void +MacLow::ResetBlockAckInactivityTimerIfNeeded (BlockAckAgreement &agreement) +{ + if (agreement.GetTimeout () != 0) + { + NS_ASSERT (agreement.m_inactivityEvent.IsRunning ()); + agreement.m_inactivityEvent.Cancel (); + Time timeout = MicroSeconds (1024 * agreement.GetTimeout ()); + AcIndex ac = QosUtilsMapTidToAc (agreement.GetTid ()); + agreement.m_inactivityEvent = Simulator::Schedule (timeout, + &MacLowAggregationCapableTransmissionListener::BlockAckInactivityTimeout, + m_edcaListeners[ac], + agreement.GetPeer (), + agreement.GetTid ()); + } +} + +void +MacLow::RegisterBlockAckListenerForAc (enum AcIndex ac, MacLowAggregationCapableTransmissionListener *listener) +{ + m_edcaListeners.insert (std::make_pair (ac, listener)); +} + +void +MacLow::SetMpduAggregator (Ptr<MpduAggregator> aggregator) +{ + m_mpduAggregator = aggregator; +} + +Ptr<MpduAggregator> +MacLow::GetMpduAggregator (void) +{ + return m_mpduAggregator; +} + +void +MacLow::DeaggregateAmpduAndReceive (Ptr<Packet> aggregatedPacket, double rxSnr, WifiTxVector txVector, WifiPreamble preamble) +{ +#ifndef WITH_MORE_FIX_TO_BA_IN_MAC_LOW + m_currentTxVector = txVector; +#endif + NS_LOG_FUNCTION (this); + AmpduTag ampdu; + bool normalAck = false; + bool ampduSubframe = false; //flag indicating the packet belongs to an A-MPDU and is not a VHT single MPDU + if (aggregatedPacket->RemovePacketTag (ampdu)) + { + ampduSubframe = true; +#ifdef WITH_MORE_FIX_TO_BA_IN_MAC_LOW + m_currentTxVector = txVector; +#endif + MpduAggregator::DeaggregatedMpdus packets = MpduAggregator::Deaggregate (aggregatedPacket); + MpduAggregator::DeaggregatedMpdusCI n = packets.begin (); + + WifiMacHeader firsthdr; + (*n).first->PeekHeader (firsthdr); + NS_LOG_DEBUG ("duration/id=" << firsthdr.GetDuration ()); + NotifyNav ((*n).first, firsthdr, preamble); + + bool vhtSingleMpdu = (*n).second.GetEof (); + if (vhtSingleMpdu == true) + { + //If the MPDU is sent as a VHT single MPDU (EOF=1 in A-MPDU subframe header), then the responder sends an ACK. + NS_LOG_DEBUG ("Receive VHT single MPDU"); + ampduSubframe = false; + } + + if (firsthdr.GetAddr1 () == m_self) + { +#ifdef WITH_MORE_FIX_TO_BA_IN_MAC_LOW + if (!vhtSingleMpdu) + { + m_receivedAtLeastOneMpdu = true; + m_lastmpduFrom=firsthdr.GetAddr2(); + } +#else + m_receivedAtLeastOneMpdu = true; +#endif + if (firsthdr.IsAck () || firsthdr.IsBlockAck () || firsthdr.IsBlockAckReq ()) + { + ReceiveOk ((*n).first, rxSnr, txVector, preamble, ampduSubframe); + } + else if (firsthdr.IsData () || firsthdr.IsQosData ()) + { + NS_LOG_DEBUG ("Deaggregate packet from " << firsthdr.GetAddr2 () << " with sequence=" << firsthdr.GetSequenceNumber ()); + ReceiveOk ((*n).first, rxSnr, txVector, preamble, ampduSubframe); + if (firsthdr.IsQosAck ()) + { + NS_LOG_DEBUG ("Normal Ack"); + normalAck = true; + } + } + else + { + NS_FATAL_ERROR ("Received A-MPDU with invalid first MPDU type"); + } + } +#ifdef WITH_MORE_FIX_TO_BA_IN_MAC_LOW + if (ampdu.GetNoOfMpdus () == 1 && !vhtSingleMpdu) +#else + if (normalAck && (ampdu.GetNoOfMpdus () == 1) && !vhtSingleMpdu) +#endif + { +#ifdef WITH_MORE_FIX_TO_BA_IN_MAC_LOW + if (normalAck) + { +#endif + //send block Ack + if (firsthdr.IsBlockAckReq ()) + { + NS_FATAL_ERROR ("Sending a BlockAckReq with QosPolicy equal to Normal Ack"); + } + uint8_t tid = firsthdr.GetQosTid (); + AgreementsI it = m_bAckAgreements.find (std::make_pair (firsthdr.GetAddr2 (), tid)); + if (it != m_bAckAgreements.end ()) + { + NS_ASSERT (m_sendAckEvent.IsExpired ()); + /* See section 11.5.3 in IEEE 802.11 for mean of this timer */ + ResetBlockAckInactivityTimerIfNeeded (it->second.first); + NS_LOG_DEBUG ("rx A-MPDU/sendImmediateBlockAck from=" << firsthdr.GetAddr2 ()); + m_sendAckEvent = Simulator::Schedule (GetSifs (), + &MacLow::SendBlockAckAfterAmpdu, this, + firsthdr.GetQosTid (), + firsthdr.GetAddr2 (), + firsthdr.GetDuration (), + txVector); + } + else + { + NS_LOG_DEBUG ("There's not a valid agreement for this block ack request."); + } +#ifdef WITH_MORE_FIX_TO_BA_IN_MAC_LOW + } +#endif + m_receivedAtLeastOneMpdu = false; + } + } + else + { + ReceiveOk (aggregatedPacket, rxSnr, txVector, preamble, ampduSubframe); + } +} + +bool +MacLow::StopMpduAggregation (Ptr<const Packet> peekedPacket, WifiMacHeader peekedHdr, Ptr<Packet> aggregatedPacket, uint16_t size) const +{ + WifiPreamble preamble; + WifiTxVector dataTxVector = GetDataTxVector (m_currentPacket, &m_currentHdr); + if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT) + { + preamble = WIFI_PREAMBLE_VHT; + } + else if (m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ())) + { + preamble = WIFI_PREAMBLE_HT_GF; + } + else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT) + { + preamble = WIFI_PREAMBLE_HT_MF; + } + else + { + preamble = WIFI_PREAMBLE_LONG; + } + + if (peekedPacket == 0) + { + NS_LOG_DEBUG ("no more packets in queue"); + return true; + } + + NS_LOG_DEBUG("in stopMpduAgg check, peeked size="<<peekedPacket->GetSize()<<", aggregated size="<<aggregatedPacket->GetSize()); + + + //An HT STA shall not transmit a PPDU that has a duration that is greater than aPPDUMaxTime (10 milliseconds) + if (m_phy->CalculateTxDuration (aggregatedPacket->GetSize () + peekedPacket->GetSize () + peekedHdr.GetSize () + WIFI_MAC_FCS_LENGTH, dataTxVector, preamble, m_phy->GetFrequency (), 0, 0) > MilliSeconds (10)) + { + NS_LOG_DEBUG ("no more packets can be aggregated to satisfy PPDU <= aPPDUMaxTime"); + return true; + } + + if (!m_mpduAggregator->CanBeAggregated (peekedPacket->GetSize () + peekedHdr.GetSize () + WIFI_MAC_FCS_LENGTH, aggregatedPacket, size)) + { + NS_LOG_DEBUG ("no more packets can be aggregated because the maximum A-MPDU size has been reached"); + return true; + } + + return false; +} + +Ptr<Packet> +MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr) +{ + NS_LOG_DEBUG("come into Aggregate to Ampdu procedure in mac low"); + NS_ASSERT (m_aggregateQueue->GetSize () == 0); + bool isAmpdu = false; + Ptr<Packet> newPacket, tempPacket; + WifiMacHeader peekedHdr; + newPacket = packet->Copy (); + Ptr<Packet> currentAggregatedPacket; + //missing hdr.IsAck() since we have no means of knowing the Tid of the Ack yet + if (hdr.IsQosData () || hdr.IsBlockAck ()|| hdr.IsBlockAckReq ()) + { + Time tstamp; + uint8_t tid = GetTid (packet, hdr); + Ptr<WifiMacQueue> queue; + AcIndex ac = QosUtilsMapTidToAc (tid); + //since a blockack agreement always preceeds mpdu aggregation there should always exist blockAck listener + std::map<AcIndex, MacLowAggregationCapableTransmissionListener*>::const_iterator listenerIt = m_edcaListeners.find (ac); + NS_ASSERT (listenerIt != m_edcaListeners.end ()); + queue = listenerIt->second->GetQueue (); + + if (!hdr.GetAddr1 ().IsBroadcast () && m_mpduAggregator != 0) + { + //Have to make sure that their exist a block Ack agreement before sending an AMPDU (BlockAck Manager) + if (listenerIt->second->GetBlockAckAgreementExists (hdr.GetAddr1 (), tid)) + { + /* here is performed mpdu aggregation */ + /* MSDU aggregation happened in edca if the user asked for it so m_currentPacket may contains a normal packet or a A-MSDU*/ + currentAggregatedPacket = Create<Packet> (); + peekedHdr = hdr; + uint16_t startingSequenceNumber = 0; + uint16_t currentSequenceNumber = 0; + uint8_t qosPolicy = 0; + uint16_t blockAckSize = 0; + bool aggregated = false; + int i = 0; + Ptr<Packet> aggPacket = newPacket->Copy (); + + if (!hdr.IsBlockAckReq ()) + { + if (!hdr.IsBlockAck ()) + { + startingSequenceNumber = peekedHdr.GetSequenceNumber (); + peekedHdr.SetQosAckPolicy (WifiMacHeader::NORMAL_ACK); + } + currentSequenceNumber = peekedHdr.GetSequenceNumber (); + newPacket->AddHeader (peekedHdr); + WifiMacTrailer fcs; + newPacket->AddTrailer (fcs); + + aggregated = m_mpduAggregator->Aggregate (newPacket, currentAggregatedPacket); + + NS_LOG_DEBUG("QUEUE SIZE="<<queue->GetSize()); + if (aggregated) + { + NS_LOG_DEBUG ("first, Adding packet with Sequence number " << peekedHdr.GetSequenceNumber () << " to A-MPDU, packet size = " << newPacket->GetSize () << ", A-MPDU size = " << currentAggregatedPacket->GetSize ()); + i++; + m_sentMpdus++; + m_aggregateQueue->Enqueue (aggPacket, peekedHdr); + } + } + else if (hdr.IsBlockAckReq ()) + { + blockAckSize = packet->GetSize () + hdr.GetSize () + WIFI_MAC_FCS_LENGTH; + qosPolicy = 3; //if the last subrame is block ack req then set ack policy of all frames to blockack + CtrlBAckRequestHeader blockAckReq; + packet->PeekHeader (blockAckReq); + startingSequenceNumber = blockAckReq.GetStartingSequence (); + } + aggregated = false; + bool retry = false; + //looks for other packets to the same destination with the same Tid need to extend that to include MSDUs + Ptr<const Packet> peekedPacket = listenerIt->second->PeekNextPacketInBaQueue (peekedHdr, peekedHdr.GetAddr1 (), tid, &tstamp); + if (peekedPacket == 0) + { + peekedPacket = queue->PeekByTidAndAddress (&peekedHdr, tid, + WifiMacHeader::ADDR1, + hdr.GetAddr1 (), &tstamp); + currentSequenceNumber = listenerIt->second->PeekNextSequenceNumberfor (&peekedHdr); + + /* here is performed MSDU aggregation (two-level aggregation) */ + if (peekedPacket != 0 && listenerIt->second->GetMsduAggregator () != 0) + { + tempPacket = PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, blockAckSize); + if (tempPacket != 0) //MSDU aggregation + { + peekedPacket = tempPacket->Copy (); + } + } + } + else + { + retry = true; + currentSequenceNumber = peekedHdr.GetSequenceNumber (); + } + + NS_LOG_DEBUG("before coming into loop, queue size="<<queue->GetSize()); + while (IsInWindow (currentSequenceNumber, startingSequenceNumber, 64) && !StopMpduAggregation (peekedPacket, peekedHdr, currentAggregatedPacket, blockAckSize)) + { + NS_LOG_DEBUG("come into loop"); + //for now always send AMPDU with normal ACK + if (retry == false) + { + currentSequenceNumber = listenerIt->second->GetNextSequenceNumberfor (&peekedHdr); + peekedHdr.SetSequenceNumber (currentSequenceNumber); + peekedHdr.SetFragmentNumber (0); + peekedHdr.SetNoMoreFragments (); + peekedHdr.SetNoRetry (); + } + if (qosPolicy == 0) + { + NS_LOG_DEBUG("QOS policy=0, set normal ack"); + peekedHdr.SetQosAckPolicy (WifiMacHeader::NORMAL_ACK); + } + else + { + peekedHdr.SetQosAckPolicy (WifiMacHeader::BLOCK_ACK); + } + + newPacket = peekedPacket->Copy (); + Ptr<Packet> aggPacket = newPacket->Copy (); + + newPacket->AddHeader (peekedHdr); + WifiMacTrailer fcs; + newPacket->AddTrailer (fcs); + aggregated = m_mpduAggregator->Aggregate (newPacket, currentAggregatedPacket); + if (aggregated) + { + m_aggregateQueue->Enqueue (aggPacket, peekedHdr); + if (i == 1 && hdr.IsQosData ()) + { + if (!m_txParams.MustSendRts ()) + { + listenerIt->second->CompleteMpduTx (packet, hdr, tstamp); + } + else + { + InsertInTxQueue (packet, hdr, tstamp); + } + } + NS_LOG_DEBUG ("second, Adding packet with Sequence number " << peekedHdr.GetSequenceNumber () << " to A-MPDU, packet size = " << newPacket->GetSize () << ", A-MPDU size = " << currentAggregatedPacket->GetSize ()); + i++; + isAmpdu = true; + m_sentMpdus++; + if (!m_txParams.MustSendRts ()) + { + listenerIt->second->CompleteMpduTx (peekedPacket, peekedHdr, tstamp); + } + else + { + InsertInTxQueue (peekedPacket, peekedHdr, tstamp); + } + if (retry) + { + listenerIt->second->RemoveFromBaQueue (tid, hdr.GetAddr1 (), peekedHdr.GetSequenceNumber ()); + } + else + { + queue->Remove (peekedPacket); + } + newPacket = 0; + } + else + { + break; + } + if (retry == true) + { + peekedPacket = listenerIt->second->PeekNextPacketInBaQueue (peekedHdr, hdr.GetAddr1 (), tid, &tstamp); + if (peekedPacket == 0) + { + //I reached the first packet that I added to this A-MPDU + retry = false; + peekedPacket = queue->PeekByTidAndAddress (&peekedHdr, tid, + WifiMacHeader::ADDR1, hdr.GetAddr1 (), &tstamp); + if (peekedPacket != 0) + { + //find what will the sequence number be so that we don't send more than 64 packets apart + currentSequenceNumber = listenerIt->second->PeekNextSequenceNumberfor (&peekedHdr); + + if (listenerIt->second->GetMsduAggregator () != 0) + { + tempPacket = PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, blockAckSize); + if (tempPacket != 0) //MSDU aggregation + { + peekedPacket = tempPacket->Copy (); + } + } + } + } + else + { + currentSequenceNumber = peekedHdr.GetSequenceNumber (); + } + } + else + { + peekedPacket = queue->PeekByTidAndAddress (&peekedHdr, tid, + WifiMacHeader::ADDR1, hdr.GetAddr1 (), &tstamp); + if (peekedPacket != 0) + { + //find what will the sequence number be so that we don't send more than 64 packets apart + currentSequenceNumber = listenerIt->second->PeekNextSequenceNumberfor (&peekedHdr); + + if (listenerIt->second->GetMsduAggregator () != 0 && IsInWindow (currentSequenceNumber, startingSequenceNumber, 64)) + { + tempPacket = PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, blockAckSize); + if (tempPacket != 0) //MSDU aggregation + { + peekedPacket = tempPacket->Copy (); + } + } + } + } + } + + if (isAmpdu) + { + if (hdr.IsBlockAckReq ()) + { + newPacket = packet->Copy (); + peekedHdr = hdr; + Ptr<Packet> aggPacket = newPacket->Copy (); + m_aggregateQueue->Enqueue (aggPacket, peekedHdr); + newPacket->AddHeader (peekedHdr); + WifiMacTrailer fcs; + newPacket->AddTrailer (fcs); + m_mpduAggregator->Aggregate (newPacket, currentAggregatedPacket); + } + if (qosPolicy == 0) + { + listenerIt->second->CompleteTransfer (hdr.GetAddr1 (), tid); + } + //Add packet tag + AmpduTag ampdutag; + ampdutag.SetAmpdu (true); + ampdutag.SetNoOfMpdus (i); + newPacket = currentAggregatedPacket; + newPacket->AddPacketTag (ampdutag); + NS_LOG_DEBUG ("tx unicast A-MPDU"); + listenerIt->second->SetAmpdu (true); + } + else + { + uint32_t queueSize = m_aggregateQueue->GetSize (); + NS_ASSERT (queueSize <= 2); //since it is not an A-MPDU then only 2 packets should have been added to the queue no more + if (queueSize >= 1) + { + //remove any packets that we added to the aggregate queue + FlushAggregateQueue (); + } + } + } + //VHT single MPDU operation + WifiTxVector dataTxVector = GetDataTxVector (m_currentPacket, &m_currentHdr); + if (!isAmpdu && dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT && hdr.IsQosData ()) + { + peekedHdr = hdr; + peekedHdr.SetQosAckPolicy (WifiMacHeader::NORMAL_ACK); + + currentAggregatedPacket = Create<Packet> (); + m_mpduAggregator->AggregateVhtSingleMpdu (packet, currentAggregatedPacket); + m_aggregateQueue->Enqueue (packet, peekedHdr); + m_sentMpdus = 1; + + if (listenerIt->second->GetBlockAckAgreementExists (hdr.GetAddr1 (), tid)) + { + listenerIt->second->CompleteTransfer (peekedHdr.GetAddr1 (), tid); + } + + //Add packet tag + AmpduTag ampdutag; + ampdutag.SetAmpdu (true); + ampdutag.SetNoOfMpdus (1); + + newPacket = currentAggregatedPacket; + newPacket->AddHeader (peekedHdr); + WifiMacTrailer fcs; + newPacket->AddTrailer (fcs); + newPacket->AddPacketTag (ampdutag); + + NS_LOG_DEBUG ("tx unicast VHT single MPDU with sequence number " << hdr.GetSequenceNumber ()); + listenerIt->second->SetAmpdu (true); + } + } + NS_LOG_DEBUG ("after AMPDU aggregation complete, number of packets let in the qos queue is "<<queue->GetSize()); + + } + return newPacket; +} + +void +MacLow::FlushAggregateQueue (void) +{ + if (m_aggregateQueue->GetSize () > 0) + { + NS_LOG_DEBUG ("Flush aggregate queue"); + m_aggregateQueue->Flush (); + } + m_txPackets.clear (); +} + +void +MacLow::FlushAggregateQueue (Mac48Address destAddress) +{ + WifiMacHeader hdr; + m_aggregateQueue->Peek(&hdr); + if(hdr.GetAddr1()==destAddress) + this->FlushAggregateQueue(); +} + +void +MacLow::InsertInTxQueue (Ptr<const Packet> packet, const WifiMacHeader &hdr, Time tStamp) +{ + Item item; + + item.packet = packet; + item.hdr = hdr; + item.timestamp = tStamp; + + m_txPackets.push_back (item); +} + +Ptr<Packet> +MacLow::PerformMsduAggregation (Ptr<const Packet> packet, WifiMacHeader *hdr, Time *tstamp, Ptr<Packet> currentAmpduPacket, uint16_t blockAckSize) +{ + NS_LOG_DEBUG("come into perform Msdu aggregation"); + bool msduAggregation = false; + bool isAmsdu = false; + Ptr<Packet> currentAmsduPacket = Create<Packet> (); + Ptr<Packet> tempPacket = Create<Packet> (); + + Ptr<WifiMacQueue> queue; + AcIndex ac = QosUtilsMapTidToAc (GetTid (packet, *hdr)); + std::map<AcIndex, MacLowAggregationCapableTransmissionListener*>::const_iterator listenerIt = m_edcaListeners.find (ac); + NS_ASSERT (listenerIt != m_edcaListeners.end ()); + queue = listenerIt->second->GetQueue (); + + NS_LOG_DEBUG("with queue size="<<queue->GetSize()); + + Ptr<const Packet> peekedPacket = queue->DequeueByTidAndAddress (hdr, hdr->GetQosTid (), + WifiMacHeader::ADDR1, hdr->GetAddr1 ()); + + listenerIt->second->GetMsduAggregator ()->Aggregate (packet, currentAmsduPacket, + listenerIt->second->GetSrcAddressForAggregation (*hdr), + listenerIt->second->GetDestAddressForAggregation (*hdr)); + + peekedPacket = queue->PeekByTidAndAddress (hdr, hdr->GetQosTid (), + WifiMacHeader::ADDR1, hdr->GetAddr1 (), tstamp); + NS_LOG_DEBUG("before coming into loop of PerformMsduAggregation, left packets in the queue="<<queue->GetSize()); + while (peekedPacket != 0) + { + NS_LOG_DEBUG("come into loop of PerformMsduAggregation"); + + tempPacket = currentAmsduPacket; + + msduAggregation = listenerIt->second->GetMsduAggregator ()->Aggregate (peekedPacket, tempPacket, + listenerIt->second->GetSrcAddressForAggregation (*hdr), + listenerIt->second->GetDestAddressForAggregation (*hdr)); + + if(currentAmsduPacket==tempPacket) + NS_LOG_DEBUG("after aggregate, it is the same"); + else + NS_LOG_DEBUG("after aggregate, it is different\n"); + if (msduAggregation && !StopMpduAggregation (tempPacket, *hdr, currentAmpduPacket, blockAckSize)) + { + isAmsdu = true; + currentAmsduPacket = tempPacket; + queue->Remove (peekedPacket); + NS_LOG_DEBUG("MSDU aggregate, left packets in the queue="<<queue->GetSize()); + } + else + { + NS_LOG_DEBUG("stopped aggregation."); + if(currentAmsduPacket==tempPacket) + NS_LOG_DEBUG("it is the same"); + else + NS_LOG_DEBUG("it is different\n"); + break; + } + if(currentAmsduPacket==tempPacket) + NS_LOG_DEBUG("no advance"); + else + NS_LOG_DEBUG("temp is in advance"); + peekedPacket = queue->PeekByTidAndAddress (hdr, hdr->GetQosTid (), WifiMacHeader::ADDR1, hdr->GetAddr1 (), tstamp); + } + + if (isAmsdu) + { + NS_LOG_DEBUG ("A-MSDU with size = " << currentAmsduPacket->GetSize ()); + hdr->SetQosAmsdu (); + hdr->SetAddr3 (GetBssid ()); + return currentAmsduPacket; + } + else + { + NS_LOG_DEBUG("no AMSDU, left packets in the queue="<<queue->GetSize()); + NS_LOG_DEBUG("push front and return 0"); + queue->PushFront (packet, *hdr); + return 0; + } +} + +} //namespace ns3 |