wlan_mlme/client/
scanner.rs

1// Copyright 2021 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::WlanSoftmacBandCapabilityExt as _;
6use crate::client::Context;
7use crate::client::convert_beacon::construct_bss_description;
8use crate::ddk_converter::cssid_from_ssid_unchecked;
9use crate::device::{self, DeviceOps};
10use crate::error::Error;
11use anyhow::format_err;
12use fidl_fuchsia_wlan_ieee80211 as fidl_ieee80211;
13use fidl_fuchsia_wlan_mlme as fidl_mlme;
14use fidl_fuchsia_wlan_softmac as fidl_softmac;
15use fuchsia_trace as trace;
16use ieee80211::{Bssid, MacAddr};
17use log::{error, warn};
18use thiserror::Error;
19use wlan_common::mac::{self, CapabilityInfo};
20use wlan_common::mgmt_writer;
21use wlan_common::time::TimeUnit;
22use wlan_frame_writer::write_frame_to_vec;
23use wlan_trace as wtrace;
24
25// TODO(https://fxbug.dev/42171393): Currently hardcoded until parameters supported.
26const MIN_HOME_TIME: zx::MonotonicDuration = zx::MonotonicDuration::from_millis(0);
27const MIN_PROBES_PER_CHANNEL: u8 = 0;
28const MAX_PROBES_PER_CHANNEL: u8 = 0;
29
30#[derive(Error, Debug, PartialEq, Eq)]
31pub enum ScanError {
32    #[error("scanner is busy")]
33    Busy,
34    #[error("invalid arg: empty channel list")]
35    EmptyChannelList,
36    #[error("invalid arg: max_channel_time < min_channel_time")]
37    MaxChannelTimeLtMin,
38    #[error("fail starting device scan: {}", _0)]
39    StartOffloadScanFails(zx::Status),
40    #[error("invalid response")]
41    InvalidResponse,
42}
43
44impl From<ScanError> for zx::Status {
45    fn from(e: ScanError) -> Self {
46        match e {
47            ScanError::Busy => zx::Status::UNAVAILABLE,
48            ScanError::EmptyChannelList | ScanError::MaxChannelTimeLtMin => {
49                zx::Status::INVALID_ARGS
50            }
51            ScanError::StartOffloadScanFails(status) => status,
52            ScanError::InvalidResponse => zx::Status::INVALID_ARGS,
53        }
54    }
55}
56
57impl From<ScanError> for fidl_mlme::ScanResultCode {
58    fn from(e: ScanError) -> Self {
59        match e {
60            ScanError::Busy => fidl_mlme::ScanResultCode::NotSupported,
61            ScanError::EmptyChannelList | ScanError::MaxChannelTimeLtMin => {
62                fidl_mlme::ScanResultCode::InvalidArgs
63            }
64            ScanError::StartOffloadScanFails(zx::Status::NOT_SUPPORTED) => {
65                fidl_mlme::ScanResultCode::NotSupported
66            }
67            ScanError::StartOffloadScanFails(..) => fidl_mlme::ScanResultCode::InternalError,
68            ScanError::InvalidResponse => fidl_mlme::ScanResultCode::InternalError,
69        }
70    }
71}
72
73pub struct Scanner {
74    ongoing_scan: Option<OngoingScan>,
75    /// MAC address of current client interface
76    iface_mac: MacAddr,
77    scanning_enabled: bool,
78}
79
80impl Scanner {
81    pub fn new(iface_mac: MacAddr) -> Self {
82        Self { ongoing_scan: None, iface_mac, scanning_enabled: true }
83    }
84
85    pub fn bind<'a, D>(&'a mut self, ctx: &'a mut Context<D>) -> BoundScanner<'a, D> {
86        BoundScanner { scanner: self, ctx }
87    }
88
89    pub fn is_scanning(&self) -> bool {
90        self.ongoing_scan.is_some()
91    }
92}
93
94pub struct BoundScanner<'a, D> {
95    scanner: &'a mut Scanner,
96    ctx: &'a mut Context<D>,
97}
98
99enum OngoingScan {
100    PassiveOffloadScan {
101        /// Scan txn_id that's currently being serviced.
102        mlme_txn_id: u64,
103        /// Unique identifier returned from the device driver when the scan began.
104        in_progress_device_scan_id: u64,
105    },
106    ActiveOffloadScan {
107        /// Scan txn_id that's currently being serviced.
108        mlme_txn_id: u64,
109        /// Unique identifier returned from the device driver when the scan began.
110        in_progress_device_scan_id: u64,
111        /// Remaining arguments to be sent to future scan requests.
112        remaining_active_scan_requests: Vec<fidl_softmac::WlanSoftmacStartActiveScanRequest>,
113    },
114}
115
116impl OngoingScan {
117    fn scan_id(&self) -> u64 {
118        match self {
119            Self::PassiveOffloadScan { in_progress_device_scan_id, .. } => {
120                *in_progress_device_scan_id
121            }
122            Self::ActiveOffloadScan { in_progress_device_scan_id, .. } => {
123                *in_progress_device_scan_id
124            }
125        }
126    }
127}
128
129impl<'a, D: DeviceOps> BoundScanner<'a, D> {
130    /// Temporarily disable scanning. If scan cancellation is supported, any
131    /// ongoing scan will be cancelled when scanning is disabled. If a scan
132    /// is in progress but cannot be cancelled, this function returns
133    /// zx::Status::NOT_SUPPORTED and makes no changes to the system.
134    pub async fn disable_scanning(&mut self) -> Result<(), zx::Status> {
135        if self.scanner.scanning_enabled {
136            self.cancel_ongoing_scan().await?;
137            self.scanner.scanning_enabled = false;
138        }
139        Ok(())
140    }
141
142    pub fn enable_scanning(&mut self) {
143        self.scanner.scanning_enabled = true;
144    }
145
146    /// Canceling any software scan that's in progress
147    /// TODO(b/254290448): Remove 'pub' when all clients use enable/disable scanning.
148    pub async fn cancel_ongoing_scan(&mut self) -> Result<(), zx::Status> {
149        if let Some(scan) = &self.scanner.ongoing_scan {
150            let discovery_support = self.ctx.device.discovery_support().await?;
151            if discovery_support
152                .scan_offload
153                .and_then(|offload| offload.scan_cancel_supported)
154                .unwrap_or(false)
155            {
156                self.ctx
157                    .device
158                    .cancel_scan(&fidl_softmac::WlanSoftmacBaseCancelScanRequest {
159                        scan_id: Some(scan.scan_id()),
160                        ..Default::default()
161                    })
162                    .await
163            } else {
164                Err(zx::Status::NOT_SUPPORTED)
165            }
166        } else {
167            Ok(())
168        }
169    }
170
171    /// Handle scan request. Queue requested scan channels in channel scheduler.
172    ///
173    /// If a scan request is in progress, or the new request has invalid argument (empty channel
174    /// list or larger min channel time than max), then the request is rejected.
175    pub async fn on_sme_scan(&'a mut self, req: fidl_mlme::ScanRequest) -> Result<(), Error> {
176        if self.scanner.ongoing_scan.is_some() || !self.scanner.scanning_enabled {
177            return Err(Error::ScanError(ScanError::Busy));
178        }
179        if req.channel_list.is_empty() {
180            return Err(Error::ScanError(ScanError::EmptyChannelList));
181        }
182        if req.max_channel_time < req.min_channel_time {
183            return Err(Error::ScanError(ScanError::MaxChannelTimeLtMin));
184        }
185
186        let query_response = self
187            .ctx
188            .device
189            .wlan_softmac_query_response()
190            .await
191            .map_err(|status| Error::Status(String::from("Failed to query device."), status))?;
192        let discovery_support = device::try_query_discovery_support(&mut self.ctx.device).await?;
193
194        // TODO(https://fxbug.dev/321627682): MLME only supports offloaded scanning.
195        if discovery_support.scan_offload.and_then(|offload| offload.supported).unwrap_or(false) {
196            match req.scan_type {
197                fidl_mlme::ScanTypes::Passive => self.start_passive_scan(req).await,
198                fidl_mlme::ScanTypes::Active => self.start_active_scan(req, &query_response).await,
199            }
200            .map(|ongoing_scan| self.scanner.ongoing_scan = Some(ongoing_scan))
201            .map_err(|e| {
202                self.scanner.ongoing_scan.take();
203                e
204            })
205        } else {
206            Err(Error::ScanError(ScanError::StartOffloadScanFails(zx::Status::NOT_SUPPORTED)))
207        }
208    }
209
210    async fn start_passive_scan(
211        &mut self,
212        req: fidl_mlme::ScanRequest,
213    ) -> Result<OngoingScan, Error> {
214        Ok(OngoingScan::PassiveOffloadScan {
215            mlme_txn_id: req.txn_id,
216            in_progress_device_scan_id: self
217                .ctx
218                .device
219                .start_passive_scan(&fidl_softmac::WlanSoftmacBaseStartPassiveScanRequest {
220                    channels: Some(req.channel_list),
221                    // TODO(https://fxbug.dev/42171328): A TimeUnit is generally limited to 2 octets. Conversion here
222                    // is required since fuchsia.wlan.mlme/ScanRequest.min_channel_time has a width of
223                    // four octets.
224                    min_channel_time: Some(
225                        zx::MonotonicDuration::from(TimeUnit(req.min_channel_time as u16))
226                            .into_nanos(),
227                    ),
228                    max_channel_time: Some(
229                        zx::MonotonicDuration::from(TimeUnit(req.max_channel_time as u16))
230                            .into_nanos(),
231                    ),
232                    min_home_time: Some(MIN_HOME_TIME.into_nanos()),
233                    ..Default::default()
234                })
235                .await
236                .map_err(|status| Error::ScanError(ScanError::StartOffloadScanFails(status)))?
237                .scan_id
238                .ok_or(Error::ScanError(ScanError::InvalidResponse))?,
239        })
240    }
241
242    async fn start_active_scan(
243        &mut self,
244        req: fidl_mlme::ScanRequest,
245        query_response: &fidl_softmac::WlanSoftmacQueryResponse,
246    ) -> Result<OngoingScan, Error> {
247        let ssids_list = req.ssid_list.iter().map(cssid_from_ssid_unchecked).collect::<Vec<_>>();
248
249        let mac_header = write_frame_to_vec!({
250            headers: {
251                mac::MgmtHdr: &self.probe_request_mac_header(),
252            },
253        })?;
254
255        let mut remaining_active_scan_requests = active_scan_request_series(
256            // TODO(https://fxbug.dev/42171328): A TimeUnit is generally limited to 2 octets. Conversion here
257            // is required since fuchsia.wlan.mlme/ScanRequest.min_channel_time has a width of
258            // four octets.
259            query_response,
260            req.channel_list,
261            ssids_list,
262            mac_header,
263            zx::MonotonicDuration::from(TimeUnit(req.min_channel_time as u16)).into_nanos(),
264            zx::MonotonicDuration::from(TimeUnit(req.max_channel_time as u16)).into_nanos(),
265            MIN_HOME_TIME.into_nanos(),
266            MIN_PROBES_PER_CHANNEL,
267            MAX_PROBES_PER_CHANNEL,
268        )?;
269
270        match remaining_active_scan_requests.pop() {
271            None => {
272                error!("unexpected empty list of active scan args");
273                return Err(Error::ScanError(ScanError::StartOffloadScanFails(
274                    zx::Status::INVALID_ARGS,
275                )));
276            }
277            Some(active_scan_request) => Ok(OngoingScan::ActiveOffloadScan {
278                mlme_txn_id: req.txn_id,
279                in_progress_device_scan_id: self
280                    .start_next_active_scan(&active_scan_request)
281                    .await
282                    .map_err(|scan_error| Error::ScanError(scan_error))?,
283                remaining_active_scan_requests,
284            }),
285        }
286    }
287
288    async fn start_next_active_scan(
289        &mut self,
290        request: &fidl_softmac::WlanSoftmacStartActiveScanRequest,
291    ) -> Result<u64, ScanError> {
292        match self.ctx.device.start_active_scan(request).await {
293            Ok(response) => Ok(response.scan_id.ok_or_else(|| {
294                error!("Active scan response missing scan id!");
295                ScanError::InvalidResponse
296            })?),
297            Err(status) => Err(ScanError::StartOffloadScanFails(status)),
298        }
299    }
300
301    /// Called when MLME receives an advertisement from the AP, e.g. a Beacon or Probe
302    /// Response frame. If a scan is in progress, then the advertisement will be saved
303    /// in the BSS map.
304    pub fn handle_ap_advertisement(
305        &mut self,
306        bssid: Bssid,
307        beacon_interval: TimeUnit,
308        capability_info: CapabilityInfo,
309        ies: &[u8],
310        rx_info: fidl_softmac::WlanRxInfo,
311    ) {
312        wtrace::duration!("BoundScanner::handle_ap_advertisement");
313
314        let mlme_txn_id = match self.scanner.ongoing_scan {
315            Some(OngoingScan::PassiveOffloadScan { mlme_txn_id, .. }) => mlme_txn_id,
316            Some(OngoingScan::ActiveOffloadScan { mlme_txn_id, .. }) => mlme_txn_id,
317            None => return,
318        };
319        let bss_description =
320            construct_bss_description(bssid, beacon_interval, capability_info, ies, rx_info);
321        let bss_description = match bss_description {
322            Ok(bss) => bss,
323            Err(e) => {
324                warn!("Failed to process beacon or probe response: {}", e);
325                return;
326            }
327        };
328        send_scan_result(mlme_txn_id, bss_description, &mut self.ctx.device);
329    }
330
331    pub async fn handle_scan_complete(&mut self, status: zx::Status, scan_id: u64) {
332        macro_rules! send_on_scan_end {
333            ($mlme_txn_id: ident, $code:expr) => {
334                self.ctx
335                    .device
336                    .send_mlme_event(fidl_mlme::MlmeEvent::OnScanEnd {
337                        end: fidl_mlme::ScanEnd { txn_id: $mlme_txn_id, code: $code },
338                    })
339                    .unwrap_or_else(|e| error!("error sending MLME ScanEnd: {}", e));
340            };
341        }
342
343        match self.scanner.ongoing_scan.take() {
344            // TODO(https://fxbug.dev/42172565): A spurious ScanComplete should not silently cancel an
345            // MlmeScan by permanently taking the contents of ongoing_scan.
346            None => {
347                warn!("Unexpected ScanComplete when no scan in progress.");
348            }
349            Some(OngoingScan::PassiveOffloadScan { mlme_txn_id, in_progress_device_scan_id })
350                if in_progress_device_scan_id == scan_id =>
351            {
352                send_on_scan_end!(
353                    mlme_txn_id,
354                    if status == zx::Status::OK {
355                        fidl_mlme::ScanResultCode::Success
356                    } else {
357                        error!("passive offload scan failed: {}", status);
358                        fidl_mlme::ScanResultCode::InternalError
359                    }
360                );
361            }
362            Some(OngoingScan::ActiveOffloadScan {
363                mlme_txn_id,
364                in_progress_device_scan_id,
365                mut remaining_active_scan_requests,
366            }) if in_progress_device_scan_id == scan_id => {
367                if status != zx::Status::OK {
368                    error!("active offload scan failed: {}", status);
369                    send_on_scan_end!(mlme_txn_id, fidl_mlme::ScanResultCode::InternalError);
370                    return;
371                }
372
373                match remaining_active_scan_requests.pop() {
374                    None => {
375                        send_on_scan_end!(mlme_txn_id, fidl_mlme::ScanResultCode::Success);
376                    }
377                    Some(active_scan_request) => {
378                        match self.start_next_active_scan(&active_scan_request).await {
379                            Ok(in_progress_device_scan_id) => {
380                                self.scanner.ongoing_scan = Some(OngoingScan::ActiveOffloadScan {
381                                    mlme_txn_id,
382                                    in_progress_device_scan_id,
383                                    remaining_active_scan_requests,
384                                });
385                            }
386                            Err(scan_error) => {
387                                self.scanner.ongoing_scan.take();
388                                send_on_scan_end!(mlme_txn_id, scan_error.into());
389                            }
390                        }
391                    }
392                }
393            }
394            Some(other) => {
395                let in_progress_device_scan_id = match other {
396                    OngoingScan::ActiveOffloadScan { in_progress_device_scan_id, .. } => {
397                        in_progress_device_scan_id
398                    }
399                    OngoingScan::PassiveOffloadScan { in_progress_device_scan_id, .. } => {
400                        in_progress_device_scan_id
401                    }
402                };
403                warn!(
404                    "Unexpected scan ID upon scan completion. expected: {}, returned: {}",
405                    in_progress_device_scan_id, scan_id
406                );
407                self.scanner.ongoing_scan.replace(other);
408            }
409        }
410    }
411
412    fn probe_request_mac_header(&mut self) -> mac::MgmtHdr {
413        mgmt_writer::mgmt_hdr_to_ap(
414            mac::FrameControl(0)
415                .with_frame_type(mac::FrameType::MGMT)
416                .with_mgmt_subtype(mac::MgmtSubtype::PROBE_REQ),
417            ieee80211::BROADCAST_ADDR.into(),
418            self.scanner.iface_mac,
419            mac::SequenceControl(0)
420                .with_seq_num(self.ctx.seq_mgr.next_sns1(&ieee80211::BROADCAST_ADDR) as u16),
421        )
422    }
423}
424
425fn band_cap_for_band(
426    query_response: &fidl_softmac::WlanSoftmacQueryResponse,
427    band: fidl_ieee80211::WlanBand,
428) -> Option<&fidl_softmac::WlanSoftmacBandCapability> {
429    query_response
430        .band_caps
431        .as_ref()
432        .map(|band_caps| band_caps.iter())
433        .into_iter()
434        .flatten()
435        .filter(|band_cap| band_cap.band == Some(band))
436        .next()
437}
438
439// TODO(https://fxbug.dev/42172555): Zero should not mark a null rate.
440fn supported_rates_for_band(
441    query_response: &fidl_softmac::WlanSoftmacQueryResponse,
442    band: fidl_ieee80211::WlanBand,
443) -> Result<Vec<u8>, Error> {
444    let rates = band_cap_for_band(&query_response, band)
445        .ok_or_else(|| format_err!("no capabilities found for band {:?}", band))?
446        .basic_rates()
447        .map(From::from)
448        .ok_or_else(|| format_err!("no basic rates found for band capabilities"))?;
449    Ok(rates)
450}
451
452// TODO(https://fxbug.dev/42172557): This is not correct. Channel numbers do not imply band.
453fn band_from_channel_number(channel_number: u8) -> fidl_ieee80211::WlanBand {
454    if channel_number > 14 {
455        fidl_ieee80211::WlanBand::FiveGhz
456    } else {
457        fidl_ieee80211::WlanBand::TwoGhz
458    }
459}
460
461fn active_scan_request_series(
462    query_response: &fidl_softmac::WlanSoftmacQueryResponse,
463    channels: Vec<u8>,
464    ssids: Vec<fidl_ieee80211::CSsid>,
465    mac_header: Vec<u8>,
466    min_channel_time: zx::sys::zx_duration_t,
467    max_channel_time: zx::sys::zx_duration_t,
468    min_home_time: zx::sys::zx_duration_t,
469    min_probes_per_channel: u8,
470    max_probes_per_channel: u8,
471) -> Result<Vec<fidl_softmac::WlanSoftmacStartActiveScanRequest>, Error> {
472    // TODO(https://fxbug.dev/42172557): The fuchsia.wlan.mlme/MLME API assumes channels numbers imply bands
473    //                        and so partitioning channels must be done internally.
474    struct BandChannels {
475        band: fidl_ieee80211::WlanBand,
476        channels: Vec<u8>,
477    }
478    let band_channels_list: [BandChannels; 2] = channels.into_iter().fold(
479        [
480            BandChannels { band: fidl_ieee80211::WlanBand::FiveGhz, channels: vec![] },
481            BandChannels { band: fidl_ieee80211::WlanBand::TwoGhz, channels: vec![] },
482        ],
483        |mut band_channels_list, channel| {
484            for band_channels in &mut band_channels_list {
485                if band_from_channel_number(channel) == band_channels.band {
486                    band_channels.channels.push(channel);
487                }
488            }
489            band_channels_list
490        },
491    );
492
493    let mut active_scan_request_series = vec![];
494    for band_channels in band_channels_list {
495        let band = band_channels.band;
496        let channels = band_channels.channels;
497        if channels.is_empty() {
498            continue;
499        }
500        let supported_rates = supported_rates_for_band(query_response, band)?;
501        active_scan_request_series.push(fidl_softmac::WlanSoftmacStartActiveScanRequest {
502            channels: Some(channels),
503            ssids: Some(ssids.clone()),
504            mac_header: Some(mac_header.clone()),
505            // Exclude the SSID IE because the device driver will generate using ssids_list.
506            ies: Some(write_frame_to_vec!({
507                ies: {
508                    supported_rates: supported_rates,
509                    extended_supported_rates: {/* continue rates */},
510                }
511            })?),
512            min_channel_time: Some(min_channel_time),
513            max_channel_time: Some(max_channel_time),
514            min_home_time: Some(min_home_time),
515            min_probes_per_channel: Some(min_probes_per_channel),
516            max_probes_per_channel: Some(max_probes_per_channel),
517            ..Default::default()
518        });
519    }
520    Ok(active_scan_request_series)
521}
522
523fn send_scan_result<D: DeviceOps>(
524    txn_id: u64,
525    bss: fidl_ieee80211::BssDescription,
526    device: &mut D,
527) {
528    if trace::is_enabled() {
529        let trace_bss = wlan_common::bss::BssDescription::try_from(bss.clone())
530            .map(|bss| format!("{}", bss))
531            .unwrap_or_else(|e| format!("{}", e));
532        wtrace::duration!("send_scan_result", "bss" => &*trace_bss);
533    }
534    device
535        .send_mlme_event(fidl_mlme::MlmeEvent::OnScanResult {
536            result: fidl_mlme::ScanResult {
537                txn_id,
538                timestamp_nanos: zx::MonotonicInstant::get().into_nanos(),
539                bss,
540            },
541        })
542        .unwrap_or_else(|e| error!("error sending MLME ScanResult: {}", e));
543}
544
545#[cfg(test)]
546mod tests {
547    use super::*;
548    use crate::client::TimedEvent;
549    use crate::device::{FakeDevice, FakeDeviceState};
550    use crate::test_utils::{MockWlanRxInfo, fake_wlan_channel};
551    use assert_matches::assert_matches;
552    use fuchsia_sync::Mutex;
553    use ieee80211::{MacAddrBytes, Ssid};
554    use std::sync::{Arc, LazyLock};
555    use test_case::test_case;
556    use wlan_common::sequence::SequenceManager;
557    use wlan_common::timer::{self, Timer, create_timer};
558
559    static BSSID_FOO: LazyLock<Bssid> = LazyLock::new(|| [6u8; 6].into());
560    const CAPABILITY_INFO_FOO: CapabilityInfo = CapabilityInfo(1);
561    const BEACON_INTERVAL_FOO: u16 = 100;
562
563    #[rustfmt::skip]
564    static BEACON_IES_FOO: &'static [u8] = &[
565        // SSID: "ssid"
566        0x00, 0x03, b'f', b'o', b'o',
567        // Supported rates: 24(B), 36, 48, 54
568        0x01, 0x04, 0xb0, 0x48, 0x60, 0x6c,
569        // TIM - DTIM count: 0, DTIM period: 1, PVB: 2
570        0x05, 0x04, 0x00, 0x01, 0x00, 0x02,
571    ];
572
573    static RX_INFO_FOO: LazyLock<fidl_softmac::WlanRxInfo> = LazyLock::new(|| {
574        MockWlanRxInfo { rssi_dbm: -30, ..MockWlanRxInfo::with_channel(fake_wlan_channel().into()) }
575            .into()
576    });
577    static BSS_DESCRIPTION_FOO: LazyLock<fidl_ieee80211::BssDescription> =
578        LazyLock::new(|| fidl_ieee80211::BssDescription {
579            bssid: BSSID_FOO.to_array(),
580            bss_type: fidl_ieee80211::BssType::Infrastructure,
581            beacon_period: BEACON_INTERVAL_FOO,
582            capability_info: CAPABILITY_INFO_FOO.0,
583            ies: BEACON_IES_FOO.to_vec(),
584            rssi_dbm: RX_INFO_FOO.rssi_dbm,
585            channel: fidl_ieee80211::WlanChannel {
586                primary: RX_INFO_FOO.channel.primary,
587                cbw: fidl_ieee80211::ChannelBandwidth::Cbw20,
588                secondary80: 0,
589            },
590            snr_db: 0,
591        });
592    static BSSID_BAR: LazyLock<Bssid> = LazyLock::new(|| [1u8; 6].into());
593
594    const CAPABILITY_INFO_BAR: CapabilityInfo = CapabilityInfo(33);
595    const BEACON_INTERVAL_BAR: u16 = 150;
596    #[rustfmt::skip]
597    static BEACON_IES_BAR: &'static [u8] = &[
598        // SSID: "ss"
599        0x00, 0x03, b'b', b'a', b'r',
600        // Supported rates: 24(B), 36, 48, 54
601        0x01, 0x04, 0xb0, 0x48, 0x60, 0x6c,
602        // TIM - DTIM count: 0, DTIM period: 1, PVB: 2
603        0x05, 0x04, 0x00, 0x01, 0x00, 0x02,
604    ];
605    static RX_INFO_BAR: LazyLock<fidl_softmac::WlanRxInfo> = LazyLock::new(|| {
606        MockWlanRxInfo { rssi_dbm: -60, ..MockWlanRxInfo::with_channel(fake_wlan_channel().into()) }
607            .into()
608    });
609    static BSS_DESCRIPTION_BAR: LazyLock<fidl_ieee80211::BssDescription> =
610        LazyLock::new(|| fidl_ieee80211::BssDescription {
611            bssid: BSSID_BAR.to_array(),
612            bss_type: fidl_ieee80211::BssType::Infrastructure,
613            beacon_period: BEACON_INTERVAL_BAR,
614            capability_info: CAPABILITY_INFO_BAR.0,
615            ies: BEACON_IES_BAR.to_vec(),
616            rssi_dbm: RX_INFO_BAR.rssi_dbm,
617            channel: fidl_ieee80211::WlanChannel {
618                primary: RX_INFO_BAR.channel.primary,
619                cbw: fidl_ieee80211::ChannelBandwidth::Cbw20,
620                secondary80: 0,
621            },
622            snr_db: 0,
623        });
624
625    static IFACE_MAC: LazyLock<MacAddr> = LazyLock::new(|| [7u8; 6].into());
626
627    fn passive_scan_req() -> fidl_mlme::ScanRequest {
628        fidl_mlme::ScanRequest {
629            txn_id: 1337,
630            scan_type: fidl_mlme::ScanTypes::Passive,
631            channel_list: vec![6],
632            ssid_list: vec![],
633            probe_delay: 0,
634            min_channel_time: 100,
635            max_channel_time: 300,
636        }
637    }
638
639    fn active_scan_req(channel_list: &[u8]) -> fidl_mlme::ScanRequest {
640        fidl_mlme::ScanRequest {
641            txn_id: 1337,
642            scan_type: fidl_mlme::ScanTypes::Active,
643            channel_list: Vec::from(channel_list),
644            ssid_list: vec![
645                Ssid::try_from("foo").unwrap().into(),
646                Ssid::try_from("bar").unwrap().into(),
647            ],
648            probe_delay: 3,
649            min_channel_time: 100,
650            max_channel_time: 300,
651        }
652    }
653
654    #[fuchsia::test(allow_stalls = false)]
655    async fn test_handle_scan_req_reject_if_busy() {
656        let mut m = MockObjects::new().await;
657        let mut ctx = m.make_ctx();
658        let mut scanner = Scanner::new(*IFACE_MAC);
659
660        scanner
661            .bind(&mut ctx)
662            .on_sme_scan(passive_scan_req())
663            .await
664            .expect("expect scan req accepted");
665        let scan_req = fidl_mlme::ScanRequest { txn_id: 1338, ..passive_scan_req() };
666        let result = scanner.bind(&mut ctx).on_sme_scan(scan_req).await;
667        assert_matches!(result, Err(Error::ScanError(ScanError::Busy)));
668        m.fake_device_state
669            .lock()
670            .next_mlme_msg::<fidl_mlme::ScanEnd>()
671            .expect_err("unexpected MLME ScanEnd from BoundScanner");
672    }
673
674    #[fuchsia::test(allow_stalls = false)]
675    async fn test_handle_scan_req_reject_if_disabled() {
676        let mut m = MockObjects::new().await;
677        let mut ctx = m.make_ctx();
678        let mut scanner = Scanner::new(*IFACE_MAC);
679
680        scanner.bind(&mut ctx).disable_scanning().await.expect("Failed to disable scanning");
681        let result = scanner.bind(&mut ctx).on_sme_scan(passive_scan_req()).await;
682        assert_matches!(result, Err(Error::ScanError(ScanError::Busy)));
683        m.fake_device_state
684            .lock()
685            .next_mlme_msg::<fidl_mlme::ScanEnd>()
686            .expect_err("unexpected MLME ScanEnd from BoundScanner");
687
688        // Accept after reenabled.
689        scanner.bind(&mut ctx).enable_scanning();
690        scanner
691            .bind(&mut ctx)
692            .on_sme_scan(passive_scan_req())
693            .await
694            .expect("expect scan req accepted");
695    }
696
697    #[fuchsia::test(allow_stalls = false)]
698    async fn test_handle_scan_req_empty_channel_list() {
699        let mut m = MockObjects::new().await;
700        let mut ctx = m.make_ctx();
701        let mut scanner = Scanner::new(*IFACE_MAC);
702
703        let scan_req = fidl_mlme::ScanRequest { channel_list: vec![], ..passive_scan_req() };
704        let result = scanner.bind(&mut ctx).on_sme_scan(scan_req).await;
705        assert_matches!(result, Err(Error::ScanError(ScanError::EmptyChannelList)));
706        m.fake_device_state
707            .lock()
708            .next_mlme_msg::<fidl_mlme::ScanEnd>()
709            .expect_err("unexpected MLME ScanEnd from BoundScanner");
710    }
711
712    #[fuchsia::test(allow_stalls = false)]
713    async fn test_handle_scan_req_invalid_channel_time() {
714        let mut m = MockObjects::new().await;
715        let mut ctx = m.make_ctx();
716        let mut scanner = Scanner::new(*IFACE_MAC);
717
718        let scan_req = fidl_mlme::ScanRequest {
719            min_channel_time: 101,
720            max_channel_time: 100,
721            ..passive_scan_req()
722        };
723        let result = scanner.bind(&mut ctx).on_sme_scan(scan_req).await;
724        assert_matches!(result, Err(Error::ScanError(ScanError::MaxChannelTimeLtMin)));
725        m.fake_device_state
726            .lock()
727            .next_mlme_msg::<fidl_mlme::ScanEnd>()
728            .expect_err("unexpected MLME ScanEnd from BoundScanner");
729    }
730
731    #[fuchsia::test(allow_stalls = false)]
732    async fn test_start_offload_passive_scan_success() {
733        let mut m = MockObjects::new().await;
734        let mut ctx = m.make_ctx();
735        let mut scanner = Scanner::new(*IFACE_MAC);
736        let test_start_timestamp_nanos = zx::MonotonicInstant::get().into_nanos();
737
738        scanner
739            .bind(&mut ctx)
740            .on_sme_scan(passive_scan_req())
741            .await
742            .expect("expect scan req accepted");
743
744        // Verify that passive offload scan is requested
745        assert_eq!(
746            m.fake_device_state.lock().captured_passive_scan_request,
747            Some(fidl_softmac::WlanSoftmacBaseStartPassiveScanRequest {
748                channels: Some(vec![6]),
749                min_channel_time: Some(102_400_000),
750                max_channel_time: Some(307_200_000),
751                min_home_time: Some(0),
752                ..Default::default()
753            }),
754        );
755        let expected_scan_id = m.fake_device_state.lock().next_scan_id - 1;
756
757        // Mock receiving a beacon
758        handle_beacon_foo(&mut scanner, &mut ctx);
759        let scan_result = m
760            .fake_device_state
761            .lock()
762            .next_mlme_msg::<fidl_mlme::ScanResult>()
763            .expect("error reading ScanResult");
764        assert_eq!(scan_result.txn_id, 1337);
765        assert!(scan_result.timestamp_nanos > test_start_timestamp_nanos);
766        assert_eq!(scan_result.bss, *BSS_DESCRIPTION_FOO);
767
768        // Verify ScanEnd sent after handle_scan_complete
769        scanner.bind(&mut ctx).handle_scan_complete(zx::Status::OK, expected_scan_id).await;
770        let scan_end = m
771            .fake_device_state
772            .lock()
773            .next_mlme_msg::<fidl_mlme::ScanEnd>()
774            .expect("error reading MLME ScanEnd");
775        assert_eq!(
776            scan_end,
777            fidl_mlme::ScanEnd { txn_id: 1337, code: fidl_mlme::ScanResultCode::Success }
778        );
779    }
780
781    struct ExpectedDynamicActiveScanRequest {
782        channels: Vec<u8>,
783        ies: Vec<u8>,
784    }
785
786    #[test_case(&[6],
787                Some(ExpectedDynamicActiveScanRequest {
788                    channels: vec![6],
789                    ies: vec![ 0x01, // Element ID for Supported Rates
790                               0x08, // Length
791                               0x02, 0x04, 0x0b, 0x16, 0x0c, 0x12, 0x18, 0x24, // Supported Rates
792                               0x32, // Element ID for Extended Supported Rates
793                               0x04, // Length
794                               0x30, 0x48, 0x60, 0x6c // Extended Supported Rates
795                    ]}),
796                None; "single channel")]
797    #[test_case(&[1, 2, 3, 4, 5],
798                Some(ExpectedDynamicActiveScanRequest {
799                    channels: vec![1, 2, 3, 4, 5],
800                    ies: vec![ 0x01, // Element ID for Supported Rates
801                               0x08, // Length
802                               0x02, 0x04, 0x0b, 0x16, 0x0c, 0x12, 0x18, 0x24, // Supported Rates
803                               0x32, // Element ID for Extended Supported Rates
804                               0x04, // Length
805                               0x30, 0x48, 0x60, 0x6c // Extended Supported Rates
806                    ]}),
807                None; "multiple channels 2.4GHz band")]
808    #[test_case(&[36, 40, 100, 108],
809                None,
810                Some(ExpectedDynamicActiveScanRequest {
811                    channels: vec![36, 40, 100, 108],
812                    ies: vec![ 0x01, // Element ID for Supported Rates
813                               0x08, // Length
814                               0x02, 0x04, 0x0b, 0x16, 0x30, 0x60, 0x7e, 0x7f // Supported Rates
815                    ],
816                }); "multiple channels 5GHz band")]
817    #[test_case(&[1, 2, 3, 4, 5, 36, 40, 100, 108],
818                Some(ExpectedDynamicActiveScanRequest {
819                    channels: vec![1, 2, 3, 4, 5],
820                    ies: vec![ 0x01, // Element ID for Supported Rates
821                               0x08, // Length
822                               0x02, 0x04, 0x0b, 0x16, 0x0c, 0x12, 0x18, 0x24, // Supported Rates
823                               0x32, // Element ID for Extended Supported Rates
824                               0x04, // Length
825                               0x30, 0x48, 0x60, 0x6c // Extended Supported Rates
826                    ]}),
827                Some(ExpectedDynamicActiveScanRequest {
828                    channels: vec![36, 40, 100, 108],
829                    ies: vec![ 0x01, // Element ID for Supported Rates
830                               0x08, // Length
831                               0x02, 0x04, 0x0b, 0x16, 0x30, 0x60, 0x7e, 0x7f, // Supported Rates
832                    ],
833                }); "multiple bands")]
834    #[fuchsia::test(allow_stalls = false)]
835    async fn test_start_active_scan_success(
836        channel_list: &[u8],
837        expected_two_ghz_dynamic_args: Option<ExpectedDynamicActiveScanRequest>,
838        expected_five_ghz_dynamic_args: Option<ExpectedDynamicActiveScanRequest>,
839    ) {
840        let mut m = MockObjects::new().await;
841        let mut ctx = m.make_ctx();
842        let mut scanner = Scanner::new(*IFACE_MAC);
843        let test_start_timestamp_nanos = zx::MonotonicInstant::get().into_nanos();
844
845        scanner
846            .bind(&mut ctx)
847            .on_sme_scan(active_scan_req(channel_list))
848            .await
849            .expect("expect scan req accepted");
850
851        for probe_request_ies in &[expected_two_ghz_dynamic_args, expected_five_ghz_dynamic_args] {
852            match probe_request_ies {
853                None => {}
854                Some(ExpectedDynamicActiveScanRequest { channels, ies, .. }) => {
855                    // Verify that active offload scan is requested
856                    assert_eq!(
857                        m.fake_device_state.lock().captured_active_scan_request,
858                        Some(fidl_softmac::WlanSoftmacStartActiveScanRequest {
859                            channels: Some(channels.clone()),
860                            ssids: Some(vec![
861                                cssid_from_ssid_unchecked(&Ssid::try_from("foo").unwrap().into()),
862                                cssid_from_ssid_unchecked(&Ssid::try_from("bar").unwrap().into()),
863                            ]),
864                            mac_header: Some(vec![
865                                0x40, 0x00, // Frame Control
866                                0x00, 0x00, // Duration
867                                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // Address 1
868                                0x07, 0x07, 0x07, 0x07, 0x07, 0x07, // Address 2
869                                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // Address 3
870                                0x10, 0x00, // Sequence Control
871                            ]),
872                            ies: Some(ies.clone()),
873                            min_channel_time: Some(102_400_000),
874                            max_channel_time: Some(307_200_000),
875                            min_home_time: Some(0),
876                            min_probes_per_channel: Some(0),
877                            max_probes_per_channel: Some(0),
878                            ..Default::default()
879                        }),
880                        "active offload scan not initiated"
881                    );
882                    let expected_scan_id = m.fake_device_state.lock().next_scan_id - 1;
883
884                    // Mock receiving beacons
885                    handle_beacon_foo(&mut scanner, &mut ctx);
886                    let scan_result = m
887                        .fake_device_state
888                        .lock()
889                        .next_mlme_msg::<fidl_mlme::ScanResult>()
890                        .expect("error reading ScanResult");
891                    assert_eq!(scan_result.txn_id, 1337);
892                    assert!(scan_result.timestamp_nanos > test_start_timestamp_nanos);
893                    assert_eq!(scan_result.bss, *BSS_DESCRIPTION_FOO);
894
895                    handle_beacon_bar(&mut scanner, &mut ctx);
896                    let scan_result = m
897                        .fake_device_state
898                        .lock()
899                        .next_mlme_msg::<fidl_mlme::ScanResult>()
900                        .expect("error reading ScanResult");
901                    assert_eq!(scan_result.txn_id, 1337);
902                    assert!(scan_result.timestamp_nanos > test_start_timestamp_nanos);
903                    assert_eq!(scan_result.bss, *BSS_DESCRIPTION_BAR);
904
905                    // Verify ScanEnd sent after handle_scan_complete
906                    scanner
907                        .bind(&mut ctx)
908                        .handle_scan_complete(zx::Status::OK, expected_scan_id)
909                        .await;
910                }
911            }
912        }
913        let scan_end = m
914            .fake_device_state
915            .lock()
916            .next_mlme_msg::<fidl_mlme::ScanEnd>()
917            .expect("error reading MLME ScanEnd");
918        assert_eq!(
919            scan_end,
920            fidl_mlme::ScanEnd { txn_id: 1337, code: fidl_mlme::ScanResultCode::Success }
921        );
922    }
923
924    #[fuchsia::test(allow_stalls = false)]
925    async fn test_start_passive_scan_fails() {
926        let mut m = MockObjects::new().await;
927        m.fake_device_state.lock().config.start_passive_scan_fails = true;
928        let mut ctx = m.make_ctx();
929        let mut scanner = Scanner::new(*IFACE_MAC);
930
931        let result = scanner.bind(&mut ctx).on_sme_scan(passive_scan_req()).await;
932        assert_matches!(
933            result,
934            Err(Error::ScanError(ScanError::StartOffloadScanFails(zx::Status::NOT_SUPPORTED)))
935        );
936        m.fake_device_state
937            .lock()
938            .next_mlme_msg::<fidl_mlme::ScanEnd>()
939            .expect_err("unexpected MLME ScanEnd from BoundScanner");
940    }
941
942    #[fuchsia::test(allow_stalls = false)]
943    async fn test_start_active_scan_fails() {
944        let mut m = MockObjects::new().await;
945        m.fake_device_state.lock().config.start_active_scan_fails = true;
946        let mut ctx = m.make_ctx();
947        let mut scanner = Scanner::new(*IFACE_MAC);
948
949        let result = scanner.bind(&mut ctx).on_sme_scan(active_scan_req(&[6])).await;
950        assert_matches!(
951            result,
952            Err(Error::ScanError(ScanError::StartOffloadScanFails(zx::Status::NOT_SUPPORTED)))
953        );
954        m.fake_device_state
955            .lock()
956            .next_mlme_msg::<fidl_mlme::ScanEnd>()
957            .expect_err("unexpected MLME ScanEnd from BoundScanner");
958    }
959
960    #[fuchsia::test(allow_stalls = false)]
961    async fn test_start_passive_scan_canceled() {
962        let mut m = MockObjects::new().await;
963        let mut ctx = m.make_ctx();
964        let mut scanner = Scanner::new(*IFACE_MAC);
965        let test_start_timestamp_nanos = zx::MonotonicInstant::get().into_nanos();
966
967        scanner
968            .bind(&mut ctx)
969            .on_sme_scan(passive_scan_req())
970            .await
971            .expect("expect scan req accepted");
972
973        // Verify that passive offload scan is requested
974        assert_matches!(
975            m.fake_device_state.lock().captured_passive_scan_request,
976            Some(_),
977            "passive offload scan not initiated"
978        );
979        let expected_scan_id = m.fake_device_state.lock().next_scan_id - 1;
980
981        // Mock receiving a beacon
982        handle_beacon_foo(&mut scanner, &mut ctx);
983        let scan_result = m
984            .fake_device_state
985            .lock()
986            .next_mlme_msg::<fidl_mlme::ScanResult>()
987            .expect("error reading ScanResult");
988        assert_eq!(scan_result.txn_id, 1337);
989        assert!(scan_result.timestamp_nanos > test_start_timestamp_nanos);
990        assert_eq!(scan_result.bss, *BSS_DESCRIPTION_FOO);
991
992        // Verify ScanEnd sent after handle_scan_complete
993        scanner.bind(&mut ctx).handle_scan_complete(zx::Status::CANCELED, expected_scan_id).await;
994        let scan_end = m
995            .fake_device_state
996            .lock()
997            .next_mlme_msg::<fidl_mlme::ScanEnd>()
998            .expect("error reading MLME ScanEnd");
999        assert_eq!(
1000            scan_end,
1001            fidl_mlme::ScanEnd { txn_id: 1337, code: fidl_mlme::ScanResultCode::InternalError }
1002        );
1003    }
1004
1005    #[fuchsia::test(allow_stalls = false)]
1006    async fn test_start_active_scan_canceled() {
1007        let mut m = MockObjects::new().await;
1008        let mut ctx = m.make_ctx();
1009        let mut scanner = Scanner::new(*IFACE_MAC);
1010        let test_start_timestamp_nanos = zx::MonotonicInstant::get().into_nanos();
1011
1012        scanner
1013            .bind(&mut ctx)
1014            .on_sme_scan(active_scan_req(&[6]))
1015            .await
1016            .expect("expect scan req accepted");
1017
1018        // Verify that active offload scan is requested
1019        assert!(
1020            m.fake_device_state.lock().captured_active_scan_request.is_some(),
1021            "active offload scan not initiated"
1022        );
1023        let expected_scan_id = m.fake_device_state.lock().next_scan_id - 1;
1024
1025        // Mock receiving a beacon
1026        handle_beacon_foo(&mut scanner, &mut ctx);
1027        let scan_result = m
1028            .fake_device_state
1029            .lock()
1030            .next_mlme_msg::<fidl_mlme::ScanResult>()
1031            .expect("error reading ScanResult");
1032        assert_eq!(scan_result.txn_id, 1337);
1033        assert!(scan_result.timestamp_nanos > test_start_timestamp_nanos);
1034        assert_eq!(scan_result.bss, *BSS_DESCRIPTION_FOO);
1035
1036        // Verify ScanEnd sent after handle_scan_complete
1037        scanner.bind(&mut ctx).handle_scan_complete(zx::Status::CANCELED, expected_scan_id).await;
1038        let scan_end = m
1039            .fake_device_state
1040            .lock()
1041            .next_mlme_msg::<fidl_mlme::ScanEnd>()
1042            .expect("error reading MLME ScanEnd");
1043        assert_eq!(
1044            scan_end,
1045            fidl_mlme::ScanEnd { txn_id: 1337, code: fidl_mlme::ScanResultCode::InternalError }
1046        );
1047    }
1048
1049    #[fuchsia::test(allow_stalls = false)]
1050    async fn test_handle_ap_advertisement() {
1051        let mut m = MockObjects::new().await;
1052        let mut ctx = m.make_ctx();
1053        let mut scanner = Scanner::new(*IFACE_MAC);
1054        let test_start_timestamp_nanos = zx::MonotonicInstant::get().into_nanos();
1055
1056        scanner
1057            .bind(&mut ctx)
1058            .on_sme_scan(passive_scan_req())
1059            .await
1060            .expect("expect scan req accepted");
1061        handle_beacon_foo(&mut scanner, &mut ctx);
1062        let ongoing_scan_id = scanner.ongoing_scan.as_ref().unwrap().scan_id();
1063        scanner.bind(&mut ctx).handle_scan_complete(zx::Status::OK, ongoing_scan_id).await;
1064
1065        let scan_result = m
1066            .fake_device_state
1067            .lock()
1068            .next_mlme_msg::<fidl_mlme::ScanResult>()
1069            .expect("error reading MLME ScanResult");
1070        assert_eq!(scan_result.txn_id, 1337);
1071        assert!(scan_result.timestamp_nanos > test_start_timestamp_nanos);
1072        assert_eq!(scan_result.bss, *BSS_DESCRIPTION_FOO);
1073
1074        let scan_end = m
1075            .fake_device_state
1076            .lock()
1077            .next_mlme_msg::<fidl_mlme::ScanEnd>()
1078            .expect("error reading MLME ScanEnd");
1079        assert_eq!(
1080            scan_end,
1081            fidl_mlme::ScanEnd { txn_id: 1337, code: fidl_mlme::ScanResultCode::Success }
1082        );
1083    }
1084
1085    #[fuchsia::test(allow_stalls = false)]
1086    async fn test_handle_ap_advertisement_multiple() {
1087        let mut m = MockObjects::new().await;
1088        let mut ctx = m.make_ctx();
1089        let mut scanner = Scanner::new(*IFACE_MAC);
1090        let test_start_timestamp_nanos = zx::MonotonicInstant::get().into_nanos();
1091
1092        scanner
1093            .bind(&mut ctx)
1094            .on_sme_scan(passive_scan_req())
1095            .await
1096            .expect("expect scan req accepted");
1097
1098        handle_beacon_foo(&mut scanner, &mut ctx);
1099        handle_beacon_bar(&mut scanner, &mut ctx);
1100        let ongoing_scan_id = scanner.ongoing_scan.as_ref().unwrap().scan_id();
1101        scanner.bind(&mut ctx).handle_scan_complete(zx::Status::OK, ongoing_scan_id).await;
1102
1103        // Verify that one scan result is sent for each beacon
1104        let foo_scan_result = m
1105            .fake_device_state
1106            .lock()
1107            .next_mlme_msg::<fidl_mlme::ScanResult>()
1108            .expect("error reading MLME ScanResult");
1109        assert_eq!(foo_scan_result.txn_id, 1337);
1110        assert!(foo_scan_result.timestamp_nanos > test_start_timestamp_nanos);
1111        assert_eq!(foo_scan_result.bss, *BSS_DESCRIPTION_FOO);
1112
1113        let bar_scan_result = m
1114            .fake_device_state
1115            .lock()
1116            .next_mlme_msg::<fidl_mlme::ScanResult>()
1117            .expect("error reading MLME ScanResult");
1118        assert_eq!(bar_scan_result.txn_id, 1337);
1119        assert!(bar_scan_result.timestamp_nanos > foo_scan_result.timestamp_nanos);
1120        assert_eq!(bar_scan_result.bss, *BSS_DESCRIPTION_BAR);
1121
1122        let scan_end = m
1123            .fake_device_state
1124            .lock()
1125            .next_mlme_msg::<fidl_mlme::ScanEnd>()
1126            .expect("error reading MLME ScanEnd");
1127        assert_eq!(
1128            scan_end,
1129            fidl_mlme::ScanEnd { txn_id: 1337, code: fidl_mlme::ScanResultCode::Success }
1130        );
1131    }
1132
1133    #[fuchsia::test(allow_stalls = false)]
1134    async fn not_scanning_vs_scanning() {
1135        let mut m = MockObjects::new().await;
1136        let mut ctx = m.make_ctx();
1137        let mut scanner = Scanner::new(*IFACE_MAC);
1138        assert_eq!(false, scanner.is_scanning());
1139
1140        scanner
1141            .bind(&mut ctx)
1142            .on_sme_scan(passive_scan_req())
1143            .await
1144            .expect("expect scan req accepted");
1145        assert_eq!(true, scanner.is_scanning());
1146    }
1147
1148    fn handle_beacon_foo(scanner: &mut Scanner, ctx: &mut Context<FakeDevice>) {
1149        scanner.bind(ctx).handle_ap_advertisement(
1150            *BSSID_FOO,
1151            TimeUnit(BEACON_INTERVAL_FOO),
1152            CAPABILITY_INFO_FOO,
1153            BEACON_IES_FOO,
1154            RX_INFO_FOO.clone(),
1155        );
1156    }
1157
1158    fn handle_beacon_bar(scanner: &mut Scanner, ctx: &mut Context<FakeDevice>) {
1159        scanner.bind(ctx).handle_ap_advertisement(
1160            *BSSID_BAR,
1161            TimeUnit(BEACON_INTERVAL_BAR),
1162            CAPABILITY_INFO_BAR,
1163            BEACON_IES_BAR,
1164            RX_INFO_BAR.clone(),
1165        );
1166    }
1167
1168    struct MockObjects {
1169        fake_device: FakeDevice,
1170        fake_device_state: Arc<Mutex<FakeDeviceState>>,
1171        _time_stream: timer::EventStream<TimedEvent>,
1172        timer: Option<Timer<TimedEvent>>,
1173    }
1174
1175    impl MockObjects {
1176        // TODO(https://fxbug.dev/327499461): This function is async to ensure MLME functions will
1177        // run in an async context and not call `wlan_common::timer::Timer::now` without an
1178        // executor.
1179        async fn new() -> Self {
1180            let (timer, _time_stream) = create_timer();
1181            let (fake_device, fake_device_state) = FakeDevice::new().await;
1182            Self { fake_device, fake_device_state, _time_stream, timer: Some(timer) }
1183        }
1184
1185        fn make_ctx(&mut self) -> Context<FakeDevice> {
1186            Context {
1187                _config: Default::default(),
1188                device: self.fake_device.clone(),
1189                timer: self.timer.take().unwrap(),
1190                seq_mgr: SequenceManager::new(),
1191            }
1192        }
1193    }
1194}
wlan_mlme/client/scanner.rs

wlan_mlme/client/
scanner.rs
