wlan_hw_sim/
lib.rs

Help
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::event::action::{self, AuthenticationControl, AuthenticationTap};
6use crate::event::{branch, Handler};
7use fidl::endpoints::{create_endpoints, create_proxy};
8use fidl_fuchsia_wlan_common::WlanMacRole;
9use fidl_fuchsia_wlan_tap::{WlanRxInfo, WlantapPhyConfig, WlantapPhyProxy};
10use fuchsia_component::client::connect_to_protocol_at;
11use ieee80211::{Bssid, MacAddr, Ssid};
12use lazy_static::lazy_static;
13use std::future::Future;
14use std::pin::pin;
15use wlan_common::bss::Protection;
16use wlan_common::channel::{Cbw, Channel};
17use wlan_common::ie::rsn::cipher::{Cipher, CIPHER_CCMP_128, CIPHER_TKIP};
18use wlan_common::ie::rsn::rsne;
19use wlan_common::ie::rsn::suite_filter::DEFAULT_GROUP_MGMT_CIPHER;
20use wlan_common::ie::wpa;
21use wlan_common::{data_writer, mac, mgmt_writer, TimeUnit};
22use wlan_frame_writer::write_frame_to_vec;
23use wlan_rsn::rsna::UpdateSink;
24use {
25    fidl_fuchsia_wlan_common as fidl_common, fidl_fuchsia_wlan_mlme as fidl_mlme,
26    fidl_fuchsia_wlan_policy as fidl_policy, fidl_fuchsia_wlan_softmac as fidl_wlan_softmac,
27};
28
29pub mod event;
30pub mod netdevice_helper;
31pub mod test_utils;
32
33pub use wlancfg_helper::*;
34
35mod config;
36mod wlancfg_helper;
37
38pub const PSK_STR_LEN: usize = 64;
39
40lazy_static! {
41    pub static ref CLIENT_MAC_ADDR: MacAddr = [0x67, 0x62, 0x6f, 0x6e, 0x69, 0x6b].into();
42    pub static ref AP_MAC_ADDR: Bssid = [0x70, 0xf1, 0x1c, 0x05, 0x2d, 0x7f].into();
43    pub static ref AP_SSID: Ssid = Ssid::try_from("ap_ssid").unwrap();
44    pub static ref ETH_DST_MAC: MacAddr = [0x65, 0x74, 0x68, 0x64, 0x73, 0x74].into();
45}
46
47pub const WLANCFG_DEFAULT_AP_CHANNEL: Channel = Channel { primary: 11, cbw: Cbw::Cbw20 };
48
49lazy_static! {
50    // TODO(https://fxbug.dev/42060050): This sleep was introduced to preserve the old timing behavior
51    // of scanning when hw-sim depending on the SoftMAC driver iterating through all of the
52    // channels.
53    pub static ref ARTIFICIAL_SCAN_SLEEP: zx::MonotonicDuration = zx::MonotonicDuration::from_seconds(2);
54
55    // Once a client interface is available for scanning, it takes up to around 30s for a scan
56    // to complete (see https://fxbug.dev/42061276). Allow at least double that amount of time to reduce
57    // flakiness and longer than the timeout WLAN policy should have.
58    pub static ref SCAN_RESPONSE_TEST_TIMEOUT: zx::MonotonicDuration = zx::MonotonicDuration::from_seconds(70);
59}
60
61/// A client supplicant.
62///
63/// Provides the client and security components necessary to attempt a connection via Policy.
64pub struct Supplicant<'a> {
65    pub controller: &'a fidl_policy::ClientControllerProxy,
66    pub state_update_stream: &'a mut fidl_policy::ClientStateUpdatesRequestStream,
67    pub security_type: fidl_policy::SecurityType,
68    pub password: Option<&'a str>,
69}
70
71impl<'a> Supplicant<'a> {
72    /// Clones the supplicant through reborrowing of mutable references.
73    ///
74    /// # Examples
75    ///
76    /// This function can be used for templating.
77    ///
78    /// ```rust,ignore
79    /// let mut supplicant = Supplicant { /* ... */ }; // Template.
80    /// // ...
81    /// // Connect via the template supplicant but with a particular password.
82    /// let _ = connect(Supplicant { password: "********", ..supplicant.reborrow() });
83    /// ```
84    pub fn reborrow(&mut self) -> Supplicant<'_> {
85        Supplicant {
86            controller: self.controller,
87            state_update_stream: &mut *self.state_update_stream,
88            security_type: self.security_type,
89            password: self.password,
90        }
91    }
92}
93
94pub fn default_wlantap_config_client() -> WlantapPhyConfig {
95    wlantap_config_client(format!("wlantap-client"), *CLIENT_MAC_ADDR)
96}
97
98pub fn wlantap_config_client(name: String, mac_addr: MacAddr) -> WlantapPhyConfig {
99    config::create_wlantap_config(name, mac_addr, WlanMacRole::Client)
100}
101
102pub fn default_wlantap_config_ap() -> WlantapPhyConfig {
103    wlantap_config_ap(format!("wlantap-ap"), (*AP_MAC_ADDR).into())
104}
105
106pub fn wlantap_config_ap(name: String, mac_addr: MacAddr) -> WlantapPhyConfig {
107    config::create_wlantap_config(name, mac_addr, WlanMacRole::Ap)
108}
109
110pub fn rx_info_with_default_ap() -> WlanRxInfo {
111    rx_info_with_valid_rssi(&WLANCFG_DEFAULT_AP_CHANNEL, 0)
112}
113
114fn rx_info_with_valid_rssi(channel: &Channel, rssi_dbm: i8) -> WlanRxInfo {
115    WlanRxInfo {
116        rx_flags: 0,
117        valid_fields: if rssi_dbm == 0 {
118            0
119        } else {
120            fidl_wlan_softmac::WlanRxInfoValid::RSSI.bits()
121        },
122        phy: fidl_common::WlanPhyType::Dsss,
123        data_rate: 0,
124        channel: fidl_common::WlanChannel::from(channel),
125        mcs: 0,
126        rssi_dbm,
127        snr_dbh: 0,
128    }
129}
130
131pub fn send_sae_authentication_frame(
132    sae_frame: &fidl_mlme::SaeFrame,
133    channel: &Channel,
134    bssid: &Bssid,
135    proxy: &WlantapPhyProxy,
136) -> Result<(), anyhow::Error> {
137    let buffer = write_frame_to_vec!({
138        headers: {
139            mac::MgmtHdr: &mgmt_writer::mgmt_hdr_from_ap(
140                mac::FrameControl(0)
141                    .with_frame_type(mac::FrameType::MGMT)
142                    .with_mgmt_subtype(mac::MgmtSubtype::AUTH),
143                *CLIENT_MAC_ADDR,
144                bssid.clone().into(),
145                mac::SequenceControl(0).with_seq_num(123),
146            ),
147            mac::AuthHdr: &mac::AuthHdr {
148                auth_alg_num: mac::AuthAlgorithmNumber::SAE,
149                auth_txn_seq_num: sae_frame.seq_num,
150                status_code: sae_frame.status_code.into(),
151            },
152        },
153        body: &sae_frame.sae_fields[..],
154    })?;
155    proxy.rx(&buffer, &rx_info_with_valid_rssi(channel, 0))?;
156    Ok(())
157}
158
159pub fn send_open_authentication(
160    channel: &Channel,
161    bssid: &Bssid,
162    status_code: impl Into<mac::StatusCode>,
163    proxy: &WlantapPhyProxy,
164) -> Result<(), anyhow::Error> {
165    let buffer = write_frame_to_vec!({
166        headers: {
167            mac::MgmtHdr: &mgmt_writer::mgmt_hdr_from_ap(
168                mac::FrameControl(0)
169                    .with_frame_type(mac::FrameType::MGMT)
170                    .with_mgmt_subtype(mac::MgmtSubtype::AUTH),
171                *CLIENT_MAC_ADDR,
172                bssid.clone().into(),
173                mac::SequenceControl(0).with_seq_num(123),
174            ),
175            mac::AuthHdr: &mac::AuthHdr {
176                auth_alg_num: mac::AuthAlgorithmNumber::OPEN,
177                auth_txn_seq_num: 2,
178                status_code: status_code.into(),
179            },
180        },
181    })?;
182    proxy.rx(&buffer, &rx_info_with_valid_rssi(channel, 0))?;
183    Ok(())
184}
185
186pub fn send_association_response(
187    channel: &Channel,
188    bssid: &Bssid,
189    status_code: impl Into<mac::StatusCode>,
190    proxy: &WlantapPhyProxy,
191) -> Result<(), anyhow::Error> {
192    let buffer = write_frame_to_vec!({
193        headers: {
194            mac::MgmtHdr: &mgmt_writer::mgmt_hdr_from_ap(
195                mac::FrameControl(0)
196                    .with_frame_type(mac::FrameType::MGMT)
197                    .with_mgmt_subtype(mac::MgmtSubtype::ASSOC_RESP),
198                *CLIENT_MAC_ADDR,
199                bssid.clone().into(),
200                mac::SequenceControl(0).with_seq_num(123),
201            ),
202            mac::AssocRespHdr: &mac::AssocRespHdr {
203                capabilities: mac::CapabilityInfo(0).with_ess(true).with_short_preamble(true),
204                status_code: status_code.into(),
205                aid: 2, // does not matter
206            },
207        },
208        ies: {
209            // These rates will be captured in assoc_cfg to initialize Minstrel. 11b rates are
210            // ignored.
211            // tx_vec_idx:        _     _     _   129   130     _   131   132
212            supported_rates: &[0x82, 0x84, 0x8b, 0x0c, 0x12, 0x96, 0x18, 0x24],
213            // tx_vec_idx:              133 134 basic_135  136
214            extended_supported_rates:  &[48, 72, 128 + 96, 108],
215        },
216    })?;
217    proxy.rx(&buffer, &rx_info_with_valid_rssi(channel, 0))?;
218    Ok(())
219}
220
221pub fn send_disassociate(
222    channel: &Channel,
223    bssid: &Bssid,
224    reason_code: impl Into<mac::ReasonCode>,
225    proxy: &WlantapPhyProxy,
226) -> Result<(), anyhow::Error> {
227    let buffer = write_frame_to_vec!({
228        headers: {
229            mac::MgmtHdr: &mgmt_writer::mgmt_hdr_from_ap(
230                mac::FrameControl(0)
231                    .with_frame_type(mac::FrameType::MGMT)
232                    .with_mgmt_subtype(mac::MgmtSubtype::DISASSOC),
233                *CLIENT_MAC_ADDR,
234                bssid.clone().into(),
235                mac::SequenceControl(0).with_seq_num(123),
236            ),
237            mac::DisassocHdr: &mac::DisassocHdr {
238                reason_code: reason_code.into(),
239            },
240        },
241    })?;
242    proxy.rx(&buffer, &rx_info_with_valid_rssi(channel, 0))?;
243    Ok(())
244}
245
246pub fn password_or_psk_to_policy_credential<S: ToString>(
247    password_or_psk: Option<S>,
248) -> fidl_policy::Credential {
249    return match password_or_psk {
250        None => fidl_policy::Credential::None(fidl_policy::Empty),
251        Some(p) => {
252            let p = p.to_string().as_bytes().to_vec();
253            if p.len() == PSK_STR_LEN {
254                // The PSK is given in a 64 character hexadecimal string.
255                let psk = hex::decode(p).expect("Failed to decode psk");
256                fidl_policy::Credential::Psk(psk)
257            } else {
258                fidl_policy::Credential::Password(p)
259            }
260        }
261    };
262}
263
264pub fn create_authenticator(
265    bssid: &Bssid,
266    ssid: &Ssid,
267    password_or_psk: &str,
268    // The group key cipher
269    gtk_cipher: Cipher,
270    // The advertised protection in the IEs during the 4-way handshake
271    advertised_protection: Protection,
272    // The protection used for the actual handshake
273    supplicant_protection: Protection,
274) -> wlan_rsn::Authenticator {
275    let nonce_rdr =
276        wlan_rsn::nonce::NonceReader::new(&bssid.clone().into()).expect("creating nonce reader");
277    let gtk_provider = wlan_rsn::GtkProvider::new(gtk_cipher, 1, 0).expect("creating gtk provider");
278
279    let advertised_protection_info = match advertised_protection {
280        Protection::Wpa3Personal => wlan_rsn::ProtectionInfo::Rsne(rsne::Rsne::wpa3_rsne()),
281        Protection::Wpa2Wpa3Personal => {
282            wlan_rsn::ProtectionInfo::Rsne(rsne::Rsne::wpa2_wpa3_rsne())
283        }
284        Protection::Wpa2Personal | Protection::Wpa1Wpa2Personal => wlan_rsn::ProtectionInfo::Rsne(
285            rsne::Rsne::wpa2_rsne_with_caps(rsne::RsnCapabilities(0)),
286        ),
287        Protection::Wpa2PersonalTkipOnly | Protection::Wpa1Wpa2PersonalTkipOnly => {
288            panic!("need tkip support")
289        }
290        Protection::Wpa1 => {
291            wlan_rsn::ProtectionInfo::LegacyWpa(wpa::fake_wpa_ies::fake_deprecated_wpa1_vendor_ie())
292        }
293        _ => {
294            panic!("{} not implemented", advertised_protection)
295        }
296    };
297
298    match supplicant_protection {
299        Protection::Wpa1 | Protection::Wpa2Personal => {
300            let psk = match password_or_psk.len() {
301                PSK_STR_LEN => {
302                    // The PSK is given in a 64 character hexadecimal string.
303                    hex::decode(password_or_psk).expect("Failed to decode psk").into_boxed_slice()
304                }
305                _ => {
306                    wlan_rsn::psk::compute(password_or_psk.as_bytes(), ssid).expect("computing PSK")
307                }
308            };
309            let supplicant_protection_info = match supplicant_protection {
310                Protection::Wpa1 => wlan_rsn::ProtectionInfo::LegacyWpa(
311                    wpa::fake_wpa_ies::fake_deprecated_wpa1_vendor_ie(),
312                ),
313                Protection::Wpa2Personal => wlan_rsn::ProtectionInfo::Rsne(
314                    rsne::Rsne::wpa2_rsne_with_caps(rsne::RsnCapabilities(0)),
315                ),
316                _ => unreachable!("impossible combination in this nested match"),
317            };
318            wlan_rsn::Authenticator::new_wpa2psk_ccmp128(
319                nonce_rdr,
320                std::sync::Arc::new(std::sync::Mutex::new(gtk_provider)),
321                psk,
322                *CLIENT_MAC_ADDR,
323                supplicant_protection_info,
324                bssid.clone().into(),
325                advertised_protection_info,
326            )
327            .expect("creating authenticator")
328        }
329        Protection::Wpa3Personal => {
330            let igtk_provider = wlan_rsn::IgtkProvider::new(DEFAULT_GROUP_MGMT_CIPHER)
331                .expect("creating igtk provider");
332            let supplicant_protection_info =
333                wlan_rsn::ProtectionInfo::Rsne(rsne::Rsne::wpa3_rsne());
334            wlan_rsn::Authenticator::new_wpa3(
335                nonce_rdr,
336                std::sync::Arc::new(std::sync::Mutex::new(gtk_provider)),
337                std::sync::Arc::new(std::sync::Mutex::new(igtk_provider)),
338                ssid.clone(),
339                password_or_psk.as_bytes().to_vec(),
340                *CLIENT_MAC_ADDR,
341                supplicant_protection_info,
342                bssid.clone().into(),
343                advertised_protection_info,
344            )
345            .expect("creating authenticator")
346        }
347        _ => {
348            panic!("Cannot create an authenticator for {}", supplicant_protection)
349        }
350    }
351}
352
353pub enum ApAdvertisementMode {
354    Beacon,
355    ProbeResponse,
356}
357
358pub trait ApAdvertisement {
359    fn mode(&self) -> ApAdvertisementMode;
360    fn channel(&self) -> &Channel;
361    fn bssid(&self) -> &Bssid;
362    fn ssid(&self) -> &Ssid;
363    fn protection(&self) -> &Protection;
364    fn rssi_dbm(&self) -> i8;
365    fn wsc_ie(&self) -> Option<&Vec<u8>>;
366
367    fn beacon_interval(&self) -> TimeUnit {
368        TimeUnit::DEFAULT_BEACON_INTERVAL * 20u16
369    }
370
371    fn capabilities(&self) -> mac::CapabilityInfo {
372        mac::CapabilityInfo(0)
373            // IEEE Std 802.11-2016, 9.4.1.4: An AP sets the ESS subfield to 1 and the IBSS
374            // subfield to 0 within transmitted Beacon or Probe Response frames.
375            .with_ess(true)
376            .with_ibss(false)
377            // IEEE Std 802.11-2016, 9.4.1.4: An AP sets the Privacy subfield to 1 within
378            // transmitted Beacon, Probe Response, (Re)Association Response frames if data
379            // confidentiality is required for all Data frames exchanged within the BSS.
380            .with_privacy(*self.protection() != Protection::Open)
381    }
382
383    fn send(&self, phy: &WlantapPhyProxy) -> Result<(), anyhow::Error> {
384        let buffer = self.generate_frame()?;
385        phy.rx(&buffer, &rx_info_with_valid_rssi(&self.channel(), self.rssi_dbm()))?;
386        Ok(())
387    }
388
389    fn generate_frame(&self) -> Result<Vec<u8>, anyhow::Error> {
390        let mode = self.mode();
391        let protection = self.protection();
392        let beacon_header = match mode {
393            ApAdvertisementMode::Beacon => {
394                Some(mac::BeaconHdr::new(self.beacon_interval(), self.capabilities()))
395            }
396            _ => None,
397        };
398        let probe_response_header = match mode {
399            ApAdvertisementMode::ProbeResponse => {
400                Some(mac::ProbeRespHdr::new(self.beacon_interval(), self.capabilities()))
401            }
402            _ => None,
403        };
404
405        let buffer = write_frame_to_vec!({
406            headers: {
407                mac::MgmtHdr: &mgmt_writer::mgmt_hdr_from_ap(
408                    mac::FrameControl(0)
409                        .with_frame_type(mac::FrameType::MGMT)
410                        .with_mgmt_subtype(match mode {
411                            ApAdvertisementMode::Beacon => mac::MgmtSubtype::BEACON,
412                            ApAdvertisementMode::ProbeResponse{..} => mac::MgmtSubtype::PROBE_RESP
413                        }),
414                    match mode {
415                        ApAdvertisementMode::Beacon => ieee80211::BROADCAST_ADDR,
416                        ApAdvertisementMode::ProbeResponse{..} => *CLIENT_MAC_ADDR
417                    },
418                    *self.bssid(),
419                    mac::SequenceControl(0).with_seq_num(123),
420                ),
421                mac::BeaconHdr?: beacon_header,
422                mac::ProbeRespHdr?: probe_response_header,
423            },
424            ies: {
425                ssid: &self.ssid(),
426                supported_rates: &[0x82, 0x84, 0x8b, 0x0c, 0x12, 0x96, 0x18, 0x24, 0x30, 0x48, 0xe0, 0x6c],
427                extended_supported_rates: { /* continues from supported_rates */ },
428                dsss_param_set: &ie::DsssParamSet { current_channel: self.channel().primary },
429                rsne?: match protection {
430                    Protection::Unknown => panic!("Cannot send beacon with unknown protection"),
431                    Protection::Open | Protection::Wep | Protection::Wpa1 => None,
432                    Protection::Wpa1Wpa2Personal | Protection::Wpa2Personal =>
433                        Some(rsne::Rsne::wpa2_rsne_with_caps(rsne::RsnCapabilities(0))),
434                    Protection::Wpa2Wpa3Personal => Some(rsne::Rsne::wpa2_wpa3_rsne()),
435                    Protection::Wpa3Personal => Some(rsne::Rsne::wpa3_rsne()),
436                    _ => panic!("unsupported fake beacon: {:?}", protection),
437                },
438                wpa1?: match protection {
439                    Protection::Unknown => panic!("Cannot send beacon with unknown protection"),
440                    Protection::Open | Protection::Wep => None,
441                    Protection::Wpa1 | Protection::Wpa1Wpa2Personal => Some(wpa::fake_wpa_ies::fake_deprecated_wpa1_vendor_ie()),
442                    Protection::Wpa2Personal | Protection::Wpa2Wpa3Personal | Protection::Wpa3Personal => None,
443                    _ => panic!("unsupported fake beacon: {:?}", protection),
444                },
445                wsc?: self.wsc_ie()
446            },
447        })?;
448        Ok(buffer.into())
449    }
450}
451
452pub struct Beacon {
453    pub channel: Channel,
454    pub bssid: Bssid,
455    pub ssid: Ssid,
456    pub protection: Protection,
457    pub rssi_dbm: i8,
458}
459
460impl ApAdvertisement for Beacon {
461    fn mode(&self) -> ApAdvertisementMode {
462        ApAdvertisementMode::Beacon
463    }
464    fn channel(&self) -> &Channel {
465        &self.channel
466    }
467    fn bssid(&self) -> &Bssid {
468        &self.bssid
469    }
470    fn ssid(&self) -> &Ssid {
471        &self.ssid
472    }
473    fn protection(&self) -> &Protection {
474        &self.protection
475    }
476    fn rssi_dbm(&self) -> i8 {
477        self.rssi_dbm
478    }
479    fn wsc_ie(&self) -> Option<&Vec<u8>> {
480        None
481    }
482}
483
484pub struct ProbeResponse {
485    pub channel: Channel,
486    pub bssid: Bssid,
487    pub ssid: Ssid,
488    pub protection: Protection,
489    pub rssi_dbm: i8,
490    pub wsc_ie: Option<Vec<u8>>,
491}
492
493impl ApAdvertisement for ProbeResponse {
494    fn mode(&self) -> ApAdvertisementMode {
495        ApAdvertisementMode::ProbeResponse
496    }
497    fn channel(&self) -> &Channel {
498        &self.channel
499    }
500    fn bssid(&self) -> &Bssid {
501        &self.bssid
502    }
503    fn ssid(&self) -> &Ssid {
504        &self.ssid
505    }
506    fn protection(&self) -> &Protection {
507        &self.protection
508    }
509    fn rssi_dbm(&self) -> i8 {
510        self.rssi_dbm
511    }
512    fn wsc_ie(&self) -> Option<&Vec<u8>> {
513        self.wsc_ie.as_ref()
514    }
515}
516
517pub async fn save_network_and_wait_until_connected(
518    test_ns_prefix: &str,
519    ssid: &Ssid,
520    security_type: fidl_policy::SecurityType,
521    credential: fidl_policy::Credential,
522) -> (fidl_policy::ClientControllerProxy, fidl_policy::ClientStateUpdatesRequestStream) {
523    // Connect to the client policy service and get a client controller.
524    let (client_controller, mut client_state_update_stream) =
525        wlancfg_helper::init_client_controller(test_ns_prefix).await;
526
527    save_network(&client_controller, ssid, security_type, credential).await;
528
529    // Wait until the policy layer indicates that the client has successfully connected.
530    let id = fidl_policy::NetworkIdentifier { ssid: ssid.to_vec(), type_: security_type.clone() };
531    wait_until_client_state(&mut client_state_update_stream, |update| {
532        has_id_and_state(update, &id, fidl_policy::ConnectionState::Connected)
533    })
534    .await;
535
536    (client_controller, client_state_update_stream)
537}
538
539/// Runs a future until completion or timeout with a client event handler that attempts to connect
540/// to an AP with the given SSID, BSSID, and protection.
541pub async fn connect_or_timeout_with<F>(
542    helper: &mut test_utils::TestHelper,
543    timeout: zx::MonotonicDuration,
544    ssid: &Ssid,
545    bssid: &Bssid,
546    protection: &Protection,
547    authenticator: Option<wlan_rsn::Authenticator>,
548    future: F,
549) -> F::Output
550where
551    F: Future + Unpin,
552{
553    let phy = helper.proxy();
554    let channel = Channel::new(1, Cbw::Cbw20);
555    let beacons = [Beacon {
556        channel,
557        bssid: bssid.clone(),
558        ssid: ssid.clone(),
559        protection: protection.clone(),
560        rssi_dbm: -30,
561    }];
562    let mut control = authenticator
563        .map(|authenticator| AuthenticationControl { updates: UpdateSink::new(), authenticator });
564    let connect = if let Some(ref mut control) = control {
565        let tap = AuthenticationTap { control, handler: action::authenticate_with_control_state() };
566        event::boxed(action::connect_with_authentication_tap(
567            &phy, ssid, bssid, &channel, protection, tap,
568        ))
569    } else {
570        event::boxed(action::connect_with_open_authentication(
571            &phy, ssid, bssid, &channel, protection,
572        ))
573    };
574    helper
575        .run_until_complete_or_timeout(
576            timeout,
577            format!(
578                "connecting to {} ({:02X?}) with {:?} protection",
579                ssid.to_string_not_redactable(),
580                bssid,
581                protection,
582            ),
583            branch::or((
584                event::on_scan(action::send_advertisements_and_scan_completion(&phy, beacons)),
585                event::on_transmit(connect),
586            ))
587            .expect("failed to connect client"),
588            future,
589        )
590        .await
591}
592
593/// Waits for a timeout or Policy to establish a connection to an AP with the given SSID, BSSID,
594/// and protection.
595pub async fn connect_or_timeout(
596    helper: &mut test_utils::TestHelper,
597    timeout: zx::MonotonicDuration,
598    ssid: &Ssid,
599    bssid: &Bssid,
600    bss_protection: &Protection,
601    password_or_psk: Option<&str>,
602    security_type: fidl_policy::SecurityType,
603) {
604    let authenticator = match bss_protection {
605        Protection::Wpa3Personal | Protection::Wpa2Wpa3Personal => {
606            password_or_psk.map(|password_or_psk| {
607                create_authenticator(
608                    bssid,
609                    ssid,
610                    password_or_psk,
611                    CIPHER_CCMP_128,
612                    *bss_protection,
613                    Protection::Wpa3Personal,
614                )
615            })
616        }
617        Protection::Wpa2Personal | Protection::Wpa1Wpa2Personal => {
618            password_or_psk.map(|password_or_psk| {
619                create_authenticator(
620                    bssid,
621                    ssid,
622                    password_or_psk,
623                    CIPHER_CCMP_128,
624                    *bss_protection,
625                    Protection::Wpa2Personal,
626                )
627            })
628        }
629        Protection::Wpa2PersonalTkipOnly | Protection::Wpa1Wpa2PersonalTkipOnly => {
630            panic!("Hardware simulator does not support WPA2-TKIP.")
631        }
632        Protection::Wpa1 => password_or_psk.map(|password_or_psk| {
633            create_authenticator(
634                bssid,
635                ssid,
636                password_or_psk,
637                CIPHER_TKIP,
638                *bss_protection,
639                Protection::Wpa1,
640            )
641        }),
642        Protection::Open => None,
643        _ => {
644            panic!("Unsupported WLAN protection: {}", bss_protection)
645        }
646    };
647
648    let credential = password_or_psk_to_policy_credential(password_or_psk);
649    let test_ns_prefix = helper.test_ns_prefix().to_string();
650    let connect = pin!(save_network_and_wait_until_connected(
651        &test_ns_prefix,
652        ssid,
653        security_type,
654        credential
655    ));
656    connect_or_timeout_with(helper, timeout, ssid, bssid, bss_protection, authenticator, connect)
657        .await;
658}
659
660pub fn rx_wlan_data_frame(
661    channel: &Channel,
662    addr1: &MacAddr,
663    addr2: &MacAddr,
664    addr3: &MacAddr,
665    payload: &[u8],
666    ether_type: u16,
667    phy: &WlantapPhyProxy,
668) -> Result<(), anyhow::Error> {
669    let buffer = write_frame_to_vec!({
670        headers: {
671            mac::FixedDataHdrFields: &mac::FixedDataHdrFields {
672                frame_ctrl: mac::FrameControl(0)
673                    .with_frame_type(mac::FrameType::DATA)
674                    .with_data_subtype(mac::DataSubtype(0))
675                    .with_from_ds(true),
676                duration: 0,
677                addr1: *addr1,
678                addr2: *addr2,
679                addr3: *addr3,
680                seq_ctrl: mac::SequenceControl(0).with_seq_num(3),
681            },
682            mac::LlcHdr: &data_writer::make_snap_llc_hdr(ether_type),
683        },
684        payload: payload,
685    })?;
686
687    phy.rx(&buffer, &rx_info_with_valid_rssi(channel, 0))?;
688    Ok(())
689}
690
691pub async fn loop_until_iface_is_found(helper: &mut test_utils::TestHelper) {
692    // Connect to the client policy service and get a client controller.
693    let policy_provider =
694        connect_to_protocol_at::<fidl_policy::ClientProviderMarker>(helper.test_ns_prefix())
695            .expect("connecting to wlan policy");
696    let (client_controller, server_end) = create_proxy();
697    let (update_client_end, _update_server_end) = create_endpoints();
698    let () =
699        policy_provider.get_controller(server_end, update_client_end).expect("getting controller");
700
701    // Attempt to issue a scan command until the request succeeds.  Scanning will fail until a
702    // client interface is available.  A successful response to a scan request indicates that the
703    // client policy layer is ready to use.
704    // TODO(https://fxbug.dev/42135259): Figure out a new way to signal that the client policy layer is ready to go.
705    let mut retry = test_utils::RetryWithBackoff::infinite_with_max_interval(
706        zx::MonotonicDuration::from_seconds(10),
707    );
708    loop {
709        let (scan_proxy, server_end) = create_proxy();
710        client_controller.scan_for_networks(server_end).expect("requesting scan");
711
712        let fut = pin!(async move { scan_proxy.get_next().await.expect("getting scan results") });
713
714        let phy = helper.proxy();
715        match helper
716            .run_until_complete_or_timeout(
717                *SCAN_RESPONSE_TEST_TIMEOUT,
718                "receive a scan response",
719                event::on_scan(action::send_advertisements_and_scan_completion(
720                    &phy,
721                    [] as [Beacon; 0],
722                )),
723                fut,
724            )
725            .await
726        {
727            Err(_) => {
728                retry.sleep_unless_after_deadline().await.unwrap_or_else(|_| {
729                    panic!("Wlanstack did not recognize the interface in time")
730                });
731            }
732            Ok(_) => return,
733        }
734    }
735}
wlan_hw_sim/lib.rs

wlan_hw_sim/
lib.rs
