A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
sta-wifi-mac.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2006, 2009 INRIA
3 * Copyright (c) 2009 MIRKO BANCHI
4 *
5 * SPDX-License-Identifier: GPL-2.0-only
6 *
7 * Authors: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
8 * Mirko Banchi <mk.banchi@gmail.com>
9 */
10
11#ifndef STA_WIFI_MAC_H
12#define STA_WIFI_MAC_H
13
14#include "wifi-mac.h"
15
16#include "ns3/eht-configuration.h"
17
18#include <set>
19#include <variant>
20
23class ProbeExchTest;
24
25namespace ns3
26{
27
28class SupportedRates;
32class EmlsrManager;
33
34/**
35 * @ingroup wifi
36 *
37 * Type of association performed by this device (provided that it is supported by the standard
38 * configured for this device).
39 */
40enum class WifiAssocType : uint8_t
41{
42 LEGACY = 0,
44};
45
46/**
47 * @ingroup wifi
48 *
49 * Scan type (active or passive)
50 */
51enum class WifiScanType : uint8_t
52{
53 ACTIVE = 0,
55};
56
57/**
58 * @ingroup wifi
59 *
60 * Structure holding scan parameters
61 */
63{
64 /**
65 * Struct identifying a channel to scan.
66 * A channel number equal to zero indicates to scan all the channels;
67 * an unspecified band (WIFI_PHY_BAND_UNSPECIFIED) indicates to scan
68 * all the supported PHY bands.
69 */
70 struct Channel
71 {
72 uint16_t number{0}; ///< channel number
74 };
75
76 /// typedef for a list of channels
77 using ChannelList = std::list<Channel>;
78
79 WifiScanType type; ///< indicates either active or passive scanning
80 Ssid ssid; ///< desired SSID or wildcard SSID
81 std::vector<ChannelList> channelList; ///< list of channels to scan, for each link
82 Time probeDelay; ///< delay prior to transmitting a Probe Request
83 Time minChannelTime; ///< minimum time to spend on each channel
84 Time maxChannelTime; ///< maximum time to spend on each channel
85};
86
87/**
88 * @ingroup wifi
89 *
90 * Enumeration for power management modes
91 */
99
100/**
101 * @ingroup wifi
102 *
103 * The Wifi MAC high model for a non-AP STA in a BSS. The state
104 * machine is as follows:
105 *
106 \verbatim
107 ┌───────────┐ ┌────────────────┐ ┌─────────────┐
108 │ Start │ ┌─────┤ Associated ◄───────────────────┐ ┌──► Refused │
109 └─┬─────────┘ │ └────────────────┘ │ │ └─────────────┘
110 │ │ │ │
111 │ │ ┌─────────────────────────────────────┐ │ │
112 │ │ │ │ │ │
113 │ ┌─────────────▼─▼──┐ ┌──────────────┐ ┌───┴──▼────┴───────────────────┐
114 └──► Unassociated ├───────► Scanning ├───────► Wait Association Response │
115 └──────────────────┘ └──────┬──▲────┘ └───────────────┬──▲────────────┘
116 │ │ │ │
117 │ │ │ │
118 └──┘ └──┘
119 \endverbatim
120 *
121 * Notes:
122 * 1. The state 'Start' is not included in #MacState and only used
123 * for illustration purpose.
124 * 2. The Unassociated state is a transient state before STA starts the
125 * scanning procedure which moves it into the Scanning state.
126 * 3. In Scanning, STA is gathering beacon or probe response frames from APs,
127 * resulted in a list of candidate AP. After the timeout, it then tries to
128 * associate to the best AP, which is indicated by the Association Manager.
129 * STA will restart the scanning procedure if SetActiveProbing() called.
130 * 4. In the case when AP responded to STA's association request with a
131 * refusal, STA will try to associate to the next best AP until the list
132 * of candidate AP is exhausted which sends STA to Refused state.
133 * - Note that this behavior is not currently tested since ns-3 does not
134 * implement association refusal at present.
135 * 5. The transition from Wait Association Response to Unassociated
136 * occurs if an association request fails without explicit
137 * refusal (i.e., the AP fails to respond).
138 * 6. The transition from Associated to Wait Association Response
139 * occurs when STA's PHY capabilities changed. In this state, STA
140 * tries to reassociate with the previously associated AP.
141 * 7. The transition from Associated to Unassociated occurs if the number
142 * of missed beacons exceeds the threshold.
143 */
144class StaWifiMac : public WifiMac
145{
146 public:
147 /// Allow test cases to access private members
148 friend class ::AmpduAggregationTest;
149 friend class ::MultiLinkOperationsTestBase;
150 friend class ::ProbeExchTest;
152
153 /**
154 * Struct to hold information regarding observed AP through
155 * active/passive scanning
156 */
157 struct ApInfo
158 {
159 /**
160 * Information about links to setup
161 */
163 {
164 uint8_t localLinkId; ///< local link ID
165 uint8_t apLinkId; ///< AP link ID
166 Mac48Address bssid; ///< BSSID
167 };
168
170 Mac48Address m_apAddr; ///< AP MAC address
171 double m_snr; ///< SNR in linear scale
172 MgtFrameType m_frame; ///< The body of the management frame used to update AP info
173 WifiScanParams::Channel m_channel; ///< The channel the management frame was received on
174 uint8_t m_linkId; ///< ID of the link used to communicate with the AP
175 std::list<SetupLinksInfo>
176 m_setupLinks; ///< information about the links to setup between MLDs
177 };
178
179 /**
180 * @brief Get the type ID.
181 * @return the object TypeId
182 */
183 static TypeId GetTypeId();
184
185 StaWifiMac();
186 ~StaWifiMac() override;
187
188 bool CanForwardPacketsTo(Mac48Address to) const override;
189 int64_t AssignStreams(int64_t stream) override;
190
191 /**
192 * @param phys the physical layers attached to this MAC.
193 */
194 void SetWifiPhys(const std::vector<Ptr<WifiPhy>>& phys) override;
195
196 /**
197 * Set the Association Manager.
198 *
199 * @param assocManager the Association Manager
200 */
201 void SetAssocManager(Ptr<WifiAssocManager> assocManager);
202
203 /**
204 * Set the EMLSR Manager.
205 *
206 * @param emlsrManager the EMLSR Manager
207 */
208 void SetEmlsrManager(Ptr<EmlsrManager> emlsrManager);
209
210 /**
211 * @return the EMLSR Manager
212 */
214
215 /**
216 * Get the frame body of the Probe Request to transmit on the given link.
217 *
218 * @param linkId the ID of the given link
219 * @return the Probe Request frame body
220 */
221 MgtProbeRequestHeader GetProbeRequest(uint8_t linkId) const;
222
223 /**
224 * Get the frame body of the Multi-Link Probe Request to transmit on the given link.
225 *
226 * @param linkId the ID of the given link
227 * @param apLinkIds ID of the links on which the requested APs, affiliated with the
228 * AP MLD, operate
229 * @param apMldId the AP MLD ID to include in the Common Info field
230 * @return the Multi-Link Probe Request frame body
231 */
233 const std::vector<uint8_t>& apLinkIds,
234 std::optional<uint8_t> apMldId) const;
235
236 /**
237 * Enqueue the given probe request packet for transmission on the given link.
238 *
239 * @param probeReq the given Probe Request frame body
240 * @param linkId the ID of the given link
241 * @param addr1 the MAC address for the Address1 field
242 * @param addr3 the MAC address for the Address3 field
243 */
244 void EnqueueProbeRequest(const MgtProbeRequestHeader& probeReq,
245 uint8_t linkId,
248
249 /**
250 * This method is called after wait beacon timeout or wait probe request timeout has
251 * occurred. This will trigger association process from beacons or probe responses
252 * gathered while scanning.
253 *
254 * @param bestAp the info about the best AP to associate with, if one was found
255 */
256 void ScanningTimeout(const std::optional<ApInfo>& bestAp);
257
258 /**
259 * Return whether we are associated with an AP.
260 *
261 * @return true if we are associated with an AP, false otherwise
262 */
263 bool IsAssociated() const;
264
265 /**
266 * Get the IDs of the setup links (if any).
267 *
268 * @return the IDs of the setup links
269 */
270 std::set<uint8_t> GetSetupLinkIds() const;
271
272 /**
273 * Return the association ID.
274 *
275 * @return the association ID
276 */
277 uint16_t GetAssociationId() const;
278
279 /// @return the type of association procedure performed by this device
281
282 /**
283 * Enable or disable Power Save mode on the given link.
284 *
285 * @param enableLinkIdPair a pair indicating whether to enable or not power save mode on
286 * the link with the given ID
287 */
288 void SetPowerSaveMode(const std::pair<bool, uint8_t>& enableLinkIdPair);
289
290 /**
291 * @param linkId the ID of the given link
292 * @return the current Power Management mode of the STA operating on the given link
293 */
294 WifiPowerManagementMode GetPmMode(uint8_t linkId) const;
295
296 /**
297 * Set the Power Management mode of the setup links after association.
298 *
299 * @param linkId the ID of the link used to establish association
300 */
301 void SetPmModeAfterAssociation(uint8_t linkId);
302
303 /**
304 * Notify that the MPDU we sent was successfully received by the receiver
305 * (i.e. we received an Ack from the receiver).
306 *
307 * @param mpdu the MPDU that we successfully sent
308 */
309 void TxOk(Ptr<const WifiMpdu> mpdu);
310
311 void NotifyChannelSwitching(uint8_t linkId) override;
312
313 /**
314 * Notify the MAC that EMLSR mode has changed on the given set of links.
315 *
316 * @param linkIds the IDs of the links that are now EMLSR links (EMLSR mode is disabled
317 * on other links)
318 */
319 void NotifyEmlsrModeChanged(const std::set<uint8_t>& linkIds);
320
321 /**
322 * @param linkId the ID of the given link
323 * @return whether the EMLSR mode is enabled on the given link
324 */
325 bool IsEmlsrLink(uint8_t linkId) const;
326
327 /**
328 * Notify that the given PHY switched channel to operate on another EMLSR link.
329 *
330 * @param phy the given PHY
331 * @param linkId the ID of the EMLSR link on which the given PHY operates after
332 * the channel switch
333 * @param delay the delay after which the channel switch will be completed
334 */
335 void NotifySwitchingEmlsrLink(Ptr<WifiPhy> phy, uint8_t linkId, Time delay);
336
337 /**
338 * Cancel any scheduled event for connecting the given PHY to an EMLSR link.
339 *
340 * @param phyId the ID of the given PHY
341 */
342 void CancelEmlsrPhyConnectEvent(uint8_t phyId);
343
344 /**
345 * Block transmissions on the given link for the given reason.
346 *
347 * @param linkId the ID of the given link
348 * @param reason the reason for blocking transmissions on the given link
349 */
350 void BlockTxOnLink(uint8_t linkId, WifiQueueBlockedReason reason);
351
352 /**
353 * Unblock transmissions on the given links for the given reason.
354 *
355 * @param linkIds the IDs of the given links
356 * @param reason the reason for unblocking transmissions on the given links
357 */
358 void UnblockTxOnLink(std::set<uint8_t> linkIds, WifiQueueBlockedReason reason);
359
360 protected:
361 /**
362 * Structure holding information specific to a single link. Here, the meaning of
363 * "link" is that of the 11be amendment which introduced multi-link devices. For
364 * previous amendments, only one link can be created.
365 */
367 {
368 /// Destructor (a virtual method is needed to make this struct polymorphic)
369 ~StaLinkEntity() override;
370
371 bool sendAssocReq; //!< whether this link is used to send the
372 //!< Association Request frame
373 std::optional<Mac48Address> bssid; //!< BSSID of the AP to associate with over this link
374 WifiPowerManagementMode pmMode{WIFI_PM_ACTIVE}; /**< the current PM mode, if the STA is
375 associated, or the PM mode to switch
376 to upon association, otherwise */
377 bool emlsrEnabled{false}; //!< whether EMLSR mode is enabled on this link
378 };
379
380 /**
381 * Get a reference to the link associated with the given ID.
382 *
383 * @param linkId the given link ID
384 * @return a reference to the link associated with the given ID
385 */
386 StaLinkEntity& GetLink(uint8_t linkId) const;
387
388 /**
389 * Cast the given LinkEntity object to StaLinkEntity.
390 *
391 * @param link the given LinkEntity object
392 * @return a reference to the object casted to StaLinkEntity
393 */
394 StaLinkEntity& GetStaLink(const std::unique_ptr<WifiMac::LinkEntity>& link) const;
395
396 public:
397 /**
398 * The current MAC state of the STA.
399 */
408
409 private:
410 void DoCompleteConfig() override;
411
412 /**
413 * Enable or disable active probing.
414 *
415 * @param enable enable or disable active probing
416 */
417 void SetActiveProbing(bool enable);
418 /**
419 * Return whether active probing is enabled.
420 *
421 * @return true if active probing is enabled, false otherwise
422 */
423 bool GetActiveProbing() const;
424
425 /**
426 * Determine whether the supported rates indicated in a given Beacon frame or
427 * Probe Response frame fit with the configured membership selector.
428 *
429 * @param frame the given Beacon or Probe Response frame
430 * @param linkId ID of the link the mgt frame was received over
431 * @return whether the the supported rates indicated in the given management
432 * frame fit with the configured membership selector
433 */
434 bool CheckSupportedRates(std::variant<MgtBeaconHeader, MgtProbeResponseHeader> frame,
435 uint8_t linkId);
436
437 void Receive(Ptr<const WifiMpdu> mpdu, uint8_t linkId) override;
438 std::unique_ptr<LinkEntity> CreateLinkEntity() const override;
439 Mac48Address DoGetLocalAddress(const Mac48Address& remoteAddr) const override;
440 void Enqueue(Ptr<WifiMpdu> mpdu, Mac48Address to, Mac48Address from) override;
441 void NotifyDropPacketToEnqueue(Ptr<Packet> packet, Mac48Address to) override;
442
443 /**
444 * Process the Beacon frame received on the given link.
445 *
446 * @param mpdu the MPDU containing the Beacon frame
447 * @param linkId the ID of the given link
448 */
449 void ReceiveBeacon(Ptr<const WifiMpdu> mpdu, uint8_t linkId);
450
451 /**
452 * Process the Probe Response frame received on the given link.
453 *
454 * @param mpdu the MPDU containing the Probe Response frame
455 * @param linkId the ID of the given link
456 */
457 void ReceiveProbeResp(Ptr<const WifiMpdu> mpdu, uint8_t linkId);
458
459 /**
460 * Process the (Re)Association Response frame received on the given link.
461 *
462 * @param mpdu the MPDU containing the (Re)Association Response frame
463 * @param linkId the ID of the given link
464 */
465 void ReceiveAssocResp(Ptr<const WifiMpdu> mpdu, uint8_t linkId);
466
467 /**
468 * Update operations information from the given management frame.
469 *
470 * @param frame the body of the given management frame
471 * @param addr MAC address of the sender
472 * @param linkId ID of the link the management frame was received over
473 */
474 void RecordOperations(const MgtFrameType& frame, const Mac48Address& addr, uint8_t linkId);
475
476 /**
477 * Update operational settings based on associated AP's information provided by the given
478 * management frame (Beacon, Probe Response or Association Response).
479 *
480 * @param frame the body of the given management frame
481 * @param apAddr MAC address of the AP
482 * @param bssid MAC address of BSSID
483 * @param linkId ID of the link the management frame was received over
484 */
485 void ApplyOperationalSettings(const MgtFrameType& frame,
486 const Mac48Address& apAddr,
487 const Mac48Address& bssid,
488 uint8_t linkId);
489
490 /**
491 * Get the (Re)Association Request frame to send on a given link. The returned frame
492 * never includes a Multi-Link Element.
493 *
494 * @param isReassoc whether a Reassociation Request has to be returned
495 * @param linkId the ID of the given link
496 * @return the (Re)Association Request frame
497 */
498 std::variant<MgtAssocRequestHeader, MgtReassocRequestHeader> GetAssociationRequest(
499 bool isReassoc,
500 uint8_t linkId) const;
501
502 /**
503 * Forward an association or reassociation request packet to the DCF.
504 * The standard is not clear on the correct queue for management frames if QoS is supported.
505 * We always use the DCF.
506 *
507 * @param isReassoc flag whether it is a reassociation request
508 *
509 */
510 void SendAssociationRequest(bool isReassoc);
511 /**
512 * Try to ensure that we are associated with an AP by taking an appropriate action
513 * depending on the current association status.
514 */
516 /**
517 * This method is called after the association timeout occurred. We switch the state to
518 * WAIT_ASSOC_RESP and re-send an association request.
519 */
520 void AssocRequestTimeout();
521 /**
522 * Start the scanning process which trigger active or passive scanning based on the
523 * active probing flag.
524 */
525 void StartScanning();
526 /**
527 * Return whether we are waiting for an association response from an AP.
528 *
529 * @return true if we are waiting for an association response from an AP, false otherwise
530 */
531 bool IsWaitAssocResp() const;
532
533 /**
534 * This method is called after we have not received a beacon from the AP on any link.
535 */
536 void MissedBeacons();
537 /**
538 * Restarts the beacon timer.
539 *
540 * @param delay the delay before the watchdog fires
541 */
542 void RestartBeaconWatchdog(Time delay);
543 /**
544 * Set the state to unassociated and try to associate again.
545 */
546 void Disassociated();
547 /**
548 * Return an instance of SupportedRates that contains all rates that we support
549 * including HT rates.
550 *
551 * @param linkId the ID of the link for which the request is made
552 * @return SupportedRates all rates that we support
553 */
554 AllSupportedRates GetSupportedRates(uint8_t linkId) const;
555 /**
556 * Return the Basic Multi-Link Element to include in the management frames transmitted
557 * on the given link
558 *
559 * @param isReassoc whether the Basic Multi-Link Element is included in a Reassociation Request
560 * @param linkId the ID of the given link
561 * @return the Basic Multi-Link Element
562 */
563 MultiLinkElement GetBasicMultiLinkElement(bool isReassoc, uint8_t linkId) const;
564
565 /**
566 * Return the Probe Request Multi-Link Element to include in the management frames to transmit.
567 *
568 * @param apLinkIds ID of the links on which the requested APs operate
569 * @param apMldId the AP MLD ID to include in the Common Info field
570 * @return the Probe Request Multi-Link Element
571 */
572 MultiLinkElement GetProbeReqMultiLinkElement(const std::vector<uint8_t>& apLinkIds,
573 std::optional<uint8_t> apMldId) const;
574
575 /**
576 * @param apNegSupport the negotiation type supported by the AP MLD
577 * @return the TID-to-Link Mapping element(s) to include in Association Request frame.
578 */
579 std::vector<TidToLinkMapping> GetTidToLinkMappingElements(
580 WifiTidToLinkMappingNegSupport apNegSupport);
581
582 /**
583 * Set the current MAC state.
584 *
585 * @param value the new state
586 */
587 void SetState(MacState value);
588
589 /**
590 * EDCA Parameters
591 */
593 {
594 AcIndex ac; //!< the access category
595 uint32_t cwMin; //!< the minimum contention window size
596 uint32_t cwMax; //!< the maximum contention window size
597 uint8_t aifsn; //!< the number of slots that make up an AIFS
598 Time txopLimit; //!< the TXOP limit
599 };
600
601 /**
602 * Set the EDCA parameters for the given link.
603 *
604 * @param params the EDCA parameters
605 * @param linkId the ID of the given link
606 */
607 void SetEdcaParameters(const EdcaParams& params, uint8_t linkId);
608
609 /**
610 * MU EDCA Parameters
611 */
613 {
614 AcIndex ac; //!< the access category
615 uint32_t cwMin; //!< the minimum contention window size
616 uint32_t cwMax; //!< the maximum contention window size
617 uint8_t aifsn; //!< the number of slots that make up an AIFS
618 Time muEdcaTimer; //!< the MU EDCA timer
619 };
620
621 /**
622 * Set the MU EDCA parameters for the given link.
623 *
624 * @param params the MU EDCA parameters
625 * @param linkId the ID of the given link
626 */
627 void SetMuEdcaParameters(const MuEdcaParams& params, uint8_t linkId);
628
629 /**
630 * Return the Capability information for the given link.
631 *
632 * @param linkId the ID of the given link
633 * @return the Capability information that we support
634 */
635 CapabilityInformation GetCapabilities(uint8_t linkId) const;
636
637 /**
638 * Indicate that PHY capabilities have changed.
639 */
641
642 /**
643 * Get the current primary20 channel used on the given link as a
644 * (channel number, PHY band) pair.
645 *
646 * @param linkId the ID of the given link
647 * @return a (channel number, PHY band) pair
648 */
649 WifiScanParams::Channel GetCurrentChannel(uint8_t linkId) const;
650
651 void DoInitialize() override;
652 void DoDispose() override;
653
654 MacState m_state; ///< MAC state
655 uint16_t m_aid; ///< Association AID
656 Ptr<WifiAssocManager> m_assocManager; ///< Association Manager
657 WifiAssocType m_assocType; ///< type of association
659 Time m_waitBeaconTimeout; ///< wait beacon timeout
660 Time m_probeRequestTimeout; ///< probe request timeout
661 Time m_assocRequestTimeout; ///< association request timeout
662 EventId m_assocRequestEvent; ///< association request event
663 uint32_t m_maxMissedBeacons; ///< maximum missed beacons
664 EventId m_beaconWatchdog; //!< beacon watchdog
665 Time m_beaconWatchdogEnd{0}; //!< beacon watchdog end
666 bool m_enableScanning; //!< enable channel scanning
667 bool m_activeProbing; ///< active probing
668 Ptr<RandomVariableStream> m_probeDelay; ///< RandomVariable used to randomize the time
669 ///< of the first Probe Response on each channel
670 Time m_pmModeSwitchTimeout; ///< PM mode switch timeout
671 std::map<uint8_t, EventId> m_emlsrLinkSwitch; ///< maps PHY ID to the event scheduled to switch
672 ///< the corresponding PHY to a new EMLSR link
673
674 /// store the DL TID-to-Link Mapping included in the Association Request frame
676 /// store the UL TID-to-Link Mapping included in the Association Request frame
678
682 TracedCallback<Time> m_beaconArrival; ///< beacon arrival logger
683 TracedCallback<ApInfo> m_beaconInfo; ///< beacon info logger
685 m_emlsrLinkSwitchLogger; ///< EMLSR link switch logger
686
687 /// TracedCallback signature for link setup completed/canceled events
688 using LinkSetupCallback = void (*)(uint8_t /* link ID */, Mac48Address /* AP address */);
689
690 /// TracedCallback signature for EMLSR link switch events
691 using EmlsrLinkSwitchCallback = void (*)(uint8_t /* link ID */, Ptr<WifiPhy> /* PHY */);
692};
693
694/**
695 * @brief Stream insertion operator.
696 *
697 * @param os the output stream
698 * @param apInfo the AP information
699 * @returns a reference to the stream
700 */
701std::ostream& operator<<(std::ostream& os, const StaWifiMac::ApInfo& apInfo);
702
703} // namespace ns3
704
705#endif /* STA_WIFI_MAC_H */
Ampdu Aggregation Test.
Probe Request-Probe Response exchange.
EmlsrManager is an abstract base class defining the API that EHT non-AP MLDs with EMLSR activated can...
An identifier for simulation events.
Definition event-id.h:44
an EUI-48 address
static Mac48Address GetBroadcast()
Implement the header for management frames of type probe request.
Smart pointer class similar to boost::intrusive_ptr.
Definition ptr.h:67
The basic uniform Random Number Generator (RNG).
The IEEE 802.11 SSID Information Element.
Definition ssid.h:25
std::set< uint8_t > GetSetupLinkIds() const
Get the IDs of the setup links (if any).
void ScanningTimeout(const std::optional< ApInfo > &bestAp)
This method is called after wait beacon timeout or wait probe request timeout has occurred.
Time m_waitBeaconTimeout
wait beacon timeout
int64_t AssignStreams(int64_t stream) override
Assign a fixed random variable stream number to the random variables used by this model.
void SetPowerSaveMode(const std::pair< bool, uint8_t > &enableLinkIdPair)
Enable or disable Power Save mode on the given link.
Ptr< WifiAssocManager > m_assocManager
Association Manager.
void DoCompleteConfig() override
Allow subclasses to complete the configuration of the MAC layer components.
bool m_activeProbing
active probing
void DoInitialize() override
Initialize() implementation.
void SetAssocManager(Ptr< WifiAssocManager > assocManager)
Set the Association Manager.
bool CanForwardPacketsTo(Mac48Address to) const override
Return true if packets can be forwarded to the given destination, false otherwise.
std::unique_ptr< LinkEntity > CreateLinkEntity() const override
Create a LinkEntity object.
void SetState(MacState value)
Set the current MAC state.
Time m_beaconWatchdogEnd
beacon watchdog end
bool m_enableScanning
enable channel scanning
AllSupportedRates GetSupportedRates(uint8_t linkId) const
Return an instance of SupportedRates that contains all rates that we support including HT rates.
void SetEdcaParameters(const EdcaParams &params, uint8_t linkId)
Set the EDCA parameters for the given link.
TracedCallback< Mac48Address > m_deAssocLogger
disassociation logger
MacState
The current MAC state of the STA.
void NotifyChannelSwitching(uint8_t linkId) override
Notify that channel on the given link has been switched.
bool GetActiveProbing() const
Return whether active probing is enabled.
EventId m_beaconWatchdog
beacon watchdog
void PhyCapabilitiesChanged()
Indicate that PHY capabilities have changed.
WifiAssocType m_assocType
type of association
StaLinkEntity & GetStaLink(const std::unique_ptr< WifiMac::LinkEntity > &link) const
Cast the given LinkEntity object to StaLinkEntity.
void ReceiveProbeResp(Ptr< const WifiMpdu > mpdu, uint8_t linkId)
Process the Probe Response frame received on the given link.
void SetPmModeAfterAssociation(uint8_t linkId)
Set the Power Management mode of the setup links after association.
WifiScanParams::Channel GetCurrentChannel(uint8_t linkId) const
Get the current primary20 channel used on the given link as a (channel number, PHY band) pair.
uint16_t GetAssociationId() const
Return the association ID.
void TryToEnsureAssociated()
Try to ensure that we are associated with an AP by taking an appropriate action depending on the curr...
void ReceiveAssocResp(Ptr< const WifiMpdu > mpdu, uint8_t linkId)
Process the (Re)Association Response frame received on the given link.
void NotifySwitchingEmlsrLink(Ptr< WifiPhy > phy, uint8_t linkId, Time delay)
Notify that the given PHY switched channel to operate on another EMLSR link.
std::variant< MgtAssocRequestHeader, MgtReassocRequestHeader > GetAssociationRequest(bool isReassoc, uint8_t linkId) const
Get the (Re)Association Request frame to send on a given link.
static TypeId GetTypeId()
Get the type ID.
MultiLinkElement GetBasicMultiLinkElement(bool isReassoc, uint8_t linkId) const
Return the Basic Multi-Link Element to include in the management frames transmitted on the given link...
void CancelEmlsrPhyConnectEvent(uint8_t phyId)
Cancel any scheduled event for connecting the given PHY to an EMLSR link.
void(*)(uint8_t, Mac48Address) LinkSetupCallback
TracedCallback signature for link setup completed/canceled events.
void DoDispose() override
Destructor implementation.
void BlockTxOnLink(uint8_t linkId, WifiQueueBlockedReason reason)
Block transmissions on the given link for the given reason.
std::map< uint8_t, EventId > m_emlsrLinkSwitch
maps PHY ID to the event scheduled to switch the corresponding PHY to a new EMLSR link
void RecordOperations(const MgtFrameType &frame, const Mac48Address &addr, uint8_t linkId)
Update operations information from the given management frame.
StaLinkEntity & GetLink(uint8_t linkId) const
Get a reference to the link associated with the given ID.
uint32_t m_maxMissedBeacons
maximum missed beacons
TracedCallback< uint8_t, Mac48Address > m_setupCompleted
link setup completed logger
TracedCallback< Mac48Address > m_assocLogger
association logger
void SetWifiPhys(const std::vector< Ptr< WifiPhy > > &phys) override
void SetMuEdcaParameters(const MuEdcaParams &params, uint8_t linkId)
Set the MU EDCA parameters for the given link.
void NotifyEmlsrModeChanged(const std::set< uint8_t > &linkIds)
Notify the MAC that EMLSR mode has changed on the given set of links.
bool CheckSupportedRates(std::variant< MgtBeaconHeader, MgtProbeResponseHeader > frame, uint8_t linkId)
Determine whether the supported rates indicated in a given Beacon frame or Probe Response frame fit w...
Mac48Address DoGetLocalAddress(const Mac48Address &remoteAddr) const override
This method is called if this device is an MLD to determine the MAC address of the affiliated STA use...
void RestartBeaconWatchdog(Time delay)
Restarts the beacon timer.
friend class WifiStaticSetupHelper
void SetEmlsrManager(Ptr< EmlsrManager > emlsrManager)
Set the EMLSR Manager.
void NotifyDropPacketToEnqueue(Ptr< Packet > packet, Mac48Address to) override
Allow subclasses to take actions when a packet to enqueue has been dropped.
Time m_pmModeSwitchTimeout
PM mode switch timeout.
void Disassociated()
Set the state to unassociated and try to associate again.
Ptr< EmlsrManager > GetEmlsrManager() const
void TxOk(Ptr< const WifiMpdu > mpdu)
Notify that the MPDU we sent was successfully received by the receiver (i.e.
MgtProbeRequestHeader GetProbeRequest(uint8_t linkId) const
Get the frame body of the Probe Request to transmit on the given link.
MgtProbeRequestHeader GetMultiLinkProbeRequest(uint8_t linkId, const std::vector< uint8_t > &apLinkIds, std::optional< uint8_t > apMldId) const
Get the frame body of the Multi-Link Probe Request to transmit on the given link.
void Receive(Ptr< const WifiMpdu > mpdu, uint8_t linkId) override
This method acts as the MacRxMiddle receive callback and is invoked to notify us that a frame has bee...
WifiTidLinkMapping m_ulTidLinkMappingInAssocReq
store the UL TID-to-Link Mapping included in the Association Request frame
WifiPowerManagementMode GetPmMode(uint8_t linkId) const
Ptr< RandomVariableStream > m_probeDelay
RandomVariable used to randomize the time of the first Probe Response on each channel.
TracedCallback< ApInfo > m_beaconInfo
beacon info logger
void MissedBeacons()
This method is called after we have not received a beacon from the AP on any link.
uint16_t m_aid
Association AID.
void(*)(uint8_t, Ptr< WifiPhy >) EmlsrLinkSwitchCallback
TracedCallback signature for EMLSR link switch events.
MacState m_state
MAC state.
bool IsEmlsrLink(uint8_t linkId) const
WifiAssocType GetAssocType() const
void StartScanning()
Start the scanning process which trigger active or passive scanning based on the active probing flag.
std::vector< TidToLinkMapping > GetTidToLinkMappingElements(WifiTidToLinkMappingNegSupport apNegSupport)
TracedCallback< Time > m_beaconArrival
beacon arrival logger
void UnblockTxOnLink(std::set< uint8_t > linkIds, WifiQueueBlockedReason reason)
Unblock transmissions on the given links for the given reason.
void AssocRequestTimeout()
This method is called after the association timeout occurred.
void Enqueue(Ptr< WifiMpdu > mpdu, Mac48Address to, Mac48Address from) override
Ptr< EmlsrManager > m_emlsrManager
EMLSR Manager.
void ApplyOperationalSettings(const MgtFrameType &frame, const Mac48Address &apAddr, const Mac48Address &bssid, uint8_t linkId)
Update operational settings based on associated AP's information provided by the given management fra...
Time m_assocRequestTimeout
association request timeout
void ReceiveBeacon(Ptr< const WifiMpdu > mpdu, uint8_t linkId)
Process the Beacon frame received on the given link.
Time m_probeRequestTimeout
probe request timeout
void SetActiveProbing(bool enable)
Enable or disable active probing.
CapabilityInformation GetCapabilities(uint8_t linkId) const
Return the Capability information for the given link.
bool IsAssociated() const
Return whether we are associated with an AP.
~StaWifiMac() override
bool IsWaitAssocResp() const
Return whether we are waiting for an association response from an AP.
MultiLinkElement GetProbeReqMultiLinkElement(const std::vector< uint8_t > &apLinkIds, std::optional< uint8_t > apMldId) const
Return the Probe Request Multi-Link Element to include in the management frames to transmit.
EventId m_assocRequestEvent
association request event
void EnqueueProbeRequest(const MgtProbeRequestHeader &probeReq, uint8_t linkId, const Mac48Address &addr1=Mac48Address::GetBroadcast(), const Mac48Address &addr3=Mac48Address::GetBroadcast())
Enqueue the given probe request packet for transmission on the given link.
void SendAssociationRequest(bool isReassoc)
Forward an association or reassociation request packet to the DCF.
TracedCallback< uint8_t, Ptr< WifiPhy >, bool > m_emlsrLinkSwitchLogger
EMLSR link switch logger.
WifiTidLinkMapping m_dlTidLinkMappingInAssocReq
store the DL TID-to-Link Mapping included in the Association Request frame
The Supported Rates Information Element.
Simulation virtual time values and global simulation resolution.
Definition nstime.h:96
Forward calls to a chain of Callback.
a unique identifier for an interface.
Definition type-id.h:49
Abstract base class for the Association Manager, which manages scanning and association for single li...
std::variant< MgtBeaconHeader, MgtProbeResponseHeader, MgtAssocResponseHeader > MgtFrameType
type of the management frames
Definition wifi-mac.h:108
WifiScanType
Scan type (active or passive)
WifiPowerManagementMode
Enumeration for power management modes.
WifiPhyBand
Identifies the PHY band.
WifiQueueBlockedReason
Enumeration of the reasons to block container queues.
AcIndex
This enumeration defines the Access Categories as an enumeration with values corresponding to the AC ...
Definition qos-utils.h:63
WifiAssocType
Type of association performed by this device (provided that it is supported by the standard configure...
@ WIFI_PM_SWITCHING_TO_ACTIVE
@ WIFI_PM_POWERSAVE
@ WIFI_PM_SWITCHING_TO_PS
@ WIFI_PM_ACTIVE
@ WIFI_PHY_BAND_UNSPECIFIED
Unspecified.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
WifiTidToLinkMappingNegSupport
TID-to-Link Mapping Negotiation Support.
std::ostream & operator<<(std::ostream &os, const Angles &a)
Definition angles.cc:148
std::map< tid_t, std::set< linkId_t > > WifiTidLinkMapping
TID-indexed map of the link set to which the TID is mapped.
Definition wifi-utils.h:77
Struct containing all supported rates.
Struct to hold information regarding observed AP through active/passive scanning.
MgtFrameType m_frame
The body of the management frame used to update AP info.
WifiScanParams::Channel m_channel
The channel the management frame was received on.
std::list< SetupLinksInfo > m_setupLinks
information about the links to setup between MLDs
Mac48Address m_apAddr
AP MAC address.
uint8_t m_linkId
ID of the link used to communicate with the AP.
Mac48Address m_bssid
BSSID.
double m_snr
SNR in linear scale.
uint32_t cwMax
the maximum contention window size
AcIndex ac
the access category
uint32_t cwMin
the minimum contention window size
uint8_t aifsn
the number of slots that make up an AIFS
Time txopLimit
the TXOP limit
Time muEdcaTimer
the MU EDCA timer
uint8_t aifsn
the number of slots that make up an AIFS
uint32_t cwMin
the minimum contention window size
AcIndex ac
the access category
uint32_t cwMax
the maximum contention window size
Struct identifying a channel to scan.
WifiPhyBand band
PHY band.
uint16_t number
channel number
Structure holding scan parameters.
std::list< Channel > ChannelList
typedef for a list of channels
std::vector< ChannelList > channelList
list of channels to scan, for each link
Time probeDelay
delay prior to transmitting a Probe Request
WifiScanType type
indicates either active or passive scanning
Time maxChannelTime
maximum time to spend on each channel
Ssid ssid
desired SSID or wildcard SSID
Time minChannelTime
minimum time to spend on each channel