| // Copyright 2018 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| use anyhow::{Context as _, Error, format_err}; | |
| use bt_repl::{CommandSet, ReplControl, ReplHandler}; | |
| use fidl_fuchsia_bluetooth::{HostId as FidlHostId, PeerId as FidlPeerId}; | |
| use fidl_fuchsia_bluetooth_sys::{ | |
| AccessMarker, AccessProxy, BondableMode, HostWatcherMarker, HostWatcherProxy, | |
| PairingDelegateMarker, PairingMarker, PairingOptions, PairingProxy, PairingSecurityLevel, | |
| ProcedureTokenProxy, TechnologyType, | |
| }; | |
| use fuchsia_async as fasync; | |
| use fuchsia_bluetooth::types::io_capabilities::{InputCapability, OutputCapability}; | |
| use fuchsia_bluetooth::types::{HostId, HostInfo, Peer, PeerId, addresses_to_custom_string}; | |
| use fuchsia_component::client::connect_to_protocol; | |
| use fuchsia_sync::Mutex; | |
| use futures::channel::mpsc; | |
| use futures::{FutureExt, StreamExt, TryFutureExt, select}; | |
| use prettytable::{Row, Table, format, row}; | |
| use regex::Regex; | |
| use std::cmp::Ordering; | |
| use std::collections::HashMap; | |
| use std::pin::pin; | |
| use std::str::FromStr; | |
| use std::sync::Arc; | |
| use crate::commands::{Cmd, command_source}; | |
| use crate::types::{DeviceClass, MajorClass, MinorClass, TryInto}; | |
| mod commands; | |
| mod types; | |
| static PROMPT: &str = "\x1b[34mbt>\x1b[0m "; | |
| /// Escape code to clear the pty line on which the cursor is located. | |
| /// Used when event output is intermingled with the REPL prompt. | |
| static CLEAR_LINE: &str = "\x1b[2K"; | |
| async fn get_active_host(state: &Mutex<State>) -> Result<String, Error> { | |
| let state = state.lock(); | |
| let active_iter = state.hosts.iter().find(|&h| h.active); | |
| match active_iter { | |
| Some(host) => Ok(host.to_string()), | |
| None => Ok(String::from("No host instances")), | |
| } | |
| } | |
| async fn get_hosts(state: &Mutex<State>) -> Result<String, Error> { | |
| let hosts = &state.lock().hosts; | |
| if hosts.is_empty() { | |
| return Ok(String::from("No host instances detected")); | |
| } | |
| // Create table of results | |
| let mut table = Table::new(); | |
| table.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR); | |
| let _ = table.set_titles(row![ | |
| "HostId", | |
| "Addresses", | |
| "Active", | |
| "Technology", | |
| "Name", | |
| "Discoverable", | |
| "Discovering", | |
| ]); | |
| for host in hosts { | |
| let _ = table.add_row(row![ | |
| host.id.to_string(), | |
| addresses_to_custom_string(&host.addresses, "\n"), | |
| host.active.to_string(), | |
| format!("{:?}", host.technology), | |
| host.local_name.clone().unwrap_or_else(|| "(unknown)".to_string()), | |
| host.discoverable.to_string(), | |
| host.discovering.to_string(), | |
| ]); | |
| } | |
| Ok(format!("{}", table)) | |
| } | |
| async fn set_active_host<'a>( | |
| args: &'a [&'a str], | |
| host_svc: &'a HostWatcherProxy, | |
| ) -> Result<String, Error> { | |
| if args.len() != 1 { | |
| return Err(format_err!("usage: {}", Cmd::SetController.usage())); | |
| } | |
| println!("Setting active controller"); | |
| let host_id = HostId::from_str(args[0])?; | |
| let fidl_host_id: FidlHostId = host_id.into(); | |
| match host_svc.set_active(&fidl_host_id).await { | |
| Ok(_) => Ok(String::new()), | |
| Err(err) => Ok(format!("Error setting active controller: {}", err)), | |
| } | |
| } | |
| async fn set_local_name<'a>( | |
| args: &'a [&'a str], | |
| access_svc: &'a AccessProxy, | |
| ) -> Result<String, Error> { | |
| if args.len() != 1 { | |
| return Ok(format!("usage: {}", Cmd::SetLocalName.usage())); | |
| } | |
| println!("Setting local name of the active controller"); | |
| match access_svc.set_local_name(args[0]) { | |
| Ok(_) => Ok(String::new()), | |
| Err(err) => Ok(format!("Error setting local name: {:?}", err)), | |
| } | |
| } | |
| /// Set the class of device for the currently active controller. Arguments are optional, and | |
| /// defaults will be used if arguments aren't provided. | |
| /// | |
| /// Returns an error if the input is not recognized as a valid device class . | |
| async fn set_device_class<'a>( | |
| args: &'a [&'a str], | |
| access_svc: &'a AccessProxy, | |
| ) -> Result<String, Error> { | |
| let mut args = args.iter(); | |
| println!("Setting device class of the active controller"); | |
| let device_class = DeviceClass { | |
| major: args | |
| .next() | |
| .map(|arg| TryInto::try_into(&**arg)) | |
| .unwrap_or(Ok(MajorClass::Uncategorized))?, | |
| minor: args | |
| .next() | |
| .map(|arg| TryInto::try_into(&**arg)) | |
| .unwrap_or(Ok(MinorClass::not_set()))?, | |
| service: TryInto::try_into(args)?, | |
| } | |
| .into(); | |
| match access_svc.set_device_class(&device_class) { | |
| Ok(_) => Ok(format!("Set device class to 0x{:x}", device_class.value)), | |
| Err(err) => Ok(format!("Error setting device class: {}", err)), | |
| } | |
| } | |
| fn match_peer<'a>(pattern: &'a str, peer: &Peer) -> bool { | |
| let pattern_upper = &pattern.to_uppercase(); | |
| peer.id.to_string().to_uppercase().contains(pattern_upper) | |
| || peer.address.to_string().to_uppercase().contains(pattern_upper) | |
| || peer.name.as_ref().is_some_and(|p| p.contains(pattern)) | |
| } | |
| /// Order connected peers as greater than unconnected peers and bonded peers greater than unbonded | |
| /// peers. | |
| fn cmp_peers(a: &Peer, b: &Peer) -> Ordering { | |
| (a.connected, a.bonded).cmp(&(b.connected, b.bonded)) | |
| } | |
| fn get_peers<'a>(args: &'a [&'a str], state: &Mutex<State>, full_details: bool) -> String { | |
| let find = match args.len() { | |
| 0 => "", | |
| 1 => args[0], | |
| _ => { | |
| let cmd = if full_details { Cmd::ShowPeers } else { Cmd::ListPeers }; | |
| return format!("usage: {}", cmd.usage()); | |
| } | |
| }; | |
| let state = state.lock(); | |
| if state.peers.is_empty() { | |
| return String::from("No known peers"); | |
| } | |
| let mut peers: Vec<&Peer> = state.peers.values().filter(|p| match_peer(&find, p)).collect(); | |
| peers.sort_by(|a, b| cmp_peers(&*a, &*b)); | |
| let matched = format!("Showing {}/{} peers\n", peers.len(), state.peers.len()); | |
| if peers.is_empty() { | |
| return matched; | |
| } | |
| if full_details { | |
| return String::from_iter( | |
| std::iter::once(matched).chain(peers.iter().map(|p| p.to_string())), | |
| ); | |
| } | |
| // Create table of results | |
| let mut table = Table::new(); | |
| table.set_format(*format::consts::FORMAT_NO_BORDER); | |
| let _ = table.set_titles(row![ | |
| "PeerId", | |
| "Address", | |
| "Technology", | |
| "Name", | |
| "Appearance", | |
| "Connected", | |
| "Bonded", | |
| ]); | |
| for val in peers.into_iter() { | |
| let _ = table.add_row(peer_to_table_row(val)); | |
| } | |
| [matched, format!("{}", table)].join("\n") | |
| } | |
| /// Get the string representation of a peer from either an identifier or address | |
| fn get_peer<'a>(args: &'a [&'a str], state: &Mutex<State>) -> String { | |
| if args.len() != 1 { | |
| return format!("usage: {}", Cmd::Peer.usage()); | |
| } | |
| to_identifier(state, args[0]) | |
| .and_then(|id| state.lock().peers.get(&id).map(|peer| peer.to_string())) | |
| .unwrap_or_else(|| String::from("No known peer")) | |
| } | |
| /// Returns basic peer information formatted as a prettytable Row | |
| fn peer_to_table_row(peer: &Peer) -> Row { | |
| row![ | |
| peer.id.to_string(), | |
| peer.address.to_string(), | |
| format! {"{:?}", peer.technology}, | |
| peer.name.as_ref().map_or_else(|| "".to_string(), |x| format!("{:?}", x)), | |
| peer.appearance.as_ref().map_or_else(|| "".to_string(), |x| format!("{:?}", x)), | |
| peer.connected.to_string(), | |
| peer.bonded.to_string(), | |
| ] | |
| } | |
| async fn set_discovery( | |
| discovery: bool, | |
| state: &Mutex<State>, | |
| access_svc: &AccessProxy, | |
| ) -> Result<String, Error> { | |
| println!("{} Discovery!", if discovery { "Starting" } else { "Stopping" }); | |
| if !discovery { | |
| state.lock().discovery_token = None; | |
| return Ok(String::new()); | |
| } | |
| let (token, token_server) = fidl::endpoints::create_proxy(); | |
| match access_svc.start_discovery(token_server).await? { | |
| Ok(_) => { | |
| state.lock().discovery_token = Some(token); | |
| Ok(String::new()) | |
| } | |
| Err(err) => Ok(format!("Discovery error: {:?}", err)), | |
| } | |
| } | |
| // Find the identifier for a `Peer` based on a `key` that is either an identifier or an | |
| // address. | |
| // Returns `None` if the given address does not belong to a known peer. | |
| fn to_identifier(state: &Mutex<State>, key: &str) -> Option<PeerId> { | |
| // Compile regex inline because it is not ever expected to be a bottleneck | |
| let address_pattern = Regex::new(r"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$") | |
| .expect("Could not compile mac address regex pattern."); | |
| if address_pattern.is_match(key) { | |
| state.lock().peers.values().find(|peer| &peer.address == key).map(|peer| peer.id) | |
| } else { | |
| key.parse().ok() | |
| } | |
| } | |
| async fn connect<'a>( | |
| args: &'a [&'a str], | |
| state: &'a Mutex<State>, | |
| access_proxy: &'a AccessProxy, | |
| with_pairing: Option<&'a PairingProxy>, | |
| ) -> Result<String, Error> { | |
| if args.len() != 1 { | |
| let cmd = if with_pairing.is_some() { Cmd::Bond } else { Cmd::Connect }; | |
| return Ok(format!("usage: {}", cmd.usage())); | |
| } | |
| // `args[0]` is the identifier of the peer to connect to | |
| let peer_id = match to_identifier(state, args[0]) { | |
| Some(id) => id, | |
| None => return Ok(format!("Unable to connect: Unknown address {}", args[0])), | |
| }; | |
| if let Err(e) = access_proxy.connect(&peer_id.into()).await? { | |
| return Ok(format!("connect error: {:?}", e)); | |
| } | |
| let pairing = with_pairing | |
| .map(|p| create_pairing_task(InputCapability::None, OutputCapability::None, &p)) | |
| .transpose()?; | |
| if let Some((pairing_task, mut recv)) = pairing { | |
| if let Some((paired_id, paired)) = recv.next().await { | |
| // If pairing was completed, exit. | |
| let _ = pairing_task.abort(); | |
| println!( | |
| "Completed {} pairing for {}.", | |
| if paired { "successful" } else { "unsuccessful" }, | |
| paired_id | |
| ); | |
| } else { | |
| println!("Note: No pairing occurred with {}.", peer_id); | |
| } | |
| } | |
| Ok(String::new()) | |
| } | |
| fn parse_disconnect<'a>(args: &'a [&'a str], state: &'a Mutex<State>) -> Result<PeerId, String> { | |
| if args.len() != 1 { | |
| return Err(format!("usage: {}", Cmd::Disconnect.usage())); | |
| } | |
| // `args[0]` is the identifier of the peer to connect to | |
| match to_identifier(state, args[0]) { | |
| Some(id) => Ok(id), | |
| None => return Err(format!("Unable to disconnect: Unknown address {}", args[0])), | |
| } | |
| } | |
| async fn handle_disconnect(id: PeerId, access_svc: &AccessProxy) -> Result<String, Error> { | |
| let response = access_svc.disconnect(&id.into()).await?; | |
| match response { | |
| Ok(_) => Ok(String::new()), | |
| Err(err) => Ok(format!("Disconnect error: {:?}", err)), | |
| } | |
| } | |
| async fn disconnect<'a>( | |
| args: &'a [&'a str], | |
| state: &'a Mutex<State>, | |
| access_svc: &'a AccessProxy, | |
| ) -> Result<String, Error> { | |
| match parse_disconnect(args, state) { | |
| Ok(id) => handle_disconnect(id, access_svc).await, | |
| Err(msg) => Ok(msg), | |
| } | |
| } | |
| fn parse_pairing_security_level(level: &str) -> Result<PairingSecurityLevel, String> { | |
| match level.to_ascii_uppercase().as_str() { | |
| "AUTH" => Ok(PairingSecurityLevel::Authenticated), | |
| "ENC" => Ok(PairingSecurityLevel::Encrypted), | |
| _ => { | |
| return Err( | |
| "Unable to pair: security level must be either \"AUTH\" or \"ENC\"".to_string() | |
| ); | |
| } | |
| } | |
| } | |
| fn parse_bondable_mode(mode: &str) -> Result<BondableMode, String> { | |
| match mode.to_ascii_uppercase().as_str() { | |
| "T" => Ok(BondableMode::Bondable), | |
| "F" => Ok(BondableMode::NonBondable), | |
| _ => return Err("Bondable mode must be either \"T\" or \"F\"".to_string()), | |
| } | |
| } | |
| fn parse_pairing_transport(transport: &str) -> Result<TechnologyType, String> { | |
| match transport.to_ascii_uppercase().as_str() { | |
| "BREDR" | "CLASSIC" => Ok(TechnologyType::Classic), | |
| "LE" => Ok(TechnologyType::LowEnergy), | |
| _ => { | |
| return Err("If present, transport must be \"BREDR\"/\"CLASSIC\" or \"LE\"".to_string()); | |
| } | |
| } | |
| } | |
| fn parse_pair(args: &[&str], state: &Mutex<State>) -> Result<(FidlPeerId, PairingOptions), String> { | |
| if args.len() < 3 || args.len() > 4 { | |
| return Err(format!("usage: {}", Cmd::Pair.usage())); | |
| } | |
| // `args[0]` is the identifier of the peer to connect to | |
| let peer_id = match to_identifier(state, args[0]) { | |
| Some(id) => id, | |
| None => return Err(format!("Unable to pair: invalid peer address: {}", args[0])), | |
| }; | |
| let le_security_level = Some(parse_pairing_security_level(args[1])?); | |
| // `args[2]` is the requested bonding preference of the pairing | |
| let bondable_mode = Some(parse_bondable_mode(args[2])?); | |
| // if `args[3]` is present, it corresponds to the connected transport over which to pair | |
| let transport = if args.len() == 4 { Some(parse_pairing_transport(args[3])?) } else { None }; | |
| Ok(( | |
| peer_id.into(), | |
| PairingOptions { le_security_level, bondable_mode, transport, ..Default::default() }, | |
| )) | |
| } | |
| async fn handle_pair( | |
| peer_id: FidlPeerId, | |
| pairing_opts: PairingOptions, | |
| access_svc: &AccessProxy, | |
| ) -> Result<String, Error> { | |
| match access_svc.pair(&peer_id, &pairing_opts).await? { | |
| Ok(_) => Ok(String::new()), | |
| Err(err) => Ok(format!("Pair error: {:?}", err)), | |
| } | |
| } | |
| async fn pair( | |
| args: &[&str], | |
| state: &Mutex<State>, | |
| access_svc: &AccessProxy, | |
| ) -> Result<String, Error> { | |
| match parse_pair(args, state) { | |
| Ok((peer_id, pairing_opts)) => handle_pair(peer_id, pairing_opts, access_svc).await, | |
| Err(e) => Ok(e), | |
| } | |
| } | |
| // Creates a pairing task with the given input / output capabilities which will prompt for consent | |
| // to the pairing. The returned task will continue prompting for requests until it is dropped. | |
| fn create_pairing_task( | |
| input_cap: InputCapability, | |
| output_cap: OutputCapability, | |
| pairing_svc: &PairingProxy, | |
| ) -> Result<(fasync::Task<()>, mpsc::Receiver<(PeerId, bool)>), Error> { | |
| let (pairing_delegate_client, delegate_stream) = | |
| fidl::endpoints::create_request_stream::<PairingDelegateMarker>(); | |
| let (sender, recv) = mpsc::channel(0); | |
| let pairing_delegate_server = pairing_delegate::handle_requests(delegate_stream, sender); | |
| let _ = pairing_svc.set_pairing_delegate( | |
| input_cap.into(), | |
| output_cap.into(), | |
| pairing_delegate_client, | |
| ); | |
| let task = fasync::Task::spawn(pairing_delegate_server.map(|res| println!("{res:?}"))); | |
| println!( | |
| "Pairing delegate setup with input capability {:?} and output capability {:?}.", | |
| input_cap, output_cap | |
| ); | |
| Ok((task, recv)) | |
| } | |
| async fn allow_pairing(args: &[&str], access_svc: &PairingProxy) -> Result<String, Error> { | |
| let (input_cap, output_cap) = match args.len() { | |
| 0 => (InputCapability::None, OutputCapability::None), | |
| 2 => ( | |
| InputCapability::from_str(args[0]).map_err(|_| { | |
| format_err!("unknown input capability: {}", Cmd::AllowPairing.usage()) | |
| })?, | |
| OutputCapability::from_str(args[1]).map_err(|_| { | |
| format_err!("unknown output capability: {}", Cmd::AllowPairing.usage()) | |
| })?, | |
| ), | |
| _ => return Err(format_err!("usage: {}", Cmd::AllowPairing.usage())), | |
| }; | |
| let (delegate_task, mut receiver) = create_pairing_task(input_cap, output_cap, access_svc)?; | |
| // TODO(fxbug.dev/443280885): Make repeated pairing attempts optional or | |
| // provide a mechanism for early exit without killing the entire process. | |
| while let Some((paired_id, paired)) = receiver.next().await { | |
| if !paired { | |
| println!("Pairing with {} was unsuccessful.", paired_id); | |
| continue; | |
| } | |
| let _ = delegate_task.abort(); | |
| return Ok(format!("Completed successful pairing with {}.", paired_id)); | |
| } | |
| Err(format_err!("Pairing delegate closed without a pairing")) | |
| } | |
| async fn forget<'a>( | |
| args: &'a [&'a str], | |
| state: &'a Mutex<State>, | |
| access_svc: &'a AccessProxy, | |
| ) -> Result<String, Error> { | |
| if args.len() != 1 { | |
| return Ok(format!("usage: {}", Cmd::Forget.usage())); | |
| } | |
| // `args[0]` is the identifier of the remote device to connect to | |
| let peer_id = match to_identifier(state, args[0]) { | |
| Some(id) => id, | |
| None => return Ok(format!("Unable to forget: Unknown address {}", args[0])), | |
| }; | |
| match access_svc.forget(&peer_id.into()).await? { | |
| Ok(_) => { | |
| println!("Peer has been removed"); | |
| Ok(String::new()) | |
| } | |
| Err(err) => Ok(format!("Forget error: {:?}", err)), | |
| } | |
| } | |
| async fn set_discoverable( | |
| discoverable: bool, | |
| access_svc: &AccessProxy, | |
| state: &Mutex<State>, | |
| ) -> Result<String, Error> { | |
| if discoverable { | |
| println!("Becoming discoverable.."); | |
| if state.lock().discoverable_token.is_some() { | |
| return Ok(String::new()); | |
| } | |
| let (token, token_server) = fidl::endpoints::create_proxy(); | |
| match access_svc.make_discoverable(token_server).await? { | |
| Ok(_) => { | |
| state.lock().discoverable_token = Some(token); | |
| Ok(String::new()) | |
| } | |
| Err(err) => Ok(format!("MakeDiscoverable error: {:?}", err)), | |
| } | |
| } else { | |
| println!("Revoking discoverability.."); | |
| state.lock().discoverable_token = None; | |
| Ok(String::new()) | |
| } | |
| } | |
| fn print_peer_state_updates(state: &State, peer: &Peer) { | |
| if let Some(msg) = peer_state_updates(state, peer) { | |
| println!("{} {} {}", peer.id, peer.address, msg) | |
| } | |
| } | |
| fn peer_state_updates(state: &State, peer: &Peer) -> Option<String> { | |
| let previous = state.peers.get(&peer.id); | |
| let was_connected = previous.is_some_and(|p| p.connected); | |
| let was_bonded = previous.is_some_and(|p| p.bonded); | |
| let conn_str = match (was_connected, peer.connected) { | |
| (false, true) => Some("[connected]"), | |
| (true, false) => Some("[disconnected]"), | |
| _ => None, | |
| }; | |
| let bond_str = match (was_bonded, peer.bonded) { | |
| (false, true) => Some("[bonded]"), | |
| (true, false) => Some("[unbonded]"), | |
| _ => None, | |
| }; | |
| match (conn_str, bond_str) { | |
| (Some(a), Some(b)) => Some(format!("{} {}", a, b)), | |
| (Some(a), None) => Some(a.to_string()), | |
| (None, Some(b)) => Some(b.to_string()), | |
| (None, None) => None, | |
| } | |
| } | |
| /// Tracks all state local to the command line tool. | |
| pub struct State { | |
| pub peers: HashMap<PeerId, Peer>, | |
| pub discoverable_token: Option<ProcedureTokenProxy>, | |
| pub discovery_token: Option<ProcedureTokenProxy>, | |
| pub hosts: Vec<HostInfo>, | |
| } | |
| impl State { | |
| pub fn new() -> State { | |
| State { | |
| peers: HashMap::new(), | |
| discoverable_token: None, | |
| discovery_token: None, | |
| hosts: vec![], | |
| } | |
| } | |
| } | |
| /// Handles the commands entered into the bt-cli REPL. | |
| struct BtCliHandler { | |
| access_svc: AccessProxy, | |
| host_svc: HostWatcherProxy, | |
| pairing_svc: PairingProxy, | |
| state: Arc<Mutex<State>>, | |
| } | |
| impl ReplHandler for BtCliHandler { | |
| type Command = Cmd; | |
| async fn handle(&mut self, cmd: Cmd, args: &[&str]) -> Result<ReplControl, Error> { | |
| let access_svc = &self.access_svc; | |
| let host_svc = &self.host_svc; | |
| let pairing_svc = &self.pairing_svc; | |
| let state = &self.state; | |
| let res = match cmd { | |
| Cmd::Connect => connect(args, state, access_svc, None).await, | |
| Cmd::Bond => connect(args, state, access_svc, Some(pairing_svc)).await, | |
| Cmd::Disconnect => disconnect(args, state, access_svc).await, | |
| Cmd::Pair => pair(args, state, access_svc).await, | |
| Cmd::AllowPairing => allow_pairing(args, pairing_svc).await, | |
| Cmd::Forget => forget(args, state, access_svc).await, | |
| Cmd::StartDiscovery => set_discovery(true, state, access_svc).await, | |
| Cmd::StopDiscovery => set_discovery(false, state, access_svc).await, | |
| Cmd::Discoverable => set_discoverable(true, access_svc, state).await, | |
| Cmd::NotDiscoverable => set_discoverable(false, access_svc, state).await, | |
| Cmd::ListPeers => Ok(get_peers(args, state, false)), | |
| Cmd::ShowPeers => Ok(get_peers(args, state, true)), | |
| Cmd::Peer => Ok(get_peer(args, state)), | |
| Cmd::ListControllers => get_hosts(state).await, | |
| Cmd::SetController => set_active_host(args, host_svc).await, | |
| Cmd::SetLocalName => set_local_name(args, access_svc).await, | |
| Cmd::SetDeviceClass => set_device_class(args, access_svc).await, | |
| Cmd::Controller => get_active_host(state).await, | |
| }?; | |
| if !res.is_empty() { | |
| println!("{}", res); | |
| } | |
| Ok(ReplControl::Continue) | |
| } | |
| } | |
| async fn watch_peers(access_svc: AccessProxy, state: Arc<Mutex<State>>) -> Result<(), Error> { | |
| // Used to avoid printing all peers on first watch_peers() call. | |
| let mut first_loop = true; | |
| loop { | |
| let (updated, removed) = access_svc.watch_peers().await?; | |
| for peer in updated.into_iter() { | |
| let peer = Peer::try_from(peer).context("Malformed FIDL peer")?; | |
| if !first_loop { | |
| print!("{}", CLEAR_LINE); | |
| print_peer_state_updates(&state.lock(), &peer); | |
| } | |
| let _ = state.lock().peers.insert(peer.id, peer); | |
| } | |
| for id in removed.into_iter() { | |
| let peer_id = PeerId::try_from(id).context("Malformed FIDL peer id")?; | |
| let _ = state.lock().peers.remove(&peer_id); | |
| } | |
| first_loop = false; | |
| } | |
| } | |
| async fn watch_hosts(host_svc: HostWatcherProxy, state: Arc<Mutex<State>>) -> Result<(), Error> { | |
| let mut first_result = true; | |
| loop { | |
| let fidl_hosts = host_svc.watch().await?; | |
| let mut hosts = Vec::<HostInfo>::new(); | |
| if !first_result && !hosts.is_empty() { | |
| print!("{}", CLEAR_LINE); | |
| } | |
| for fidl_host in &fidl_hosts { | |
| let host = HostInfo::try_from(fidl_host)?; | |
| if !first_result { | |
| println!( | |
| "Controller updated: [addresses: {}, active: {}, discoverable: {}, discovering: {}]", | |
| addresses_to_custom_string(&host.addresses, " "), | |
| host.active, | |
| host.discoverable, | |
| host.discovering | |
| ); | |
| } | |
| hosts.push(host); | |
| } | |
| state.lock().hosts = hosts; | |
| first_result = false; | |
| } | |
| } | |
| #[fuchsia::main(logging = false)] | |
| async fn main() -> Result<(), Error> { | |
| let access_svc = connect_to_protocol::<AccessMarker>() | |
| .context("failed to connect to bluetooth access interface")?; | |
| let host_watcher_svc = | |
| connect_to_protocol::<HostWatcherMarker>().context("failed to watch hosts")?; | |
| let pairing_svc = connect_to_protocol::<PairingMarker>() | |
| .context("failed to connect to bluetooth pairing interface")?; | |
| let state = Arc::new(Mutex::new(State::new())); | |
| let peer_watcher = watch_peers(access_svc.clone(), state.clone()); | |
| let handler = BtCliHandler { | |
| access_svc, | |
| host_svc: host_watcher_svc.clone(), | |
| pairing_svc, | |
| state: state.clone(), | |
| }; | |
| let repl = bt_repl::run(PROMPT, command_source(state.clone()), handler) | |
| .map_err(|e| e.context("REPL failed unexpectedly")); | |
| let host_watcher = watch_hosts(host_watcher_svc, state); | |
| let repl = pin!(repl); | |
| let peer_watcher = pin!(peer_watcher); | |
| select! { | |
| r = repl.fuse() => r, | |
| p = peer_watcher.fuse() => p, | |
| h = host_watcher.fuse() => h, | |
| } | |
| } | |
| #[cfg(test)] | |
| mod tests { | |
| use super::*; | |
| use assert_matches::assert_matches; | |
| use bt_fidl_mocks::sys::{AccessMock, PairingMock}; | |
| use fidl::endpoints::Proxy; | |
| use fidl_fuchsia_bluetooth as fbt; | |
| use fidl_fuchsia_bluetooth_sys as fsys; | |
| use fidl_fuchsia_bluetooth_sys::{InputCapability, OutputCapability}; | |
| use fuchsia_bluetooth::types::Address; | |
| use futures::join; | |
| use std::task::Poll; | |
| use zx::MonotonicDuration; | |
| fn peer(connected: bool, bonded: bool) -> Peer { | |
| Peer { | |
| id: PeerId(0xdeadbeef), | |
| address: Address::Public([1, 0, 0, 0, 0, 0]), | |
| technology: fsys::TechnologyType::LowEnergy, | |
| connected, | |
| bonded, | |
| name: None, | |
| appearance: Some(fbt::Appearance::Phone), | |
| device_class: None, | |
| rssi: None, | |
| tx_power: None, | |
| le_services: vec![], | |
| bredr_services: vec![], | |
| } | |
| } | |
| fn named_peer(id: PeerId, address: Address, name: Option<String>) -> Peer { | |
| Peer { | |
| id, | |
| address, | |
| technology: fsys::TechnologyType::LowEnergy, | |
| connected: false, | |
| bonded: false, | |
| name, | |
| appearance: Some(fbt::Appearance::Phone), | |
| device_class: None, | |
| rssi: None, | |
| tx_power: None, | |
| le_services: vec![], | |
| bredr_services: vec![], | |
| } | |
| } | |
| fn custom_peer( | |
| id: PeerId, | |
| address: Address, | |
| connected: bool, | |
| bonded: bool, | |
| rssi: Option<i8>, | |
| ) -> Peer { | |
| Peer { | |
| id, | |
| address, | |
| technology: fsys::TechnologyType::LowEnergy, | |
| connected, | |
| bonded, | |
| name: None, | |
| appearance: Some(fbt::Appearance::Phone), | |
| device_class: None, | |
| rssi, | |
| tx_power: None, | |
| le_services: vec![], | |
| bredr_services: vec![], | |
| } | |
| } | |
| fn custom_host( | |
| id: HostId, | |
| address: Address, | |
| active: bool, | |
| discoverable: bool, | |
| discovering: bool, | |
| name: Option<String>, | |
| ) -> HostInfo { | |
| HostInfo { | |
| id, | |
| technology: fsys::TechnologyType::LowEnergy, | |
| addresses: vec![address], | |
| active, | |
| local_name: name, | |
| discoverable, | |
| discovering, | |
| } | |
| } | |
| fn state_with(p: Peer) -> State { | |
| let mut state = State::new(); | |
| let _ = state.peers.insert(p.id, p); | |
| state | |
| } | |
| #[fuchsia::test] | |
| async fn test_get_hosts() { | |
| // Fields for table view of hosts | |
| let fields = Regex::new(r"HostId[ \t]*\|[ \t]*Addresses[ \t]*\|[ \t]*Active[ \t]*\|[ \t]*Technology[ \t]*\|[ \t]*Name[ \t]*\|[ \t]*Discoverable[ \t]*\|[ \t]*Discovering").unwrap(); | |
| // No hosts | |
| let mut output = get_hosts(&Mutex::new(State::new())).await.unwrap(); | |
| assert!(!fields.is_match(&output)); | |
| assert!(output.contains("No host instances")); | |
| let mut state = State::new(); | |
| state.hosts.push(custom_host( | |
| HostId(0xbeef), | |
| Address::Public([0x11, 0x00, 0x55, 0x7E, 0xDE, 0xAD]), | |
| false, | |
| false, | |
| false, | |
| Some("Sapphire".to_string()), | |
| )); | |
| state.hosts.push(custom_host( | |
| HostId(0xabcd), | |
| Address::Random([0x22, 0x00, 0x55, 0x7E, 0xDE, 0xAD]), | |
| false, | |
| false, | |
| true, | |
| None, | |
| )); | |
| let state = Mutex::new(state); | |
| // Hosts exist | |
| output = get_hosts(&state).await.unwrap(); | |
| assert!(fields.is_match(&output)); | |
| assert!(output.contains("ef")); | |
| assert!(output.contains("cd")); | |
| } | |
| #[test] | |
| fn test_match_peer() { | |
| let nameless_peer = | |
| named_peer(PeerId(0xabcd), Address::Public([0xAB, 0x89, 0x67, 0x45, 0x23, 0x01]), None); | |
| let named_peer = named_peer( | |
| PeerId(0xbeef), | |
| Address::Public([0x11, 0x00, 0x55, 0x7E, 0xDE, 0xAD]), | |
| Some("Sapphire".to_string()), | |
| ); | |
| assert!(match_peer("23", &nameless_peer)); | |
| assert!(!match_peer("23", &named_peer)); | |
| assert!(match_peer("cd", &nameless_peer)); | |
| assert!(match_peer("bee", &named_peer)); | |
| assert!(match_peer("BEE", &named_peer)); | |
| assert!(!match_peer("Sapphire", &nameless_peer)); | |
| assert!(match_peer("Sapphire", &named_peer)); | |
| assert!(match_peer("", &nameless_peer)); | |
| assert!(match_peer("", &named_peer)); | |
| assert!(match_peer("DE", &named_peer)); | |
| assert!(match_peer("de", &named_peer)); | |
| } | |
| #[test] | |
| fn test_get_peers_full_details() { | |
| let mut state = State::new(); | |
| let _ = state.peers.insert( | |
| PeerId(0xabcd), | |
| named_peer(PeerId(0xabcd), Address::Public([0xAB, 0x89, 0x67, 0x45, 0x23, 0x01]), None), | |
| ); | |
| let _ = state.peers.insert( | |
| PeerId(0xbeef), | |
| named_peer( | |
| PeerId(0xbeef), | |
| Address::Public([0x11, 0x00, 0x55, 0x7E, 0xDE, 0xAD]), | |
| Some("Sapphire".to_string()), | |
| ), | |
| ); | |
| let state = Mutex::new(state); | |
| let get_peers = | |
| |args: &[&str], state: &Mutex<State>| -> String { get_peers(args, state, true) }; | |
| // Fields for detailed view of peers | |
| let fields = Regex::new(r"Id(?s).*Address(?s).*Technology(?s).*Name(?s).*Appearance(?s).*Connected(?s).*Bonded(?s).*LE Services(?s).*BR/EDR Serv\.").unwrap(); | |
| // Empty arguments matches everything | |
| assert!(fields.is_match(&get_peers(&[], &state))); | |
| assert!(get_peers(&[], &state).contains("2/2 peers")); | |
| assert!(get_peers(&[], &state).contains("01:23:45")); | |
| assert!(get_peers(&[], &state).contains("AD:DE:7E")); | |
| // No matches prints nothing. | |
| assert!(!fields.is_match(&get_peers(&["nomatch"], &state))); | |
| assert!(get_peers(&["nomatch"], &state).contains("0/2 peers")); | |
| assert!(!get_peers(&["nomatch"], &state).contains("01:23:45")); | |
| assert!(!get_peers(&["nomatch"], &state).contains("AD:DE:7E")); | |
| // We can match either one | |
| assert!(get_peers(&["01:23"], &state).contains("1/2 peers")); | |
| assert!(get_peers(&["01:23"], &state).contains("01:23:45")); | |
| assert!(get_peers(&["abcd"], &state).contains("1/2 peers")); | |
| assert!(get_peers(&["beef"], &state).contains("AD:DE:7E")); | |
| } | |
| #[test] | |
| fn test_get_peers_less_details() { | |
| let mut state = State::new(); | |
| let _ = state.peers.insert( | |
| PeerId(0xabcd), | |
| named_peer(PeerId(0xabcd), Address::Public([0xAB, 0x89, 0x67, 0x45, 0x23, 0x01]), None), | |
| ); | |
| let _ = state.peers.insert( | |
| PeerId(0xbeef), | |
| named_peer( | |
| PeerId(0xbeef), | |
| Address::Public([0x11, 0x00, 0x55, 0x7E, 0xDE, 0xAD]), | |
| Some("Sapphire".to_string()), | |
| ), | |
| ); | |
| let state = Mutex::new(state); | |
| let get_peers = | |
| |args: &[&str], state: &Mutex<State>| -> String { get_peers(args, state, false) }; | |
| // Fields for table view of peers | |
| let fields = Regex::new(r"PeerId[ \t]*\|[ \t]*Address[ \t]*\|[ \t]*Technology[ \t]*\|[ \t]*Name[ \t]*\|[ \t]*Appearance[ \t]*\|[ \t]*Connected[ \t]*\|[ \t]*Bonded").unwrap(); | |
| // Empty arguments matches everything | |
| assert!(fields.is_match(&get_peers(&[], &state))); | |
| assert!(get_peers(&[], &state).contains("2/2 peers")); | |
| assert!(get_peers(&[], &state).contains("01:23:45")); | |
| assert!(get_peers(&[], &state).contains("AD:DE:7E")); | |
| // No matches prints nothing. | |
| assert!(!fields.is_match(&get_peers(&["nomatch"], &state))); | |
| assert!(get_peers(&["nomatch"], &state).contains("0/2 peers")); | |
| assert!(!get_peers(&["nomatch"], &state).contains("01:23:45")); | |
| assert!(!get_peers(&["nomatch"], &state).contains("AD:DE:7E")); | |
| // We can match either one | |
| assert!(get_peers(&["01:23"], &state).contains("1/2 peers")); | |
| assert!(get_peers(&["01:23"], &state).contains("01:23:45")); | |
| assert!(get_peers(&["abcd"], &state).contains("1/2 peers")); | |
| assert!(get_peers(&["beef"], &state).contains("AD:DE:7E")); | |
| } | |
| #[test] | |
| fn cmp_peers_correctly_orders_peers() { | |
| // Sorts connected correctly | |
| let peer_a = | |
| custom_peer(PeerId(0xbeef), Address::Public([1, 0, 0, 0, 0, 0]), false, false, None); | |
| let peer_b = | |
| custom_peer(PeerId(0xbaaf), Address::Public([2, 0, 0, 0, 0, 0]), true, false, None); | |
| assert_eq!(cmp_peers(&peer_a, &peer_b), Ordering::Less); | |
| // Sorts bonded correctly | |
| let peer_a = | |
| custom_peer(PeerId(0xbeef), Address::Public([1, 0, 0, 0, 0, 0]), false, false, None); | |
| let peer_b = | |
| custom_peer(PeerId(0xbaaf), Address::Public([2, 0, 0, 0, 0, 0]), false, true, None); | |
| assert_eq!(cmp_peers(&peer_a, &peer_b), Ordering::Less); | |
| } | |
| #[test] | |
| fn test_peer_updates() { | |
| // Expected Value Table | |
| // each row lists: | |
| // (current peer conn/bond state, new peer conn/bond state, expected string) | |
| let test_cases = vec![ | |
| // missing | |
| (None, (true, false), Some("[connected]")), | |
| (None, (true, true), Some("[connected] [bonded]")), | |
| (None, (false, true), Some("[bonded]")), | |
| (None, (false, false), None), | |
| // disconnected, unbonded | |
| (Some((false, false)), (true, false), Some("[connected]")), | |
| (Some((false, false)), (true, true), Some("[connected] [bonded]")), | |
| (Some((false, false)), (false, true), Some("[bonded]")), | |
| (Some((false, false)), (false, false), None), | |
| // connected, unbonded | |
| (Some((true, false)), (true, false), None), | |
| (Some((true, false)), (true, true), Some("[bonded]")), | |
| (Some((true, false)), (false, true), Some("[disconnected] [bonded]")), | |
| (Some((true, false)), (false, false), Some("[disconnected]")), | |
| // disconnected, bonded | |
| (Some((false, true)), (true, false), Some("[connected] [unbonded]")), | |
| (Some((false, true)), (true, true), Some("[connected]")), | |
| (Some((false, true)), (false, true), None), | |
| (Some((false, true)), (false, false), Some("[unbonded]")), | |
| // connected, bonded | |
| (Some((true, true)), (true, false), Some("[unbonded]")), | |
| (Some((true, true)), (true, true), None), | |
| (Some((true, true)), (false, true), Some("[disconnected]")), | |
| (Some((true, true)), (false, false), Some("[disconnected] [unbonded]")), | |
| ]; | |
| for case in test_cases { | |
| let (prev, (connected, bonded), expected) = case; | |
| let state = match prev { | |
| Some((c, b)) => state_with(peer(c, b)), | |
| None => State::new(), | |
| }; | |
| assert_eq!( | |
| peer_state_updates(&state, &peer(connected, bonded)), | |
| expected.map(|s| s.to_string()) | |
| ); | |
| } | |
| } | |
| // Test that command lines entered parse correctly to the expected disconnect calls | |
| #[test] | |
| fn test_parse_disconnect() { | |
| let state = Mutex::new(state_with(peer(true, false))); | |
| let cases = vec![ | |
| // valid peer id | |
| ("disconnect deadbeef", Ok(PeerId(0xdeadbeef))), | |
| // unknown address | |
| ( | |
| "disconnect 00:00:00:00:00:00", | |
| Err("Unable to disconnect: Unknown address 00:00:00:00:00:00".to_string()), | |
| ), | |
| // known address | |
| ("disconnect 00:00:00:00:00:01", Ok(PeerId(0xdeadbeef))), | |
| // no id param | |
| ("disconnect", Err(format!("usage: {}", Cmd::Disconnect.usage()))), | |
| ]; | |
| for (line, expected) in cases { | |
| assert_eq!(parse_disconnect_id(line, &state), expected); | |
| } | |
| } | |
| /// Splits `line` into a command and its arguments, as the REPL does. | |
| fn parse_cmd(line: &str) -> Option<(Cmd, Vec<&str>)> { | |
| let mut words = line.split_whitespace(); | |
| let cmd = words.next()?.parse::<Cmd>().ok()?; | |
| Some((cmd, words.collect())) | |
| } | |
| fn parse_disconnect_id(line: &str, state: &Mutex<State>) -> Result<PeerId, String> { | |
| let args = match parse_cmd(line) { | |
| Some((Cmd::Disconnect, args)) => Ok(args), | |
| Some((_, _)) => Err("Command is not disconnect"), | |
| None => Err("failed"), | |
| }?; | |
| parse_disconnect(&args, state) | |
| } | |
| // Tests that command lines entered parse correctly to the expected pairing calls | |
| #[test] | |
| fn test_parse_pairing_security_level() { | |
| let cases = vec![ | |
| ("Enc", Ok(PairingSecurityLevel::Encrypted)), | |
| ("AUTH", Ok(PairingSecurityLevel::Authenticated)), | |
| ( | |
| "SC", | |
| Err("Unable to pair: security level must be either \"AUTH\" or \"ENC\"".to_string()), | |
| ), | |
| ]; | |
| for (input_str, expected) in cases { | |
| assert_eq!(parse_pairing_security_level(input_str), expected); | |
| } | |
| } | |
| #[test] | |
| fn test_parse_bondable_mode() { | |
| let cases = vec![ | |
| ("T", Ok(BondableMode::Bondable)), | |
| ("f", Ok(BondableMode::NonBondable)), | |
| ("TEST", Err("Bondable mode must be either \"T\" or \"F\"".to_string())), | |
| ]; | |
| for (input_str, expected) in cases { | |
| assert_eq!(parse_bondable_mode(input_str), expected); | |
| } | |
| } | |
| #[test] | |
| fn test_parse_pairing_transport() { | |
| let cases = vec![ | |
| ("CLAssIC", Ok(TechnologyType::Classic)), | |
| ("BrEdr", Ok(TechnologyType::Classic)), | |
| ("LE", Ok(TechnologyType::LowEnergy)), | |
| ( | |
| "TEST", | |
| Err("If present, transport must be \"BREDR\"/\"CLASSIC\" or \"LE\"".to_string()), | |
| ), | |
| ]; | |
| for (input_str, expected) in cases { | |
| assert_eq!(parse_pairing_transport(input_str), expected); | |
| } | |
| } | |
| #[test] | |
| fn test_parse_pair() { | |
| let state = Mutex::new(state_with(custom_peer( | |
| PeerId(0xbeef), | |
| Address::Public([1, 0, 0, 0, 0, 0]), | |
| true, | |
| false, | |
| None, | |
| ))); | |
| let cases = vec![ | |
| // valid peer id | |
| ( | |
| "pair beef ENC T LE", | |
| Ok(( | |
| FidlPeerId { value: u64::from_str_radix("beef", 16).unwrap() }, | |
| PairingOptions { | |
| le_security_level: Some(PairingSecurityLevel::Encrypted), | |
| bondable_mode: Some(BondableMode::Bondable), | |
| transport: Some(TechnologyType::LowEnergy), | |
| ..Default::default() | |
| }, | |
| )), | |
| ), | |
| // known address, no transport | |
| ( | |
| "pair 00:00:00:00:00:01 AUTH F", | |
| Ok(( | |
| FidlPeerId { value: u64::from_str_radix("beef", 16).unwrap() }, | |
| PairingOptions { | |
| le_security_level: Some(PairingSecurityLevel::Authenticated), | |
| bondable_mode: Some(BondableMode::NonBondable), | |
| transport: None, | |
| ..Default::default() | |
| }, | |
| )), | |
| ), | |
| // no id param | |
| ("pair", Err(format!("usage: {}", Cmd::Pair.usage()))), | |
| ]; | |
| for (line, expected) in cases { | |
| assert_eq!(parse_pair_args(line, &state), expected); | |
| } | |
| } | |
| fn parse_pair_args( | |
| line: &str, | |
| state: &Mutex<State>, | |
| ) -> Result<(FidlPeerId, PairingOptions), String> { | |
| let args = match parse_cmd(line) { | |
| Some((Cmd::Pair, args)) => Ok(args), | |
| Some((_, _)) => Err("Command is not pair"), | |
| None => Err("failed"), | |
| }?; | |
| parse_pair(&args, state) | |
| } | |
| fn timeout() -> MonotonicDuration { | |
| MonotonicDuration::from_seconds(20) | |
| } | |
| #[fuchsia::test(allow_stalls = false)] | |
| async fn test_disconnect() { | |
| let peer = peer(true, false); | |
| let peer_id = peer.id; | |
| let peer_id_string = peer.id.to_string(); | |
| let args = vec![peer_id_string.as_str()]; | |
| let state = Mutex::new(state_with(peer)); | |
| let (proxy, mut mock) = AccessMock::new(timeout()).expect("failed to create mock"); | |
| let cmd = disconnect(args.as_slice(), &state, &proxy); | |
| let mock_expect = mock.expect_disconnect(peer_id.into(), Ok(())); | |
| let (result, mock_result) = join!(cmd, mock_expect); | |
| let _ = mock_result.expect("mock FIDL expectation not satisfied"); | |
| assert_eq!("".to_string(), result.expect("expected success")); | |
| } | |
| #[fuchsia::test(allow_stalls = false)] | |
| async fn test_disconnect_error() { | |
| let peer = peer(true, false); | |
| let peer_id = peer.id; | |
| let peer_id_string = peer.id.to_string(); | |
| let args = vec![peer_id_string.as_str()]; | |
| let state = Mutex::new(state_with(peer)); | |
| let (proxy, mut mock) = AccessMock::new(timeout()).expect("failed to create mock"); | |
| let cmd = disconnect(args.as_slice(), &state, &proxy); | |
| let mock_expect = mock.expect_disconnect(peer_id.into(), Err(fsys::Error::Failed)); | |
| let (result, mock_result) = join!(cmd, mock_expect); | |
| let _ = mock_result.expect("mock FIDL expectation not satisfied"); | |
| assert!(result.expect("expected a result").contains("Disconnect error")); | |
| } | |
| #[test] | |
| fn test_allow_pairing_no_args() { | |
| let mut exec = fasync::TestExecutor::new(); | |
| let args = vec![]; | |
| let (proxy, mut mock) = | |
| PairingMock::new(MonotonicDuration::from_seconds(1)).expect("failed to create mock"); | |
| let pair = allow_pairing(args.as_slice(), &proxy); | |
| let mut pair = pin!(pair); | |
| assert!(exec.run_until_stalled(&mut pair).is_pending()); | |
| let mock_expect = | |
| mock.expect_set_pairing_delegate(InputCapability::None, OutputCapability::None); | |
| assert!(exec.run_singlethreaded(mock_expect).is_ok()); | |
| } | |
| #[fuchsia::test] | |
| fn test_allow_pairing_args() { | |
| let mut exec = fasync::TestExecutor::new(); | |
| let (proxy, mut mock) = | |
| PairingMock::new(MonotonicDuration::from_seconds(1)).expect("failed to create mock"); | |
| // Enable pairing with confirmation input cap and display output cap. | |
| let args = vec!["confirmation", "display"]; | |
| let pair = allow_pairing(args.as_slice(), &proxy); | |
| let mut pair = pin!(pair); | |
| // Should be waiting until pairing is completed. | |
| assert!(exec.run_until_stalled(&mut pair).is_pending()); | |
| // Expect pairing delegate to be set with the correct capabilities. | |
| let proxy = exec | |
| .run_singlethreaded(mock.expect_set_pairing_delegate( | |
| InputCapability::Confirmation, | |
| OutputCapability::Display, | |
| )) | |
| .expect("cannot get proxy"); | |
| assert!(!proxy.is_closed()); | |
| // Force closing of the proxy. | |
| std::mem::drop(proxy); | |
| // Verify that allow_pairing existed with error. | |
| assert_matches!(exec.run_until_stalled(&mut pair), Poll::Ready(Err(_))); | |
| } | |
| #[fuchsia::test(allow_stalls = false)] | |
| async fn test_allow_pairing_error() { | |
| // Arguments that don't correspond to any capabilities. | |
| let args = vec!["nonsense", "fake"]; | |
| let (proxy, _mock) = | |
| PairingMock::new(MonotonicDuration::from_seconds(1)).expect("failed to create mock"); | |
| assert!(allow_pairing(args.as_slice(), &proxy).await.is_err()); | |
| // Incorrect number of arguments. | |
| let args = vec!["none"]; | |
| let (proxy, _mock) = | |
| PairingMock::new(MonotonicDuration::from_seconds(1)).expect("failed to create mock"); | |
| assert!(allow_pairing(args.as_slice(), &proxy).await.is_err()); | |
| } | |
| #[fuchsia::test(allow_stalls = false)] | |
| async fn test_forget() { | |
| let peer = peer(true, false); | |
| let peer_id = peer.id; | |
| let peer_id_string = peer.id.to_string(); | |
| let args = vec![peer_id_string.as_str()]; | |
| let state = Mutex::new(state_with(peer)); | |
| let (proxy, mut mock) = | |
| AccessMock::new(MonotonicDuration::from_seconds(1)).expect("failed to create mock"); | |
| let cmd = forget(args.as_slice(), &state, &proxy); | |
| let mock_expect = mock.expect_forget(peer_id.into(), Ok(())); | |
| let (result, mock_result) = join!(cmd, mock_expect); | |
| assert!(mock_result.is_ok()); | |
| assert_eq!("".to_string(), result.expect("expected success")); | |
| } | |
| #[fuchsia::test(allow_stalls = false)] | |
| async fn test_forget_error() { | |
| let peer = peer(true, false); | |
| let peer_id = peer.id; | |
| let peer_id_string = peer.id.to_string(); | |
| let args = vec![peer_id_string.as_str()]; | |
| let state = Mutex::new(state_with(peer)); | |
| let (proxy, mut mock) = | |
| AccessMock::new(MonotonicDuration::from_seconds(1)).expect("failed to create mock"); | |
| let cmd = forget(args.as_slice(), &state, &proxy); | |
| let mock_expect = mock.expect_forget(peer_id.into(), Err(fsys::Error::Failed)); | |
| let (result, mock_result) = join!(cmd, mock_expect); | |
| assert!(mock_result.is_ok()); | |
| assert!(result.expect("expected a result").contains("Forget error")); | |
| } | |
| #[fuchsia::test(allow_stalls = false)] | |
| async fn test_pair() { | |
| let peer = | |
| custom_peer(PeerId(0xbeef), Address::Public([1, 0, 0, 0, 0, 0]), true, false, None); | |
| let peer_id = peer.id; | |
| let peer_id_string = peer.id.to_string(); | |
| let pairing_options = PairingOptions { | |
| le_security_level: Some(PairingSecurityLevel::Encrypted), | |
| bondable_mode: Some(BondableMode::Bondable), | |
| transport: None, | |
| ..Default::default() | |
| }; | |
| let args = vec![peer_id_string.as_str(), "ENC", "T"]; | |
| let state = Mutex::new(state_with(peer)); | |
| let (proxy, mut mock) = | |
| AccessMock::new(MonotonicDuration::from_seconds(1)).expect("failed to create mock"); | |
| let cmd = pair(args.as_slice(), &state, &proxy); | |
| let mock_expect = mock.expect_pair(peer_id.into(), pairing_options, Ok(())); | |
| let (result, mock_result) = join!(cmd, mock_expect); | |
| assert!(mock_result.is_ok()); | |
| assert_eq!("".to_string(), result.expect("expected success")); | |
| } | |
| #[fuchsia::test(allow_stalls = false)] | |
| async fn test_pair_error() { | |
| let peer = | |
| custom_peer(PeerId(0xbeef), Address::Public([1, 0, 0, 0, 0, 0]), true, false, None); | |
| let peer_id = peer.id; | |
| let peer_id_string = peer.id.to_string(); | |
| let pairing_options = PairingOptions { | |
| le_security_level: Some(PairingSecurityLevel::Encrypted), | |
| bondable_mode: Some(BondableMode::Bondable), | |
| transport: None, | |
| ..Default::default() | |
| }; | |
| let args = vec![peer_id_string.as_str(), "ENC", "T"]; | |
| let state = Mutex::new(state_with(peer)); | |
| let (proxy, mut mock) = | |
| AccessMock::new(MonotonicDuration::from_seconds(1)).expect("failed to create mock"); | |
| let cmd = pair(args.as_slice(), &state, &proxy); | |
| let mock_expect = | |
| mock.expect_pair(peer_id.into(), pairing_options, Err(fsys::Error::Failed)); | |
| let (result, mock_result) = join!(cmd, mock_expect); | |
| assert!(mock_result.is_ok()); | |
| assert!(result.expect("expected a result").contains("Pair error")); | |
| } | |
| #[fuchsia::test] | |
| async fn handle_dispatches_commands() { | |
| let (access_svc, _access_server) = fidl::endpoints::create_proxy::<AccessMarker>(); | |
| let (host_svc, _host_server) = fidl::endpoints::create_proxy::<HostWatcherMarker>(); | |
| let (pairing_svc, _pairing_server) = fidl::endpoints::create_proxy::<PairingMarker>(); | |
| let state = Arc::new(Mutex::new(State::new())); | |
| let mut handler = BtCliHandler { access_svc, host_svc, pairing_svc, state }; | |
| assert_eq!(handler.handle(Cmd::ListPeers, &[]).await.unwrap(), ReplControl::Continue); | |
| assert_eq!(handler.handle(Cmd::Controller, &[]).await.unwrap(), ReplControl::Continue); | |
| assert!(handler.handle(Cmd::SetController, &[]).await.is_err()); | |
| } | |
| } |