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