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 * 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;
151
152 /**
153 * Struct to hold information regarding observed AP through
154 * active/passive scanning
155 */
156 struct ApInfo
157 {
158 /**
159 * Information about links to setup
160 */
162 {
163 uint8_t localLinkId; ///< local link ID
164 uint8_t apLinkId; ///< AP link ID
165 Mac48Address bssid; ///< BSSID
166 };
167
169 Mac48Address m_apAddr; ///< AP MAC address
170 double m_snr; ///< SNR in linear scale
171 MgtFrameType m_frame; ///< The body of the management frame used to update AP info
172 WifiScanParams::Channel m_channel; ///< The channel the management frame was received on
173 uint8_t m_linkId; ///< ID of the link used to communicate with the AP
174 std::list<SetupLinksInfo>
175 m_setupLinks; ///< information about the links to setup between MLDs
176 };
177
178 /**
179 * @brief Get the type ID.
180 * @return the object TypeId
181 */
182 static TypeId GetTypeId();
183
184 StaWifiMac();
185 ~StaWifiMac() override;
186
187 bool CanForwardPacketsTo(Mac48Address to) const override;
188 int64_t AssignStreams(int64_t stream) override;
189
190 /**
191 * @param phys the physical layers attached to this MAC.
192 */
193 void SetWifiPhys(const std::vector<Ptr<WifiPhy>>& phys) override;
194
195 /**
196 * Set the Association Manager.
197 *
198 * @param assocManager the Association Manager
199 */
200 void SetAssocManager(Ptr<WifiAssocManager> assocManager);
201
202 /**
203 * Set the EMLSR Manager.
204 *
205 * @param emlsrManager the EMLSR Manager
206 */
207 void SetEmlsrManager(Ptr<EmlsrManager> emlsrManager);
208
209 /**
210 * @return the EMLSR Manager
211 */
213
214 /**
215 * Get the frame body of the Probe Request to transmit on the given link.
216 *
217 * @param linkId the ID of the given link
218 * @return the Probe Request frame body
219 */
220 MgtProbeRequestHeader GetProbeRequest(uint8_t linkId) const;
221
222 /**
223 * Get the frame body of the Multi-Link Probe Request to transmit on the given link.
224 *
225 * @param linkId the ID of the given link
226 * @param apLinkIds ID of the links on which the requested APs, affiliated with the
227 * AP MLD, operate
228 * @param apMldId the AP MLD ID to include in the Common Info field
229 * @return the Multi-Link Probe Request frame body
230 */
232 const std::vector<uint8_t>& apLinkIds,
233 std::optional<uint8_t> apMldId) const;
234
235 /**
236 * Enqueue the given probe request packet for transmission on the given link.
237 *
238 * @param probeReq the given Probe Request frame body
239 * @param linkId the ID of the given link
240 * @param addr1 the MAC address for the Address1 field
241 * @param addr3 the MAC address for the Address3 field
242 */
243 void EnqueueProbeRequest(const MgtProbeRequestHeader& probeReq,
244 uint8_t linkId,
247
248 /**
249 * This method is called after wait beacon timeout or wait probe request timeout has
250 * occurred. This will trigger association process from beacons or probe responses
251 * gathered while scanning.
252 *
253 * @param bestAp the info about the best AP to associate with, if one was found
254 */
255 void ScanningTimeout(const std::optional<ApInfo>& bestAp);
256
257 /**
258 * Return whether we are associated with an AP.
259 *
260 * @return true if we are associated with an AP, false otherwise
261 */
262 bool IsAssociated() const;
263
264 /**
265 * Get the IDs of the setup links (if any).
266 *
267 * @return the IDs of the setup links
268 */
269 std::set<uint8_t> GetSetupLinkIds() const;
270
271 /**
272 * Return the association ID.
273 *
274 * @return the association ID
275 */
276 uint16_t GetAssociationId() const;
277
278 /// @return the type of association procedure performed by this device
280
281 /**
282 * Enable or disable Power Save mode on the given link.
283 *
284 * @param enableLinkIdPair a pair indicating whether to enable or not power save mode on
285 * the link with the given ID
286 */
287 void SetPowerSaveMode(const std::pair<bool, uint8_t>& enableLinkIdPair);
288
289 /**
290 * @param linkId the ID of the given link
291 * @return the current Power Management mode of the STA operating on the given link
292 */
293 WifiPowerManagementMode GetPmMode(uint8_t linkId) const;
294
295 /**
296 * Set the Power Management mode of the setup links after association.
297 *
298 * @param linkId the ID of the link used to establish association
299 */
300 void SetPmModeAfterAssociation(uint8_t linkId);
301
302 /**
303 * Notify that the MPDU we sent was successfully received by the receiver
304 * (i.e. we received an Ack from the receiver).
305 *
306 * @param mpdu the MPDU that we successfully sent
307 */
308 void TxOk(Ptr<const WifiMpdu> mpdu);
309
310 void NotifyChannelSwitching(uint8_t linkId) override;
311
312 /**
313 * Notify the MAC that EMLSR mode has changed on the given set of links.
314 *
315 * @param linkIds the IDs of the links that are now EMLSR links (EMLSR mode is disabled
316 * on other links)
317 */
318 void NotifyEmlsrModeChanged(const std::set<uint8_t>& linkIds);
319
320 /**
321 * @param linkId the ID of the given link
322 * @return whether the EMLSR mode is enabled on the given link
323 */
324 bool IsEmlsrLink(uint8_t linkId) const;
325
326 /**
327 * Notify that the given PHY switched channel to operate on another EMLSR link.
328 *
329 * @param phy the given PHY
330 * @param linkId the ID of the EMLSR link on which the given PHY operates after
331 * the channel switch
332 * @param delay the delay after which the channel switch will be completed
333 */
334 void NotifySwitchingEmlsrLink(Ptr<WifiPhy> phy, uint8_t linkId, Time delay);
335
336 /**
337 * Cancel any scheduled event for connecting the given PHY to an EMLSR link.
338 *
339 * @param phyId the ID of the given PHY
340 */
341 void CancelEmlsrPhyConnectEvent(uint8_t phyId);
342
343 /**
344 * Block transmissions on the given link for the given reason.
345 *
346 * @param linkId the ID of the given link
347 * @param reason the reason for blocking transmissions on the given link
348 */
349 void BlockTxOnLink(uint8_t linkId, WifiQueueBlockedReason reason);
350
351 /**
352 * Unblock transmissions on the given links for the given reason.
353 *
354 * @param linkIds the IDs of the given links
355 * @param reason the reason for unblocking transmissions on the given links
356 */
357 void UnblockTxOnLink(std::set<uint8_t> linkIds, WifiQueueBlockedReason reason);
358
359 protected:
360 /**
361 * Structure holding information specific to a single link. Here, the meaning of
362 * "link" is that of the 11be amendment which introduced multi-link devices. For
363 * previous amendments, only one link can be created.
364 */
366 {
367 /// Destructor (a virtual method is needed to make this struct polymorphic)
368 ~StaLinkEntity() override;
369
370 bool sendAssocReq; //!< whether this link is used to send the
371 //!< Association Request frame
372 std::optional<Mac48Address> bssid; //!< BSSID of the AP to associate with over this link
373 WifiPowerManagementMode pmMode{WIFI_PM_ACTIVE}; /**< the current PM mode, if the STA is
374 associated, or the PM mode to switch
375 to upon association, otherwise */
376 bool emlsrEnabled{false}; //!< whether EMLSR mode is enabled on this link
377 };
378
379 /**
380 * Get a reference to the link associated with the given ID.
381 *
382 * @param linkId the given link ID
383 * @return a reference to the link associated with the given ID
384 */
385 StaLinkEntity& GetLink(uint8_t linkId) const;
386
387 /**
388 * Cast the given LinkEntity object to StaLinkEntity.
389 *
390 * @param link the given LinkEntity object
391 * @return a reference to the object casted to StaLinkEntity
392 */
393 StaLinkEntity& GetStaLink(const std::unique_ptr<WifiMac::LinkEntity>& link) const;
394
395 public:
396 /**
397 * The current MAC state of the STA.
398 */
407
408 private:
409 void DoCompleteConfig() override;
410
411 /**
412 * Enable or disable active probing.
413 *
414 * @param enable enable or disable active probing
415 */
416 void SetActiveProbing(bool enable);
417 /**
418 * Return whether active probing is enabled.
419 *
420 * @return true if active probing is enabled, false otherwise
421 */
422 bool GetActiveProbing() const;
423
424 /**
425 * Determine whether the supported rates indicated in a given Beacon frame or
426 * Probe Response frame fit with the configured membership selector.
427 *
428 * @param frame the given Beacon or Probe Response frame
429 * @param linkId ID of the link the mgt frame was received over
430 * @return whether the the supported rates indicated in the given management
431 * frame fit with the configured membership selector
432 */
433 bool CheckSupportedRates(std::variant<MgtBeaconHeader, MgtProbeResponseHeader> frame,
434 uint8_t linkId);
435
436 void Receive(Ptr<const WifiMpdu> mpdu, uint8_t linkId) override;
437 std::unique_ptr<LinkEntity> CreateLinkEntity() const override;
438 Mac48Address DoGetLocalAddress(const Mac48Address& remoteAddr) const override;
439 void Enqueue(Ptr<WifiMpdu> mpdu, Mac48Address to, Mac48Address from) override;
440 void NotifyDropPacketToEnqueue(Ptr<Packet> packet, Mac48Address to) override;
441
442 /**
443 * Process the Beacon frame received on the given link.
444 *
445 * @param mpdu the MPDU containing the Beacon frame
446 * @param linkId the ID of the given link
447 */
448 void ReceiveBeacon(Ptr<const WifiMpdu> mpdu, uint8_t linkId);
449
450 /**
451 * Process the Probe Response frame received on the given link.
452 *
453 * @param mpdu the MPDU containing the Probe Response frame
454 * @param linkId the ID of the given link
455 */
456 void ReceiveProbeResp(Ptr<const WifiMpdu> mpdu, uint8_t linkId);
457
458 /**
459 * Process the (Re)Association Response frame received on the given link.
460 *
461 * @param mpdu the MPDU containing the (Re)Association Response frame
462 * @param linkId the ID of the given link
463 */
464 void ReceiveAssocResp(Ptr<const WifiMpdu> mpdu, uint8_t linkId);
465
466 /**
467 * Update operations information from the given management frame.
468 *
469 * @param frame the body of the given management frame
470 * @param addr MAC address of the sender
471 * @param linkId ID of the link the management frame was received over
472 */
473 void RecordOperations(const MgtFrameType& frame, const Mac48Address& addr, uint8_t linkId);
474
475 /**
476 * Update operational settings based on associated AP's information provided by the given
477 * management frame (Beacon, Probe Response or Association Response).
478 *
479 * @param frame the body of the given management frame
480 * @param apAddr MAC address of the AP
481 * @param bssid MAC address of BSSID
482 * @param linkId ID of the link the management frame was received over
483 */
484 void ApplyOperationalSettings(const MgtFrameType& frame,
485 const Mac48Address& apAddr,
486 const Mac48Address& bssid,
487 uint8_t linkId);
488
489 /**
490 * Get the (Re)Association Request frame to send on a given link. The returned frame
491 * never includes a Multi-Link Element.
492 *
493 * @param isReassoc whether a Reassociation Request has to be returned
494 * @param linkId the ID of the given link
495 * @return the (Re)Association Request frame
496 */
497 std::variant<MgtAssocRequestHeader, MgtReassocRequestHeader> GetAssociationRequest(
498 bool isReassoc,
499 uint8_t linkId) const;
500
501 /**
502 * Forward an association or reassociation request packet to the DCF.
503 * The standard is not clear on the correct queue for management frames if QoS is supported.
504 * We always use the DCF.
505 *
506 * @param isReassoc flag whether it is a reassociation request
507 *
508 */
509 void SendAssociationRequest(bool isReassoc);
510 /**
511 * Try to ensure that we are associated with an AP by taking an appropriate action
512 * depending on the current association status.
513 */
515 /**
516 * This method is called after the association timeout occurred. We switch the state to
517 * WAIT_ASSOC_RESP and re-send an association request.
518 */
519 void AssocRequestTimeout();
520 /**
521 * Start the scanning process which trigger active or passive scanning based on the
522 * active probing flag.
523 */
524 void StartScanning();
525 /**
526 * Return whether we are waiting for an association response from an AP.
527 *
528 * @return true if we are waiting for an association response from an AP, false otherwise
529 */
530 bool IsWaitAssocResp() const;
531
532 /**
533 * This method is called after we have not received a beacon from the AP on any link.
534 */
535 void MissedBeacons();
536 /**
537 * Restarts the beacon timer.
538 *
539 * @param delay the delay before the watchdog fires
540 */
541 void RestartBeaconWatchdog(Time delay);
542 /**
543 * Set the state to unassociated and try to associate again.
544 */
545 void Disassociated();
546 /**
547 * Return an instance of SupportedRates that contains all rates that we support
548 * including HT rates.
549 *
550 * @param linkId the ID of the link for which the request is made
551 * @return SupportedRates all rates that we support
552 */
553 AllSupportedRates GetSupportedRates(uint8_t linkId) const;
554 /**
555 * Return the Basic Multi-Link Element to include in the management frames transmitted
556 * on the given link
557 *
558 * @param isReassoc whether the Basic Multi-Link Element is included in a Reassociation Request
559 * @param linkId the ID of the given link
560 * @return the Basic Multi-Link Element
561 */
562 MultiLinkElement GetBasicMultiLinkElement(bool isReassoc, uint8_t linkId) const;
563
564 /**
565 * Return the Probe Request Multi-Link Element to include in the management frames to transmit.
566 *
567 * @param apLinkIds ID of the links on which the requested APs operate
568 * @param apMldId the AP MLD ID to include in the Common Info field
569 * @return the Probe Request Multi-Link Element
570 */
571 MultiLinkElement GetProbeReqMultiLinkElement(const std::vector<uint8_t>& apLinkIds,
572 std::optional<uint8_t> apMldId) const;
573
574 /**
575 * @param apNegSupport the negotiation type supported by the AP MLD
576 * @return the TID-to-Link Mapping element(s) to include in Association Request frame.
577 */
578 std::vector<TidToLinkMapping> GetTidToLinkMappingElements(
579 WifiTidToLinkMappingNegSupport apNegSupport);
580
581 /**
582 * Set the current MAC state.
583 *
584 * @param value the new state
585 */
586 void SetState(MacState value);
587
588 /**
589 * 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 txopLimit; //!< the TXOP limit
598 };
599
600 /**
601 * Set the EDCA parameters for the given link.
602 *
603 * @param params the EDCA parameters
604 * @param linkId the ID of the given link
605 */
606 void SetEdcaParameters(const EdcaParams& params, uint8_t linkId);
607
608 /**
609 * MU EDCA Parameters
610 */
612 {
613 AcIndex ac; //!< the access category
614 uint32_t cwMin; //!< the minimum contention window size
615 uint32_t cwMax; //!< the maximum contention window size
616 uint8_t aifsn; //!< the number of slots that make up an AIFS
617 Time muEdcaTimer; //!< the MU EDCA timer
618 };
619
620 /**
621 * Set the MU EDCA parameters for the given link.
622 *
623 * @param params the MU EDCA parameters
624 * @param linkId the ID of the given link
625 */
626 void SetMuEdcaParameters(const MuEdcaParams& params, uint8_t linkId);
627
628 /**
629 * Return the Capability information for the given link.
630 *
631 * @param linkId the ID of the given link
632 * @return the Capability information that we support
633 */
634 CapabilityInformation GetCapabilities(uint8_t linkId) const;
635
636 /**
637 * Indicate that PHY capabilities have changed.
638 */
640
641 /**
642 * Get the current primary20 channel used on the given link as a
643 * (channel number, PHY band) pair.
644 *
645 * @param linkId the ID of the given link
646 * @return a (channel number, PHY band) pair
647 */
648 WifiScanParams::Channel GetCurrentChannel(uint8_t linkId) const;
649
650 void DoInitialize() override;
651 void DoDispose() override;
652
653 MacState m_state; ///< MAC state
654 uint16_t m_aid; ///< Association AID
655 Ptr<WifiAssocManager> m_assocManager; ///< Association Manager
656 WifiAssocType m_assocType; ///< type of association
658 Time m_waitBeaconTimeout; ///< wait beacon timeout
659 Time m_probeRequestTimeout; ///< probe request timeout
660 Time m_assocRequestTimeout; ///< association request timeout
661 EventId m_assocRequestEvent; ///< association request event
662 uint32_t m_maxMissedBeacons; ///< maximum missed beacons
663 EventId m_beaconWatchdog; //!< beacon watchdog
664 Time m_beaconWatchdogEnd{0}; //!< beacon watchdog end
665 bool m_activeProbing; ///< active probing
666 Ptr<RandomVariableStream> m_probeDelay; ///< RandomVariable used to randomize the time
667 ///< of the first Probe Response on each channel
668 Time m_pmModeSwitchTimeout; ///< PM mode switch timeout
669 std::map<uint8_t, EventId> m_emlsrLinkSwitch; ///< maps PHY ID to the event scheduled to switch
670 ///< the corresponding PHY to a new EMLSR link
671
672 /// store the DL TID-to-Link Mapping included in the Association Request frame
674 /// store the UL TID-to-Link Mapping included in the Association Request frame
676
680 TracedCallback<Time> m_beaconArrival; ///< beacon arrival logger
681 TracedCallback<ApInfo> m_beaconInfo; ///< beacon info logger
683 m_emlsrLinkSwitchLogger; ///< EMLSR link switch logger
684
685 /// TracedCallback signature for link setup completed/canceled events
686 using LinkSetupCallback = void (*)(uint8_t /* link ID */, Mac48Address /* AP address */);
687
688 /// TracedCallback signature for EMLSR link switch events
689 using EmlsrLinkSwitchCallback = void (*)(uint8_t /* link ID */, Ptr<WifiPhy> /* PHY */);
690};
691
692/**
693 * @brief Stream insertion operator.
694 *
695 * @param os the output stream
696 * @param apInfo the AP information
697 * @returns a reference to the stream
698 */
699std::ostream& operator<<(std::ostream& os, const StaWifiMac::ApInfo& apInfo);
700
701} // namespace ns3
702
703#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.
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.
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.
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
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
std::variant< MgtBeaconHeader, MgtProbeResponseHeader, MgtAssocResponseHeader > MgtFrameType
type of the management frames
Definition wifi-mac.h:106
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
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< uint8_t, std::set< uint8_t > > WifiTidLinkMapping
TID-indexed map of the link set to which the TID is mapped.
Definition wifi-utils.h:68
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