Update tools to use new TCP stack

tools/src/debug_proxy.rs

@@ -1,17 +1,12 @@
 // Jackson Coxson
 
-use std::{
+use std::io::Write;
-    io::Write,
-    net::{IpAddr, SocketAddr},
-    str::FromStr,
-};
 
 use clap::{Arg, Command};
 use idevice::{
-    core_device_proxy::CoreDeviceProxy, debug_proxy::DebugProxyClient,
+    core_device_proxy::CoreDeviceProxy, debug_proxy::DebugProxyClient, rsd::RsdClient,
-    tunneld::get_tunneld_devices, xpc::XPCDevice, IdeviceService, ReadWrite,
+    tcp::stream::AdapterStream, IdeviceService,
 };
-use tokio::net::TcpStream;
 
 mod common;
 
@@ -63,47 +58,6 @@ async fn main() {
     let pairing_file = matches.get_one::<String>("pairing_file");
     let host = matches.get_one::<String>("host");
 
-    let mut dp: DebugProxyClient<Box<dyn ReadWrite>> = if matches.get_flag("tunneld") {
-        let socket = SocketAddr::new(
-            IpAddr::from_str("127.0.0.1").unwrap(),
-            idevice::tunneld::DEFAULT_PORT,
-        );
-        let mut devices = get_tunneld_devices(socket)
-            .await
-            .expect("Failed to get tunneld devices");
-
-        let (_udid, device) = match udid {
-            Some(u) => (
-                u.to_owned(),
-                devices.remove(u).expect("Device not in tunneld"),
-            ),
-            None => devices.into_iter().next().expect("No devices"),
-        };
-
-        // Make the connection to RemoteXPC
-        let client = XPCDevice::new(Box::new(
-            TcpStream::connect((device.tunnel_address.as_str(), device.tunnel_port))
-                .await
-                .unwrap(),
-        ))
-        .await
-        .unwrap();
-
-        // Get the debug proxy
-        let service = client
-            .services
-            .get(idevice::debug_proxy::SERVICE_NAME)
-            .expect("Client did not contain debug proxy service");
-
-        let stream = TcpStream::connect(SocketAddr::new(
-            IpAddr::from_str(&device.tunnel_address).unwrap(),
-            service.port,
-        ))
-        .await
-        .expect("Failed to connect");
-
-        DebugProxyClient::new(Box::new(stream))
-    } else {
     let provider =
         match common::get_provider(udid, host, pairing_file, "debug-proxy-jkcoxson").await {
             Ok(p) => p,
@@ -118,24 +72,27 @@ async fn main() {
     let rsd_port = proxy.handshake.server_rsd_port;
 
     let mut adapter = proxy.create_software_tunnel().expect("no software tunnel");
-        adapter.connect(rsd_port).await.expect("no RSD connect");
+    let stream = AdapterStream::connect(&mut adapter, rsd_port)
+        .await
+        .expect("no RSD connect");
 
     // Make the connection to RemoteXPC
-        let client = XPCDevice::new(Box::new(adapter)).await.unwrap();
+    let mut client = RsdClient::new(stream).await.unwrap();
 
     // Get the debug proxy
     let service = client
-            .services
+        .get_services()
+        .await
+        .unwrap()
         .get(idevice::debug_proxy::SERVICE_NAME)
         .expect("Client did not contain debug proxy service")
         .to_owned();
 
-        let mut adapter = client.into_inner();
+    let stream = AdapterStream::connect(&mut adapter, service.port)
-        adapter.close().await.unwrap();
+        .await
-        adapter.connect(service.port).await.unwrap();
+        .unwrap();
 
-        DebugProxyClient::new(Box::new(adapter))
+    let mut dp = DebugProxyClient::new(stream);
-    };
 
     println!("Shell connected!");
     loop {

tools/src/location_simulation.rs

@@ -2,7 +2,9 @@
 // Just lists apps for now
 
 use clap::{Arg, Command};
-use idevice::{core_device_proxy::CoreDeviceProxy, xpc::XPCDevice, IdeviceService};
+use idevice::{
+    core_device_proxy::CoreDeviceProxy, rsd::RsdClient, tcp::stream::AdapterStream, IdeviceService,
+};
 
 mod common;
 
@@ -69,26 +71,31 @@ async fn main() {
     let rsd_port = proxy.handshake.server_rsd_port;
 
     let mut adapter = proxy.create_software_tunnel().expect("no software tunnel");
-    adapter.connect(rsd_port).await.expect("no RSD connect");
+    let stream = AdapterStream::connect(&mut adapter, rsd_port)
+        .await
+        .expect("no RSD connect");
 
     // Make the connection to RemoteXPC
-    let client = XPCDevice::new(Box::new(adapter)).await.unwrap();
+    let mut client = RsdClient::new(stream).await.unwrap();
 
     // Get the debug proxy
     let service = client
-        .services
+        .get_services()
+        .await
+        .unwrap()
         .get(idevice::dvt::SERVICE_NAME)
         .expect("Client did not contain DVT service")
         .to_owned();
 
-    let mut adapter = client.into_inner();
+    let stream = AdapterStream::connect(&mut adapter, service.port)
-    adapter.connect(service.port).await.unwrap();
+        .await
+        .unwrap();
 
-    let mut rs_client = idevice::dvt::remote_server::RemoteServerClient::new(Box::new(adapter));
+    let mut ls_client = idevice::dvt::remote_server::RemoteServerClient::new(stream);
-    rs_client.read_message(0).await.expect("no read??");
+    ls_client.read_message(0).await.expect("no read??");
 
     let mut ls_client =
-        idevice::dvt::location_simulation::LocationSimulationClient::new(&mut rs_client)
+        idevice::dvt::location_simulation::LocationSimulationClient::new(&mut ls_client)
             .await
             .expect("Unable to get channel for location simulation");
 

tools/src/process_control.rs

@@ -1,16 +1,9 @@
 // Jackson Coxson
 
-use std::{
-    net::{IpAddr, SocketAddr},
-    str::FromStr,
-};
-
 use clap::{Arg, Command};
 use idevice::{
-    core_device_proxy::CoreDeviceProxy, tunneld::get_tunneld_devices, xpc::XPCDevice,
+    core_device_proxy::CoreDeviceProxy, rsd::RsdClient, tcp::stream::AdapterStream, IdeviceService,
-    IdeviceService,
 };
-use tokio::net::TcpStream;
 
 mod common;
 
@@ -71,70 +64,8 @@ async fn main() {
         .get_one::<String>("bundle_id")
         .expect("No bundle ID specified");
 
-    if matches.get_flag("tunneld") {
+    let provider =
-        let socket = SocketAddr::new(
+        match common::get_provider(udid, host, pairing_file, "process_control-jkcoxson").await {
-            IpAddr::from_str("127.0.0.1").unwrap(),
-            idevice::tunneld::DEFAULT_PORT,
-        );
-        let mut devices = get_tunneld_devices(socket)
-            .await
-            .expect("Failed to get tunneld devices");
-
-        let (_udid, device) = match udid {
-            Some(u) => (
-                u.to_owned(),
-                devices.remove(u).expect("Device not in tunneld"),
-            ),
-            None => devices.into_iter().next().expect("No devices"),
-        };
-
-        // Make the connection to RemoteXPC
-        let client = XPCDevice::new(Box::new(
-            TcpStream::connect((device.tunnel_address.as_str(), device.tunnel_port))
-                .await
-                .unwrap(),
-        ))
-        .await
-        .unwrap();
-
-        // Get the debug proxy
-        let service = client
-            .services
-            .get(idevice::dvt::SERVICE_NAME)
-            .expect("Client did not contain DVT service");
-
-        let stream = TcpStream::connect(SocketAddr::new(
-            IpAddr::from_str(&device.tunnel_address).unwrap(),
-            service.port,
-        ))
-        .await
-        .expect("Failed to connect");
-
-        let mut rs_client = idevice::dvt::remote_server::RemoteServerClient::new(Box::new(stream));
-        rs_client.read_message(0).await.expect("no read??");
-        let mut pc_client =
-            idevice::dvt::process_control::ProcessControlClient::new(&mut rs_client)
-                .await
-                .unwrap();
-
-        let pid = pc_client
-            .launch_app(bundle_id, None, None, true, false)
-            .await
-            .expect("no launch??");
-        pc_client
-            .disable_memory_limit(pid)
-            .await
-            .expect("no disable??");
-        println!("PID: {pid}");
-    } else {
-        let provider = match common::get_provider(
-            udid,
-            host,
-            pairing_file,
-            "process_control-jkcoxson",
-        )
-        .await
-        {
             Ok(p) => p,
             Err(e) => {
                 eprintln!("{e}");
@@ -148,25 +79,29 @@ async fn main() {
     let rsd_port = proxy.handshake.server_rsd_port;
 
     let mut adapter = proxy.create_software_tunnel().expect("no software tunnel");
-        adapter.connect(rsd_port).await.expect("no RSD connect");
+    let stream = AdapterStream::connect(&mut adapter, rsd_port)
+        .await
+        .expect("no RSD connect");
 
     // Make the connection to RemoteXPC
-        let client = XPCDevice::new(Box::new(adapter)).await.unwrap();
+    let mut client = RsdClient::new(stream).await.unwrap();
 
     // Get the debug proxy
     let service = client
-            .services
+        .get_services()
+        .await
+        .unwrap()
         .get(idevice::dvt::SERVICE_NAME)
         .expect("Client did not contain DVT service")
         .to_owned();
 
-        let mut adapter = client.into_inner();
+    let stream = AdapterStream::connect(&mut adapter, service.port)
-        adapter.connect(service.port).await.unwrap();
+        .await
+        .unwrap();
 
-        let mut rs_client = idevice::dvt::remote_server::RemoteServerClient::new(Box::new(adapter));
+    let mut rs_client = idevice::dvt::remote_server::RemoteServerClient::new(stream);
     rs_client.read_message(0).await.expect("no read??");
-        let mut pc_client =
+    let mut pc_client = idevice::dvt::process_control::ProcessControlClient::new(&mut rs_client)
-            idevice::dvt::process_control::ProcessControlClient::new(&mut rs_client)
         .await
         .unwrap();
 
@@ -179,8 +114,4 @@ async fn main() {
         .await
         .expect("no disable??");
     println!("PID: {pid}");
-
-        // let mut adapter = rs_client.into_inner();
-        // adapter.close().await.expect("no close??");
-    }
 }