A Discrete-Event Network Simulator
API
frame-exchange-manager.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2020 Universita' degli Studi di Napoli Federico II
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 *
17 * Author: Stefano Avallone <stavallo@unina.it>
18 */
19
21
23#include "snr-tag.h"
24#include "wifi-mac-queue.h"
25#include "wifi-mac-trailer.h"
26#include "wifi-utils.h"
27
28#include "ns3/abort.h"
29#include "ns3/log.h"
30
31#undef NS_LOG_APPEND_CONTEXT
32#define NS_LOG_APPEND_CONTEXT std::clog << "[link=" << +m_linkId << "][mac=" << m_self << "] "
33
34// Time (in nanoseconds) to be added to the PSDU duration to yield the duration
35// of the timer that is started when the PHY indicates the start of the reception
36// of a frame and we are waiting for a response.
37#define PSDU_DURATION_SAFEGUARD 400
38
39namespace ns3
40{
41
42NS_LOG_COMPONENT_DEFINE("FrameExchangeManager");
43
44NS_OBJECT_ENSURE_REGISTERED(FrameExchangeManager);
45
46TypeId
48{
49 static TypeId tid = TypeId("ns3::FrameExchangeManager")
51 .AddConstructor<FrameExchangeManager>()
52 .SetGroupName("Wifi");
53 return tid;
54}
55
57 : m_navEnd(Seconds(0)),
58 m_linkId(0),
59 m_allowedWidth(0),
60 m_promisc(false),
61 m_moreFragments(false)
62{
63 NS_LOG_FUNCTION(this);
64}
65
67{
69}
70
71void
73{
74 NS_LOG_FUNCTION(this);
77 {
79 }
81 m_mpdu = nullptr;
83 m_dcf = nullptr;
84}
85
86void
88{
89 NS_LOG_FUNCTION(this);
90 Reset();
91 m_fragmentedPacket = nullptr;
92 m_mac = nullptr;
93 m_txMiddle = nullptr;
94 m_rxMiddle = nullptr;
95 m_channelAccessManager = nullptr;
96 m_protectionManager = nullptr;
97 m_ackManager = nullptr;
98 ResetPhy();
100}
101
102void
104{
105 NS_LOG_FUNCTION(this << protectionManager);
106 m_protectionManager = protectionManager;
107}
108
111{
112 return m_protectionManager;
113}
114
115void
117{
118 NS_LOG_FUNCTION(this << ackManager);
119 m_ackManager = ackManager;
120}
121
124{
125 return m_ackManager;
126}
127
128void
130{
131 NS_LOG_FUNCTION(this << +linkId);
132 m_linkId = linkId;
133}
134
135void
137{
138 NS_LOG_FUNCTION(this << mac);
139 m_mac = mac;
140}
141
142void
144{
145 NS_LOG_FUNCTION(this << txMiddle);
146 m_txMiddle = txMiddle;
147}
148
149void
151{
152 NS_LOG_FUNCTION(this << rxMiddle);
153 m_rxMiddle = rxMiddle;
154}
155
156void
158{
159 NS_LOG_FUNCTION(this << channelAccessManager);
160 m_channelAccessManager = channelAccessManager;
161}
162
165{
167}
168
169void
171{
172 NS_LOG_FUNCTION(this << phy);
173 m_phy = phy;
174 m_phy->TraceConnectWithoutContext("PhyRxPayloadBegin",
177}
178
179void
181{
182 NS_LOG_FUNCTION(this);
183 if (m_phy)
184 {
186 "PhyRxPayloadBegin",
188 if (m_phy->GetState())
189 {
194 std::vector<bool>>());
195 }
196 m_phy = nullptr;
197 }
198}
199
200void
202{
203 NS_LOG_FUNCTION(this << address);
204 // For APs, the BSSID is the MAC address. For STAs, the BSSID will be overwritten
205 // when receiving Beacon frames or Probe Response frames
207 m_self = address;
208}
209
212{
213 return m_self;
214}
215
216void
218{
219 NS_LOG_FUNCTION(this << bssid);
220 m_bssid = bssid;
221}
222
225{
226 return m_bssid;
227}
228
229void
231{
232 NS_LOG_FUNCTION(this << &callback);
233 m_droppedMpduCallback = callback;
234}
235
236void
238{
239 NS_LOG_FUNCTION(this << &callback);
240 m_ackedMpduCallback = callback;
241}
242
243void
245{
246 m_promisc = true;
247}
248
249bool
251{
252 return m_promisc;
253}
254
255const WifiTxTimer&
257{
258 return m_txTimer;
259}
260
261void
263{
265 {
267 }
268}
269
270void
272{
273 NS_LOG_FUNCTION(this << "PSDU reception started for " << psduDuration.As(Time::US)
274 << " (txVector: " << txVector << ")");
275
277 "The TX timer and the NAV reset event cannot be both running");
278
279 // No need to reschedule timeouts if PSDU duration is null. In this case,
280 // PHY-RXEND immediately follows PHY-RXSTART (e.g. when PPDU has been filtered)
281 // and CCA will take over
282 if (m_txTimer.IsRunning() && psduDuration.IsStrictlyPositive())
283 {
284 // we are waiting for a response and something arrived
285 NS_LOG_DEBUG("Rescheduling timeout event");
287 // PHY has switched to RX, so we can reset the ack timeout
289 }
290
292 {
294 }
295}
296
297bool
299{
300 NS_LOG_FUNCTION(this << dcf << allowedWidth);
301
303 if (m_txTimer.IsRunning())
304 {
306 }
307 m_dcf = dcf;
308 m_allowedWidth = allowedWidth;
309
310 Ptr<WifiMacQueue> queue = dcf->GetWifiMacQueue();
311
312 // Even though channel access is requested when the queue is not empty, at
313 // the time channel access is granted the lifetime of the packet might be
314 // expired and the queue might be empty.
315 queue->WipeAllExpiredMpdus();
316
317 Ptr<WifiMpdu> mpdu = queue->Peek(m_linkId);
318
319 if (!mpdu)
320 {
321 NS_LOG_DEBUG("Queue empty");
323 m_dcf = nullptr;
324 return false;
325 }
326
328
329 NS_ASSERT(mpdu->GetHeader().IsData() || mpdu->GetHeader().IsMgt());
330
331 // assign a sequence number if this is not a fragment nor a retransmission
332 if (!mpdu->IsFragment() && !mpdu->GetHeader().IsRetry())
333 {
334 uint16_t sequence = m_txMiddle->GetNextSequenceNumberFor(&mpdu->GetHeader());
335 mpdu->AssignSeqNo(sequence);
336 }
337
338 NS_LOG_DEBUG("MPDU payload size=" << mpdu->GetPacketSize()
339 << ", to=" << mpdu->GetHeader().GetAddr1()
340 << ", seq=" << mpdu->GetHeader().GetSequenceControl());
341
342 // check if the MSDU needs to be fragmented
343 mpdu = GetFirstFragmentIfNeeded(mpdu);
344
347 WifiTxParameters txParams;
348 txParams.m_txVector =
350 txParams.m_protection = m_protectionManager->TryAddMpdu(mpdu, txParams);
351 txParams.m_acknowledgment = m_ackManager->TryAddMpdu(mpdu, txParams);
352 txParams.AddMpdu(mpdu);
353 UpdateTxDuration(mpdu->GetHeader().GetAddr1(), txParams);
354
355 SendMpduWithProtection(mpdu, txParams);
356
357 return true;
358}
359
362{
363 NS_LOG_FUNCTION(this << *mpdu);
364
365 if (mpdu->IsFragment())
366 {
367 // a fragment cannot be further fragmented
369 }
370 else if (GetWifiRemoteStationManager()->NeedFragmentation(mpdu))
371 {
372 NS_LOG_DEBUG("Fragmenting the MSDU");
373 m_fragmentedPacket = mpdu->GetPacket()->Copy();
374 // create the first fragment
376 0,
377 GetWifiRemoteStationManager()->GetFragmentSize(mpdu, 0));
378 // enqueue the first fragment
379 Ptr<WifiMpdu> item = Create<WifiMpdu>(fragment, mpdu->GetHeader());
380 item->GetHeader().SetMoreFragments();
381 m_mac->GetTxopQueue(mpdu->GetQueueAc())->Replace(mpdu, item);
382 return item;
383 }
384 return mpdu;
385}
386
387void
389{
390 NS_LOG_FUNCTION(this << *mpdu << &txParams);
391
392 m_mpdu = mpdu;
393 m_txParams = std::move(txParams);
394
395 // If protection is required, the MPDU must be stored in some queue because
396 // it is not put back in a queue if the RTS/CTS exchange fails
398 m_mpdu->GetHeader().IsCtl() || m_mpdu->IsQueued());
399
400 // Make sure that the acknowledgment time has been computed, so that SendRts()
401 // and SendCtsToSelf() can reuse this value.
403
404 if (m_txParams.m_acknowledgment->acknowledgmentTime == Time::Min())
405 {
407 }
408
409 // Set QoS Ack policy if this is a QoS data frame
411
412 if (m_mpdu->IsQueued())
413 {
414 m_mpdu->SetInFlight(m_linkId);
415 }
416
417 switch (m_txParams.m_protection->method)
418 {
421 break;
424 break;
426 SendMpdu();
427 break;
428 default:
429 NS_ABORT_MSG("Unknown protection type");
430 }
431
433 {
434 // we are done with frames that do not require acknowledgment
435 m_mpdu = nullptr;
436 }
437}
438
439void
441{
442 NS_LOG_FUNCTION(this);
443
446 m_phy->GetPhyBand());
447
449
451 {
453
454 if (!m_mpdu->GetHeader().IsQosData() ||
455 m_mpdu->GetHeader().GetQosAckPolicy() == WifiMacHeader::NO_ACK)
456 {
457 // No acknowledgment, hence dequeue the MPDU if it is stored in a queue
459 }
460 }
462 {
463 m_mpdu->GetHeader().SetDuration(
464 GetFrameDurationId(m_mpdu->GetHeader(),
468
469 // the timeout duration is "aSIFSTime + aSlotTime + aRxPHYStartDelay, starting
470 // at the PHY-TXEND.confirm primitive" (section 10.3.2.9 or 10.22.2.2 of 802.11-2016).
471 // aRxPHYStartDelay equals the time to transmit the PHY header.
472 WifiNormalAck* normalAcknowledgment =
473 static_cast<WifiNormalAck*>(m_txParams.m_acknowledgment.get());
474
475 Time timeout =
476 txDuration + m_phy->GetSifs() + m_phy->GetSlot() +
480 timeout,
482 this,
483 m_mpdu,
486 }
487 else
488 {
489 NS_ABORT_MSG("Unable to handle the selected acknowledgment method ("
490 << m_txParams.m_acknowledgment.get() << ")");
491 }
492
493 // transmit the MPDU
495}
496
497void
499{
500 NS_LOG_FUNCTION(this << *mpdu << txVector);
501
502 m_phy->Send(Create<WifiPsdu>(mpdu, false), txVector);
503}
504
505void
507{
508 NS_LOG_DEBUG(this << *mpdu);
509
510 if (mpdu->IsQueued())
511 {
512 m_mac->GetTxopQueue(mpdu->GetQueueAc())->DequeueIfQueued({mpdu});
513 }
514}
515
518{
519 return mpdu->GetSize();
520}
521
522void
524{
525 NS_LOG_FUNCTION(this << protection);
526 NS_ASSERT(protection);
527
528 if (protection->method == WifiProtection::NONE)
529 {
530 protection->protectionTime = Seconds(0);
531 }
532 else if (protection->method == WifiProtection::RTS_CTS)
533 {
534 WifiRtsCtsProtection* rtsCtsProtection = static_cast<WifiRtsCtsProtection*>(protection);
535 rtsCtsProtection->protectionTime = m_phy->CalculateTxDuration(GetRtsSize(),
536 rtsCtsProtection->rtsTxVector,
537 m_phy->GetPhyBand()) +
539 rtsCtsProtection->ctsTxVector,
540 m_phy->GetPhyBand()) +
541 2 * m_phy->GetSifs();
542 }
543 else if (protection->method == WifiProtection::CTS_TO_SELF)
544 {
545 WifiCtsToSelfProtection* ctsToSelfProtection =
546 static_cast<WifiCtsToSelfProtection*>(protection);
547 ctsToSelfProtection->protectionTime =
549 ctsToSelfProtection->ctsTxVector,
550 m_phy->GetPhyBand()) +
551 m_phy->GetSifs();
552 }
553}
554
555void
557{
558 NS_LOG_FUNCTION(this << acknowledgment);
559 NS_ASSERT(acknowledgment);
560
561 if (acknowledgment->method == WifiAcknowledgment::NONE)
562 {
563 acknowledgment->acknowledgmentTime = Seconds(0);
564 }
565 else if (acknowledgment->method == WifiAcknowledgment::NORMAL_ACK)
566 {
567 WifiNormalAck* normalAcknowledgment = static_cast<WifiNormalAck*>(acknowledgment);
568 normalAcknowledgment->acknowledgmentTime =
570 normalAcknowledgment->ackTxVector,
571 m_phy->GetPhyBand());
572 }
573}
574
575Time
577 Mac48Address receiver,
578 const WifiTxParameters& txParams) const
579{
580 return m_phy->CalculateTxDuration(ppduPayloadSize, txParams.m_txVector, m_phy->GetPhyBand());
581}
582
583void
585{
586 txParams.m_txDuration = GetTxDuration(txParams.GetSize(receiver), receiver, txParams);
587}
588
589Time
591 uint32_t size,
592 const WifiTxParameters& txParams,
593 Ptr<Packet> fragmentedPacket) const
594{
595 NS_LOG_FUNCTION(this << header << size << &txParams << fragmentedPacket);
596
597 NS_ASSERT(txParams.m_acknowledgment &&
598 txParams.m_acknowledgment->acknowledgmentTime != Time::Min());
599 Time durationId = txParams.m_acknowledgment->acknowledgmentTime;
600
601 // if the current frame is a fragment followed by another fragment, we have to
602 // update the Duration/ID to cover the next fragment and the corresponding Ack
603 if (header.IsMoreFragments())
604 {
605 uint32_t payloadSize = size - header.GetSize() - WIFI_MAC_FCS_LENGTH;
606 uint32_t nextFragmentOffset = (header.GetFragmentNumber() + 1) * payloadSize;
607 uint32_t nextFragmentSize =
608 std::min(fragmentedPacket->GetSize() - nextFragmentOffset, payloadSize);
609 WifiTxVector ackTxVector =
611
612 durationId +=
613 2 * m_phy->GetSifs() +
615 m_phy->CalculateTxDuration(nextFragmentSize, txParams.m_txVector, m_phy->GetPhyBand());
616 }
617 return durationId;
618}
619
620Time
622 Time txDuration,
623 Time response) const
624{
625 NS_LOG_FUNCTION(this << rtsTxVector << txDuration << response);
626
627 WifiTxVector ctsTxVector;
628 ctsTxVector = GetWifiRemoteStationManager()->GetCtsTxVector(m_self, rtsTxVector.GetMode());
629
630 return m_phy->GetSifs() +
631 m_phy->CalculateTxDuration(GetCtsSize(), ctsTxVector, m_phy->GetPhyBand()) /* CTS */
632 + m_phy->GetSifs() + txDuration + response;
633}
634
635void
637{
638 NS_LOG_FUNCTION(this << &txParams);
639
640 NS_ASSERT(txParams.GetPsduInfoMap().size() == 1);
641 Mac48Address receiver = txParams.GetPsduInfoMap().begin()->first;
642
643 WifiMacHeader rts;
645 rts.SetDsNotFrom();
646 rts.SetDsNotTo();
647 rts.SetNoRetry();
648 rts.SetNoMoreFragments();
649 rts.SetAddr1(receiver);
650 rts.SetAddr2(m_self);
651
652 NS_ASSERT(txParams.m_protection && txParams.m_protection->method == WifiProtection::RTS_CTS);
653 WifiRtsCtsProtection* rtsCtsProtection =
654 static_cast<WifiRtsCtsProtection*>(txParams.m_protection.get());
655
656 NS_ASSERT(txParams.m_txDuration != Time::Min());
657 rts.SetDuration(GetRtsDurationId(rtsCtsProtection->rtsTxVector,
658 txParams.m_txDuration,
659 txParams.m_acknowledgment->acknowledgmentTime));
660 Ptr<WifiMpdu> mpdu = Create<WifiMpdu>(Create<Packet>(), rts);
661
662 // After transmitting an RTS frame, the STA shall wait for a CTSTimeout interval with
663 // a value of aSIFSTime + aSlotTime + aRxPHYStartDelay (IEEE 802.11-2016 sec. 10.3.2.7).
664 // aRxPHYStartDelay equals the time to transmit the PHY header.
666 rtsCtsProtection->rtsTxVector,
667 m_phy->GetPhyBand()) +
668 m_phy->GetSifs() + m_phy->GetSlot() +
672 timeout,
674 this,
675 mpdu,
676 rtsCtsProtection->rtsTxVector);
678
679 ForwardMpduDown(mpdu, rtsCtsProtection->rtsTxVector);
680}
681
682void
684 WifiTxVector& ctsTxVector,
685 double rtsSnr)
686{
687 NS_LOG_FUNCTION(this << rtsHdr << ctsTxVector << rtsSnr);
688
689 WifiMacHeader cts;
691 cts.SetDsNotFrom();
692 cts.SetDsNotTo();
693 cts.SetNoMoreFragments();
694 cts.SetNoRetry();
695 cts.SetAddr1(rtsHdr.GetAddr2());
696 Time duration = rtsHdr.GetDuration() - m_phy->GetSifs() -
698 // The TXOP holder may exceed the TXOP limit in some situations (Sec. 10.22.2.8 of 802.11-2016)
699 if (duration.IsStrictlyNegative())
700 {
701 duration = Seconds(0);
702 }
703 cts.SetDuration(duration);
704
705 Ptr<Packet> packet = Create<Packet>();
706
707 SnrTag tag;
708 tag.Set(rtsSnr);
709 packet->AddPacketTag(tag);
710
711 // CTS should always use non-HT PPDU (HT PPDU cases not supported yet)
712 ForwardMpduDown(Create<WifiMpdu>(packet, cts), ctsTxVector);
713}
714
715void
717 WifiMode rtsTxMode,
718 double rtsSnr)
719{
720 NS_LOG_FUNCTION(this << rtsHdr << rtsTxMode << rtsSnr);
721
722 WifiTxVector ctsTxVector =
724 DoSendCtsAfterRts(rtsHdr, ctsTxVector, rtsSnr);
725}
726
727Time
729 Time txDuration,
730 Time response) const
731{
732 NS_LOG_FUNCTION(this << ctsTxVector << txDuration << response);
733
734 return m_phy->GetSifs() + txDuration + response;
735}
736
737void
739{
740 NS_LOG_FUNCTION(this << &txParams);
741
742 WifiMacHeader cts;
744 cts.SetDsNotFrom();
745 cts.SetDsNotTo();
746 cts.SetNoMoreFragments();
747 cts.SetNoRetry();
748 cts.SetAddr1(m_self);
749
750 NS_ASSERT(txParams.m_protection &&
751 txParams.m_protection->method == WifiProtection::CTS_TO_SELF);
752 WifiCtsToSelfProtection* ctsToSelfProtection =
753 static_cast<WifiCtsToSelfProtection*>(txParams.m_protection.get());
754
755 NS_ASSERT(txParams.m_txDuration != Time::Min());
756 cts.SetDuration(GetCtsToSelfDurationId(ctsToSelfProtection->ctsTxVector,
757 txParams.m_txDuration,
758 txParams.m_acknowledgment->acknowledgmentTime));
759
760 ForwardMpduDown(Create<WifiMpdu>(Create<Packet>(), cts), ctsToSelfProtection->ctsTxVector);
761
762 Time ctsDuration = m_phy->CalculateTxDuration(GetCtsSize(),
763 ctsToSelfProtection->ctsTxVector,
764 m_phy->GetPhyBand());
766}
767
768void
770 const WifiTxVector& dataTxVector,
771 double dataSnr)
772{
773 NS_LOG_FUNCTION(this << hdr << dataTxVector << dataSnr);
774
775 WifiTxVector ackTxVector =
777 WifiMacHeader ack;
779 ack.SetDsNotFrom();
780 ack.SetDsNotTo();
781 ack.SetNoRetry();
782 ack.SetNoMoreFragments();
783 ack.SetAddr1(hdr.GetAddr2());
784 // 802.11-2016, Section 9.2.5.7: Duration/ID is received duration value
785 // minus the time to transmit the Ack frame and its SIFS interval
786 Time duration = hdr.GetDuration() - m_phy->GetSifs() -
788 // The TXOP holder may exceed the TXOP limit in some situations (Sec. 10.22.2.8 of 802.11-2016)
789 if (duration.IsStrictlyNegative())
790 {
791 duration = Seconds(0);
792 }
793 ack.SetDuration(duration);
794
795 Ptr<Packet> packet = Create<Packet>();
796
797 SnrTag tag;
798 tag.Set(dataSnr);
799 packet->AddPacketTag(tag);
800
801 ForwardMpduDown(Create<WifiMpdu>(packet, ack), ackTxVector);
802}
803
806{
807 NS_LOG_FUNCTION(this);
808 NS_ASSERT(m_mpdu->GetHeader().IsMoreFragments());
809
810 WifiMacHeader& hdr = m_mpdu->GetHeader();
812
813 uint32_t startOffset = hdr.GetFragmentNumber() * m_mpdu->GetPacketSize();
814 uint32_t size = m_fragmentedPacket->GetSize() - startOffset;
815
816 if (size > m_mpdu->GetPacketSize())
817 {
818 // this is not the last fragment
819 size = m_mpdu->GetPacketSize();
820 hdr.SetMoreFragments();
821 }
822 else
823 {
824 hdr.SetNoMoreFragments();
825 }
826
827 return Create<WifiMpdu>(m_fragmentedPacket->CreateFragment(startOffset, size), hdr);
828}
829
830void
832{
833 NS_LOG_FUNCTION(this);
834
835 // Upon a transmission success, a non-QoS station transmits the next fragment,
836 // if any, or releases the channel, otherwise
837 if (m_moreFragments)
838 {
839 NS_LOG_DEBUG("Schedule transmission of next fragment in a SIFS");
842 this,
843 m_dcf,
845 m_moreFragments = false;
846 }
847 else
848 {
850 m_dcf = nullptr;
851 }
852}
853
854void
856{
857 NS_LOG_FUNCTION(this);
858 // A non-QoS station always releases the channel upon a transmission failure
860 m_dcf = nullptr;
861}
862
863void
865{
866 NS_LOG_FUNCTION(this << *mpdu << txVector);
867
869
870 if (!GetWifiRemoteStationManager()->NeedRetransmission(mpdu))
871 {
872 NS_LOG_DEBUG("Missed Ack, discard MPDU");
874 // Dequeue the MPDU if it is stored in a queue
875 DequeueMpdu(mpdu);
878 }
879 else
880 {
881 NS_LOG_DEBUG("Missed Ack, retransmit MPDU");
882 if (mpdu->IsQueued()) // the MPDU may have been removed due to lifetime expiration
883 {
884 mpdu = m_mac->GetTxopQueue(mpdu->GetQueueAc())->GetOriginal(mpdu);
885 mpdu->ResetInFlight(m_linkId);
886 }
887 mpdu->GetHeader().SetRetry();
890 }
891
892 m_mpdu = nullptr;
894}
895
896void
898{
899 NS_LOG_FUNCTION(this << *mpdu);
900}
901
902void
904{
905 NS_LOG_FUNCTION(this << *rts << txVector);
906
907 DoCtsTimeout(Create<WifiPsdu>(m_mpdu, true));
908 m_mpdu = nullptr;
909}
910
911void
913{
914 NS_LOG_FUNCTION(this << *psdu);
915
916 for (const auto& mpdu : *PeekPointer(psdu))
917 {
918 if (mpdu->IsQueued())
919 {
920 mpdu->ResetInFlight(m_linkId);
921 }
922 }
923
925
926 if (!GetWifiRemoteStationManager()->NeedRetransmission(*psdu->begin()))
927 {
928 NS_LOG_DEBUG("Missed CTS, discard MPDU(s)");
930 for (const auto& mpdu : *PeekPointer(psdu))
931 {
932 // Dequeue the MPDU if it is stored in a queue
933 DequeueMpdu(mpdu);
935 }
937 }
938 else
939 {
940 NS_LOG_DEBUG("Missed CTS, retransmit MPDU(s)");
942 }
943 // Make the sequence numbers of the MPDUs available again if the MPDUs have never
944 // been transmitted, both in case the MPDUs have been discarded and in case the
945 // MPDUs have to be transmitted (because a new sequence number is assigned to
946 // MPDUs that have never been transmitted and are selected for transmission)
948
950}
951
952void
954{
955 NS_LOG_FUNCTION(this << *psdu);
956
957 NS_ASSERT_MSG(psdu->GetNMpdus() == 1, "A-MPDUs should be handled by the HT FEM override");
958 auto mpdu = *psdu->begin();
959
960 // the MPDU should be still in the DCF queue, unless it expired.
961 // If the MPDU has never been transmitted and is not in-flight, it will be assigned
962 // a sequence number again the next time we try to transmit it. Therefore, we need to
963 // make its sequence number available again
964 if (!mpdu->GetHeader().IsRetry() && !mpdu->IsInFlight())
965 {
966 mpdu->UnassignSeqNo();
967 m_txMiddle->SetSequenceNumberFor(&mpdu->GetOriginal()->GetHeader());
968 }
969}
970
971void
973{
974 NS_LOG_FUNCTION(this);
975
976 // For internal collisions occurring with the EDCA access method, the appropriate
977 // retry counters (short retry counter for MSDU, A-MSDU, or MMPDU and QSRC[AC] or
978 // long retry counter for MSDU, A-MSDU, or MMPDU and QLRC[AC]) are incremented
979 // (Sec. 10.22.2.11.1 of 802.11-2016).
980 // We do not prepare the PSDU that the AC losing the internal collision would have
981 // sent. As an approximation, we consider the frame peeked from the queues of the AC.
982 Ptr<QosTxop> qosTxop = (txop->IsQosTxop() ? StaticCast<QosTxop>(txop) : nullptr);
983
984 auto mpdu =
985 (qosTxop ? qosTxop->PeekNextMpdu(m_linkId) : txop->GetWifiMacQueue()->Peek(m_linkId));
986
987 if (mpdu)
988 {
989 if (mpdu->GetHeader().HasData() && !mpdu->GetHeader().GetAddr1().IsGroup())
990 {
992 }
993
994 if (!mpdu->GetHeader().GetAddr1().IsGroup() &&
995 !GetWifiRemoteStationManager()->NeedRetransmission(mpdu))
996 {
997 NS_LOG_DEBUG("reset DCF");
999 DequeueMpdu(mpdu);
1001 txop->ResetCw(m_linkId);
1002 }
1003 else
1004 {
1005 NS_LOG_DEBUG("Update CW");
1006 txop->UpdateFailedCw(m_linkId);
1007 }
1008 }
1009
1010 txop->Txop::NotifyChannelReleased(m_linkId);
1011}
1012
1013void
1015{
1016 NS_LOG_DEBUG("Switching channel. Cancelling MAC pending events");
1018 if (m_txTimer.IsRunning())
1019 {
1020 // we were transmitting something before channel switching. Since we will
1021 // not be able to receive the response, have the timer expire now, so that
1022 // we perform the actions required in case of missing response
1024 }
1026}
1027
1028void
1030{
1031 NS_LOG_DEBUG("Device in sleep mode. Cancelling MAC pending events");
1032 Reset();
1033}
1034
1035void
1037{
1038 NS_LOG_DEBUG("Device is switched off. Cancelling MAC pending events");
1039 Reset();
1040}
1041
1042void
1044 RxSignalInfo rxSignalInfo,
1045 WifiTxVector txVector,
1046 std::vector<bool> perMpduStatus)
1047{
1049 this << psdu << rxSignalInfo << txVector << perMpduStatus.size()
1050 << std::all_of(perMpduStatus.begin(), perMpduStatus.end(), [](bool v) { return v; }));
1051
1052 if (!perMpduStatus.empty())
1053 {
1054 // for A-MPDUs, we get here only once
1055 PreProcessFrame(psdu, txVector);
1056 }
1057
1058 Mac48Address addr1 = psdu->GetAddr1();
1059
1060 if (addr1.IsGroup() || addr1 == m_self)
1061 {
1062 // receive broadcast frames or frames addressed to us only
1063 if (psdu->GetNMpdus() == 1)
1064 {
1065 // if perMpduStatus is not empty (i.e., this MPDU is not included in an A-MPDU)
1066 // then it must contain a single value which must be true (i.e., the MPDU
1067 // has been correctly received)
1068 NS_ASSERT(perMpduStatus.empty() || (perMpduStatus.size() == 1 && perMpduStatus[0]));
1069 // Ack and CTS do not carry Addr2
1070 if (!psdu->GetHeader(0).IsAck() && !psdu->GetHeader(0).IsCts())
1071 {
1073 rxSignalInfo,
1074 txVector);
1075 }
1076 ReceiveMpdu(*(psdu->begin()), rxSignalInfo, txVector, perMpduStatus.empty());
1077 }
1078 else
1079 {
1080 EndReceiveAmpdu(psdu, rxSignalInfo, txVector, perMpduStatus);
1081 }
1082 }
1083 else if (m_promisc)
1084 {
1085 for (const auto& mpdu : *PeekPointer(psdu))
1086 {
1087 if (!mpdu->GetHeader().IsCtl())
1088 {
1089 m_rxMiddle->Receive(mpdu, m_linkId);
1090 }
1091 }
1092 }
1093
1094 if (!perMpduStatus.empty())
1095 {
1096 // for A-MPDUs, we get here only once
1097 PostProcessFrame(psdu, txVector);
1098 }
1099}
1100
1101void
1103{
1104 NS_LOG_FUNCTION(this << psdu << txVector);
1105}
1106
1107void
1109{
1110 NS_LOG_FUNCTION(this << psdu << txVector);
1111
1112 UpdateNav(psdu, txVector);
1113}
1114
1115void
1117{
1118 NS_LOG_FUNCTION(this << psdu << txVector);
1119
1120 if (!psdu->HasNav())
1121 {
1122 return;
1123 }
1124
1125 Time duration = psdu->GetDuration();
1126 NS_LOG_DEBUG("Duration/ID=" << duration);
1127
1128 if (psdu->GetAddr1() == m_self)
1129 {
1130 // When the received frame’s RA is equal to the STA’s own MAC address, the STA
1131 // shall not update its NAV (IEEE 802.11-2016, sec. 10.3.2.4)
1132 return;
1133 }
1134
1135 // For all other received frames the STA shall update its NAV when the received
1136 // Duration is greater than the STA’s current NAV value (IEEE 802.11-2016 sec. 10.3.2.4)
1137 Time navEnd = Simulator::Now() + duration;
1138 if (navEnd > m_navEnd)
1139 {
1140 m_navEnd = navEnd;
1141 NS_LOG_DEBUG("Updated NAV=" << m_navEnd);
1142
1143 // A STA that used information from an RTS frame as the most recent basis to update
1144 // its NAV setting is permitted to reset its NAV if no PHY-RXSTART.indication
1145 // primitive is received from the PHY during a NAVTimeout period starting when the
1146 // MAC receives a PHY-RXEND.indication primitive corresponding to the detection of
1147 // the RTS frame. NAVTimeout period is equal to:
1148 // (2 x aSIFSTime) + (CTS_Time) + aRxPHYStartDelay + (2 x aSlotTime)
1149 // The “CTS_Time” shall be calculated using the length of the CTS frame and the data
1150 // rate at which the RTS frame used for the most recent NAV update was received
1151 // (IEEE 802.11-2016 sec. 10.3.2.4)
1152 if (psdu->GetHeader(0).IsRts())
1153 {
1154 WifiTxVector ctsTxVector =
1156 Time navResetDelay =
1157 2 * m_phy->GetSifs() +
1162 }
1163 }
1164 NS_LOG_DEBUG("Current NAV=" << m_navEnd);
1165
1167}
1168
1169void
1171{
1172 NS_LOG_FUNCTION(this);
1175}
1176
1177bool
1179{
1180 return m_navEnd <= Simulator::Now();
1181}
1182
1183void
1185 RxSignalInfo rxSignalInfo,
1186 const WifiTxVector& txVector,
1187 bool inAmpdu)
1188{
1189 NS_LOG_FUNCTION(this << *mpdu << rxSignalInfo << txVector << inAmpdu);
1190 // The received MPDU is either broadcast or addressed to this station
1191 NS_ASSERT(mpdu->GetHeader().GetAddr1().IsGroup() || mpdu->GetHeader().GetAddr1() == m_self);
1192
1193 double rxSnr = rxSignalInfo.snr;
1194 const WifiMacHeader& hdr = mpdu->GetHeader();
1195
1196 if (hdr.IsCtl())
1197 {
1198 if (hdr.IsRts())
1199 {
1200 NS_ABORT_MSG_IF(inAmpdu, "Received RTS as part of an A-MPDU");
1201
1202 // A non-VHT STA that is addressed by an RTS frame behaves as follows:
1203 // - If the NAV indicates idle, the STA shall respond with a CTS frame after a SIFS
1204 // - Otherwise, the STA shall not respond with a CTS frame
1205 // (IEEE 802.11-2016 sec. 10.3.2.7)
1206 if (VirtualCsMediumIdle())
1207 {
1208 NS_LOG_DEBUG("Received RTS from=" << hdr.GetAddr2() << ", schedule CTS");
1211 this,
1212 hdr,
1213 txVector.GetMode(),
1214 rxSnr);
1215 }
1216 else
1217 {
1218 NS_LOG_DEBUG("Received RTS from=" << hdr.GetAddr2() << ", cannot schedule CTS");
1219 }
1220 }
1221 else if (hdr.IsCts() && m_txTimer.IsRunning() &&
1223 {
1224 NS_ABORT_MSG_IF(inAmpdu, "Received CTS as part of an A-MPDU");
1225 NS_ASSERT(hdr.GetAddr1() == m_self);
1226
1227 Mac48Address sender = m_mpdu->GetHeader().GetAddr1();
1228 NS_LOG_DEBUG("Received CTS from=" << sender);
1229
1230 SnrTag tag;
1231 mpdu->GetPacket()->PeekPacketTag(tag);
1232 GetWifiRemoteStationManager()->ReportRxOk(sender, rxSignalInfo, txVector);
1234 rxSnr,
1235 txVector.GetMode(),
1236 tag.Get());
1237
1238 m_txTimer.Cancel();
1241 }
1242 else if (hdr.IsAck() && m_mpdu && m_txTimer.IsRunning() &&
1244 {
1245 NS_ASSERT(hdr.GetAddr1() == m_self);
1246 SnrTag tag;
1247 mpdu->GetPacket()->PeekPacketTag(tag);
1248 ReceivedNormalAck(m_mpdu, m_txParams.m_txVector, txVector, rxSignalInfo, tag.Get());
1249 m_mpdu = nullptr;
1250 }
1251 }
1252 else if (hdr.IsMgt())
1253 {
1254 NS_ABORT_MSG_IF(inAmpdu, "Received management frame as part of an A-MPDU");
1255
1256 if (hdr.IsBeacon() || hdr.IsProbeResp())
1257 {
1258 // Apply SNR tag for beacon quality measurements
1259 SnrTag tag;
1260 tag.Set(rxSnr);
1261 Ptr<Packet> packet = mpdu->GetPacket()->Copy();
1262 packet->AddPacketTag(tag);
1263 mpdu = Create<WifiMpdu>(packet, hdr);
1264 }
1265
1266 if (hdr.GetAddr1() == m_self)
1267 {
1268 NS_LOG_DEBUG("Received " << hdr.GetTypeString() << " from=" << hdr.GetAddr2()
1269 << ", schedule ACK");
1272 this,
1273 hdr,
1274 txVector,
1275 rxSnr);
1276 }
1277
1278 m_rxMiddle->Receive(mpdu, m_linkId);
1279 }
1280 else if (hdr.IsData() && !hdr.IsQosData())
1281 {
1282 if (hdr.GetAddr1() == m_self)
1283 {
1284 NS_LOG_DEBUG("Received " << hdr.GetTypeString() << " from=" << hdr.GetAddr2()
1285 << ", schedule ACK");
1288 this,
1289 hdr,
1290 txVector,
1291 rxSnr);
1292 }
1293
1294 m_rxMiddle->Receive(mpdu, m_linkId);
1295 }
1296}
1297
1298void
1300 const WifiTxVector& txVector,
1301 const WifiTxVector& ackTxVector,
1302 const RxSignalInfo& rxInfo,
1303 double snr)
1304{
1305 Mac48Address sender = mpdu->GetHeader().GetAddr1();
1306 NS_LOG_DEBUG("Received ACK from=" << sender);
1307
1309
1310 // When fragmentation is used, only update manager when the last fragment is acknowledged
1311 if (!mpdu->GetHeader().IsMoreFragments())
1312 {
1313 GetWifiRemoteStationManager()->ReportRxOk(sender, rxInfo, ackTxVector);
1315 rxInfo.snr,
1316 ackTxVector.GetMode(),
1317 snr,
1318 txVector);
1319 }
1320 // cancel the timer
1321 m_txTimer.Cancel();
1323
1324 // The CW shall be reset to aCWmin after every successful attempt to transmit
1325 // a frame containing all or part of an MSDU or MMPDU (sec. 10.3.3 of 802.11-2016)
1327
1328 if (mpdu->GetHeader().IsMoreFragments())
1329 {
1330 // replace the current fragment with the next one
1331 m_dcf->GetWifiMacQueue()->Replace(mpdu, GetNextFragment());
1332 m_moreFragments = true;
1333 }
1334 else
1335 {
1336 // the MPDU has been acknowledged, we can now dequeue it if it is stored in a queue
1337 DequeueMpdu(mpdu);
1338 }
1339
1341}
1342
1343void
1345{
1346 NS_LOG_FUNCTION(this << *mpdu);
1347
1348 // inform the MAC that the transmission was successful
1350 {
1351 m_ackedMpduCallback(mpdu);
1352 }
1353}
1354
1355void
1357 const RxSignalInfo& rxSignalInfo,
1358 const WifiTxVector& txVector,
1359 const std::vector<bool>& perMpduStatus)
1360{
1361 NS_ASSERT_MSG(false, "A non-QoS station should not receive an A-MPDU");
1362}
1363
1364} // namespace ns3
#define min(a, b)
Definition: 80211b.c:42
bool IsNull() const
Check for null implementation.
Definition: callback.h:572
void NotifyAckTimeoutResetNow()
Notify that ack timer has reset.
void NotifyAckTimeoutStartNow(Time duration)
Notify that ack timer has started for the given duration.
void NotifyCtsTimeoutStartNow(Time duration)
Notify that CTS timer has started for the given duration.
void NotifyCtsTimeoutResetNow()
Notify that CTS timer has reset.
void NotifyNavResetNow(Time duration)
void NotifyNavStartNow(Time duration)
void Cancel()
This method is syntactic sugar for the ns3::Simulator::Cancel method.
Definition: event-id.cc:55
bool IsRunning() const
This method is syntactic sugar for !IsExpired().
Definition: event-id.cc:76
void DoCtsTimeout(Ptr< WifiPsdu > psdu)
Take required actions when the CTS timer fired after sending an RTS to protect the given PSDU expires...
Ptr< WifiMpdu > m_mpdu
the MPDU being transmitted
virtual void SetAckManager(Ptr< WifiAckManager > ackManager)
Set the Acknowledgment Manager to use.
void NotifyOffNow()
This method is typically invoked by the PhyListener to notify the MAC layer that the device has been ...
virtual void NotifyInternalCollision(Ptr< Txop > txop)
Notify that an internal collision has occurred for the given Txop.
static TypeId GetTypeId()
Get the type ID.
uint8_t m_linkId
the ID of the link this object is associated with
Ptr< WifiMac > m_mac
the MAC layer on this station
DroppedMpdu m_droppedMpduCallback
the dropped MPDU callback
virtual void SetWifiMac(const Ptr< WifiMac > mac)
Set the MAC layer to use.
virtual void ResetPhy()
Remove WifiPhy associated with this FrameExchangeManager.
virtual void UpdateNav(Ptr< const WifiPsdu > psdu, const WifiTxVector &txVector)
Update the NAV, if needed, based on the Duration/ID of the given psdu.
void SendMpduWithProtection(Ptr< WifiMpdu > mpdu, WifiTxParameters &txParams)
Send an MPDU with the given TX parameters (with the specified protection).
Ptr< WifiAckManager > m_ackManager
Acknowledgment manager.
Ptr< WifiRemoteStationManager > GetWifiRemoteStationManager() const
void UpdateTxDuration(Mac48Address receiver, WifiTxParameters &txParams) const
Update the TX duration field of the given TX parameters after that the PSDU addressed to the given re...
virtual void CalculateAcknowledgmentTime(WifiAcknowledgment *acknowledgment) const
Calculate the time required to acknowledge a frame according to the given acknowledgment method.
Ptr< MacTxMiddle > m_txMiddle
the MAC TX Middle on this station
void SendNormalAck(const WifiMacHeader &hdr, const WifiTxVector &dataTxVector, double dataSnr)
Send Normal Ack.
Ptr< Packet > m_fragmentedPacket
the MSDU being fragmented
virtual void SetDroppedMpduCallback(DroppedMpdu callback)
Set the callback to invoke when an MPDU is dropped.
virtual void Reset()
Reset this frame exchange manager.
Mac48Address m_self
the MAC address of this device
virtual void TransmissionFailed()
Take necessary actions upon a transmission failure.
uint16_t m_allowedWidth
the allowed width in MHz for the current transmission
virtual void NotifyPacketDiscarded(Ptr< const WifiMpdu > mpdu)
Pass the given MPDU, discarded because of the max retry limit was reached, to the MPDU dropped callba...
WifiTxTimer m_txTimer
the timer set upon frame transmission
void SendCtsAfterRts(const WifiMacHeader &rtsHdr, WifiMode rtsTxMode, double rtsSnr)
Send CTS after receiving RTS.
virtual Time GetRtsDurationId(const WifiTxVector &rtsTxVector, Time txDuration, Time response) const
Compute how to set the Duration/ID field of an RTS frame to send to protect a frame transmitted with ...
virtual void RetransmitMpduAfterMissedAck(Ptr< WifiMpdu > mpdu) const
Retransmit an MPDU that was not acknowledged.
Mac48Address GetAddress() const
Get the MAC address.
Ptr< WifiProtectionManager > m_protectionManager
Protection manager.
virtual void ForwardMpduDown(Ptr< WifiMpdu > mpdu, WifiTxVector &txVector)
Forward an MPDU down to the PHY layer.
virtual void SetLinkId(uint8_t linkId)
Set the ID of the link this Frame Exchange Manager is associated with.
virtual bool VirtualCsMediumIdle() const
void SendRts(const WifiTxParameters &txParams)
Send RTS to begin RTS-CTS-Data-Ack transaction.
virtual void NotifyReceivedNormalAck(Ptr< WifiMpdu > mpdu)
Notify other components that an MPDU was acknowledged.
virtual void NormalAckTimeout(Ptr< WifiMpdu > mpdu, const WifiTxVector &txVector)
Called when the Ack timeout expires.
virtual void NotifySwitchingStartNow(Time duration)
virtual void SetBssid(Mac48Address bssid)
Set the Basic Service Set Identification.
void SendCtsToSelf(const WifiTxParameters &txParams)
Send CTS for a CTS-to-self mechanism.
virtual void CtsTimeout(Ptr< WifiMpdu > rts, const WifiTxVector &txVector)
Called when the CTS timeout expires.
virtual void CalculateProtectionTime(WifiProtection *protection) const
Calculate the time required to protect a frame according to the given protection method.
virtual void SetAddress(Mac48Address address)
Set the MAC address.
Ptr< WifiAckManager > GetAckManager() const
Get the Acknowledgment Manager used by this node.
virtual void DequeueMpdu(Ptr< const WifiMpdu > mpdu)
Dequeue the given MPDU from the queue in which it is stored.
virtual void NavResetTimeout()
Reset the NAV upon expiration of the NAV reset timer.
Ptr< WifiProtectionManager > GetProtectionManager() const
Get the Protection Manager used by this node.
bool IsPromisc() const
Check if the device is operating in promiscuous mode.
void SendMpdu()
Send the current MPDU, which can be acknowledged by a Normal Ack.
virtual void EndReceiveAmpdu(Ptr< const WifiPsdu > psdu, const RxSignalInfo &rxSignalInfo, const WifiTxVector &txVector, const std::vector< bool > &perMpduStatus)
This method is called when the reception of an A-MPDU including multiple MPDUs is completed.
Ptr< MacRxMiddle > m_rxMiddle
the MAC RX Middle on this station
virtual void TransmissionSucceeded()
Take necessary actions upon a transmission success.
Ptr< Txop > m_dcf
the DCF/EDCAF that gained channel access
Ptr< WifiPhy > m_phy
the PHY layer on this station
Ptr< WifiMpdu > GetFirstFragmentIfNeeded(Ptr< WifiMpdu > mpdu)
Fragment the given MPDU if needed.
Ptr< WifiMpdu > GetNextFragment()
Get the next fragment of the current MSDU.
virtual void ReleaseSequenceNumbers(Ptr< const WifiPsdu > psdu) const
Make the sequence numbers of MPDUs included in the given PSDU available again if the MPDUs have never...
void SetAckedMpduCallback(AckedMpdu callback)
Set the callback to invoke when an MPDU is successfully acked.
virtual void PreProcessFrame(Ptr< const WifiPsdu > psdu, const WifiTxVector &txVector)
Perform actions that are possibly needed when receiving any frame, independently of whether the frame...
virtual Time GetFrameDurationId(const WifiMacHeader &header, uint32_t size, const WifiTxParameters &txParams, Ptr< Packet > fragmentedPacket) const
Compute how to set the Duration/ID field of a frame being transmitted with the given TX parameters.
virtual Time GetCtsToSelfDurationId(const WifiTxVector &ctsTxVector, Time txDuration, Time response) const
Compute how to set the Duration/ID field of a CTS-to-self frame to send to protect a frame transmitte...
void DoSendCtsAfterRts(const WifiMacHeader &rtsHdr, WifiTxVector &ctsTxVector, double rtsSnr)
Send CTS after receiving RTS.
void Receive(Ptr< const WifiPsdu > psdu, RxSignalInfo rxSignalInfo, WifiTxVector txVector, std::vector< bool > perMpduStatus)
This method is intended to be called by the PHY layer every time an MPDU is received and also when th...
Mac48Address m_bssid
BSSID address (Mac48Address)
virtual void SetWifiPhy(const Ptr< WifiPhy > phy)
Set the PHY layer to use.
AckedMpdu m_ackedMpduCallback
the acknowledged MPDU callback
virtual void PostProcessFrame(Ptr< const WifiPsdu > psdu, const WifiTxVector &txVector)
Perform actions that are possibly needed after receiving any frame, independently of whether the fram...
virtual uint32_t GetPsduSize(Ptr< const WifiMpdu > mpdu, const WifiTxVector &txVector) const
Get the size in bytes of the given MPDU, which is to be transmitted with the given TXVECTOR.
Ptr< ChannelAccessManager > m_channelAccessManager
the channel access manager
virtual void ReceivedNormalAck(Ptr< WifiMpdu > mpdu, const WifiTxVector &txVector, const WifiTxVector &ackTxVector, const RxSignalInfo &rxInfo, double snr)
Perform the actions needed when a Normal Ack is received.
bool m_promisc
Flag if the device is operating in promiscuous mode.
void NotifySleepNow()
This method is typically invoked by the PhyListener to notify the MAC layer that the device has been ...
virtual void ReceiveMpdu(Ptr< const WifiMpdu > mpdu, RxSignalInfo rxSignalInfo, const WifiTxVector &txVector, bool inAmpdu)
This method handles the reception of an MPDU (possibly included in an A-MPDU)
virtual void SetChannelAccessManager(const Ptr< ChannelAccessManager > channelAccessManager)
Set the channel access manager to use.
bool m_moreFragments
true if a fragment has to be sent after a SIFS
void SetPromisc()
Enable promiscuous mode.
Time m_navEnd
NAV expiration time.
virtual void SetMacTxMiddle(const Ptr< MacTxMiddle > txMiddle)
Set the MAC TX Middle to use.
virtual void SetMacRxMiddle(const Ptr< MacRxMiddle > rxMiddle)
Set the MAC RX Middle to use.
virtual void SetProtectionManager(Ptr< WifiProtectionManager > protectionManager)
Set the Protection Manager to use.
Mac48Address GetBssid() const
Get the Basic Service Set Identification.
void DoDispose() override
Destructor implementation.
WifiTxParameters m_txParams
the TX parameters for the current frame
virtual bool StartTransmission(Ptr< Txop > dcf, uint16_t allowedWidth)
Request the FrameExchangeManager to start a frame exchange sequence.
void RxStartIndication(WifiTxVector txVector, Time psduDuration)
EventId m_navResetEvent
the event to reset the NAV after an RTS
const WifiTxTimer & GetWifiTxTimer() const
Get a const reference to the WifiTxTimer object.
virtual Time GetTxDuration(uint32_t ppduPayloadSize, Mac48Address receiver, const WifiTxParameters &txParams) const
Get the updated TX duration of the frame associated with the given TX parameters if the size of the P...
an EUI-48 address
Definition: mac48-address.h:46
bool IsGroup() const
bool TraceConnectWithoutContext(std::string name, const CallbackBase &cb)
Connect a TraceSource to a Callback without a context.
Definition: object-base.cc:311
bool TraceDisconnectWithoutContext(std::string name, const CallbackBase &cb)
Disconnect from a TraceSource a Callback previously connected without a context.
Definition: object-base.cc:339
A base class which provides memory management and object aggregation.
Definition: object.h:89
virtual void DoDispose()
Destructor implementation.
Definition: object.cc:353
uint32_t GetSize() const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:862
void AddPacketTag(const Tag &tag) const
Add a packet tag.
Definition: packet.cc:979
Ptr< Packet > CreateFragment(uint32_t start, uint32_t length) const
Create a new packet which contains a fragment of the original packet.
Definition: packet.cc:238
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:78
Ptr< WifiMpdu > PeekNextMpdu(uint8_t linkId, uint8_t tid=8, Mac48Address recipient=Mac48Address::GetBroadcast(), Ptr< const WifiMpdu > mpdu=nullptr)
Peek the next frame to transmit on the given link to the given receiver and of the given TID from the...
Definition: qos-txop.cc:359
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:568
static Time Now()
Return the current simulation virtual time.
Definition: simulator.cc:199
static EventId ScheduleNow(FUNC f, Ts &&... args)
Schedule an event to expire Now.
Definition: simulator.h:606
Introspection did not find any typical Config paths.
Definition: snr-tag.h:35
void Set(double snr)
Set the SNR to the given value.
Definition: snr-tag.cc:84
double Get() const
Return the SNR value.
Definition: snr-tag.cc:90
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
TimeWithUnit As(const Unit unit=Time::AUTO) const
Attach a unit to a Time, to facilitate output in a specific unit.
Definition: time.cc:417
bool IsStrictlyPositive() const
Exactly equivalent to t > 0.
Definition: nstime.h:350
static Time Min()
Minimum representable Time Not to be confused with Min(Time,Time).
Definition: nstime.h:286
@ US
microsecond
Definition: nstime.h:118
bool IsStrictlyNegative() const
Exactly equivalent to t < 0.
Definition: nstime.h:341
void UpdateFailedCw(uint8_t linkId)
Update the value of the CW variable for the given link to take into account a transmission failure.
Definition: txop.cc:300
Ptr< WifiMacQueue > GetWifiMacQueue() const
Return the packet queue associated with this Txop.
Definition: txop.cc:220
virtual void NotifyChannelReleased(uint8_t linkId)
Called by the FrameExchangeManager to notify the completion of the transmissions.
Definition: txop.cc:585
void ResetCw(uint8_t linkId)
Update the value of the CW variable for the given link to take into account a transmission success or...
Definition: txop.cc:291
virtual bool IsQosTxop() const
Check for QoS TXOP.
Definition: txop.cc:646
virtual void NotifyChannelAccessed(uint8_t linkId, Time txopDuration=Seconds(0))
Called by the FrameExchangeManager to notify that channel access has been granted on the given link f...
Definition: txop.cc:578
a unique identifier for an interface.
Definition: type-id.h:59
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:935
static void SetQosAckPolicy(Ptr< WifiMpdu > item, const WifiAcknowledgment *acknowledgment)
Set the QoS Ack policy for the given MPDU, which must be a QoS data frame.
Implements the IEEE 802.11 MAC header.
bool IsAck() const
Return true if the header is an Ack header.
bool IsCts() const
Return true if the header is a CTS header.
bool IsBeacon() const
Return true if the header is a Beacon header.
Mac48Address GetAddr1() const
Return the address in the Address 1 field.
bool IsMoreFragments() const
Return if the More Fragment bit is set.
void SetNoMoreFragments()
Un-set the More Fragment bit in the Frame Control Field.
bool IsMgt() const
Return true if the Type is Management.
bool IsCtl() const
Return true if the Type is Control.
Time GetDuration() const
Return the duration from the Duration/ID field (Time object).
uint32_t GetSize() const
Return the size of the WifiMacHeader in octets.
void SetDsNotFrom()
Un-set the From DS bit in the Frame Control field.
bool IsProbeResp() const
Return true if the header is a Probe Response header.
void SetMoreFragments()
Set the More Fragment bit in the Frame Control field.
void SetAddr1(Mac48Address address)
Fill the Address 1 field with the given address.
void SetType(WifiMacType type, bool resetToDsFromDs=true)
Set Type/Subtype values with the correct values depending on the given type.
Mac48Address GetAddr2() const
Return the address in the Address 2 field.
const char * GetTypeString() const
Return a string corresponds to the header type.
void SetDuration(Time duration)
Set the Duration/ID field with the given duration (Time object).
bool IsData() const
Return true if the Type is DATA.
bool IsRts() const
Return true if the header is a RTS header.
void SetAddr2(Mac48Address address)
Fill the Address 2 field with the given address.
uint8_t GetFragmentNumber() const
Return the fragment number of the header.
bool IsQosData() const
Return true if the Type is DATA and Subtype is one of the possible values for QoS Data.
void SetDsNotTo()
Un-set the To DS bit in the Frame Control field.
void SetFragmentNumber(uint8_t frag)
Set the fragment number of the header.
void SetNoRetry()
Un-set the Retry bit in the Frame Control field.
virtual void NotifyChannelSwitching(uint8_t linkId)
Notify that channel on the given link has been switched.
Definition: wifi-mac.cc:556
virtual Ptr< WifiMacQueue > GetTxopQueue(AcIndex ac) const
Get the wifi MAC queue of the (Qos)Txop associated with the given AC, if such (Qos)Txop is installed,...
Definition: wifi-mac.cc:536
Ptr< WifiRemoteStationManager > GetWifiRemoteStationManager(uint8_t linkId=0) const
Definition: wifi-mac.cc:886
represent a single transmission mode
Definition: wifi-mode.h:50
void Send(Ptr< const WifiPsdu > psdu, const WifiTxVector &txVector)
This function is a wrapper for the Send variant that accepts a WifiConstPsduMap as first argument.
Definition: wifi-phy.cc:1693
Time GetSlot() const
Return the slot duration for this PHY.
Definition: wifi-phy.cc:786
Time GetSifs() const
Return the Short Interframe Space (SIFS) for this PHY.
Definition: wifi-phy.cc:774
static Time CalculateTxDuration(uint32_t size, const WifiTxVector &txVector, WifiPhyBand band, uint16_t staId=SU_STA_ID)
Definition: wifi-phy.cc:1480
Ptr< WifiPhyStateHelper > GetState() const
Return the WifiPhyStateHelper of this PHY.
Definition: wifi-phy.cc:436
WifiPhyBand GetPhyBand() const
Get the configured Wi-Fi band.
Definition: wifi-phy.cc:996
void SetReceiveOkCallback(RxOkCallback callback)
Definition: wifi-phy.cc:442
static Time CalculatePhyPreambleAndHeaderDuration(const WifiTxVector &txVector)
Definition: wifi-phy.cc:1473
const WifiMacHeader & GetHeader(std::size_t i) const
Get the header of the i-th MPDU.
Definition: wifi-psdu.cc:279
Time GetDuration() const
Get the duration from the Duration/ID field, which is common to all the MPDUs.
Definition: wifi-psdu.cc:153
std::vector< Ptr< WifiMpdu > >::const_iterator begin() const
Return a const iterator to the first MPDU.
Definition: wifi-psdu.cc:333
Mac48Address GetAddr2() const
Get the Transmitter Address (TA), which is common to all the MPDUs.
Definition: wifi-psdu.cc:128
bool HasNav() const
Definition: wifi-psdu.cc:143
Mac48Address GetAddr1() const
Get the Receiver Address (RA), which is common to all the MPDUs.
Definition: wifi-psdu.cc:113
std::size_t GetNMpdus() const
Return the number of MPDUs constituting the PSDU.
Definition: wifi-psdu.cc:327
void ReportDataFailed(Ptr< const WifiMpdu > mpdu)
Should be invoked whenever the AckTimeout associated to a transmission attempt expires.
WifiTxVector GetAckTxVector(Mac48Address to, const WifiTxVector &dataTxVector) const
Return a TXVECTOR for the Ack frame given the destination and the mode of the Data used by the sender...
void ReportFinalDataFailed(Ptr< const WifiMpdu > mpdu)
Should be invoked after calling ReportDataFailed if NeedRetransmission returns false.
void ReportRtsOk(const WifiMacHeader &header, double ctsSnr, WifiMode ctsMode, double rtsSnr)
Should be invoked whenever we receive the CTS associated to an RTS we just sent.
void ReportRxOk(Mac48Address address, RxSignalInfo rxSignalInfo, WifiTxVector txVector)
void ReportFinalRtsFailed(const WifiMacHeader &header)
Should be invoked after calling ReportRtsFailed if NeedRetransmission returns false.
WifiTxVector GetCtsTxVector(Mac48Address to, WifiMode rtsTxMode) const
Return a TXVECTOR for the CTS frame given the destination and the mode of the RTS used by the sender.
WifiTxVector GetDataTxVector(const WifiMacHeader &header, uint16_t allowedWidth)
void ReportDataOk(Ptr< const WifiMpdu > mpdu, double ackSnr, WifiMode ackMode, double dataSnr, WifiTxVector dataTxVector)
Should be invoked whenever we receive the ACK associated to a data packet we just sent.
void ReportRtsFailed(const WifiMacHeader &header)
Should be invoked whenever the RtsTimeout associated to a transmission attempt expires.
This class stores the TX parameters (TX vector, protection mechanism, acknowledgment mechanism,...
const PsduInfoMap & GetPsduInfoMap() const
Get a const reference to the map containing information about PSDUs.
std::unique_ptr< WifiProtection > m_protection
protection method
uint32_t GetSize(Mac48Address receiver) const
Get the size in bytes of the (A-)MPDU addressed to the given receiver.
std::unique_ptr< WifiAcknowledgment > m_acknowledgment
acknowledgment method
Time m_txDuration
TX duration of the frame.
WifiTxVector m_txVector
TXVECTOR of the frame being prepared.
void AddMpdu(Ptr< const WifiMpdu > mpdu)
Record that an MPDU is being added to the current frame.
void Clear()
Reset the TX parameters.
This class is used to handle the timer that a station starts when transmitting a frame that solicits ...
Definition: wifi-tx-timer.h:49
bool IsRunning() const
Return true if the timer is running.
void Cancel()
Cancel the timer.
void Set(Reason reason, const Time &delay, MEM mem_ptr, OBJ obj, Args... args)
This method is called when a frame soliciting a response is transmitted.
Reason GetReason() const
Get the reason why the timer was started.
void Reschedule(const Time &delay)
Reschedule the timer to time out the given amount of time from the moment this function is called.
This class mimics the TXVECTOR which is to be passed to the PHY in order to define the parameters whi...
WifiMode GetMode(uint16_t staId=SU_STA_ID) const
If this TX vector is associated with an SU PPDU, return the selected payload transmission mode.
#define PSDU_DURATION_SAFEGUARD
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:66
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:86
Callback< R, Args... > MakeNullCallback()
Definition: callback.h:750
#define NS_ABORT_MSG(msg)
Unconditional abnormal program termination with a message.
Definition: abort.h:49
#define NS_ABORT_MSG_IF(cond, msg)
Abnormal program termination if a condition is true, with a message.
Definition: abort.h:108
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:268
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:46
Time NanoSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1372
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1336
address
Definition: first.py:40
Every class exported by the ns3 library is enclosed in the ns3 namespace.
U * PeekPointer(const Ptr< U > &p)
Definition: ptr.h:488
static const uint16_t WIFI_MAC_FCS_LENGTH
The length in octets of the IEEE 802.11 MAC FCS field.
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:707
uint32_t GetRtsSize()
Return the total RTS size (including FCS trailer).
Definition: wifi-utils.cc:103
@ WIFI_MAC_CTL_RTS
@ WIFI_MAC_CTL_CTS
@ WIFI_MAC_CTL_ACK
uint32_t GetAckSize()
Return the total Ack size (including FCS trailer).
Definition: wifi-utils.cc:58
uint32_t GetCtsSize()
Return the total CTS size (including FCS trailer).
Definition: wifi-utils.cc:111
@ WIFI_MAC_DROP_REACHED_RETRY_LIMIT
Definition: wifi-mac.h:78
mac
Definition: third.py:85
phy
Definition: third.py:82
ns3::Time timeout
RxSignalInfo structure containing info on the received signal.
Definition: phy-entity.h:70
double snr
SNR in linear scale.
Definition: phy-entity.h:71
WifiAcknowledgment is an abstract base struct.
Time acknowledgmentTime
time required by the acknowledgment method
const Method method
acknowledgment method
WifiCtsToSelfProtection specifies that CTS-to-self protection method is used.
WifiTxVector ctsTxVector
CTS TXVECTOR.
WifiNormalAck specifies that acknowledgment via Normal Ack is required.
WifiTxVector ackTxVector
Ack TXVECTOR.
WifiProtection is an abstract base struct.
Time protectionTime
time required by the protection method
const Method method
protection method
WifiRtsCtsProtection specifies that RTS/CTS protection method is used.
WifiTxVector ctsTxVector
CTS TXVECTOR.
WifiTxVector rtsTxVector
RTS TXVECTOR.