996 lines
38 KiB
Rust
996 lines
38 KiB
Rust
use std::collections::BTreeMap;
|
|
|
|
use redox_scheme::scheme::SchemeSync;
|
|
use redox_scheme::{CallerCtx, OpenResult};
|
|
use syscall::error::{Error, Result, EACCES, EBADF, EINVAL, ENOENT, EROFS};
|
|
use syscall::flag::{EventFlags, MODE_DIR, MODE_FILE};
|
|
use syscall::schemev2::NewFdFlags;
|
|
use syscall::Stat;
|
|
|
|
use crate::backend::{connection_state_lines, AdapterState, AdapterStatus, Backend};
|
|
use crate::bond_store::BondRecord;
|
|
|
|
const SCHEME_ROOT_ID: usize = 1;
|
|
|
|
#[derive(Clone)]
|
|
enum HandleKind {
|
|
Root,
|
|
Adapters,
|
|
Adapter(String),
|
|
Capabilities,
|
|
Status(String),
|
|
TransportStatus(String),
|
|
ScanResults(String),
|
|
ConnectionState(String),
|
|
ConnectResult(String),
|
|
DisconnectResult(String),
|
|
ReadCharResult(String),
|
|
LastError(String),
|
|
BondStorePath(String),
|
|
BondCount(String),
|
|
Bonds(String),
|
|
BondMetadata(String, String),
|
|
Scan(String),
|
|
Connect(String),
|
|
Disconnect(String),
|
|
ReadChar(String),
|
|
}
|
|
|
|
pub struct BtCtlScheme {
|
|
backend: Box<dyn Backend>,
|
|
next_id: usize,
|
|
handles: BTreeMap<usize, HandleKind>,
|
|
states: BTreeMap<String, AdapterState>,
|
|
}
|
|
|
|
impl BtCtlScheme {
|
|
pub fn new(backend: Box<dyn Backend>) -> Self {
|
|
let mut states = BTreeMap::new();
|
|
for adapter in backend.adapters() {
|
|
states.insert(
|
|
adapter.clone(),
|
|
AdapterState {
|
|
status: backend.initial_status(&adapter).as_str().to_string(),
|
|
transport_status: backend.transport_status(&adapter),
|
|
scan_results: backend.default_scan_results(&adapter),
|
|
connected_bond_ids: backend.connected_bond_ids(&adapter).unwrap_or_default(),
|
|
connect_result: backend
|
|
.connect_result(&adapter)
|
|
.unwrap_or_else(|_| "connect_result=not-run".to_string()),
|
|
disconnect_result: backend
|
|
.disconnect_result(&adapter)
|
|
.unwrap_or_else(|_| "disconnect_result=not-run".to_string()),
|
|
read_char_result: backend
|
|
.read_char_result(&adapter)
|
|
.unwrap_or_else(|_| "read_char_result=not-run".to_string()),
|
|
bond_store_path: backend.bond_store_path(&adapter).unwrap_or_default(),
|
|
bonds: backend.load_bonds(&adapter).unwrap_or_default(),
|
|
..Default::default()
|
|
},
|
|
);
|
|
}
|
|
|
|
Self {
|
|
backend,
|
|
next_id: SCHEME_ROOT_ID + 1,
|
|
handles: BTreeMap::new(),
|
|
states,
|
|
}
|
|
}
|
|
|
|
fn alloc_handle(&mut self, kind: HandleKind) -> usize {
|
|
let id = self.next_id;
|
|
self.next_id += 1;
|
|
self.handles.insert(id, kind);
|
|
id
|
|
}
|
|
|
|
fn handle(&self, id: usize) -> Result<&HandleKind> {
|
|
self.handles.get(&id).ok_or(Error::new(EBADF))
|
|
}
|
|
|
|
fn state(&self, adapter: &str) -> Result<&AdapterState> {
|
|
self.states.get(adapter).ok_or(Error::new(ENOENT))
|
|
}
|
|
|
|
fn state_mut(&mut self, adapter: &str) -> Result<&mut AdapterState> {
|
|
self.states.get_mut(adapter).ok_or(Error::new(ENOENT))
|
|
}
|
|
|
|
fn refreshed_status(&mut self, adapter: &str) -> Result<String> {
|
|
let status = self
|
|
.backend
|
|
.status(adapter)
|
|
.map_err(|_| Error::new(ENOENT))?
|
|
.as_str()
|
|
.to_string();
|
|
let transport_status = self.backend.transport_status(adapter);
|
|
let state = self.state_mut(adapter)?;
|
|
state.status = status.clone();
|
|
state.transport_status = transport_status.clone();
|
|
if status != AdapterStatus::Scanning.as_str() {
|
|
state.scan_results.clear();
|
|
}
|
|
Ok(status)
|
|
}
|
|
|
|
fn refreshed_transport_status(&mut self, adapter: &str) -> Result<String> {
|
|
let transport_status = self.backend.transport_status(adapter);
|
|
let state = self.state_mut(adapter)?;
|
|
state.transport_status = transport_status.clone();
|
|
Ok(transport_status)
|
|
}
|
|
|
|
fn refreshed_bonds(&mut self, adapter: &str) -> Result<Vec<BondRecord>> {
|
|
let bond_store_path = self
|
|
.backend
|
|
.bond_store_path(adapter)
|
|
.map_err(|_| Error::new(ENOENT))?;
|
|
let bonds = self
|
|
.backend
|
|
.load_bonds(adapter)
|
|
.map_err(|_| Error::new(ENOENT))?;
|
|
let state = self.state_mut(adapter)?;
|
|
state.bond_store_path = bond_store_path;
|
|
state.bonds = bonds.clone();
|
|
Ok(bonds)
|
|
}
|
|
|
|
fn refreshed_connected_bond_ids(&mut self, adapter: &str) -> Result<Vec<String>> {
|
|
let connected_bond_ids = self
|
|
.backend
|
|
.connected_bond_ids(adapter)
|
|
.map_err(|_| Error::new(ENOENT))?;
|
|
self.state_mut(adapter)?.connected_bond_ids = connected_bond_ids.clone();
|
|
Ok(connected_bond_ids)
|
|
}
|
|
|
|
fn refreshed_connect_result(&mut self, adapter: &str) -> Result<String> {
|
|
let connect_result = self
|
|
.backend
|
|
.connect_result(adapter)
|
|
.map_err(|_| Error::new(ENOENT))?;
|
|
self.state_mut(adapter)?.connect_result = connect_result.clone();
|
|
Ok(connect_result)
|
|
}
|
|
|
|
fn refreshed_disconnect_result(&mut self, adapter: &str) -> Result<String> {
|
|
let disconnect_result = self
|
|
.backend
|
|
.disconnect_result(adapter)
|
|
.map_err(|_| Error::new(ENOENT))?;
|
|
self.state_mut(adapter)?.disconnect_result = disconnect_result.clone();
|
|
Ok(disconnect_result)
|
|
}
|
|
|
|
fn refreshed_read_char_result(&mut self, adapter: &str) -> Result<String> {
|
|
let read_char_result = self
|
|
.backend
|
|
.read_char_result(adapter)
|
|
.map_err(|_| Error::new(ENOENT))?;
|
|
self.state_mut(adapter)?.read_char_result = read_char_result.clone();
|
|
Ok(read_char_result)
|
|
}
|
|
|
|
fn parse_read_char_request(value: &str) -> Result<(String, String, String)> {
|
|
let mut bond_id = None;
|
|
let mut service_uuid = None;
|
|
let mut char_uuid = None;
|
|
|
|
for line in value.lines().map(str::trim).filter(|line| !line.is_empty()) {
|
|
let Some((key, raw_value)) = line.split_once('=') else {
|
|
return Err(Error::new(EINVAL));
|
|
};
|
|
let parsed = raw_value.trim().to_string();
|
|
if parsed.is_empty() {
|
|
return Err(Error::new(EINVAL));
|
|
}
|
|
match key.trim() {
|
|
"bond_id" => bond_id = Some(parsed),
|
|
"service_uuid" => service_uuid = Some(parsed),
|
|
"char_uuid" => char_uuid = Some(parsed),
|
|
_ => return Err(Error::new(EINVAL)),
|
|
}
|
|
}
|
|
|
|
match (bond_id, service_uuid, char_uuid) {
|
|
(Some(bond_id), Some(service_uuid), Some(char_uuid)) => {
|
|
Ok((bond_id, service_uuid, char_uuid))
|
|
}
|
|
_ => Err(Error::new(EINVAL)),
|
|
}
|
|
}
|
|
|
|
fn format_bond_metadata(bond: &BondRecord) -> String {
|
|
let mut lines = vec![format!("bond_id={}", bond.bond_id)];
|
|
if let Some(alias) = &bond.alias {
|
|
lines.push(format!("alias={alias}"));
|
|
}
|
|
lines.push(format!("created_at_epoch={}", bond.created_at_epoch));
|
|
lines.push(format!("source={}", bond.source));
|
|
format!("{}\n", lines.join("\n"))
|
|
}
|
|
|
|
fn status_string(&self, adapter: &str) -> String {
|
|
self.backend
|
|
.status(adapter)
|
|
.map(|status| status.as_str().to_string())
|
|
.unwrap_or_else(|_| AdapterStatus::Failed.as_str().to_string())
|
|
}
|
|
|
|
fn write_handle(&mut self, kind: HandleKind, value: &str) -> Result<()> {
|
|
match kind {
|
|
HandleKind::Scan(adapter) => {
|
|
let results = match self.backend.scan(&adapter) {
|
|
Ok(results) => results,
|
|
Err(err) => {
|
|
let transport_status = self.backend.transport_status(&adapter);
|
|
let status = self.status_string(&adapter);
|
|
let state = self.state_mut(&adapter)?;
|
|
state.last_error = err;
|
|
state.status = status;
|
|
state.transport_status = transport_status;
|
|
return Ok(());
|
|
}
|
|
};
|
|
|
|
let transport_status = self.backend.transport_status(&adapter);
|
|
let state = self.state_mut(&adapter)?;
|
|
state.status = AdapterStatus::Scanning.as_str().to_string();
|
|
state.transport_status = transport_status;
|
|
state.scan_results = results;
|
|
state.last_error.clear();
|
|
}
|
|
HandleKind::Connect(adapter) => {
|
|
let bond_id = value.trim();
|
|
if bond_id.is_empty() {
|
|
return Err(Error::new(EINVAL));
|
|
}
|
|
|
|
let outcome = self.backend.connect(&adapter, bond_id);
|
|
let status = self.status_string(&adapter);
|
|
let transport_status = self.backend.transport_status(&adapter);
|
|
let connected_bond_ids = self.refreshed_connected_bond_ids(&adapter)?;
|
|
let connect_result = self.refreshed_connect_result(&adapter)?;
|
|
let disconnect_result = self.refreshed_disconnect_result(&adapter)?;
|
|
let rejected = outcome.is_err();
|
|
let state = self.state_mut(&adapter)?;
|
|
state.status = status;
|
|
state.transport_status = transport_status;
|
|
state.connected_bond_ids = connected_bond_ids;
|
|
state.connect_result = connect_result;
|
|
state.disconnect_result = disconnect_result;
|
|
let last_error = match outcome {
|
|
Ok(()) => String::new(),
|
|
Err(err) => err,
|
|
};
|
|
state.last_error = last_error;
|
|
if rejected {
|
|
return Err(Error::new(EINVAL));
|
|
}
|
|
}
|
|
HandleKind::Disconnect(adapter) => {
|
|
let bond_id = value.trim();
|
|
if bond_id.is_empty() {
|
|
return Err(Error::new(EINVAL));
|
|
}
|
|
|
|
let outcome = self.backend.disconnect(&adapter, bond_id);
|
|
let status = self.status_string(&adapter);
|
|
let transport_status = self.backend.transport_status(&adapter);
|
|
let connected_bond_ids = self.refreshed_connected_bond_ids(&adapter)?;
|
|
let connect_result = self.refreshed_connect_result(&adapter)?;
|
|
let disconnect_result = self.refreshed_disconnect_result(&adapter)?;
|
|
let rejected = outcome.is_err();
|
|
let state = self.state_mut(&adapter)?;
|
|
state.status = status;
|
|
state.transport_status = transport_status;
|
|
state.connected_bond_ids = connected_bond_ids;
|
|
state.connect_result = connect_result;
|
|
state.disconnect_result = disconnect_result;
|
|
let last_error = match outcome {
|
|
Ok(()) => String::new(),
|
|
Err(err) => err,
|
|
};
|
|
state.last_error = last_error;
|
|
if rejected {
|
|
return Err(Error::new(EINVAL));
|
|
}
|
|
}
|
|
HandleKind::ReadChar(adapter) => {
|
|
let (bond_id, service_uuid, char_uuid) = Self::parse_read_char_request(value)?;
|
|
|
|
let outcome = self
|
|
.backend
|
|
.read_char(&adapter, &bond_id, &service_uuid, &char_uuid);
|
|
let status = self.status_string(&adapter);
|
|
let transport_status = self.backend.transport_status(&adapter);
|
|
let connected_bond_ids = self.refreshed_connected_bond_ids(&adapter)?;
|
|
let connect_result = self.refreshed_connect_result(&adapter)?;
|
|
let disconnect_result = self.refreshed_disconnect_result(&adapter)?;
|
|
let read_char_result = self.refreshed_read_char_result(&adapter)?;
|
|
let rejected = outcome.is_err();
|
|
let state = self.state_mut(&adapter)?;
|
|
state.status = status;
|
|
state.transport_status = transport_status;
|
|
state.connected_bond_ids = connected_bond_ids;
|
|
state.connect_result = connect_result;
|
|
state.disconnect_result = disconnect_result;
|
|
state.read_char_result = read_char_result;
|
|
let last_error = match outcome {
|
|
Ok(()) => String::new(),
|
|
Err(err) => err,
|
|
};
|
|
state.last_error = last_error;
|
|
if rejected {
|
|
return Err(Error::new(EINVAL));
|
|
}
|
|
}
|
|
_ => return Err(Error::new(EROFS)),
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn read_handle(&mut self, kind: &HandleKind) -> Result<String> {
|
|
Ok(match kind {
|
|
HandleKind::Root => "adapters\ncapabilities\n".to_string(),
|
|
HandleKind::Adapters => {
|
|
self.states.keys().cloned().collect::<Vec<_>>().join("\n") + "\n"
|
|
}
|
|
HandleKind::Adapter(_) => {
|
|
"status\ntransport-status\nscan-results\nconnection-state\nconnect-result\ndisconnect-result\nread-char-result\nlast-error\nbond-store-path\nbond-count\nbonds\nscan\nconnect\ndisconnect\nread-char\n"
|
|
.to_string()
|
|
}
|
|
HandleKind::Capabilities => self.backend.capabilities().join("\n") + "\n",
|
|
HandleKind::Status(adapter) => {
|
|
let status = self.refreshed_status(adapter)?;
|
|
let transport_status = self.refreshed_transport_status(adapter)?;
|
|
let connected_bond_ids = self.refreshed_connected_bond_ids(adapter)?;
|
|
let bonds = self.refreshed_bonds(adapter)?;
|
|
let scan_results_count = self.state(adapter)?.scan_results.len();
|
|
let state = self.state(adapter)?;
|
|
format!(
|
|
"status={}\ntransport_status={}\nscan_results_count={}\nconnected_bond_count={}\nbond_count={}\nbond_store_path={}\n",
|
|
status,
|
|
transport_status,
|
|
scan_results_count.max(state.scan_results.len()),
|
|
connected_bond_ids.len(),
|
|
bonds.len(),
|
|
state.bond_store_path
|
|
)
|
|
}
|
|
HandleKind::TransportStatus(adapter) => {
|
|
format!("{}\n", self.refreshed_transport_status(adapter)?)
|
|
}
|
|
HandleKind::ScanResults(adapter) => self.state(adapter)?.scan_results.join("\n") + "\n",
|
|
HandleKind::ConnectionState(adapter) => {
|
|
let connected_bond_ids = self.refreshed_connected_bond_ids(adapter)?;
|
|
format!("{}\n", connection_state_lines(&connected_bond_ids).join("\n"))
|
|
}
|
|
HandleKind::ConnectResult(adapter) => {
|
|
format!("{}\n", self.refreshed_connect_result(adapter)?)
|
|
}
|
|
HandleKind::DisconnectResult(adapter) => {
|
|
format!("{}\n", self.refreshed_disconnect_result(adapter)?)
|
|
}
|
|
HandleKind::ReadCharResult(adapter) => {
|
|
format!("{}\n", self.refreshed_read_char_result(adapter)?)
|
|
}
|
|
HandleKind::LastError(adapter) => format!("{}\n", self.state(adapter)?.last_error),
|
|
HandleKind::BondStorePath(adapter) => {
|
|
let bonds = self.refreshed_bonds(adapter)?;
|
|
let _ = bonds;
|
|
format!("{}\n", self.state(adapter)?.bond_store_path)
|
|
}
|
|
HandleKind::BondCount(adapter) => {
|
|
let bonds = self.refreshed_bonds(adapter)?;
|
|
format!(
|
|
"bond_count={}\nbond_store_path={}\n",
|
|
bonds.len(),
|
|
self.state(adapter)?.bond_store_path
|
|
)
|
|
}
|
|
HandleKind::Bonds(adapter) => {
|
|
let bonds = self.refreshed_bonds(adapter)?;
|
|
if bonds.is_empty() {
|
|
"\n".to_string()
|
|
} else {
|
|
bonds
|
|
.iter()
|
|
.map(|bond| bond.bond_id.clone())
|
|
.collect::<Vec<_>>()
|
|
.join("\n")
|
|
+ "\n"
|
|
}
|
|
}
|
|
HandleKind::BondMetadata(adapter, bond_id) => self
|
|
.refreshed_bonds(adapter)?
|
|
.into_iter()
|
|
.find(|bond| &bond.bond_id == bond_id)
|
|
.map(|bond| Self::format_bond_metadata(&bond))
|
|
.ok_or(Error::new(ENOENT))?,
|
|
HandleKind::Scan(_) | HandleKind::Connect(_) | HandleKind::Disconnect(_) | HandleKind::ReadChar(_) => {
|
|
String::new()
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
impl SchemeSync for BtCtlScheme {
|
|
fn scheme_root(&mut self) -> Result<usize> {
|
|
Ok(SCHEME_ROOT_ID)
|
|
}
|
|
|
|
fn openat(
|
|
&mut self,
|
|
dirfd: usize,
|
|
path: &str,
|
|
_flags: usize,
|
|
_fcntl_flags: u32,
|
|
_ctx: &CallerCtx,
|
|
) -> Result<OpenResult> {
|
|
let kind = if dirfd == SCHEME_ROOT_ID {
|
|
match path.trim_matches('/') {
|
|
"" => HandleKind::Root,
|
|
"adapters" => HandleKind::Adapters,
|
|
"capabilities" => HandleKind::Capabilities,
|
|
_ => return Err(Error::new(ENOENT)),
|
|
}
|
|
} else {
|
|
let parent = self.handle(dirfd)?.clone();
|
|
match parent {
|
|
HandleKind::Adapters => {
|
|
let adapter = path.trim_matches('/');
|
|
self.state(adapter)?;
|
|
HandleKind::Adapter(adapter.to_string())
|
|
}
|
|
HandleKind::Adapter(adapter) => match path.trim_matches('/') {
|
|
"status" => HandleKind::Status(adapter.clone()),
|
|
"transport-status" => HandleKind::TransportStatus(adapter.clone()),
|
|
"scan-results" => HandleKind::ScanResults(adapter.clone()),
|
|
"connection-state" => HandleKind::ConnectionState(adapter.clone()),
|
|
"connect-result" => HandleKind::ConnectResult(adapter.clone()),
|
|
"disconnect-result" => HandleKind::DisconnectResult(adapter.clone()),
|
|
"read-char-result" => HandleKind::ReadCharResult(adapter.clone()),
|
|
"last-error" => HandleKind::LastError(adapter.clone()),
|
|
"bond-store-path" => HandleKind::BondStorePath(adapter.clone()),
|
|
"bond-count" => HandleKind::BondCount(adapter.clone()),
|
|
"bonds" => HandleKind::Bonds(adapter.clone()),
|
|
"scan" => HandleKind::Scan(adapter.clone()),
|
|
"connect" => HandleKind::Connect(adapter.clone()),
|
|
"disconnect" => HandleKind::Disconnect(adapter.clone()),
|
|
"read-char" => HandleKind::ReadChar(adapter.clone()),
|
|
_ => return Err(Error::new(ENOENT)),
|
|
},
|
|
HandleKind::Bonds(adapter) => {
|
|
let bond_id = path.trim_matches('/');
|
|
if bond_id.is_empty() {
|
|
return Err(Error::new(ENOENT));
|
|
}
|
|
let adapter_name = adapter.clone();
|
|
let exists = self
|
|
.refreshed_bonds(&adapter_name)?
|
|
.into_iter()
|
|
.any(|bond| bond.bond_id == bond_id);
|
|
if exists {
|
|
HandleKind::BondMetadata(adapter_name, bond_id.to_string())
|
|
} else {
|
|
return Err(Error::new(ENOENT));
|
|
}
|
|
}
|
|
_ => return Err(Error::new(EACCES)),
|
|
}
|
|
};
|
|
|
|
Ok(OpenResult::ThisScheme {
|
|
number: self.alloc_handle(kind),
|
|
flags: NewFdFlags::empty(),
|
|
})
|
|
}
|
|
|
|
fn read(
|
|
&mut self,
|
|
id: usize,
|
|
buf: &mut [u8],
|
|
offset: u64,
|
|
_flags: u32,
|
|
_ctx: &CallerCtx,
|
|
) -> Result<usize> {
|
|
let kind = self.handle(id)?.clone();
|
|
let data = self.read_handle(&kind)?;
|
|
let bytes = data.as_bytes();
|
|
let offset = usize::try_from(offset).map_err(|_| Error::new(EINVAL))?;
|
|
if offset >= bytes.len() {
|
|
return Ok(0);
|
|
}
|
|
let count = (bytes.len() - offset).min(buf.len());
|
|
buf[..count].copy_from_slice(&bytes[offset..offset + count]);
|
|
Ok(count)
|
|
}
|
|
|
|
fn write(
|
|
&mut self,
|
|
id: usize,
|
|
buf: &[u8],
|
|
_offset: u64,
|
|
_flags: u32,
|
|
_ctx: &CallerCtx,
|
|
) -> Result<usize> {
|
|
let value = std::str::from_utf8(buf).map_err(|_| Error::new(EINVAL))?;
|
|
let kind = self.handle(id)?.clone();
|
|
self.write_handle(kind, value)?;
|
|
|
|
Ok(buf.len())
|
|
}
|
|
|
|
fn fstat(&mut self, id: usize, stat: &mut Stat, _ctx: &CallerCtx) -> Result<()> {
|
|
let kind = self.handle(id)?;
|
|
stat.st_mode = match kind {
|
|
HandleKind::Root
|
|
| HandleKind::Adapters
|
|
| HandleKind::Adapter(_)
|
|
| HandleKind::Bonds(_) => MODE_DIR | 0o755,
|
|
HandleKind::Scan(_)
|
|
| HandleKind::Connect(_)
|
|
| HandleKind::Disconnect(_)
|
|
| HandleKind::ReadChar(_) => MODE_FILE | 0o644,
|
|
_ => MODE_FILE | 0o444,
|
|
};
|
|
Ok(())
|
|
}
|
|
|
|
fn fsync(&mut self, id: usize, _ctx: &CallerCtx) -> Result<()> {
|
|
let _ = self.handle(id)?;
|
|
Ok(())
|
|
}
|
|
|
|
fn fpath(&mut self, id: usize, buf: &mut [u8], _ctx: &CallerCtx) -> Result<usize> {
|
|
let path = match self.handle(id)? {
|
|
HandleKind::Root => "btctl:/".to_string(),
|
|
HandleKind::Adapters => "btctl:/adapters".to_string(),
|
|
HandleKind::Adapter(adapter) => format!("btctl:/adapters/{adapter}"),
|
|
HandleKind::Capabilities => "btctl:/capabilities".to_string(),
|
|
HandleKind::Status(adapter) => format!("btctl:/adapters/{adapter}/status"),
|
|
HandleKind::TransportStatus(adapter) => {
|
|
format!("btctl:/adapters/{adapter}/transport-status")
|
|
}
|
|
HandleKind::ScanResults(adapter) => format!("btctl:/adapters/{adapter}/scan-results"),
|
|
HandleKind::ConnectionState(adapter) => {
|
|
format!("btctl:/adapters/{adapter}/connection-state")
|
|
}
|
|
HandleKind::ConnectResult(adapter) => {
|
|
format!("btctl:/adapters/{adapter}/connect-result")
|
|
}
|
|
HandleKind::DisconnectResult(adapter) => {
|
|
format!("btctl:/adapters/{adapter}/disconnect-result")
|
|
}
|
|
HandleKind::ReadCharResult(adapter) => {
|
|
format!("btctl:/adapters/{adapter}/read-char-result")
|
|
}
|
|
HandleKind::LastError(adapter) => format!("btctl:/adapters/{adapter}/last-error"),
|
|
HandleKind::BondStorePath(adapter) => {
|
|
format!("btctl:/adapters/{adapter}/bond-store-path")
|
|
}
|
|
HandleKind::BondCount(adapter) => format!("btctl:/adapters/{adapter}/bond-count"),
|
|
HandleKind::Bonds(adapter) => format!("btctl:/adapters/{adapter}/bonds"),
|
|
HandleKind::BondMetadata(adapter, bond_id) => {
|
|
format!("btctl:/adapters/{adapter}/bonds/{bond_id}")
|
|
}
|
|
HandleKind::Scan(adapter) => format!("btctl:/adapters/{adapter}/scan"),
|
|
HandleKind::Connect(adapter) => format!("btctl:/adapters/{adapter}/connect"),
|
|
HandleKind::Disconnect(adapter) => format!("btctl:/adapters/{adapter}/disconnect"),
|
|
HandleKind::ReadChar(adapter) => format!("btctl:/adapters/{adapter}/read-char"),
|
|
};
|
|
let bytes = path.as_bytes();
|
|
let count = bytes.len().min(buf.len());
|
|
buf[..count].copy_from_slice(&bytes[..count]);
|
|
Ok(count)
|
|
}
|
|
|
|
fn fevent(&mut self, id: usize, _flags: EventFlags, _ctx: &CallerCtx) -> Result<EventFlags> {
|
|
let _ = self.handle(id)?;
|
|
Ok(EventFlags::empty())
|
|
}
|
|
|
|
fn on_close(&mut self, id: usize) {
|
|
if id != SCHEME_ROOT_ID {
|
|
self.handles.remove(&id);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::backend::StubBackend;
|
|
use std::env;
|
|
use std::fs;
|
|
use std::path::PathBuf;
|
|
use std::time::{SystemTime, UNIX_EPOCH};
|
|
|
|
fn temp_path(name: &str) -> PathBuf {
|
|
let stamp = SystemTime::now()
|
|
.duration_since(UNIX_EPOCH)
|
|
.unwrap()
|
|
.as_nanos();
|
|
env::temp_dir().join(format!("{name}-{stamp}"))
|
|
}
|
|
|
|
fn build_scheme(status_path: PathBuf, bond_store_root: PathBuf) -> BtCtlScheme {
|
|
BtCtlScheme::new(Box::new(StubBackend::new_for_test(
|
|
vec!["hci0".to_string()],
|
|
vec!["demo-beacon".to_string(), "demo-sensor".to_string()],
|
|
status_path,
|
|
bond_store_root,
|
|
)))
|
|
}
|
|
|
|
#[test]
|
|
fn root_surface_lists_expected_nodes() {
|
|
let mut scheme = build_scheme(
|
|
temp_path("rbos-btctl-root"),
|
|
temp_path("rbos-btctl-root-bonds"),
|
|
);
|
|
assert_eq!(
|
|
scheme.read_handle(&HandleKind::Root).unwrap(),
|
|
"adapters\ncapabilities\n"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn adapter_surface_lists_bond_nodes() {
|
|
let mut scheme = build_scheme(
|
|
temp_path("rbos-btctl-adapter-root"),
|
|
temp_path("rbos-btctl-adapter-root-bonds"),
|
|
);
|
|
assert_eq!(
|
|
scheme
|
|
.read_handle(&HandleKind::Adapter("hci0".to_string()))
|
|
.unwrap(),
|
|
"status\ntransport-status\nscan-results\nconnection-state\nconnect-result\ndisconnect-result\nread-char-result\nlast-error\nbond-store-path\nbond-count\nbonds\nscan\nconnect\ndisconnect\nread-char\n"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn scan_failure_records_last_error_when_transport_is_missing() {
|
|
let missing = temp_path("rbos-btctl-scan-missing");
|
|
let mut scheme = build_scheme(missing, temp_path("rbos-btctl-scan-missing-bonds"));
|
|
let adapter = "hci0".to_string();
|
|
|
|
let err = scheme.backend.scan(&adapter).unwrap_err();
|
|
let transport_status = scheme.backend.transport_status(&adapter);
|
|
let state = scheme.state_mut(&adapter).unwrap();
|
|
state.last_error = err.clone();
|
|
state.status = AdapterStatus::Failed.as_str().to_string();
|
|
state.transport_status = transport_status;
|
|
|
|
assert!(scheme
|
|
.state(&adapter)
|
|
.unwrap()
|
|
.last_error
|
|
.contains("start redbear-btusb explicitly"));
|
|
assert_eq!(scheme.state(&adapter).unwrap().status, "failed");
|
|
}
|
|
|
|
#[test]
|
|
fn scan_updates_state_when_transport_status_file_is_present() {
|
|
let status_path = temp_path("rbos-btctl-scan-visible");
|
|
fs::write(
|
|
&status_path,
|
|
&format!(
|
|
"transport=usb\nstartup=explicit\nupdated_at_epoch={}\nruntime_visibility=runtime-visible\n",
|
|
std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.unwrap()
|
|
.as_secs()
|
|
),
|
|
)
|
|
.unwrap();
|
|
let bond_store_root = temp_path("rbos-btctl-scan-visible-bonds");
|
|
let mut scheme = build_scheme(status_path.clone(), bond_store_root.clone());
|
|
let adapter = "hci0".to_string();
|
|
|
|
let results = scheme.backend.scan(&adapter).unwrap();
|
|
let transport_status = scheme.backend.transport_status(&adapter);
|
|
let state = scheme.state_mut(&adapter).unwrap();
|
|
state.status = AdapterStatus::Scanning.as_str().to_string();
|
|
state.transport_status = transport_status;
|
|
state.scan_results = results;
|
|
|
|
assert_eq!(
|
|
scheme
|
|
.read_handle(&HandleKind::Status(adapter.clone()))
|
|
.unwrap()
|
|
.lines()
|
|
.next()
|
|
.unwrap(),
|
|
"status=adapter-visible"
|
|
);
|
|
assert_eq!(
|
|
scheme.state(&adapter).unwrap().scan_results,
|
|
Vec::<String>::new()
|
|
);
|
|
|
|
fs::remove_file(status_path).unwrap();
|
|
fs::remove_dir_all(bond_store_root).ok();
|
|
}
|
|
|
|
#[test]
|
|
fn status_read_refreshes_when_transport_becomes_stale() {
|
|
let status_path = temp_path("rbos-btctl-scan-stale-read");
|
|
fs::write(
|
|
&status_path,
|
|
"transport=usb\nstartup=explicit\nupdated_at_epoch=1\nruntime_visibility=runtime-visible\n",
|
|
)
|
|
.unwrap();
|
|
let mut scheme = build_scheme(
|
|
status_path.clone(),
|
|
temp_path("rbos-btctl-scan-stale-read-bonds"),
|
|
);
|
|
|
|
let status = scheme
|
|
.read_handle(&HandleKind::Status("hci0".to_string()))
|
|
.unwrap();
|
|
let transport = scheme
|
|
.read_handle(&HandleKind::TransportStatus("hci0".to_string()))
|
|
.unwrap();
|
|
|
|
assert!(status.contains("status=explicit-startup-required"));
|
|
assert!(transport.contains("runtime_visibility=installed-only"));
|
|
|
|
fs::remove_file(status_path).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn bond_nodes_refresh_from_store_without_write_api() {
|
|
let bond_store_root = temp_path("rbos-btctl-scheme-bonds");
|
|
let mut scheme = build_scheme(
|
|
temp_path("rbos-btctl-scheme-status"),
|
|
bond_store_root.clone(),
|
|
);
|
|
let adapter = "hci0".to_string();
|
|
|
|
assert_eq!(
|
|
scheme
|
|
.read_handle(&HandleKind::BondCount(adapter.clone()))
|
|
.unwrap(),
|
|
format!(
|
|
"bond_count=0\nbond_store_path={}\n",
|
|
bond_store_root.join("hci0").join("bonds").display()
|
|
)
|
|
);
|
|
|
|
scheme
|
|
.backend
|
|
.add_stub_bond(&adapter, "AA:BB:CC:DD:EE:FF", Some("demo-sensor"))
|
|
.unwrap();
|
|
|
|
let count = scheme
|
|
.read_handle(&HandleKind::BondCount(adapter.clone()))
|
|
.unwrap();
|
|
let bonds = scheme
|
|
.read_handle(&HandleKind::Bonds(adapter.clone()))
|
|
.unwrap();
|
|
let metadata = scheme
|
|
.read_handle(&HandleKind::BondMetadata(
|
|
adapter.clone(),
|
|
"AA:BB:CC:DD:EE:FF".to_string(),
|
|
))
|
|
.unwrap();
|
|
|
|
assert!(count.contains("bond_count=1"));
|
|
assert!(bonds.contains("AA:BB:CC:DD:EE:FF"));
|
|
assert!(metadata.contains("bond_id=AA:BB:CC:DD:EE:FF"));
|
|
assert!(metadata.contains("alias=demo-sensor"));
|
|
assert!(metadata.contains("source=stub-cli"));
|
|
|
|
scheme
|
|
.backend
|
|
.remove_bond(&adapter, "AA:BB:CC:DD:EE:FF")
|
|
.unwrap();
|
|
|
|
let count_after_remove = scheme
|
|
.read_handle(&HandleKind::BondCount(adapter.clone()))
|
|
.unwrap();
|
|
assert!(count_after_remove.contains("bond_count=0"));
|
|
|
|
fs::remove_dir_all(bond_store_root).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn connect_write_updates_connection_surfaces() {
|
|
let status_path = temp_path("rbos-btctl-scheme-connect-status");
|
|
fs::write(
|
|
&status_path,
|
|
&format!(
|
|
"transport=usb\nstartup=explicit\nupdated_at_epoch={}\nruntime_visibility=runtime-visible\n",
|
|
std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.unwrap()
|
|
.as_secs()
|
|
),
|
|
)
|
|
.unwrap();
|
|
let bond_store_root = temp_path("rbos-btctl-scheme-connect-bonds");
|
|
let mut scheme = build_scheme(status_path.clone(), bond_store_root.clone());
|
|
let adapter = "hci0".to_string();
|
|
|
|
scheme
|
|
.backend
|
|
.add_stub_bond(&adapter, "AA:BB:CC:DD:EE:FF", Some("demo-sensor"))
|
|
.unwrap();
|
|
|
|
scheme
|
|
.write_handle(HandleKind::Connect(adapter.clone()), "AA:BB:CC:DD:EE:FF")
|
|
.unwrap();
|
|
|
|
let connection_state = scheme
|
|
.read_handle(&HandleKind::ConnectionState(adapter.clone()))
|
|
.unwrap();
|
|
let connect_result = scheme
|
|
.read_handle(&HandleKind::ConnectResult(adapter.clone()))
|
|
.unwrap();
|
|
|
|
assert!(connection_state.contains("connection_state=stub-connected"));
|
|
assert!(connection_state.contains("connected_bond_ids=AA:BB:CC:DD:EE:FF"));
|
|
assert!(connect_result.contains("connect_result=stub-connected bond_id=AA:BB:CC:DD:EE:FF"));
|
|
|
|
scheme
|
|
.write_handle(HandleKind::Disconnect(adapter.clone()), "AA:BB:CC:DD:EE:FF")
|
|
.unwrap();
|
|
|
|
let disconnected_state = scheme
|
|
.read_handle(&HandleKind::ConnectionState(adapter.clone()))
|
|
.unwrap();
|
|
let disconnect_result = scheme
|
|
.read_handle(&HandleKind::DisconnectResult(adapter.clone()))
|
|
.unwrap();
|
|
|
|
assert!(disconnected_state.contains("connection_state=stub-disconnected"));
|
|
assert!(disconnected_state.contains("connected_bond_ids="));
|
|
assert!(!disconnected_state.contains("connected_bond_ids=AA:BB:CC:DD:EE:FF"));
|
|
assert!(disconnect_result
|
|
.contains("disconnect_result=stub-disconnected bond_id=AA:BB:CC:DD:EE:FF"));
|
|
|
|
fs::remove_file(status_path).unwrap();
|
|
fs::remove_dir_all(bond_store_root).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn read_char_write_updates_bounded_result_surface() {
|
|
let status_path = temp_path("rbos-btctl-scheme-read-char-status");
|
|
fs::write(
|
|
&status_path,
|
|
&format!(
|
|
"transport=usb\nstartup=explicit\nupdated_at_epoch={}\nruntime_visibility=runtime-visible\n",
|
|
std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.unwrap()
|
|
.as_secs()
|
|
),
|
|
)
|
|
.unwrap();
|
|
let bond_store_root = temp_path("rbos-btctl-scheme-read-char-bonds");
|
|
let mut scheme = build_scheme(status_path.clone(), bond_store_root.clone());
|
|
let adapter = "hci0".to_string();
|
|
|
|
scheme
|
|
.backend
|
|
.add_stub_bond(&adapter, "AA:BB:CC:DD:EE:FF", Some("demo-battery-sensor"))
|
|
.unwrap();
|
|
scheme
|
|
.write_handle(HandleKind::Connect(adapter.clone()), "AA:BB:CC:DD:EE:FF")
|
|
.unwrap();
|
|
|
|
scheme
|
|
.write_handle(
|
|
HandleKind::ReadChar(adapter.clone()),
|
|
"bond_id=AA:BB:CC:DD:EE:FF\nservice_uuid=0000180f-0000-1000-8000-00805f9b34fb\nchar_uuid=00002a19-0000-1000-8000-00805f9b34fb\n",
|
|
)
|
|
.unwrap();
|
|
|
|
let read_result = scheme
|
|
.read_handle(&HandleKind::ReadCharResult(adapter.clone()))
|
|
.unwrap();
|
|
assert!(read_result.contains("read_char_result=stub-value"));
|
|
assert!(read_result.contains("workload=battery-sensor-battery-level-read"));
|
|
assert!(read_result.contains("access=read-only"));
|
|
assert!(read_result.contains("value_percent=87"));
|
|
|
|
scheme
|
|
.write_handle(
|
|
HandleKind::ReadChar(adapter.clone()),
|
|
"bond_id=AA:BB:CC:DD:EE:FF\nservice_uuid=0000180f-0000-1000-8000-00805f9b34fb\nchar_uuid=00002a1a-0000-1000-8000-00805f9b34fb\n",
|
|
)
|
|
.unwrap_err();
|
|
|
|
let read_result_after_reject = scheme
|
|
.read_handle(&HandleKind::ReadCharResult(adapter.clone()))
|
|
.unwrap();
|
|
let last_error = scheme
|
|
.read_handle(&HandleKind::LastError(adapter.clone()))
|
|
.unwrap();
|
|
assert!(read_result_after_reject
|
|
.contains("read_char_result=rejected-unsupported-characteristic"));
|
|
assert!(last_error.contains("only the experimental"));
|
|
|
|
fs::remove_file(status_path).unwrap();
|
|
fs::remove_dir_all(bond_store_root).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn connect_write_records_last_error_when_bond_is_missing() {
|
|
let status_path = temp_path("rbos-btctl-scheme-connect-missing-bond-status");
|
|
fs::write(
|
|
&status_path,
|
|
&format!(
|
|
"transport=usb\nstartup=explicit\nupdated_at_epoch={}\nruntime_visibility=runtime-visible\n",
|
|
std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.unwrap()
|
|
.as_secs()
|
|
),
|
|
)
|
|
.unwrap();
|
|
let bond_store_root = temp_path("rbos-btctl-scheme-connect-missing-bond-bonds");
|
|
let mut scheme = build_scheme(status_path.clone(), bond_store_root.clone());
|
|
let adapter = "hci0".to_string();
|
|
|
|
scheme
|
|
.write_handle(HandleKind::Connect(adapter.clone()), "AA:BB:CC:DD:EE:FF")
|
|
.unwrap_err();
|
|
|
|
let last_error = scheme
|
|
.read_handle(&HandleKind::LastError(adapter.clone()))
|
|
.unwrap();
|
|
let connect_result = scheme
|
|
.read_handle(&HandleKind::ConnectResult(adapter.clone()))
|
|
.unwrap();
|
|
|
|
assert!(last_error.contains("bond record not found"));
|
|
assert!(connect_result
|
|
.contains("connect_result=rejected-missing-bond bond_id=AA:BB:CC:DD:EE:FF"));
|
|
|
|
fs::remove_file(status_path).unwrap();
|
|
fs::remove_dir_all(bond_store_root).ok();
|
|
}
|
|
|
|
#[test]
|
|
fn disconnect_write_records_last_error_when_bond_is_missing() {
|
|
let status_path = temp_path("rbos-btctl-scheme-disconnect-missing-bond-status");
|
|
fs::write(
|
|
&status_path,
|
|
&format!(
|
|
"transport=usb\nstartup=explicit\nupdated_at_epoch={}\nruntime_visibility=runtime-visible\n",
|
|
std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.unwrap()
|
|
.as_secs()
|
|
),
|
|
)
|
|
.unwrap();
|
|
let bond_store_root = temp_path("rbos-btctl-scheme-disconnect-missing-bond-bonds");
|
|
let mut scheme = build_scheme(status_path.clone(), bond_store_root.clone());
|
|
let adapter = "hci0".to_string();
|
|
|
|
scheme
|
|
.write_handle(HandleKind::Disconnect(adapter.clone()), "AA:BB:CC:DD:EE:FF")
|
|
.unwrap_err();
|
|
|
|
let last_error = scheme
|
|
.read_handle(&HandleKind::LastError(adapter.clone()))
|
|
.unwrap();
|
|
let disconnect_result = scheme
|
|
.read_handle(&HandleKind::DisconnectResult(adapter.clone()))
|
|
.unwrap();
|
|
|
|
assert!(last_error.contains("bond record not found"));
|
|
assert!(disconnect_result
|
|
.contains("disconnect_result=rejected-missing-bond bond_id=AA:BB:CC:DD:EE:FF"));
|
|
|
|
fs::remove_file(status_path).unwrap();
|
|
fs::remove_dir_all(bond_store_root).ok();
|
|
}
|
|
}
|