refactor: introduce Transport trait

Author: hagz0r

.gitignore

@@ -0,0 +1,2 @@
+/target
+**/*.dSYM/

Cargo.lock

@@ -4,12 +4,11 @@
  * Copyright The Asahi Linux Contributors
  */
 
+use crate::transport::Transport;
 use crate::{Error, Result};
 use log::{error, info};
 use std::{
-    fs::{self, OpenOptions},
-    io::Read,
-    path, thread,
+    thread,
     time::{Duration, Instant},
 };
 
@@ -25,59 +24,36 @@ enum VdmSopType {
     SopStar = 0b11,
 }
 
-pub(crate) struct Device {
-    path: path::PathBuf,
-    key: Vec<u8>,
+pub(crate) struct Device<'a> {
+    transport: &'a mut dyn Transport,
 }
 
-fn verify_device(dev: &str) -> Result<path::PathBuf> {
-    let mut fname = OpenOptions::new()
-        .read(true)
-        .open(path::Path::new(dev).join("name"))
-        .unwrap();
-    let mut data = Vec::new();
-    fname.read_to_end(&mut data).unwrap();
-    let name = std::str::from_utf8(&data).map_err(Error::Utf8)?.trim();
-    if name != "cd321x" {
-        error!("{dev}/name \"{name}\" does not match \"cd321x\"");
-        return Err(Error::TypecController);
-    }
-
-    let vdm_dir = path::Path::new(dev).join("cd321x_vdm");
-    if !vdm_dir.exists() {
-        error!("{} does not exists", vdm_dir.display());
-        return Err(Error::FeatureMissing);
-    }
-    Ok(vdm_dir.to_path_buf())
-}
-
-impl Device {
-    pub(crate) fn new(dev: &str, code: String) -> Result<Self> {
-        let device = Self {
-            path: verify_device(dev)?,
-            key: code.into_bytes().into_iter().rev().collect::<Vec<u8>>(),
-        };
-        device.lock(device.key.as_slice())?;
+impl<'a> Device<'a> {
+    pub(crate) fn new(transport: &'a mut dyn Transport, code: &str) -> Result<Self> {
+        let mut key = code.as_bytes().to_vec();
+        key.reverse();
+        let mut device = Self { transport };
+        device.lock(&key)?;
         device.dbma(true)?;
 
         Ok(device)
     }
 
-    fn command(&self, command: &[u8; 4], data: &[u8]) -> Result<()> {
+    fn command(&mut self, command: &[u8; 4], data: &[u8]) -> Result<()> {
         let data: Vec<u8> = [command, data].concat();
-        fs::write(self.path.as_path().join("command"), &data).map_err(Error::Io)
+        self.transport.write(&data).map_err(Error::Io)
     }
 
-    fn lock(&self, key: &[u8]) -> Result<()> {
+    fn lock(&mut self, key: &[u8]) -> Result<()> {
         self.command(b"LOCK", key)
     }
 
-    fn dbma(&self, debug: bool) -> Result<()> {
+    fn dbma(&mut self, debug: bool) -> Result<()> {
         let data: [u8; 1] = if debug { [1] } else { [0] };
         self.command(b"DBMa", &data)
     }
 
-    fn vdms(&self, sop: VdmSopType, vdos: &[u32]) -> Result<()> {
+    fn vdms(&mut self, sop: VdmSopType, vdos: &[u32]) -> Result<()> {
         if vdos.is_empty() || vdos.len() > 7 {
             return Err(Error::InvalidArgument);
         }
@@ -89,13 +65,13 @@ impl Device {
         self.command(b"VDMs", &data)
     }
 
-    fn dven(&self, vdos: &[u32]) -> Result<()> {
+    fn dven(&mut self, vdos: &[u32]) -> Result<()> {
         let data: Vec<u8> = vdos.iter().flat_map(|val| val.to_le_bytes()).collect();
         self.command(b"DEVn", &data)
     }
 
-    fn is_connected(&self) -> Option<bool> {
-        let data: Vec<u8> = fs::read(self.path.as_path().join("power_status")).ok()?;
+    fn is_connected(&mut self) -> Option<bool> {
+        let data: Vec<u8> = self.transport.read(0).ok()?;
         let string = std::str::from_utf8(&data).ok()?;
         if string.len() < 6 {
             return None;
@@ -105,18 +81,18 @@ impl Device {
         Some((power_status & 1) != 0)
     }
 
-    pub(crate) fn dfu(&self) -> Result<()> {
+    pub(crate) fn dfu(&mut self) -> Result<()> {
         let vdos: [u32; 3] = [0x5ac8012, 0x106, 0x80010000];
         info!("Rebooting target into DFU mode...");
         self.vdms(VdmSopType::SopStar, &vdos)
     }
-    pub(crate) fn reboot(&self) -> Result<()> {
+    pub(crate) fn reboot(&mut self) -> Result<()> {
         let vdos: [u32; 3] = [0x5ac8012, 0x105, 0x80000000];
         info!("Rebooting target into normal mode...");
         self.vdms(VdmSopType::SopStar, &vdos)
     }
 
-    pub(crate) fn reboot_serial(&self) -> Result<()> {
+    pub(crate) fn reboot_serial(&mut self) -> Result<()> {
         self.reboot()?;
         info!("Waiting for connection...");
 
@@ -138,7 +114,7 @@ impl Device {
         self.serial()
     }
 
-    pub(crate) fn serial(&self) -> Result<()> {
+    pub(crate) fn serial(&mut self) -> Result<()> {
         let vdos: [u32; 2] = [0x5ac8012, 0x1840306];
         info!("Putting target into serial mode...");
         self.vdms(VdmSopType::SopStar, &vdos)?;
@@ -147,7 +123,7 @@ impl Device {
     }
 }
 
-impl Drop for Device {
+impl Drop for Device<'_> {
     fn drop(&mut self) {
         let lock: [u8; 4] = [0, 0, 0, 0];
         let _ = self.dbma(false);

src/cd321x.rs

@@ -5,10 +5,12 @@
  */
 
 pub mod cd321x;
+pub mod transport;
 
 use env_logger::Env;
 use log::error;
 use std::{fs, process::ExitCode};
+use transport::sysfs::SysfsTransport;
 
 #[derive(Debug)]
 #[allow(dead_code)]
@@ -56,7 +58,8 @@ fn vdmtool() -> Result<()> {
         return Err(Error::Compatible);
     }
     let code = device.to_uppercase();
-    let device = cd321x::Device::new(matches.get_one::<String>("device").unwrap(), code)?;
+    let mut transport = SysfsTransport::new(matches.get_one::<String>("device").unwrap())?;
+    let mut device = cd321x::Device::new(&mut transport, &code)?;
 
     match matches.subcommand() {
         Some(("dfu", _)) => {

src/main.rs

@@ -0,0 +1,7 @@
+pub mod sysfs;
+
+pub trait Transport {
+    fn write(&mut self, data: &[u8]) -> std::io::Result<()>;
+    /// If `len == 0`, reads the full payload (backend-defined).
+    fn read(&mut self, len: usize) -> std::io::Result<Vec<u8>>;
+}