ns-3.24: comparison src/wifi/model/mac-low.cc

equal deleted inserted replaced

-:99300a162f1c
+:9f4ae69f12b7
 {
 }
 void MacLowAggregationCapableTransmissionListener::SetAmpdu (bool ampdu)
 {
 }
-void MacLowAggregationCapableTransmissionListener::CompleteTransfer(Mac48Address address, uint8_t tid)
+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>
 }
 std::ostream &operator << (std::ostream &os, const MacLowTransmissionParameters &params)
 {
 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;
 {
 static TypeId tid = TypeId ("ns3::MacLow")
 .SetParent<Object> ()
 .SetGroupName ("Wifi")
 .AddConstructor<MacLow> ()
 ;
 return tid;
 }
 void
 MacLow::SetupPhyMacLowListener (Ptr<WifiPhy> phy)
 m_sendCtsEvent.Cancel ();
 m_sendAckEvent.Cancel ();
 m_sendDataEvent.Cancel ();
 m_waitSifsEvent.Cancel ();
 m_endTxNoAckEvent.Cancel ();
-m_waitRifsEvent.Cancel();
+m_waitRifsEvent.Cancel ();
 m_phy = 0;
 m_stationManager = 0;
 if (m_phyMacLowListener != 0)
 {
-	  delete m_phyMacLowListener;
+delete m_phyMacLowListener;
-	  m_phyMacLowListener = 0;
+m_phyMacLowListener = 0;
 }
 m_mpduAggregator = 0;
 m_sentMpdus = 0;
 m_aggregateQueue = 0;
 m_ampdu = false;
 if (m_waitRifsEvent.IsRunning ())
 {
 m_waitRifsEvent.Cancel ();
 oneRunning = true;
 }
 if (m_endTxNoAckEvent.IsRunning ())
 {
 m_endTxNoAckEvent.Cancel ();
 oneRunning = true;
 }
 if (oneRunning && m_listener != 0)
 {
 uint32_t size, actualSize;
 WifiMacTrailer fcs;
 size = packet->GetSize () + hdr.GetSize () + fcs.GetSerializedSize ();
 Ptr<Packet> p = AggregateToAmpdu (packet, hdr);
-actualSize = p->GetSize();
+actualSize = p->GetSize ();
 if (actualSize > size)
 {
 m_currentPacket = p;
 return true;
 }
 else
+{
 return false;
+}
 }
 void
 MacLow::StartTransmission (Ptr<const Packet> packet,
 const WifiMacHeader* hdr,
 m_currentHdr = *hdr;
 CancelAllEvents ();
 m_listener = listener;
 m_txParams = params;
-if(m_aggregateQueue->GetSize () == 0)
+if (m_aggregateQueue->GetSize () == 0)
 {
 m_currentPacket = packet->Copy ();
 m_ampdu = IsAmpdu (m_currentPacket, m_currentHdr);
 }
 else
 {
 /*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;
 }
 NS_LOG_DEBUG ("startTx size=" << GetSize (m_currentPacket, &m_currentHdr) <<
 ", to=" << m_currentHdr.GetAddr1 () << ", listener=" << m_listener);
 if (m_ampdu)
+{
 m_txParams.EnableCompressedBlockAck ();
+}
 if (m_txParams.MustSendRts ())
 {
 SendRtsForPacket ();
 }
 else
 {
-if (NeedCtsToSelf() && m_ctsToSelfSupported)
+if (NeedCtsToSelf () && m_ctsToSelfSupported)
 {
-SendCtsToSelf();
+SendCtsToSelf ();
 }
 else
 {
 SendDataPacket ();
 }
 }
 /* When this method completes, we have taken ownership of the medium. */
 NS_ASSERT (m_phy->IsStateTx ());
 }
 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();
+Ptr<Packet> pkt = packet->Copy ();
-bool isInAmpdu = pkt->RemovePacketTag(ampdu);
+bool isInAmpdu = pkt->RemovePacketTag (ampdu);
-if(isInAmpdu && m_receivedAtLeastOneMpdu && (ampdu.GetNoOfMpdus() == 1))
+if (isInAmpdu && m_receivedAtLeastOneMpdu && (ampdu.GetNoOfMpdus () == 1))
 {
 MpduAggregator::DeaggregatedMpdus packets = MpduAggregator::Deaggregate (pkt);
 MpduAggregator::DeaggregatedMpdusCI n = packets.begin ();
 WifiMacHeader hdr;
-(*n).first->PeekHeader(hdr);
+(*n).first->PeekHeader (hdr);
-if(hdr.IsQosData())
+if (hdr.IsQosData ())
 {
 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);
 }
-else if (hdr.IsBlockAckReq())
+else if (hdr.IsBlockAckReq ())
 {
-	      NS_LOG_DEBUG("last a-mpdu subframe is BAR");
+NS_LOG_DEBUG ("last a-mpdu subframe is BAR");
-	}
+}
 m_receivedAtLeastOneMpdu = false;
 }
 else if (m_txParams.MustWaitFastAck ())
 {
 NS_ASSERT (m_fastAckFailedTimeoutEvent.IsExpired ());
 {
 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,
 m_stationManager->ReportDataOk (m_currentHdr.GetAddr1 (), &m_currentHdr,
 rxSnr, txVector.GetMode (), tag.Get ());
 FlushAggregateQueue ();
 bool gotAck = false;
 if (m_txParams.MustWaitNormalAck ()
 && m_normalAckTimeoutEvent.IsRunning ())
 {
 m_normalAckTimeoutEvent.Cancel ();
 NotifyAckTimeoutResetNow ();
 {
 /* 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. */;
+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 ()));
 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)
 {
 uint8_t
 MacLow::GetTid (Ptr<const Packet> packet, const WifiMacHeader hdr) const
 {
 uint8_t tid = 0;
 if (hdr.IsQosData ())
-tid = hdr.GetQosTid ();
+{
+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
 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);
+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;
+{
+preamble = WIFI_PREAMBLE_HT_MF;
+}
 else
-preamble = WIFI_PREAMBLE_LONG;
+{
+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
 MacLow::GetSize (Ptr<const Packet> packet, const WifiMacHeader *hdr) const
 {
 uint32_t size;
 WifiMacTrailer fcs;
 if (m_ampdu)
-size = packet->GetSize ();
+{
+size = packet->GetSize ();
+}
 else
-size= packet->GetSize () + hdr->GetSize () + fcs.GetSerializedSize ();
+{
+size = packet->GetSize () + hdr->GetSize () + fcs.GetSerializedSize ();
+}
 return size;
 }
 WifiTxVector
 MacLow::GetCtsToSelfTxVector (Ptr<const Packet> packet, const WifiMacHeader *hdr) const
 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 ();
+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
 txTime += GetCtsDuration (hdr->GetAddr1 (), rtsTxVector);
 txTime += Time (GetSifs () * 2);
 }
 WifiTxVector dataTxVector = GetDataTxVector (packet, hdr);
 if (m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ()))
-preamble = WIFI_PREAMBLE_HT_GF;
+{
+preamble = WIFI_PREAMBLE_HT_GF;
+}
 else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
-preamble = WIFI_PREAMBLE_HT_MF;
+{
+preamble = WIFI_PREAMBLE_HT_MF;
+}
 else
-preamble = WIFI_PREAMBLE_LONG;
+{
+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 ();
 if (params.HasNextPacket ())
 {
 WifiTxVector dataTxVector = GetDataTxVector (packet, hdr);
 WifiPreamble preamble;
 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_GF;
-preamble = WIFI_PREAMBLE_HT_MF;
+}
+else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
+{
+preamble = WIFI_PREAMBLE_HT_MF;
+}
 else
-preamble = WIFI_PREAMBLE_LONG;
+{
+preamble = WIFI_PREAMBLE_LONG;
+}
 txTime += GetSifs ();
 txTime += m_phy->CalculateTxDuration (params.GetNextPacketSize (), dataTxVector, preamble, m_phy->GetFrequency (), 0, 0);
 }
 return txTime;
 }
 * 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);
+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,
 uint8_t packetType = 0;
 //Add packet tag
 AmpduTag ampdutag;
 ampdutag.SetAmpdu (true);
 Time delay = Seconds (0);
-for ( ; queueSize > 0; queueSize--)
+for (; queueSize > 0; queueSize--)
 {
 dequeuedPacket = m_aggregateQueue->Dequeue (&newHdr);
 newPacket = dequeuedPacket->Copy ();
 newHdr.SetDuration (hdr->GetDuration ());
 newPacket->AddHeader (newHdr);
 last = true;
 packetType = 2;
 }
 m_mpduAggregator->AddHeaderAndPad (newPacket, last);
-ampdutag.SetNoOfMpdus(queueSize);
+ampdutag.SetNoOfMpdus (queueSize);
-newPacket->AddPacketTag(ampdutag);
+newPacket->AddPacketTag (ampdutag);
 if (delay == Seconds (0))
 {
-NS_LOG_DEBUG("Sending MPDU as part of A-MPDU");
+NS_LOG_DEBUG ("Sending MPDU as part of A-MPDU");
 packetType = 1;
 m_phy->SendPacket (newPacket, txVector, preamble, packetType);
 }
 else
 {
 Simulator::Schedule (delay, &MacLow::SendPacket, this, newPacket, txVector, preamble, packetType);
 }
-if(queueSize > 1)
+if (queueSize > 1)
-delay = delay + m_phy->CalculateTxDuration (GetSize (newPacket, &newHdr), txVector, preamble, m_phy->GetFrequency (), packetType, 0);
+{
+delay = delay + m_phy->CalculateTxDuration (GetSize (newPacket, &newHdr), txVector, preamble, m_phy->GetFrequency (), packetType, 0);
+}
 preamble = WIFI_PREAMBLE_NONE;
 }
 }
 }
 void
 MacLow::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, WifiPreamble preamble, uint8_t packetType)
 {
-NS_LOG_DEBUG("Sending MPDU as part of A-MPDU");
+NS_LOG_DEBUG ("Sending MPDU as part of A-MPDU");
 m_phy->SendPacket (packet, txVector, preamble, packetType);
 }
 void
 MacLow::CtsTimeout (void)
 {
 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)
+if (m_sentMpdus == 0)
 {
 m_currentPacket = 0;
 }
 MacLowTransmissionListener *listener = m_listener;
 m_listener = 0;
 m_stationManager->ReportDataFailed (m_currentHdr.GetAddr1 (), &m_currentHdr);
 MacLowTransmissionListener *listener = m_listener;
 m_listener = 0;
 m_sentMpdus = 0;
 m_ampdu = false;
-FlushAggregateQueue();
+FlushAggregateQueue ();
 listener->MissedBlockAck ();
 }
 void
 MacLow::SuperFastAckTimeout ()
 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;
+{
+preamble = WIFI_PREAMBLE_HT_GF;
+}
 else //Otherwise, RTS should always use non-HT PPDU (HT PPDU cases not supported yet)
-preamble = WIFI_PREAMBLE_LONG;
+{
+preamble = WIFI_PREAMBLE_LONG;
+}
 if (m_txParams.HasDurationId ())
 {
 duration += m_txParams.GetDurationId ();
 }
 void
 MacLow::StartDataTxTimers (WifiTxVector dataTxVector)
 {
 WifiPreamble preamble;
 //Since it is data then it can have format = GF
 if (m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ()))
-preamble = WIFI_PREAMBLE_HT_GF;
+{
+preamble = WIFI_PREAMBLE_HT_GF;
+}
 else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
-preamble = WIFI_PREAMBLE_HT_MF;
+{
+preamble = WIFI_PREAMBLE_HT_MF;
+}
 else
-preamble = WIFI_PREAMBLE_LONG;
+{
+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_blockAckTimeoutEvent = Simulator::Schedule (timerDelay, &MacLow::BlockAckTimeout, this);
 }
 else if (m_txParams.HasNextPacket ())
 {
-if (m_stationManager->HasHtSupported())
+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);
+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 (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;
+//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;
+{
+preamble = WIFI_PREAMBLE_HT_MF;
+}
 else
-preamble = WIFI_PREAMBLE_LONG;
+{
+preamble = WIFI_PREAMBLE_LONG;
+}
 StartDataTxTimers (dataTxVector);
 Time duration = Seconds (0.0);
 if (m_txParams.HasDurationId ())
 {
 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;
+{
+preamble = WIFI_PREAMBLE_HT_MF;
+}
 else
-preamble = WIFI_PREAMBLE_LONG;
+{
+preamble = WIFI_PREAMBLE_LONG;
+}
 Time duration = Seconds (0);
 if (m_txParams.HasDurationId ())
 {
 duration += m_txParams.GetDurationId ();
 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 ())
 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);
 }
 /* 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++)
+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);
+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);
+listenerIt->second->CompleteMpduTx (m_txPackets.at (i).packet, m_txPackets.at (i).hdr, m_txPackets.at (i).timestamp);
 }
 m_txPackets.clear ();
 }
 WifiPreamble preamble;
 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;
+//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;
+{
+preamble = WIFI_PREAMBLE_HT_MF;
+}
 else
-preamble = WIFI_PREAMBLE_LONG;
+{
+preamble = WIFI_PREAMBLE_LONG;
+}
 StartDataTxTimers (dataTxVector);
 Time newDuration = Seconds (0);
 if (m_txParams.MustWaitBasicBlockAck ())
 {
 newDuration += GetSifs ();
 {
 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 = 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;
 }
 MacLow::WaitSifsAfterEndTx (void)
 {
 m_listener->StartNext ();
 }
 void
 MacLow::EndTxNoAck (void)
 {
 MacLowTransmissionListener *listener = m_listener;
 m_listener = 0;
 listener->EndTxNoAck ();
 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 ())
 {
 Mac48Address originator = hdr.GetAddr2 ();
 uint8_t tid = 0;
 if (hdr.IsQosData ())
-tid = hdr.GetQosTid ();
+{
+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 ()))
+if (!IsInWindow (hdr.GetSequenceNumber (), (*it).second.first.GetStartingSequence (), (*it).second.first.GetBufferSize ()))
 {
-uint16_t delta = (seqNumber - (*it).second.first.GetWinEnd() + 4096) % 4096;
+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;
+uint16_t sum = ((uint16_t)(std::abs (winEnd - bufferSize + 1))) % 4096;
 (*it).second.first.SetStartingSequence (sum);
 RxCompleteBufferedPacketsWithSmallerSequence ((*it).second.first.GetStartingSequence (), 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);
+(*it).second.first.SetWinEnd (((*it).second.first.GetStartingSequence () + (*it).second.first.GetBufferSize () - 1) % 4096);
 }
 return true;
 }
 return false;
 }
 else
-return StoreMpduIfNeeded (packet, hdr);
+{
+return StoreMpduIfNeeded (packet, hdr);
+}
 }
 bool
 MacLow::StoreMpduIfNeeded (Ptr<Packet> packet, WifiMacHeader hdr)
 {
 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 ()));
 packet->AddHeader (hdr);
 WifiMacTrailer fcs;
 packet->AddTrailer (fcs);
 WifiPreamble preamble;
 if (blockAckReqTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
-preamble = WIFI_PREAMBLE_HT_MF;
+{
+preamble = WIFI_PREAMBLE_HT_MF;
+}
 else
-preamble = WIFI_PREAMBLE_LONG;
+{
+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;
 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
 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())
+if (!m_stationManager->HasHtSupported ())
 {
 /* 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.GetStartingSequence (), originator, tid);
 RxCompleteBufferedPacketsUntilFirstLost (originator, tid);
 }
 else
 {
-if (!QosUtilsIsOldPacket ((*it).second.first.GetStartingSequence(), reqHdr.GetStartingSequence ()))
+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);
+(*it).second.first.SetWinEnd (((*it).second.first.GetStartingSequence () + (*it).second.first.GetBufferSize () - 1) % 4096);
 RxCompleteBufferedPacketsWithSmallerSequence (reqHdr.GetStartingSequence (), originator, tid);
 RxCompleteBufferedPacketsUntilFirstLost (originator, tid);
-(*it).second.first.SetWinEnd (((*it).second.first.GetStartingSequence()+(*it).second.first.GetBufferSize() - 1) % 4096);
+(*it).second.first.SetWinEnd (((*it).second.first.GetStartingSequence () + (*it).second.first.GetBufferSize () - 1) % 4096);
 }
 }
 }
 else
 {
 {
 m_currentTxVector = txVector;
 AmpduTag ampdu;
 bool normalAck = false;
 bool ampduSubframe = false;
-if (aggregatedPacket->RemovePacketTag(ampdu))
+if (aggregatedPacket->RemovePacketTag (ampdu))
 {
 ampduSubframe = true;
 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);
 if (firsthdr.GetAddr1 () == m_self)
 {
 m_receivedAtLeastOneMpdu = true;
 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 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");
+}
 }
 if (normalAck && (ampdu.GetNoOfMpdus () == 1))
 {
 //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.");
 }
 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
+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 (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_GF;
-preamble = WIFI_PREAMBLE_HT_MF;
+}
-else
+else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
-preamble = WIFI_PREAMBLE_LONG;
+{
+preamble = WIFI_PREAMBLE_HT_MF;
-if (peekedPacket == 0)
+}
-return true;
+else
+{
-//An HT STA shall not transmit a PPDU that has a duration that is greater than aPPDUMaxTime (10 milliseconds)
+preamble = WIFI_PREAMBLE_LONG;
-if(m_phy->CalculateTxDuration (aggregatedPacket->GetSize () + peekedPacket->GetSize () + peekedHdr.GetSize () + WIFI_MAC_FCS_LENGTH, dataTxVector, preamble, m_phy->GetFrequency (), 0, 0) > MilliSeconds(10))
+}
-return true;
+if (peekedPacket == 0)
-if (!m_mpduAggregator->CanBeAggregated (peekedPacket->GetSize () + peekedHdr.GetSize () + WIFI_MAC_FCS_LENGTH, aggregatedPacket, size))
+{
 return true;
+}
-return false;
+//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))
+{
+return true;
+}
+if (!m_mpduAggregator->CanBeAggregated (peekedPacket->GetSize () + peekedHdr.GetSize () + WIFI_MAC_FCS_LENGTH, aggregatedPacket, size))
+{
+return true;
+}
+return false;
 }
 Ptr<Packet>
 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)
 {
 NS_ASSERT (m_aggregateQueue->GetSize () == 0);
 bool isAmpdu = false;
 Ptr<Packet> newPacket, tempPacket;
 WifiMacHeader peekedHdr;
-newPacket = packet->Copy();
+newPacket = packet->Copy ();
 //missing hdr.IsAck() since we have no means of knowing the Tid of the Ack yet
-if (hdr.IsQosData() || hdr.IsBlockAck()|| hdr.IsBlockAckReq())
+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);
+std::map<AcIndex, MacLowAggregationCapableTransmissionListener*>::const_iterator listenerIt = m_edcaListeners.find (ac);
 NS_ASSERT (listenerIt != m_edcaListeners.end ());
-queue = listenerIt->second->GetQueue();
+queue = listenerIt->second->GetQueue ();
-if (!hdr.GetAddr1 ().IsBroadcast () && m_mpduAggregator!= 0)
+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))
+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*/
 Ptr<Packet> currentAggregatedPacket = Create<Packet> ();
 peekedHdr = hdr;
 uint16_t blockAckSize = 0;
 bool aggregated = false;
 int i = 0;
 Ptr<Packet> aggPacket = newPacket->Copy ();
-if (!hdr.IsBlockAckReq())
+if (!hdr.IsBlockAckReq ())
 {
-if (!hdr.IsBlockAck())
+if (!hdr.IsBlockAck ())
 {
-startingSequenceNumber = peekedHdr.GetSequenceNumber();
+startingSequenceNumber = peekedHdr.GetSequenceNumber ();
 peekedHdr.SetQosAckPolicy (WifiMacHeader::NORMAL_ACK);
 }
-currentSequenceNumber = peekedHdr.GetSequenceNumber();
+currentSequenceNumber = peekedHdr.GetSequenceNumber ();
 newPacket->AddHeader (peekedHdr);
 WifiMacTrailer fcs;
 newPacket->AddTrailer (fcs);
-aggregated=m_mpduAggregator->Aggregate (newPacket, currentAggregatedPacket);
+aggregated = m_mpduAggregator->Aggregate (newPacket, currentAggregatedPacket);
 if (aggregated)
 {
-NS_LOG_DEBUG ("Adding packet with Sequence number " << peekedHdr.GetSequenceNumber()<<" to A-MPDU, packet size = " << newPacket->GetSize ()<< ", A-MPDU size = " << currentAggregatedPacket->GetSize ());
+NS_LOG_DEBUG ("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())
+else if (hdr.IsBlockAckReq ())
 {
-blockAckSize = packet->GetSize() + hdr.GetSize() + WIFI_MAC_FCS_LENGTH;
+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 ();
 }
 {
 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);
+tempPacket = PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, blockAckSize);
-if (tempPacket != 0) //MSDU aggregation
+if (tempPacket != 0)  //MSDU aggregation
-peekedPacket = tempPacket->Copy();
+{
+peekedPacket = tempPacket->Copy ();
+}
 }
 }
 else
 {
 retry = true;
-currentSequenceNumber = peekedHdr.GetSequenceNumber();
+currentSequenceNumber = peekedHdr.GetSequenceNumber ();
 }
 while (IsInWindow (currentSequenceNumber, startingSequenceNumber, 64) && !StopMpduAggregation (peekedPacket, peekedHdr, currentAggregatedPacket, blockAckSize))
 {
 //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)
+{
 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);
+if (!m_txParams.MustSendRts ())
+{
+listenerIt->second->CompleteMpduTx (packet, hdr, tstamp);
+}
+else
+{
+InsertInTxQueue (packet, hdr, tstamp);
+}
 }
-else
+NS_LOG_DEBUG ("Adding packet with Sequence number " << peekedHdr.GetSequenceNumber () << " to A-MPDU, packet size = " << newPacket->GetSize () << ", A-MPDU size = " << currentAggregatedPacket->GetSize ());
-{
-InsertInTxQueue (packet, hdr, tstamp);
-}
-}
-NS_LOG_DEBUG ("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);
+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();
+{
-}
+peekedPacket = tempPacket->Copy ();
 }
+}
+}
 }
 else
-currentSequenceNumber = peekedHdr.GetSequenceNumber();
+{
+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();
+{
-}
+peekedPacket = tempPacket->Copy ();
 }
+}
+}
 }
 }
 if (isAmpdu)
 {
-if (hdr.IsBlockAckReq())
+if (hdr.IsBlockAckReq ())
 {
-newPacket = packet->Copy();
+newPacket = packet->Copy ();
 peekedHdr = hdr;
-Ptr<Packet> aggPacket = newPacket->Copy();
+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)
+if (qosPolicy == 0)
 {
 listenerIt->second->CompleteTransfer (hdr.GetAddr1 (), tid);
 }
 //Add packet tag
 AmpduTag ampdutag;
 ampdutag.SetAmpdu (true);
-ampdutag.SetNoOfMpdus(i);
+ampdutag.SetNoOfMpdus (i);
 newPacket = currentAggregatedPacket;
-newPacket->AddPacketTag(ampdutag);
+newPacket->AddPacketTag (ampdutag);
 currentAggregatedPacket = 0;
 NS_LOG_DEBUG ("tx unicast A-MPDU");
-listenerIt->second->SetAmpdu(true);
+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
 void
 MacLow::FlushAggregateQueue (void)
 {
 if (m_aggregateQueue->GetSize () > 0)
 {
-NS_LOG_DEBUG("Flush aggregate queue");
+NS_LOG_DEBUG ("Flush aggregate queue");
 m_aggregateQueue->Flush ();
 }
 m_txPackets.clear ();
 }
 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)
+MacLow::PerformMsduAggregation (Ptr<const Packet> packet, WifiMacHeader *hdr, Time *tstamp, Ptr<Packet> currentAmpduPacket, uint16_t blockAckSize)
 {
 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();
+queue = listenerIt->second->GetQueue ();
 listenerIt->second->GetMsduAggregator ()->Aggregate (packet, currentAmsduPacket,
 listenerIt->second->GetSrcAddressForAggregation (*hdr),
 listenerIt->second->GetDestAddressForAggregation (*hdr));
 Ptr<const Packet> peekedPacket = queue->PeekByTidAndAddress (hdr, hdr->GetQosTid (),
 WifiMacHeader::ADDR1, hdr->GetAddr1 (), tstamp);
 while (peekedPacket != 0)
 {
 tempPacket = currentAmsduPacket;
 msduAggregation = listenerIt->second->GetMsduAggregator ()->Aggregate (peekedPacket, tempPacket,
 listenerIt->second->GetSrcAddressForAggregation (*hdr),
 listenerIt->second->GetDestAddressForAggregation (*hdr));
 if (msduAggregation && !StopMpduAggregation (tempPacket, *hdr, currentAmpduPacket, blockAckSize))
 {
 isAmsdu = true;
 currentAmsduPacket = tempPacket;
 queue->Remove (peekedPacket);
 }
 else
 {
 break;
 }
 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
 {
 return 0;
 }
 }
-} // namespace ns3
+} //namespace ns3

changeset 11450	9f4ae69f12b7
parent 11440	af3a3d5dcc21
child 11479	a3dcf66928f3