feat: add reverse for USB/TCP direct devices

adb_cli/src/main.rs

@@ -134,6 +134,14 @@ fn main() -> Result<()> {
             device.install(&path)?;
         }
         DeviceCommands::Framebuffer { path } => device.framebuffer(&path)?,
+        DeviceCommands::Reverse { remote, local } => {
+            log::info!("Reverse port {} to local {}", remote, local);
+            device.reverse(remote, local)?;
+        }
+        DeviceCommands::ReverseRemoveAll => {
+            log::info!("Remove all previous forward rules");
+            device.reverse_remove_all()?;
+        }
     }
 
     Ok(())

adb_cli/src/models/device.rs

@@ -1,5 +1,6 @@
 use std::path::PathBuf;
 
+use adb_client::ADBProtoPort;
 use clap::Parser;
 
 use super::RebootTypeCommand;
@@ -38,4 +39,13 @@ pub enum DeviceCommands {
         /// Framebuffer image destination path
         path: String,
     },
+    /// Reverse socket connection from remote port to local port
+    Reverse {
+        /// Remote port
+        remote: ADBProtoPort,
+        /// Local port
+        local: ADBProtoPort,
+    },
+    /// Remove all previously applied reverse rules
+    ReverseRemoveAll,
 }

adb_cli/src/models/opts.rs

@@ -17,7 +17,7 @@ pub struct Opts {
 pub enum MainCommand {
     /// Server related commands
     Host(ServerCommand<HostCommand>),
-    /// Device related commands using server
+    /// Device related commands (using adb-server as a bridge)
     Local(ServerCommand<LocalCommand>),
     /// Emulator related commands
     Emu(EmulatorCommand),

adb_client/src/adb_device_ext.rs

@@ -4,7 +4,7 @@ use std::path::Path;
 use image::{ImageBuffer, ImageFormat, Rgba};
 
 use crate::models::AdbStatResponse;
-use crate::{RebootType, Result};
+use crate::{ADBProtoPort, RebootType, Result};
 
 /// Trait representing all features available on both [`crate::ADBServerDevice`] and [`crate::ADBUSBDevice`]
 pub trait ADBDeviceExt {
@@ -62,6 +62,18 @@ pub trait ADBDeviceExt {
         Ok(vec.into_inner())
     }
 
+    /// Forward socket connection
+    fn forward(&mut self, remote: ADBProtoPort, local: ADBProtoPort) -> Result<()>;
+
+    /// Remove all previously applied forward rules
+    fn forward_remove_all(&mut self) -> Result<()>;
+
+    /// Reverse socket connection
+    fn reverse(&mut self, remote: ADBProtoPort, local: ADBProtoPort) -> Result<()>;
+
+    /// Remove all reverse rules
+    fn reverse_remove_all(&mut self) -> Result<()>;
+
     /// Return a boxed instance representing this trait
     fn boxed(self) -> Box<dyn ADBDeviceExt>
     where

adb_client/src/device/adb_message_device.rs

@@ -8,7 +8,7 @@ use super::{models::MessageSubcommand, ADBTransportMessage, MessageCommand};
 
 /// Generic structure representing an ADB device reachable over an [`ADBMessageTransport`].
 /// Structure is totally agnostic over which transport is truly used.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ADBMessageDevice<T: ADBMessageTransport> {
     transport: T,
     local_id: Option<u32>,
@@ -235,6 +235,15 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
         Ok(response)
     }
 
+    pub(crate) fn set_random_local_id(&mut self) {
+        let mut rng = rand::thread_rng();
+        self.local_id = Some(rng.gen());
+    }
+
+    pub(crate) fn set_remote_id(&mut self, remote_id: u32) {
+        self.remote_id = Some(remote_id);
+    }
+
     pub(crate) fn get_local_id(&self) -> Result<u32> {
         self.local_id.ok_or(RustADBError::ADBRequestFailed(
             "connection not opened, no local_id".into(),

adb_client/src/device/adb_message_device_commands.rs

@@ -1,4 +1,6 @@
-use crate::{models::AdbStatResponse, ADBDeviceExt, ADBMessageTransport, RebootType, Result};
+use crate::{
+    models::AdbStatResponse, ADBDeviceExt, ADBMessageTransport, ADBProtoPort, RebootType, Result,
+};
 use std::{
     io::{Read, Write},
     path::Path,
@@ -38,4 +40,20 @@ impl<T: ADBMessageTransport> ADBDeviceExt for ADBMessageDevice<T> {
     fn framebuffer_inner(&mut self) -> Result<image::ImageBuffer<image::Rgba<u8>, Vec<u8>>> {
         self.framebuffer_inner()
     }
+
+    fn forward(&mut self, remote: ADBProtoPort, local: ADBProtoPort) -> Result<()> {
+        todo!()
+    }
+
+    fn forward_remove_all(&mut self) -> Result<()> {
+        todo!()
+    }
+
+    fn reverse(&mut self, remote: ADBProtoPort, local: ADBProtoPort) -> Result<()> {
+        self.reverse(remote, local)
+    }
+
+    fn reverse_remove_all(&mut self) -> Result<()> {
+        self.reverse_remove_all()
+    }
 }

adb_client/src/device/adb_tcp_device.rs

@@ -5,7 +5,10 @@ use std::{io::Read, net::SocketAddr};
 use super::adb_message_device::ADBMessageDevice;
 use super::models::MessageCommand;
 use super::ADBTransportMessage;
-use crate::{ADBDeviceExt, ADBMessageTransport, ADBTransport, Result, RustADBError, TcpTransport};
+use crate::{
+    ADBDeviceExt, ADBMessageTransport, ADBProtoPort, ADBTransport, Result, RustADBError,
+    TcpTransport,
+};
 
 /// Represent a device reached and available over USB.
 #[derive(Debug)]
@@ -106,6 +109,26 @@ impl ADBDeviceExt for ADBTcpDevice {
     fn framebuffer_inner(&mut self) -> Result<image::ImageBuffer<image::Rgba<u8>, Vec<u8>>> {
         self.inner.framebuffer_inner()
     }
+
+    #[inline]
+    fn forward(&mut self, remote: ADBProtoPort, local: ADBProtoPort) -> Result<()> {
+        self.inner.forward(remote, local)
+    }
+
+    #[inline]
+    fn forward_remove_all(&mut self) -> Result<()> {
+        self.inner.forward_remove_all()
+    }
+
+    #[inline]
+    fn reverse(&mut self, remote: ADBProtoPort, local: ADBProtoPort) -> Result<()> {
+        self.inner.reverse(remote, local)
+    }
+
+    #[inline]
+    fn reverse_remove_all(&mut self) -> Result<()> {
+        self.inner.reverse_remove_all()
+    }
 }
 
 impl Drop for ADBTcpDevice {

adb_client/src/device/adb_usb_device.rs

@@ -14,6 +14,7 @@ use super::{ADBRsaKey, ADBTransportMessage};
 use crate::device::adb_transport_message::{AUTH_RSAPUBLICKEY, AUTH_SIGNATURE, AUTH_TOKEN};
 use crate::ADBDeviceExt;
 use crate::ADBMessageTransport;
+use crate::ADBProtoPort;
 use crate::ADBTransport;
 use crate::{Result, RustADBError, USBTransport};
 
@@ -289,6 +290,26 @@ impl ADBDeviceExt for ADBUSBDevice {
     fn framebuffer_inner(&mut self) -> Result<image::ImageBuffer<image::Rgba<u8>, Vec<u8>>> {
         self.inner.framebuffer_inner()
     }
+
+    #[inline]
+    fn forward(&mut self, remote: ADBProtoPort, local: ADBProtoPort) -> Result<()> {
+        self.inner.forward(remote, local)
+    }
+
+    #[inline]
+    fn forward_remove_all(&mut self) -> Result<()> {
+        self.inner.forward_remove_all()
+    }
+
+    #[inline]
+    fn reverse(&mut self, remote: ADBProtoPort, local: ADBProtoPort) -> Result<()> {
+        self.inner.reverse(remote, local)
+    }
+
+    #[inline]
+    fn reverse_remove_all(&mut self) -> Result<()> {
+        self.inner.reverse_remove_all()
+    }
 }
 
 impl Drop for ADBUSBDevice {

adb_client/src/device/commands/mod.rs

@@ -3,5 +3,6 @@ mod install;
 mod pull;
 mod push;
 mod reboot;
+mod reverse;
 mod shell;
 mod stat;