wlan_sme/serve/
client.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::client::{
6    self as client_sme, ConnectResult, ConnectTransactionEvent, ConnectTransactionStream,
7    RoamResult, ScheduledScanReceiver,
8};
9use crate::{MlmeEventStream, MlmeSink, MlmeStream};
10use fidl::endpoints::{ControlHandle, RequestStream, ServerEnd};
11use fidl_fuchsia_wlan_common as fidl_common;
12use fidl_fuchsia_wlan_ieee80211 as fidl_ieee80211;
13use fidl_fuchsia_wlan_mlme as fidl_mlme;
14use fidl_fuchsia_wlan_sme::{self as fidl_sme, ClientSmeRequest, TelemetryRequest};
15use fuchsia_sync::Mutex;
16use futures::channel::mpsc;
17use futures::prelude::*;
18use futures::select;
19use ieee80211::MacAddrBytes;
20use log::error;
21use std::pin::pin;
22use std::sync::Arc;
23use wlan_common::scan::write_vmo;
24
25pub type Endpoint = ServerEnd<fidl_sme::ClientSmeMarker>;
26type Sme = client_sme::ClientSme;
27
28#[allow(clippy::too_many_arguments, reason = "mass allow for https://fxbug.dev/381896734")]
29pub fn serve(
30    cfg: crate::Config,
31    device_info: fidl_mlme::DeviceInfo,
32    security_support: fidl_common::SecuritySupport,
33    spectrum_management_support: fidl_common::SpectrumManagementSupport,
34    event_stream: MlmeEventStream,
35    new_fidl_clients: mpsc::UnboundedReceiver<Endpoint>,
36    new_telemetry_fidl_clients: mpsc::UnboundedReceiver<
37        fidl::endpoints::ServerEnd<fidl_sme::TelemetryMarker>,
38    >,
39    inspector: fuchsia_inspect::Inspector,
40    inspect_node: fuchsia_inspect::Node,
41) -> (MlmeSink, MlmeStream, impl Future<Output = Result<(), anyhow::Error>>) {
42    let wpa3_supported =
43        security_support.mfp.as_ref().is_some_and(|mfp| mfp.supported.unwrap_or(false))
44            && security_support.sae.as_ref().is_some_and(|sae| {
45                sae.driver_handler_supported.unwrap_or(false)
46                    || sae.sme_handler_supported.unwrap_or(false)
47            });
48    let owe_supported =
49        security_support.mfp.as_ref().is_some_and(|mfp| mfp.supported.unwrap_or(false))
50            && security_support.owe.as_ref().is_some_and(|owe| owe.supported.unwrap_or(false));
51    let cfg = client_sme::ClientConfig::from_config(cfg, wpa3_supported, owe_supported);
52    let (sme, mlme_sink, mlme_stream, time_stream) = Sme::new(
53        cfg,
54        device_info,
55        inspector,
56        inspect_node,
57        security_support,
58        spectrum_management_support,
59    );
60    let fut = async move {
61        let sme = Arc::new(Mutex::new(sme));
62        let mlme_sme = super::serve_mlme_sme(event_stream, Arc::clone(&sme), time_stream);
63        let sme_fidl = super::serve_fidl(&*sme, new_fidl_clients, handle_fidl_request);
64        let telemetry_fidl =
65            super::serve_fidl(&*sme, new_telemetry_fidl_clients, handle_telemetry_fidl_request);
66        let mlme_sme = pin!(mlme_sme);
67        let sme_fidl = pin!(sme_fidl);
68        select! {
69            mlme_sme = mlme_sme.fuse() => mlme_sme?,
70            sme_fidl = sme_fidl.fuse() => match sme_fidl? {},
71            telemetry_fidl = telemetry_fidl.fuse() => match telemetry_fidl? {},
72        }
73        Ok(())
74    };
75    (mlme_sink, mlme_stream, fut)
76}
77
78async fn handle_fidl_request(
79    sme: &Mutex<Sme>,
80    request: fidl_sme::ClientSmeRequest,
81) -> Result<(), fidl::Error> {
82    #[allow(clippy::unit_arg, reason = "mass allow for https://fxbug.dev/381896734")]
83    match request {
84        ClientSmeRequest::Scan { req, responder } => Ok(scan(sme, req, |result| match result {
85            Ok(scan_results) => responder.send(Ok(write_vmo(scan_results)?)).map_err(|e| e.into()),
86            Err(e) => responder.send(Err(e)).map_err(|e| e.into()),
87        })
88        .await
89        .unwrap_or_else(|e| error!("Error handling a scan transaction: {:?}", e))),
90        ClientSmeRequest::Connect { req, txn, .. } => Ok(connect(sme, txn, req)
91            .await
92            .unwrap_or_else(|e| error!("Error handling a connect transaction: {:?}", e))),
93        ClientSmeRequest::Roam { req, .. } => Ok(roam(sme, req)),
94        ClientSmeRequest::Disconnect { responder, reason } => {
95            disconnect(sme, reason, responder);
96            Ok(())
97        }
98        ClientSmeRequest::Status { responder } => responder.send(&status(sme)),
99        ClientSmeRequest::WmmStatus { responder } => wmm_status(sme, responder).await,
100        ClientSmeRequest::StartScheduledScan { req, txn, responder } => {
101            start_scheduled_scan(sme, req, txn, responder).await
102        }
103
104        ClientSmeRequest::GetScheduledScanEnabled { responder } => {
105            let receiver = sme.lock().on_get_scheduled_scan_enabled_command();
106            let resp = match receiver.await {
107                Ok(result) => result,
108                Err(_) => Err(zx::sys::ZX_ERR_CANCELED),
109            };
110            responder
111                .send(resp.as_ref().map(|r| !r.active_txn_ids.is_empty()).map_err(|e| *e))
112                .unwrap_or_else(|e| error!("Error sending response: {:?}", e));
113            Ok(())
114        }
115        ClientSmeRequest::ScanForController { req, responder } => {
116            Ok(scan(sme, req, |result| match result {
117                Ok(results) => responder.send(Ok(&results[..])).map_err(|e| e.into()),
118                Err(e) => responder.send(Err(e)).map_err(|e| e.into()),
119            })
120            .await
121            .unwrap_or_else(|e| error!("Error handling a test scan transaction: {:?}", e)))
122        }
123        ClientSmeRequest::SetMacAddress { mac_addr, responder } => {
124            Ok(set_mac_address(sme, mac_addr, responder).await?)
125        }
126        ClientSmeRequest::InstallApfPacketFilter { program, responder } => {
127            let receiver = sme.lock().install_apf_packet_filter(program);
128            let resp = match receiver.await {
129                Ok(result) => result,
130                Err(_) => Err(zx::sys::ZX_ERR_CANCELED),
131            };
132            responder.send(resp).unwrap_or_else(|e| error!("Error sending response: {:?}", e));
133            Ok(())
134        }
135        ClientSmeRequest::ReadApfPacketFilterData { responder } => {
136            let receiver = sme.lock().read_apf_packet_filter_data();
137            let resp = match receiver.await {
138                Ok(result) => result.map(|r| r.memory),
139                Err(_) => Err(zx::sys::ZX_ERR_CANCELED),
140            };
141            responder
142                .send(resp.as_ref().map(|m| &m[..]).map_err(|e| *e))
143                .unwrap_or_else(|e| error!("Error sending response: {:?}", e));
144            Ok(())
145        }
146        ClientSmeRequest::SetApfPacketFilterEnabled { enabled, responder } => {
147            let receiver = sme.lock().set_apf_packet_filter_enabled(enabled);
148            let resp = match receiver.await {
149                Ok(result) => result,
150                Err(_) => Err(zx::sys::ZX_ERR_CANCELED),
151            };
152            responder.send(resp).unwrap_or_else(|e| error!("Error sending response: {:?}", e));
153            Ok(())
154        }
155        ClientSmeRequest::GetApfPacketFilterEnabled { responder } => {
156            let receiver = sme.lock().get_apf_packet_filter_enabled();
157            let resp = match receiver.await {
158                Ok(result) => result.map(|r| r.enabled),
159                Err(_) => Err(zx::sys::ZX_ERR_CANCELED),
160            };
161            responder
162                .send(resp.as_ref().map(|e| *e).map_err(|e| *e))
163                .unwrap_or_else(|e| error!("Error sending response: {:?}", e));
164            Ok(())
165        }
166    }
167}
168
169async fn handle_telemetry_fidl_request(
170    sme: &Mutex<Sme>,
171    request: TelemetryRequest,
172) -> Result<(), fidl::Error> {
173    match request {
174        TelemetryRequest::QueryTelemetrySupport { responder, .. } => {
175            let support_fut = sme.lock().query_telemetry_support();
176            let support = support_fut
177                .await
178                .map_err(|_| zx::Status::CONNECTION_ABORTED.into_raw())
179                .and_then(|result| result);
180            responder.send(support.as_ref().map_err(|e| *e))
181        }
182        TelemetryRequest::GetIfaceStats { responder, .. } => {
183            let iface_stats_fut = sme.lock().iface_stats();
184            let iface_stats = iface_stats_fut
185                .await
186                .map_err(|_| zx::Status::CONNECTION_ABORTED.into_raw())
187                .and_then(|stats| match stats {
188                    fidl_mlme::GetIfaceStatsResponse::Stats(stats) => Ok(stats),
189                    fidl_mlme::GetIfaceStatsResponse::ErrorStatus(err) => Err(err),
190                });
191            responder.send(iface_stats.as_ref().map_err(|e| *e))
192        }
193        TelemetryRequest::GetHistogramStats { responder, .. } => {
194            let histogram_stats_fut = sme.lock().histogram_stats();
195            let histogram_stats = histogram_stats_fut
196                .await
197                .map_err(|_| zx::Status::CONNECTION_ABORTED.into_raw())
198                .and_then(|stats| match stats {
199                    fidl_mlme::GetIfaceHistogramStatsResponse::Stats(stats) => Ok(stats),
200                    fidl_mlme::GetIfaceHistogramStatsResponse::ErrorStatus(err) => Err(err),
201                });
202            responder.send(histogram_stats.as_ref().map_err(|e| *e))
203        }
204        TelemetryRequest::GetSignalReport { responder, .. } => {
205            let signal_report_fut = sme.lock().signal_report();
206            let signal_report = signal_report_fut
207                .await
208                .map_err(|_| zx::Status::CONNECTION_ABORTED.into_raw())
209                .and_then(|result| result);
210            responder.send(signal_report.as_ref().map_err(|e| *e))
211        }
212        TelemetryRequest::CloneInspectVmo { responder } => {
213            let inspect_vmo =
214                sme.lock().on_clone_inspect_vmo().ok_or_else(|| zx::Status::INTERNAL.into_raw());
215            responder.send(inspect_vmo)
216        }
217    }
218}
219
220async fn scan(
221    sme: &Mutex<Sme>,
222    request: fidl_sme::ScanRequest,
223    responder: impl FnOnce(
224        Result<Vec<fidl_sme::ScanResult>, fidl_sme::ScanErrorCode>,
225    ) -> Result<(), anyhow::Error>,
226) -> Result<(), anyhow::Error> {
227    let receiver = sme.lock().on_scan_command(request);
228    let receive_result = match receiver.await {
229        Ok(receive_result) => receive_result,
230        Err(e) => {
231            error!("Scan receiver error: {:?}", e);
232            responder(Err(fidl_sme::ScanErrorCode::InternalError))?;
233            return Ok(());
234        }
235    };
236
237    match receive_result {
238        Ok(scan_results) => {
239            let results = scan_results.into_iter().map(Into::into).collect::<Vec<_>>();
240            responder(Ok(results))
241        }
242        Err(mlme_scan_result_code) => {
243            let scan_error_code = match mlme_scan_result_code {
244                fidl_mlme::ScanResultCode::Success | fidl_mlme::ScanResultCode::InvalidArgs => {
245                    error!("Internal scan error: {:?}", mlme_scan_result_code);
246                    fidl_sme::ScanErrorCode::InternalError
247                }
248                fidl_mlme::ScanResultCode::NotSupported => fidl_sme::ScanErrorCode::NotSupported,
249                fidl_mlme::ScanResultCode::InternalError => {
250                    fidl_sme::ScanErrorCode::InternalMlmeError
251                }
252                fidl_mlme::ScanResultCode::ShouldWait => fidl_sme::ScanErrorCode::ShouldWait,
253                fidl_mlme::ScanResultCode::CanceledByDriverOrFirmware => {
254                    fidl_sme::ScanErrorCode::CanceledByDriverOrFirmware
255                }
256            };
257            responder(Err(scan_error_code))
258        }
259    }?;
260    Ok(())
261}
262
263async fn connect(
264    sme: &Mutex<Sme>,
265    txn: Option<ServerEnd<fidl_sme::ConnectTransactionMarker>>,
266    req: fidl_sme::ConnectRequest,
267) -> Result<(), anyhow::Error> {
268    #[allow(clippy::manual_map, reason = "mass allow for https://fxbug.dev/381896734")]
269    let handle = match txn {
270        None => None,
271        Some(txn) => Some(txn.into_stream().control_handle()),
272    };
273    let connect_txn_stream = sme.lock().on_connect_command(req);
274    serve_connect_txn_stream(handle, connect_txn_stream).await?;
275    Ok(())
276}
277
278/// Serves a scheduled scan session by processing a stream for events sent by MLME and processed in
279/// SME's scan scheduler, and a stream for client-initiated cancellations.
280async fn serve_sched_scan_session(
281    txn_handle: fidl_sme::ScheduledScanTransactionControlHandle,
282    txn_stream: fidl_sme::ScheduledScanTransactionRequestStream,
283    session: ScheduledScanReceiver,
284) -> Result<(), anyhow::Error> {
285    // Client will close the transaction channel to cancel session.
286    let mut cancellation_stream = txn_stream.fuse();
287    let mut session_stream = session.fuse();
288    loop {
289        futures::select! {
290            scan_results = session_stream.next() => {
291                if let Some(vmo) = scan_results {
292                    txn_handle.send_on_scheduled_scan_matches_available(vmo)?;
293                } else {
294                    // Stream closed naturally (SME dropped sender because firmware stopped it).
295                    txn_handle.shutdown_with_epitaph(zx::Status::OK);
296                    break;
297                }
298            },
299            _ = cancellation_stream.next() => {
300                // Client dropped transaction stream. Cleanup is handled by ScheduledScanReceiver's
301                // Drop implementation.
302                break;
303            }
304        }
305    }
306    Ok(())
307}
308
309/// Creates a new scheduled scan session and starts serving it.
310async fn start_scheduled_scan(
311    sme: &Mutex<Sme>,
312    req: fidl_common::ScheduledScanRequest,
313    txn_server: ServerEnd<fidl_sme::ScheduledScanTransactionMarker>,
314    responder: fidl_sme::ClientSmeStartScheduledScanResponder,
315) -> Result<(), fidl::Error> {
316    let txn_receiver_stream = txn_server.into_stream();
317    let txn_sender_handle = txn_receiver_stream.control_handle();
318    let (receiver, session) = sme.lock().on_start_scheduled_scan_command(req);
319    match receiver.await.unwrap_or_else(|_| Err(zx::Status::CANCELED.into_raw())) {
320        Ok(()) => {
321            responder.send(Ok(()))?;
322            serve_sched_scan_session(txn_sender_handle, txn_receiver_stream, session)
323                .await
324                .unwrap_or_else(|e| {
325                    error!("Error serving sched scan txn stream: {:?}", e);
326                });
327        }
328        Err(status) => {
329            responder.send(Err(status))?;
330            txn_sender_handle.shutdown_with_epitaph(zx::Status::from_raw(status));
331        }
332    }
333    Ok(())
334}
335
336async fn serve_connect_txn_stream(
337    handle: Option<fidl_sme::ConnectTransactionControlHandle>,
338    mut connect_txn_stream: ConnectTransactionStream,
339) -> Result<(), anyhow::Error> {
340    if let Some(handle) = handle {
341        loop {
342            match connect_txn_stream.next().await {
343                Some(event) => match event {
344                    ConnectTransactionEvent::OnConnectResult { result, is_reconnect } => {
345                        let connect_result = convert_connect_result(&result, is_reconnect);
346                        handle.send_on_connect_result(&connect_result)
347                    }
348                    ConnectTransactionEvent::OnRoamResult { result } => {
349                        let roam_result = convert_roam_result(&result);
350                        handle.send_on_roam_result(&roam_result)
351                    }
352                    ConnectTransactionEvent::OnDisconnect { info } => {
353                        handle.send_on_disconnect(&info)
354                    }
355                    ConnectTransactionEvent::OnSignalReport { ind } => {
356                        handle.send_on_signal_report(&ind)
357                    }
358                    ConnectTransactionEvent::OnChannelSwitched { info } => {
359                        handle.send_on_channel_switched(&info)
360                    }
361                }?,
362                // SME has dropped the ConnectTransaction endpoint, likely due to a disconnect.
363                None => return Ok(()),
364            }
365        }
366    }
367    Ok(())
368}
369
370fn roam(sme: &Mutex<Sme>, req: fidl_sme::RoamRequest) {
371    sme.lock().on_roam_command(req);
372}
373
374fn disconnect(
375    sme: &Mutex<Sme>,
376    policy_disconnect_reason: fidl_sme::UserDisconnectReason,
377    responder: fidl_sme::ClientSmeDisconnectResponder,
378) {
379    sme.lock().on_disconnect_command(policy_disconnect_reason, responder);
380}
381
382fn status(sme: &Mutex<Sme>) -> fidl_sme::ClientStatusResponse {
383    sme.lock().status().into()
384}
385
386async fn wmm_status(
387    sme: &Mutex<Sme>,
388    responder: fidl_sme::ClientSmeWmmStatusResponder,
389) -> Result<(), fidl::Error> {
390    let receiver = sme.lock().wmm_status();
391    let wmm_status = match receiver.await {
392        Ok(result) => result,
393        Err(_) => Err(zx::sys::ZX_ERR_CANCELED),
394    };
395    responder.send(wmm_status.as_ref().map_err(|e| *e))
396}
397
398async fn set_mac_address(
399    sme: &Mutex<Sme>,
400    mac_addr: [u8; 6],
401    responder: fidl_sme::ClientSmeSetMacAddressResponder,
402) -> Result<(), fidl::Error> {
403    let receiver = sme.lock().set_mac_address(mac_addr);
404    let resp = match receiver.await {
405        Ok(Ok(())) => {
406            sme.lock().update_mac_address(mac_addr);
407            Ok(())
408        }
409        Ok(result @ Err(_)) => result,
410        Err(_) => Err(zx::sys::ZX_ERR_CANCELED),
411    };
412    responder.send(resp)
413}
414
415fn convert_connect_result(result: &ConnectResult, is_reconnect: bool) -> fidl_sme::ConnectResult {
416    let (code, is_credential_rejected) = match result {
417        ConnectResult::Success => (fidl_ieee80211::StatusCode::Success, false),
418        ConnectResult::Canceled => (fidl_ieee80211::StatusCode::Canceled, false),
419        ConnectResult::Failed(failure) => {
420            (failure.status_code(), failure.likely_due_to_credential_rejected())
421        }
422    };
423    fidl_sme::ConnectResult { code, is_credential_rejected, is_reconnect }
424}
425
426fn convert_roam_result(result: &RoamResult) -> fidl_sme::RoamResult {
427    match result {
428        RoamResult::Success(bss) => {
429            let bss_description =
430                Some(Box::new(fidl_ieee80211::BssDescription::from(*bss.clone())));
431            fidl_sme::RoamResult {
432                bssid: bss.bssid.to_array(),
433                status_code: fidl_ieee80211::StatusCode::Success,
434                // Must always be false on roam success.
435                original_association_maintained: false,
436                bss_description,
437                disconnect_info: None,
438                is_credential_rejected: false,
439            }
440        }
441        RoamResult::Failed(failure) => {
442            #[allow(clippy::manual_map, reason = "mass allow for https://fxbug.dev/381896734")]
443            fidl_sme::RoamResult {
444                bssid: failure.selected_bssid.to_array(),
445                status_code: failure.status_code,
446                // Current implementation assumes that all roam attempts incur disassociation from the
447                // original BSS. When this changes (e.g. due to Fast BSS Transition support), this
448                // hard-coded field should be set from the RoamResult enum.
449                original_association_maintained: false,
450                bss_description: match &failure.selected_bss {
451                    Some(bss) => Some(Box::new(bss.clone().into())),
452                    None => None,
453                },
454                disconnect_info: Some(Box::new(failure.disconnect_info)),
455                is_credential_rejected: failure.likely_due_to_credential_rejected(),
456            }
457        }
458    }
459}
460
461#[cfg(test)]
462mod tests {
463    use super::*;
464    use crate::client::{ConnectFailure, EstablishRsnaFailure, EstablishRsnaFailureReason};
465    use crate::test_utils;
466    use assert_matches::assert_matches;
467    use fidl::endpoints::create_proxy_and_stream;
468    use fidl_fuchsia_wlan_internal as fidl_internal;
469    use fidl_fuchsia_wlan_mlme::ScanResultCode;
470    use fidl_fuchsia_wlan_sme::{self as fidl_sme};
471    use fuchsia_async as fasync;
472    use futures::stream::StreamFuture;
473    use futures::task::Poll;
474    use rand::Rng;
475    use rand::prelude::ThreadRng;
476    use std::pin::pin;
477    use test_case::test_case;
478    use wlan_common::random_bss_description;
479    use wlan_common::scan::{self, Incompatible};
480    use wlan_rsn::auth;
481
482    #[test]
483    fn test_convert_connect_result() {
484        assert_eq!(
485            convert_connect_result(&ConnectResult::Success, false),
486            fidl_sme::ConnectResult {
487                code: fidl_ieee80211::StatusCode::Success,
488                is_credential_rejected: false,
489                is_reconnect: false,
490            }
491        );
492        assert_eq!(
493            convert_connect_result(&ConnectResult::Canceled, true),
494            fidl_sme::ConnectResult {
495                code: fidl_ieee80211::StatusCode::Canceled,
496                is_credential_rejected: false,
497                is_reconnect: true,
498            }
499        );
500        let connect_result =
501            ConnectResult::Failed(ConnectFailure::ScanFailure(ScanResultCode::ShouldWait));
502        assert_eq!(
503            convert_connect_result(&connect_result, false),
504            fidl_sme::ConnectResult {
505                code: fidl_ieee80211::StatusCode::Canceled,
506                is_credential_rejected: false,
507                is_reconnect: false,
508            }
509        );
510
511        let connect_result =
512            ConnectResult::Failed(ConnectFailure::EstablishRsnaFailure(EstablishRsnaFailure {
513                auth_method: Some(auth::MethodName::Psk),
514                reason: EstablishRsnaFailureReason::InternalError,
515            }));
516        assert_eq!(
517            convert_connect_result(&connect_result, false),
518            fidl_sme::ConnectResult {
519                code: fidl_ieee80211::StatusCode::EstablishRsnaFailure,
520                is_credential_rejected: false,
521                is_reconnect: false,
522            }
523        );
524
525        let connect_result =
526            ConnectResult::Failed(ConnectFailure::EstablishRsnaFailure(EstablishRsnaFailure {
527                auth_method: Some(auth::MethodName::Psk),
528                reason: EstablishRsnaFailureReason::RsnaResponseTimeout(
529                    wlan_rsn::Error::LikelyWrongCredential,
530                ),
531            }));
532        assert_eq!(
533            convert_connect_result(&connect_result, false),
534            fidl_sme::ConnectResult {
535                code: fidl_ieee80211::StatusCode::EstablishRsnaFailure,
536                is_credential_rejected: true,
537                is_reconnect: false,
538            }
539        );
540
541        let connect_result =
542            ConnectResult::Failed(ConnectFailure::EstablishRsnaFailure(EstablishRsnaFailure {
543                auth_method: Some(auth::MethodName::Psk),
544                reason: EstablishRsnaFailureReason::RsnaCompletionTimeout(
545                    wlan_rsn::Error::LikelyWrongCredential,
546                ),
547            }));
548        assert_eq!(
549            convert_connect_result(&connect_result, false),
550            fidl_sme::ConnectResult {
551                code: fidl_ieee80211::StatusCode::EstablishRsnaFailure,
552                is_credential_rejected: true,
553                is_reconnect: false,
554            }
555        );
556
557        let connect_result =
558            ConnectResult::Failed(ConnectFailure::EstablishRsnaFailure(EstablishRsnaFailure {
559                auth_method: Some(auth::MethodName::Psk),
560                reason: EstablishRsnaFailureReason::RsnaCompletionTimeout(
561                    wlan_rsn::Error::MissingGtkProvider,
562                ),
563            }));
564        assert_eq!(
565            convert_connect_result(&connect_result, false),
566            fidl_sme::ConnectResult {
567                code: fidl_ieee80211::StatusCode::EstablishRsnaFailure,
568                is_credential_rejected: false,
569                is_reconnect: false,
570            }
571        );
572
573        let connect_result =
574            ConnectResult::Failed(ConnectFailure::ScanFailure(ScanResultCode::InternalError));
575        assert_eq!(
576            convert_connect_result(&connect_result, false),
577            fidl_sme::ConnectResult {
578                code: fidl_ieee80211::StatusCode::RefusedReasonUnspecified,
579                is_credential_rejected: false,
580                is_reconnect: false,
581            }
582        );
583    }
584
585    // TODO(https://fxbug.dev/42164611): There is no test coverage for consistency between MLME scan results
586    // and SME scan results produced by wlanstack. In particular, the timestamp_nanos field
587    // of fidl_mlme::ScanResult is dropped in SME, and no tests reveal this problem.
588
589    #[test_case(1, true; "with 1 result")]
590    #[test_case(2, true; "with 2 results")]
591    #[test_case(30, true; "with 30 results")]
592    #[test_case(4000, true; "with 4000 results")]
593    #[test_case(50000, false; "with 50000 results")]
594    #[test_case(100000, false; "with 100000 results")]
595    fn scan_results_are_effectively_unbounded(number_of_scan_results: usize, randomize: bool) {
596        let mut exec = fasync::TestExecutor::new();
597        let (client_sme_proxy, mut client_sme_stream) =
598            create_proxy_and_stream::<fidl_sme::ClientSmeMarker>();
599
600        // Request scan
601        async fn request_and_collect_result(
602            client_sme_proxy: &fidl_sme::ClientSmeProxy,
603        ) -> fidl_sme::ClientSmeScanResult {
604            client_sme_proxy
605                .scan(&fidl_sme::ScanRequest::Passive(fidl_sme::PassiveScanRequest {
606                    channels: vec![],
607                }))
608                .await
609                .expect("FIDL request failed")
610        }
611
612        let result_fut = request_and_collect_result(&client_sme_proxy);
613        let mut result_fut = pin!(result_fut);
614
615        assert_matches!(exec.run_until_stalled(&mut result_fut), Poll::Pending);
616
617        // Generate and send scan results
618        let mut rng = rand::rng();
619        let scan_result_list = if randomize {
620            (0..number_of_scan_results).map(|_| random_scan_result(&mut rng).into()).collect()
621        } else {
622            vec![random_scan_result(&mut rng).into(); number_of_scan_results]
623        };
624        assert_matches!(exec.run_until_stalled(&mut client_sme_stream.next()),
625                        Poll::Ready(Some(Ok(fidl_sme::ClientSmeRequest::Scan {
626                            req: _, responder,
627                        }))) => {
628                            let vmo = write_vmo(scan_result_list.clone()).expect("failed to write VMO");
629                            responder.send(Ok(vmo)).expect("failed to send scan results");
630                        }
631        );
632
633        // Verify scan results
634        assert_matches!(exec.run_until_stalled(&mut result_fut), Poll::Ready(Ok(vmo)) => {
635            assert_eq!(scan_result_list, scan::read_vmo(vmo).expect("failed to read VMO"));
636        })
637    }
638
639    #[test]
640    fn test_serve_connect_txn_stream() {
641        let mut exec = fasync::TestExecutor::new();
642
643        let (sme_proxy, sme_connect_txn_stream) = mpsc::unbounded();
644        let (fidl_client_proxy, fidl_connect_txn_stream) =
645            create_proxy_and_stream::<fidl_sme::ConnectTransactionMarker>();
646        let fidl_client_fut = fidl_client_proxy.take_event_stream().into_future();
647        let mut fidl_client_fut = pin!(fidl_client_fut);
648        let fidl_connect_txn_handle = fidl_connect_txn_stream.control_handle();
649
650        let test_fut =
651            serve_connect_txn_stream(Some(fidl_connect_txn_handle), sme_connect_txn_stream);
652        let mut test_fut = pin!(test_fut);
653
654        // Test sending OnConnectResult
655        sme_proxy
656            .unbounded_send(ConnectTransactionEvent::OnConnectResult {
657                result: ConnectResult::Success,
658                is_reconnect: true,
659            })
660            .expect("expect sending ConnectTransactionEvent to succeed");
661        assert_matches!(exec.run_until_stalled(&mut test_fut), Poll::Pending);
662        let event = assert_matches!(poll_stream_fut(&mut exec, &mut fidl_client_fut), Poll::Ready(Some(Ok(event))) => event);
663        assert_matches!(
664            event,
665            fidl_sme::ConnectTransactionEvent::OnConnectResult {
666                result: fidl_sme::ConnectResult {
667                    code: fidl_ieee80211::StatusCode::Success,
668                    is_credential_rejected: false,
669                    is_reconnect: true,
670                }
671            }
672        );
673
674        // Test sending OnDisconnect
675        let input_info = fidl_sme::DisconnectInfo {
676            is_sme_reconnecting: true,
677            disconnect_source: fidl_sme::DisconnectSource::Mlme(fidl_sme::DisconnectCause {
678                reason_code: fidl_ieee80211::ReasonCode::UnspecifiedReason,
679                mlme_event_name: fidl_sme::DisconnectMlmeEventName::DeauthenticateIndication,
680            }),
681        };
682        sme_proxy
683            .unbounded_send(ConnectTransactionEvent::OnDisconnect { info: input_info })
684            .expect("expect sending ConnectTransactionEvent to succeed");
685        assert_matches!(exec.run_until_stalled(&mut test_fut), Poll::Pending);
686        let event = assert_matches!(poll_stream_fut(&mut exec, &mut fidl_client_fut), Poll::Ready(Some(Ok(event))) => event);
687        assert_matches!(event, fidl_sme::ConnectTransactionEvent::OnDisconnect { info: output_info } => {
688            assert_eq!(input_info, output_info);
689        });
690
691        // Test sending OnSignalReport
692        let input_ind = fidl_internal::SignalReportIndication { rssi_dbm: -40, snr_db: 30 };
693        sme_proxy
694            .unbounded_send(ConnectTransactionEvent::OnSignalReport { ind: input_ind })
695            .expect("expect sending ConnectTransactionEvent to succeed");
696        assert_matches!(exec.run_until_stalled(&mut test_fut), Poll::Pending);
697        let event = assert_matches!(poll_stream_fut(&mut exec, &mut fidl_client_fut), Poll::Ready(Some(Ok(event))) => event);
698        assert_matches!(event, fidl_sme::ConnectTransactionEvent::OnSignalReport { ind } => {
699            assert_eq!(input_ind, ind);
700        });
701
702        // Test sending OnChannelSwitched
703        let input_info = fidl_internal::ChannelSwitchInfo { new_channel: 8 };
704        sme_proxy
705            .unbounded_send(ConnectTransactionEvent::OnChannelSwitched { info: input_info })
706            .expect("expect sending ConnectTransactionEvent to succeed");
707        assert_matches!(exec.run_until_stalled(&mut test_fut), Poll::Pending);
708        let event = assert_matches!(poll_stream_fut(&mut exec, &mut fidl_client_fut), Poll::Ready(Some(Ok(event))) => event);
709        assert_matches!(event, fidl_sme::ConnectTransactionEvent::OnChannelSwitched { info } => {
710            assert_eq!(input_info, info);
711        });
712
713        // When SME proxy is dropped, the fut should terminate
714        std::mem::drop(sme_proxy);
715        assert_matches!(exec.run_until_stalled(&mut test_fut), Poll::Ready(Ok(())));
716    }
717
718    fn poll_stream_fut<S: Stream + std::marker::Unpin>(
719        exec: &mut fasync::TestExecutor,
720        stream_fut: &mut StreamFuture<S>,
721    ) -> Poll<Option<S::Item>> {
722        exec.run_until_stalled(stream_fut).map(|(item, stream)| {
723            *stream_fut = stream.into_future();
724            item
725        })
726    }
727
728    // Create roughly over 2k bytes ScanResult
729    fn random_scan_result(rng: &mut ThreadRng) -> wlan_common::scan::ScanResult {
730        use wlan_common::security::SecurityDescriptor;
731
732        // TODO(https://fxbug.dev/42164451): Merge this with a similar function in wlancfg.
733        wlan_common::scan::ScanResult {
734            compatibility: match rng.random_range(0..4) {
735                0 => wlan_common::scan::Compatible::expect_ok([SecurityDescriptor::OPEN]),
736                1 => wlan_common::scan::Compatible::expect_ok([SecurityDescriptor::WPA2_PERSONAL]),
737                2 => wlan_common::scan::Compatible::expect_ok([
738                    SecurityDescriptor::WPA2_PERSONAL,
739                    SecurityDescriptor::WPA3_PERSONAL,
740                ]),
741                _ => Incompatible::unknown(),
742            },
743            timestamp: zx::MonotonicInstant::from_nanos(rng.random()),
744            bss_description: random_bss_description!(),
745        }
746    }
747
748    #[test]
749    fn test_handle_fidl_request_apf() {
750        let mut exec = fasync::TestExecutor::new();
751        let inspector = fuchsia_inspect::Inspector::default();
752        let (sme, _mlme_sink, mut mlme_stream, _time_stream) = client_sme::ClientSme::new(
753            client_sme::ClientConfig::default(),
754            test_utils::fake_device_info([0; 6].into()),
755            inspector.clone(),
756            inspector.root().create_child("sme"),
757            wlan_common::test_utils::fake_features::fake_security_support(),
758            wlan_common::test_utils::fake_features::fake_spectrum_management_support_empty(),
759        );
760        let sme = Mutex::new(sme);
761
762        // Test InstallApfPacketFilter
763        let (proxy, stream) = create_proxy_and_stream::<fidl_sme::ClientSmeMarker>();
764        let program = vec![1, 2, 3];
765        let mut install_fut = proxy.install_apf_packet_filter(&program);
766        let mut stream = pin!(stream);
767
768        // Run handle_fidl_request for the install request
769        assert_matches!(exec.run_until_stalled(&mut stream.next()), Poll::Ready(Some(Ok(req))) => {
770            let mut handle_fut = pin!(handle_fidl_request(&sme, req));
771            assert_matches!(exec.run_until_stalled(&mut handle_fut), Poll::Pending);
772
773            // Forward from SME to MLME
774            assert_matches!(exec.run_until_stalled(&mut mlme_stream.next()), Poll::Ready(Some(crate::MlmeRequest::InstallApfPacketFilter(req, responder))) => {
775                assert_eq!(req.program, program);
776                responder.respond(Ok(()));
777            });
778
779            assert_matches!(exec.run_until_stalled(&mut handle_fut), Poll::Ready(Ok(())));
780        });
781        assert_matches!(exec.run_until_stalled(&mut install_fut), Poll::Ready(Ok(Ok(()))));
782
783        // Test ReadApfPacketFilterData
784        let mut read_fut = proxy.read_apf_packet_filter_data();
785        assert_matches!(exec.run_until_stalled(&mut stream.next()), Poll::Ready(Some(Ok(req))) => {
786            let mut handle_fut = pin!(handle_fidl_request(&sme, req));
787            assert_matches!(exec.run_until_stalled(&mut handle_fut), Poll::Pending);
788
789            // Forward from SME to MLME
790            assert_matches!(exec.run_until_stalled(&mut mlme_stream.next()), Poll::Ready(Some(crate::MlmeRequest::ReadApfPacketFilterData(responder))) => {
791                responder.respond(Ok(fidl_mlme::MlmeReadApfPacketFilterDataResponse {
792                    memory: vec![4, 5, 6],
793                }));
794            });
795
796            assert_matches!(exec.run_until_stalled(&mut handle_fut), Poll::Ready(Ok(())));
797        });
798        assert_matches!(exec.run_until_stalled(&mut read_fut), Poll::Ready(Ok(Ok(data))) => {
799            assert_eq!(data, vec![4, 5, 6]);
800        });
801
802        // Test SetApfPacketFilterEnabled
803        let mut set_enabled_fut = proxy.set_apf_packet_filter_enabled(true);
804        assert_matches!(exec.run_until_stalled(&mut stream.next()), Poll::Ready(Some(Ok(req))) => {
805            let mut handle_fut = pin!(handle_fidl_request(&sme, req));
806            assert_matches!(exec.run_until_stalled(&mut handle_fut), Poll::Pending);
807
808            // Forward from SME to MLME
809            assert_matches!(exec.run_until_stalled(&mut mlme_stream.next()), Poll::Ready(Some(crate::MlmeRequest::SetApfPacketFilterEnabled(req, responder))) => {
810                assert!(req.enabled);
811                responder.respond(Ok(()));
812            });
813
814            assert_matches!(exec.run_until_stalled(&mut handle_fut), Poll::Ready(Ok(())));
815        });
816        assert_matches!(exec.run_until_stalled(&mut set_enabled_fut), Poll::Ready(Ok(Ok(()))));
817
818        // Test GetApfPacketFilterEnabled
819        let mut get_enabled_fut = proxy.get_apf_packet_filter_enabled();
820        assert_matches!(exec.run_until_stalled(&mut stream.next()), Poll::Ready(Some(Ok(req))) => {
821            let mut handle_fut = pin!(handle_fidl_request(&sme, req));
822            assert_matches!(exec.run_until_stalled(&mut handle_fut), Poll::Pending);
823
824            // Forward from SME to MLME
825            assert_matches!(exec.run_until_stalled(&mut mlme_stream.next()), Poll::Ready(Some(crate::MlmeRequest::GetApfPacketFilterEnabled(responder))) => {
826                responder.respond(Ok(fidl_mlme::MlmeGetApfPacketFilterEnabledResponse {
827                    enabled: true,
828                }));
829            });
830
831            assert_matches!(exec.run_until_stalled(&mut handle_fut), Poll::Ready(Ok(())));
832        });
833        assert_matches!(exec.run_until_stalled(&mut get_enabled_fut), Poll::Ready(Ok(Ok(true))));
834    }
835
836    #[test_case(Ok(()); "ok")]
837    #[test_case(Err(123); "err")]
838    fn test_handle_fidl_request_set_mac_address(set_mac_address_result: Result<(), i32>) {
839        let mut exec = fasync::TestExecutor::new();
840        let inspector = fuchsia_inspect::Inspector::default();
841        let (sme, _mlme_sink, mut mlme_stream, _time_stream) = client_sme::ClientSme::new(
842            client_sme::ClientConfig::default(),
843            test_utils::fake_device_info([0; 6].into()),
844            inspector.clone(),
845            inspector.root().create_child("sme"),
846            wlan_common::test_utils::fake_features::fake_security_support(),
847            wlan_common::test_utils::fake_features::fake_spectrum_management_support_empty(),
848        );
849        let sme = Mutex::new(sme);
850
851        // Send SetMacAddress request
852        let (proxy, stream) = create_proxy_and_stream::<fidl_sme::ClientSmeMarker>();
853        let new_mac = [1, 2, 3, 4, 5, 6];
854        let mut set_mac_fut = proxy.set_mac_address(&new_mac);
855        let mut stream = pin!(stream);
856
857        // Handle SetMacAddress request
858        assert_matches!(exec.run_until_stalled(&mut stream.next()), Poll::Ready(Some(Ok(req))) => {
859            let mut handle_fut = pin!(handle_fidl_request(&sme, req));
860            assert_matches!(exec.run_until_stalled(&mut handle_fut), Poll::Pending);
861
862            assert_matches!(exec.run_until_stalled(&mut mlme_stream.next()), Poll::Ready(Some(crate::MlmeRequest::SetMacAddress(mac, responder))) => {
863                assert_eq!(mac, new_mac);
864                responder.respond(set_mac_address_result);
865            });
866
867            assert_matches!(exec.run_until_stalled(&mut handle_fut), Poll::Ready(Ok(())));
868        });
869
870        if set_mac_address_result.is_ok() {
871            assert_matches!(exec.run_until_stalled(&mut set_mac_fut), Poll::Ready(Ok(Ok(()))));
872            // Verify the device_info in client_sme is updated
873            assert_eq!(sme.lock().device_info().sta_addr, new_mac);
874        } else {
875            assert_matches!(exec.run_until_stalled(&mut set_mac_fut), Poll::Ready(Ok(Err(123))));
876            assert_eq!(sme.lock().device_info().sta_addr, [0; 6]);
877        }
878    }
879
880    #[test]
881    fn test_handle_fidl_request_set_mac_address_cancelled() {
882        let mut exec = fasync::TestExecutor::new();
883        let inspector = fuchsia_inspect::Inspector::default();
884        let (sme, _mlme_sink, mut mlme_stream, _time_stream) = client_sme::ClientSme::new(
885            client_sme::ClientConfig::default(),
886            test_utils::fake_device_info([0; 6].into()),
887            inspector.clone(),
888            inspector.root().create_child("sme"),
889            wlan_common::test_utils::fake_features::fake_security_support(),
890            wlan_common::test_utils::fake_features::fake_spectrum_management_support_empty(),
891        );
892        let sme = Mutex::new(sme);
893
894        // Send SetMacAddress request
895        let (proxy, stream) = create_proxy_and_stream::<fidl_sme::ClientSmeMarker>();
896        let new_mac = [1, 2, 3, 4, 5, 6];
897        let mut set_mac_fut = proxy.set_mac_address(&new_mac);
898        let mut stream = pin!(stream);
899
900        // Handle SetMacAddress request
901        assert_matches!(exec.run_until_stalled(&mut stream.next()), Poll::Ready(Some(Ok(req))) => {
902            let mut handle_fut = pin!(handle_fidl_request(&sme, req));
903            assert_matches!(exec.run_until_stalled(&mut handle_fut), Poll::Pending);
904
905            assert_matches!(exec.run_until_stalled(&mut mlme_stream.next()), Poll::Ready(Some(crate::MlmeRequest::SetMacAddress(_mac, _responder))) => {
906                // Drop the responder to simulate an error
907            });
908
909            assert_matches!(exec.run_until_stalled(&mut handle_fut), Poll::Ready(Ok(())));
910        });
911
912        assert_matches!(
913            exec.run_until_stalled(&mut set_mac_fut),
914            Poll::Ready(Ok(Err(zx::sys::ZX_ERR_CANCELED)))
915        );
916        assert_eq!(sme.lock().device_info().sta_addr, [0; 6]);
917    }
918}
wlan_sme/serve/client.rs

wlan_sme/serve/
client.rs
