Update C examples for new FFI

ffi/examples/CMakeLists.txt

@@ -11,7 +11,6 @@ set(EXAMPLES_DIR ${CMAKE_SOURCE_DIR}/../examples)
 
 # Find all C example files
 file(GLOB EXAMPLE_SOURCES ${EXAMPLES_DIR}/*.c)
-find_package(OpenSSL REQUIRED)
 
 # Create an executable for each example file
 foreach(EXAMPLE_FILE ${EXAMPLE_SOURCES})
@@ -27,14 +26,10 @@ foreach(EXAMPLE_FILE ${EXAMPLE_SOURCES})
     # Link the static Rust library
     target_link_libraries(${EXAMPLE_NAME} PRIVATE ${STATIC_LIB})
 
-    # Link OpenSSL
-    target_link_libraries(${EXAMPLE_NAME} PRIVATE OpenSSL::SSL OpenSSL::Crypto)
-
     # libplist
 
     if( APPLE )
       # use static linking
-      pkg_search_module(PLIST REQUIRED libplist-2.0)
       find_library( LIBPLIST libplist-2.0.a REQUIRED )
       message( STATUS "(Static linking) LIBPLIST " ${LIBPLIST} )
       target_link_libraries ( ${EXAMPLE_NAME} PRIVATE ${LIBPLIST} )

ffi/examples/afc.c

@@ -169,7 +169,7 @@ int main(int argc, char **argv) {
   }
 
   // Create TCP provider
-  TcpProviderHandle *provider = NULL;
+  IdeviceProviderHandle *provider = NULL;
   err = idevice_tcp_provider_new((struct sockaddr *)&addr, pairing_file,
                                  "ImageMounterTest", &provider);
   if (err != IdeviceSuccess) {
@@ -180,13 +180,13 @@ int main(int argc, char **argv) {
 
   // Connect to AFC service
   AfcClientHandle *client = NULL;
-  err = afc_client_connect_tcp(provider, &client);
+  err = afc_client_connect(provider, &client);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to AFC service: %d\n", err);
-    tcp_provider_free(provider);
+    idevice_provider_free(provider);
     return 1;
   }
-  tcp_provider_free(provider);
+  idevice_provider_free(provider);
 
   // Process command
   int success = 1;

ffi/examples/debug_proxy.c

@@ -17,7 +17,7 @@ void print_usage(const char *program_name) {
 
 int main(int argc, char **argv) {
   // Initialize logger
-  idevice_init_logger(Debug, Disabled, NULL);
+  idevice_init_logger(Info, Disabled, NULL);
 
   if (argc < 2) {
     print_usage(argv[0]);
@@ -25,7 +25,7 @@ int main(int argc, char **argv) {
   }
 
   const char *device_ip = argv[1];
-  const char *pairing_file = argc > 2 ? argv[2] : "pairing_file.plist";
+  const char *pairing_file = argc > 2 ? argv[2] : "pairing.plist";
 
   /*****************************************************************
    * CoreDeviceProxy Setup
@@ -51,7 +51,7 @@ int main(int argc, char **argv) {
   }
 
   // Create TCP provider
-  TcpProviderHandle *tcp_provider = NULL;
+  IdeviceProviderHandle *tcp_provider = NULL;
   err = idevice_tcp_provider_new((struct sockaddr *)&addr, pairing,
                                  "DebugProxyShell", &tcp_provider);
   if (err != IdeviceSuccess) {
@@ -62,14 +62,13 @@ int main(int argc, char **argv) {
 
   // Connect to CoreDeviceProxy
   CoreDeviceProxyHandle *core_device = NULL;
-  err = core_device_proxy_connect_tcp(tcp_provider, &core_device);
+  err = core_device_proxy_connect(tcp_provider, &core_device);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to CoreDeviceProxy: %d\n", err);
-    tcp_provider_free(tcp_provider);
+    idevice_provider_free(tcp_provider);
-    idevice_pairing_file_free(pairing);
     return 1;
   }
-  tcp_provider_free(tcp_provider);
+  idevice_provider_free(tcp_provider);
 
   // Get server RSD port
   uint16_t rsd_port;
@@ -77,7 +76,6 @@ int main(int argc, char **argv) {
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to get server RSD port: %d\n", err);
     core_device_proxy_free(core_device);
-    idevice_pairing_file_free(pairing);
     return 1;
   }
   printf("Server RSD Port: %d\n", rsd_port);
@@ -92,92 +90,45 @@ int main(int argc, char **argv) {
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to create TCP adapter: %d\n", err);
     core_device_proxy_free(core_device);
-    idevice_pairing_file_free(pairing);
     return 1;
   }
 
   // Connect to RSD port
-  err = adapter_connect(adapter, rsd_port);
+  AdapterStreamHandle *stream = NULL;
+  err = adapter_connect(adapter, rsd_port, &stream);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to RSD port: %d\n", err);
     adapter_free(adapter);
-    core_device_proxy_free(core_device);
-    idevice_pairing_file_free(pairing);
     return 1;
   }
   printf("Successfully connected to RSD port\n");
 
   /*****************************************************************
-   * XPC Device Setup
+   * RSD Handshake
    *****************************************************************/
-  printf("\n=== Setting up XPC Device ===\n");
+  printf("\n=== Performing RSD Handshake ===\n");
 
-  XPCDeviceAdapterHandle *xpc_device = NULL;
+  RsdHandshakeHandle *handshake = NULL;
-  err = xpc_device_new(adapter, &xpc_device);
+  err = rsd_handshake_new(stream, &handshake);
   if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to create XPC device: %d\n", err);
+    fprintf(stderr, "Failed to perform RSD handshake: %d\n", err);
+    adapter_close(stream);
     adapter_free(adapter);
-    core_device_proxy_free(core_device);
-    idevice_pairing_file_free(pairing);
     return 1;
   }
 
-  /*****************************************************************
-   * Get Debug Proxy Service
-   *****************************************************************/
-  printf("\n=== Getting Debug Proxy Service ===\n");
-
-  XPCServiceHandle *debug_service = NULL;
-  err = xpc_device_get_service(
-      xpc_device, "com.apple.internal.dt.remote.debugproxy", &debug_service);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to get debug proxy service: %d\n", err);
-    xpc_device_free(xpc_device);
-    adapter_free(adapter);
-    core_device_proxy_free(core_device);
-    idevice_pairing_file_free(pairing);
-    return 1;
-  }
-  printf("Debug Proxy Service Port: %d\n", debug_service->port);
-
   /*****************************************************************
    * Debug Proxy Setup
    *****************************************************************/
   printf("\n=== Setting up Debug Proxy ===\n");
 
-  // Get the adapter back from XPC device
-  AdapterHandle *debug_adapter = NULL;
-  err = xpc_device_adapter_into_inner(xpc_device, &debug_adapter);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to extract adapter: %d\n", err);
-    xpc_service_free(debug_service);
-    xpc_device_free(xpc_device);
-    core_device_proxy_free(core_device);
-    idevice_pairing_file_free(pairing);
-    return 1;
-  }
-
-  // Connect to debug proxy port
-  err = adapter_connect(debug_adapter, debug_service->port);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to connect to debug proxy port: %d\n", err);
-    adapter_free(debug_adapter);
-    xpc_service_free(debug_service);
-    core_device_proxy_free(core_device);
-    idevice_pairing_file_free(pairing);
-    return 1;
-  }
-  printf("Successfully connected to debug proxy port\n");
-
   // Create DebugProxyClient
-  DebugProxyAdapterHandle *debug_proxy = NULL;
+  DebugProxyHandle *debug_proxy = NULL;
-  err = debug_proxy_adapter_new(debug_adapter, &debug_proxy);
+  err = debug_proxy_connect_rsd(adapter, handshake, &debug_proxy);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to create debug proxy client: %d\n", err);
-    adapter_free(debug_adapter);
+    rsd_handshake_free(handshake);
-    xpc_service_free(debug_service);
+    adapter_free(adapter);
-    core_device_proxy_free(core_device);
-    idevice_pairing_file_free(pairing);
     return 1;
   }
 
@@ -264,7 +215,8 @@ int main(int argc, char **argv) {
    * Cleanup
    *****************************************************************/
   debug_proxy_free(debug_proxy);
-  xpc_service_free(debug_service);
+  rsd_handshake_free(handshake);
+  adapter_free(adapter);
 
   printf("\nDebug session ended\n");
   return 0;

ffi/examples/enable_jit.c

@@ -15,7 +15,7 @@ void print_usage(const char *program_name) {
 
 int main(int argc, char **argv) {
   // Initialize logger
-  idevice_init_logger(Debug, Disabled, NULL);
+  idevice_init_logger(Info, Disabled, NULL);
 
   if (argc < 3) {
     print_usage(argv[0]);
@@ -42,17 +42,17 @@ int main(int argc, char **argv) {
   }
 
   // Read pairing file
-  IdevicePairingFile *pairing = NULL;
+  struct IdevicePairingFile *pairing = NULL;
-  IdeviceErrorCode err = idevice_pairing_file_read(pairing_file, &pairing);
+  enum IdeviceErrorCode err = idevice_pairing_file_read(pairing_file, &pairing);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to read pairing file: %d\n", err);
     return 1;
   }
 
   // Create TCP provider
-  TcpProviderHandle *tcp_provider = NULL;
+  struct IdeviceProviderHandle *provider = NULL;
   err = idevice_tcp_provider_new((struct sockaddr *)&addr, pairing,
-                                 "ProcessDebugTest", &tcp_provider);
+                                 "ProcessDebugTest", &provider);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to create TCP provider: %d\n", err);
     idevice_pairing_file_free(pairing);
@@ -60,14 +60,14 @@ int main(int argc, char **argv) {
   }
 
   // Connect to CoreDeviceProxy
-  CoreDeviceProxyHandle *core_device = NULL;
+  struct CoreDeviceProxyHandle *core_device = NULL;
-  err = core_device_proxy_connect_tcp(tcp_provider, &core_device);
+  err = core_device_proxy_connect(provider, &core_device);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to CoreDeviceProxy: %d\n", err);
-    tcp_provider_free(tcp_provider);
+    idevice_provider_free(provider);
     return 1;
   }
-  tcp_provider_free(tcp_provider);
+  idevice_provider_free(provider);
 
   // Get server RSD port
   uint16_t rsd_port;
@@ -84,7 +84,7 @@ int main(int argc, char **argv) {
    *****************************************************************/
   printf("\n=== Creating TCP Tunnel Adapter ===\n");
 
-  AdapterHandle *adapter = NULL;
+  struct AdapterHandle *adapter = NULL;
   err = core_device_proxy_create_tcp_adapter(core_device, &adapter);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to create TCP adapter: %d\n", err);
@@ -93,46 +93,59 @@ int main(int argc, char **argv) {
   }
 
   // Connect to RSD port
-  err = adapter_connect(adapter, rsd_port);
+  struct ReadWriteOpaque *rsd_stream = NULL;
+  err = adapter_connect(adapter, rsd_port, &rsd_stream);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to RSD port: %d\n", err);
     adapter_free(adapter);
-    core_device_proxy_free(core_device);
     return 1;
   }
   printf("Successfully connected to RSD port\n");
 
+  adapter_pcap(adapter, "jit.pcap");
+
   /*****************************************************************
-   * XPC Device Setup
+   * RSD Handshake
    *****************************************************************/
-  printf("\n=== Setting up XPC Device ===\n");
+  printf("\n=== Performing RSD Handshake ===\n");
 
-  XPCDeviceAdapterHandle *xpc_device = NULL;
+  struct RsdHandshakeHandle *rsd_handshake = NULL;
-  err = xpc_device_new(adapter, &xpc_device);
+  err = rsd_handshake_new(rsd_stream, &rsd_handshake);
   if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to create XPC device: %d\n", err);
+    fprintf(stderr, "Failed to create RSD handshake: %d\n", err);
     adapter_free(adapter);
-    core_device_proxy_free(core_device);
     return 1;
   }
 
-  // Get DebugProxy service
+  // Get services
-  XPCServiceHandle *debug_service = NULL;
+  struct CRsdServiceArray *services = NULL;
-  err = xpc_device_get_service(
+  err = rsd_get_services(rsd_handshake, &services);
-      xpc_device, "com.apple.internal.dt.remote.debugproxy", &debug_service);
   if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to get debug proxy service: %d\n", err);
+    fprintf(stderr, "Failed to get RSD services: %d\n", err);
+    rsd_handshake_free(rsd_handshake);
+    adapter_free(adapter);
     return 1;
   }
 
-  // Get ProcessControl service
+  // Find debug proxy and process control services
-  XPCServiceHandle *pc_service = NULL;
+  uint16_t debug_port = 0;
-  err = xpc_device_get_service(xpc_device, "com.apple.instruments.dtservicehub",
+  uint16_t pc_port = 0;
-                               &pc_service);
+
-  if (err != IdeviceSuccess) {
+  for (size_t i = 0; i < services->count; i++) {
-    fprintf(stderr, "Failed to get process control service: %d\n", err);
+    struct CRsdService *service = &services->services[i];
-    xpc_device_free(xpc_device);
+    if (strcmp(service->name, "com.apple.internal.dt.remote.debugproxy") == 0) {
-    core_device_proxy_free(core_device);
+      debug_port = service->port;
+    } else if (strcmp(service->name, "com.apple.instruments.dtservicehub") ==
+               0) {
+      pc_port = service->port;
+    }
+  }
+
+  rsd_free_services(services);
+
+  if (debug_port == 0 || pc_port == 0) {
+    fprintf(stderr, "Required services not found\n");
+    adapter_free(adapter);
     return 1;
   }
 
@@ -141,46 +154,31 @@ int main(int argc, char **argv) {
    *****************************************************************/
   printf("\n=== Launching App ===\n");
 
-  // Get the adapter back from XPC device
-  AdapterHandle *pc_adapter = NULL;
-  err = xpc_device_adapter_into_inner(xpc_device, &pc_adapter);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to extract adapter: %d\n", err);
-    xpc_device_free(xpc_device);
-    core_device_proxy_free(core_device);
-    return 1;
-  }
-
   // Connect to process control port
-  err = adapter_connect(pc_adapter, pc_service->port);
+  struct ReadWriteOpaque *pc_stream = NULL;
+  err = adapter_connect(adapter, pc_port, &pc_stream);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to process control port: %d\n", err);
-    adapter_free(pc_adapter);
+    adapter_free(adapter);
-    xpc_service_free(pc_service);
-    core_device_proxy_free(core_device);
     return 1;
   }
   printf("Successfully connected to process control port\n");
 
   // Create RemoteServerClient
-  RemoteServerAdapterHandle *remote_server = NULL;
+  struct RemoteServerHandle *remote_server = NULL;
-  err = remote_server_adapter_new(pc_adapter, &remote_server);
+  err = remote_server_new(pc_stream, &remote_server);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to create remote server: %d\n", err);
-    adapter_free(pc_adapter);
+    adapter_free(adapter);
-    xpc_service_free(pc_service);
-    core_device_proxy_free(core_device);
     return 1;
   }
 
   // Create ProcessControlClient
-  ProcessControlAdapterHandle *process_control = NULL;
+  struct ProcessControlHandle *process_control = NULL;
   err = process_control_new(remote_server, &process_control);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to create process control client: %d\n", err);
     remote_server_free(remote_server);
-    xpc_service_free(pc_service);
-    core_device_proxy_free(core_device);
     return 1;
   }
 
@@ -192,8 +190,6 @@ int main(int argc, char **argv) {
     fprintf(stderr, "Failed to launch app: %d\n", err);
     process_control_free(process_control);
     remote_server_free(remote_server);
-    xpc_service_free(pc_service);
-    core_device_proxy_free(core_device);
     return 1;
   }
   printf("Successfully launched app with PID: %" PRIu64 "\n", pid);
@@ -203,44 +199,24 @@ int main(int argc, char **argv) {
    *****************************************************************/
   printf("\n=== Attaching Debugger ===\n");
 
-  // Get the adapter back from the remote server
-  AdapterHandle *debug_adapter = NULL;
-  err = remote_server_adapter_into_inner(remote_server, &debug_adapter);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to extract adapter: %d\n", err);
-    xpc_service_free(debug_service);
-    process_control_free(process_control);
-    remote_server_free(remote_server);
-    xpc_service_free(pc_service);
-    core_device_proxy_free(core_device);
-    return 1;
-  }
-
   // Connect to debug proxy port
-  err = adapter_connect(debug_adapter, debug_service->port);
+  struct ReadWriteOpaque *debug_stream = NULL;
+  err = adapter_connect(adapter, debug_port, &debug_stream);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to debug proxy port: %d\n", err);
-    adapter_free(debug_adapter);
-    xpc_service_free(debug_service);
     process_control_free(process_control);
     remote_server_free(remote_server);
-    xpc_service_free(pc_service);
-    core_device_proxy_free(core_device);
     return 1;
   }
   printf("Successfully connected to debug proxy port\n");
 
   // Create DebugProxyClient
-  DebugProxyAdapterHandle *debug_proxy = NULL;
+  struct DebugProxyHandle *debug_proxy = NULL;
-  err = debug_proxy_adapter_new(debug_adapter, &debug_proxy);
+  err = debug_proxy_connect_rsd(adapter, rsd_handshake, &debug_proxy);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to create debug proxy client: %d\n", err);
-    adapter_free(debug_adapter);
-    xpc_service_free(debug_service);
     process_control_free(process_control);
     remote_server_free(remote_server);
-    xpc_service_free(pc_service);
-    core_device_proxy_free(core_device);
     return 1;
   }
 
@@ -248,17 +224,13 @@ int main(int argc, char **argv) {
   char attach_command[64];
   snprintf(attach_command, sizeof(attach_command), "vAttach;%" PRIx64, pid);
 
-  DebugserverCommandHandle *attach_cmd =
+  struct DebugserverCommandHandle *attach_cmd =
       debugserver_command_new(attach_command, NULL, 0);
   if (attach_cmd == NULL) {
     fprintf(stderr, "Failed to create attach command\n");
     debug_proxy_free(debug_proxy);
-    adapter_free(debug_adapter);
-    xpc_service_free(debug_service);
     process_control_free(process_control);
     remote_server_free(remote_server);
-    xpc_service_free(pc_service);
-    core_device_proxy_free(core_device);
     return 1;
   }
 
@@ -274,7 +246,8 @@ int main(int argc, char **argv) {
   }
 
   // Send detach command
-  DebugserverCommandHandle *detach_cmd = debugserver_command_new("D", NULL, 0);
+  struct DebugserverCommandHandle *detach_cmd =
+      debugserver_command_new("D", NULL, 0);
   if (detach_cmd == NULL) {
     fprintf(stderr, "Failed to create detach command\n");
   } else {
@@ -296,7 +269,10 @@ int main(int argc, char **argv) {
    * Cleanup
    *****************************************************************/
   debug_proxy_free(debug_proxy);
-  xpc_service_free(debug_service);
+  process_control_free(process_control);
+  remote_server_free(remote_server);
+  adapter_free(adapter);
+  rsd_handshake_free(rsd_handshake);
 
   printf("\nDebug session completed\n");
   return 0;

ffi/examples/heartbeat.c

@@ -28,7 +28,7 @@ int main() {
   }
 
   // Create TCP provider
-  TcpProviderHandle *provider = NULL;
+  IdeviceProviderHandle *provider = NULL;
   err = idevice_tcp_provider_new((struct sockaddr *)&addr, pairing_file,
                                  "ExampleProvider", &provider);
   if (err != IdeviceSuccess) {
@@ -39,13 +39,13 @@ int main() {
 
   // Connect to installation proxy
   HeartbeatClientHandle *client = NULL;
-  err = heartbeat_connect_tcp(provider, &client);
+  err = heartbeat_connect(provider, &client);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to installation proxy: %d\n", err);
-    tcp_provider_free(provider);
+    idevice_provider_free(provider);
     return 1;
   }
-  tcp_provider_free(provider);
+  idevice_provider_free(provider);
 
   u_int64_t current_interval = 15;
   while (1) {

ffi/examples/ipa_installer.c

@@ -10,7 +10,8 @@ void print_usage() {
   printf("Usage: ipa_installer [options] <ipa_path>\n");
   printf("Options:\n");
   printf("  --ip IP_ADDRESS       Device IP address (default: 10.7.0.2)\n");
-    printf("  --pairing FILE        Pairing file path (default: pairing_file.plist)\n");
+  printf("  --pairing FILE        Pairing file path (default: "
+         "pairing_file.plist)\n");
   printf("  --udid UDID           Device UDID (optional)\n");
 }
 
@@ -99,14 +100,15 @@ int main(int argc, char **argv) {
 
   // Read pairing file
   IdevicePairingFile *pairing_file = NULL;
-    IdeviceErrorCode err = idevice_pairing_file_read(pairing_file_path, &pairing_file);
+  IdeviceErrorCode err =
+      idevice_pairing_file_read(pairing_file_path, &pairing_file);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to read pairing file: %d\n", err);
     return 1;
   }
 
   // Create TCP provider
-    TcpProviderHandle *provider = NULL;
+  IdeviceProviderHandle *provider = NULL;
   err = idevice_tcp_provider_new((struct sockaddr *)&addr, pairing_file,
                                  "IPAInstaller", &provider);
   if (err != IdeviceSuccess) {
@@ -117,10 +119,10 @@ int main(int argc, char **argv) {
 
   // Connect to AFC service
   AfcClientHandle *afc_client = NULL;
-    err = afc_client_connect_tcp(provider, &afc_client);
+  err = afc_client_connect(provider, &afc_client);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to AFC service: %d\n", err);
-        tcp_provider_free(provider);
+    idevice_provider_free(provider);
     return 1;
   }
 
@@ -147,7 +149,7 @@ int main(int argc, char **argv) {
   }
 
   AfcFileHandle *file = NULL;
-    err = afc_file_open(afc_client, dest_path, AfcWrOnly | AfcCreat, &file);
+  err = afc_file_open(afc_client, dest_path, AfcWrOnly, &file);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to open destination file: %d\n", err);
     free(data);
@@ -187,7 +189,7 @@ int main(int argc, char **argv) {
   // Cleanup
   installation_proxy_client_free(instproxy_client);
   afc_client_free(afc_client);
-    tcp_provider_free(provider);
+  idevice_provider_free(provider);
 
   return err == IdeviceSuccess ? 0 : 1;
 }

ffi/examples/list_apps.c

@@ -27,7 +27,7 @@ int main() {
   }
 
   // Create TCP provider
-  TcpProviderHandle *provider = NULL;
+  IdeviceProviderHandle *provider = NULL;
   err = idevice_tcp_provider_new((struct sockaddr *)&addr, pairing_file,
                                  "ExampleProvider", &provider);
   if (err != IdeviceSuccess) {
@@ -41,7 +41,7 @@ int main() {
   err = installation_proxy_connect_tcp(provider, &client);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to installation proxy: %d\n", err);
-    tcp_provider_free(provider);
+    idevice_provider_free(provider);
     return 1;
   }
 
@@ -56,7 +56,7 @@ int main() {
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to get apps: %d\n", err);
     installation_proxy_client_free(client);
-    tcp_provider_free(provider);
+    idevice_provider_free(provider);
     return 1;
   }
 
@@ -79,7 +79,7 @@ int main() {
 
   // Cleanup
   installation_proxy_client_free(client);
-  tcp_provider_free(provider);
+  idevice_provider_free(provider);
 
   return 0;
 }

ffi/examples/location_simulation.c

@@ -40,7 +40,7 @@ int main(int argc, char **argv) {
   }
 
   // Create TCP provider
-  TcpProviderHandle *tcp_provider = NULL;
+  IdeviceProviderHandle *tcp_provider = NULL;
   err = idevice_tcp_provider_new((struct sockaddr *)&addr, pairing,
                                  "LocationSimCLI", &tcp_provider);
   if (err != IdeviceSuccess) {
@@ -51,8 +51,8 @@ int main(int argc, char **argv) {
 
   // Connect to CoreDeviceProxy
   CoreDeviceProxyHandle *core_device = NULL;
-  err = core_device_proxy_connect_tcp(tcp_provider, &core_device);
+  err = core_device_proxy_connect(tcp_provider, &core_device);
-  tcp_provider_free(tcp_provider);
+  idevice_provider_free(tcp_provider);
   idevice_pairing_file_free(pairing);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to CoreDeviceProxy: %d\n", err);
@@ -77,62 +77,36 @@ int main(int argc, char **argv) {
     return 1;
   }
 
-  err = adapter_connect(adapter, rsd_port);
+  // Connect to RSD port
+  AdapterStreamHandle *stream = NULL;
+  err = adapter_connect(adapter, rsd_port, &stream);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to RSD port: %d\n", err);
     adapter_free(adapter);
     return 1;
   }
 
-  // Create XPC device
+  RsdHandshakeHandle *handshake = NULL;
-  XPCDeviceAdapterHandle *xpc_device = NULL;
+  err = rsd_handshake_new(stream, &handshake);
-  err = xpc_device_new(adapter, &xpc_device);
   if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to create XPC device: %d\n", err);
+    fprintf(stderr, "Failed to perform RSD handshake: %d\n", err);
+    adapter_close(stream);
     adapter_free(adapter);
     return 1;
   }
 
-  // Get debug proxy service
-  XPCServiceHandle *dvt_service = NULL;
-  err = xpc_device_get_service(
-      xpc_device, "com.apple.instruments.server.services.LocationSimulation",
-      &dvt_service);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to get DVT service: %d\n", err);
-    xpc_device_free(xpc_device);
-    return 1;
-  }
-
-  // Reuse the adapter and connect to debug proxy port
-  AdapterHandle *debug_adapter = NULL;
-  err = xpc_device_adapter_into_inner(xpc_device, &debug_adapter);
-  xpc_device_free(xpc_device);
-  xpc_service_free(dvt_service);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to extract adapter: %d\n", err);
-    return 1;
-  }
-
-  adapter_close(debug_adapter);
-  err = adapter_connect(debug_adapter, dvt_service->port);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to connect to debug proxy port: %d\n", err);
-    adapter_free(debug_adapter);
-    return 1;
-  }
-
   // Create RemoteServerClient
-  RemoteServerAdapterHandle *remote_server = NULL;
+  RemoteServerHandle *remote_server = NULL;
-  err = remote_server_adapter_new(debug_adapter, &remote_server);
+  err = remote_server_connect_rsd(adapter, handshake, &remote_server);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to create remote server: %d\n", err);
-    adapter_free(debug_adapter);
+    adapter_free(adapter);
+    rsd_handshake_free(handshake);
     return 1;
   }
 
   // Create LocationSimulationClient
-  LocationSimulationAdapterHandle *location_sim = NULL;
+  LocationSimulationHandle *location_sim = NULL;
   err = location_simulation_new(remote_server, &location_sim);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to create location simulation client: %d\n", err);

ffi/examples/lockdownd.c

@@ -29,7 +29,7 @@ int main() {
   }
 
   // Create TCP provider
-  TcpProviderHandle *provider = NULL;
+  IdeviceProviderHandle *provider = NULL;
   err = idevice_tcp_provider_new((struct sockaddr *)&addr, pairing_file,
                                  "LockdowndTest", &provider);
   if (err != IdeviceSuccess) {
@@ -40,10 +40,10 @@ int main() {
 
   // Connect to lockdownd
   LockdowndClientHandle *client = NULL;
-  err = lockdownd_connect_tcp(provider, &client);
+  err = lockdownd_connect(provider, &client);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to lockdownd: %d\n", err);
-    tcp_provider_free(provider);
+    idevice_provider_free(provider);
     return 1;
   }
 
@@ -60,7 +60,7 @@ int main() {
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to start session: %d\n", err);
     lockdownd_client_free(client);
-    tcp_provider_free(provider);
+    idevice_provider_free(provider);
     return 1;
   }
 
@@ -159,7 +159,7 @@ int main() {
 
   // Cleanup
   lockdownd_client_free(client);
-  tcp_provider_free(provider);
+  idevice_provider_free(provider);
 
   return 0;
 }

ffi/examples/mount_personalized.c

@@ -99,7 +99,7 @@ int main(int argc, char **argv) {
   }
 
   // Create TCP provider
-  TcpProviderHandle *provider = NULL;
+  IdeviceProviderHandle *provider = NULL;
   err = idevice_tcp_provider_new((struct sockaddr *)&addr, pairing_file,
                                  "ImageMounterTest", &provider);
   if (err != IdeviceSuccess) {
@@ -124,10 +124,10 @@ int main(int argc, char **argv) {
 
   // Connect to lockdownd
   LockdowndClientHandle *lockdown_client = NULL;
-  err = lockdownd_connect_tcp(provider, &lockdown_client);
+  err = lockdownd_connect(provider, &lockdown_client);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to lockdownd: %d\n", err);
-    tcp_provider_free(provider);
+    idevice_provider_free(provider);
     free(image);
     free(trustcache);
     free(build_manifest);
@@ -139,7 +139,7 @@ int main(int argc, char **argv) {
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to start session: %d\n", err);
     lockdownd_client_free(lockdown_client);
-    tcp_provider_free(provider);
+    idevice_provider_free(provider);
     idevice_pairing_file_free(pairing_file_2);
     free(image);
     free(trustcache);
@@ -155,7 +155,7 @@ int main(int argc, char **argv) {
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to get UniqueChipID: %d\n", err);
     lockdownd_client_free(lockdown_client);
-    tcp_provider_free(provider);
+    idevice_provider_free(provider);
     free(image);
     free(trustcache);
     free(build_manifest);
@@ -168,11 +168,11 @@ int main(int argc, char **argv) {
 
   // Connect to image mounter
   ImageMounterHandle *mounter_client = NULL;
-  err = image_mounter_connect_tcp(provider, &mounter_client);
+  err = image_mounter_connect(provider, &mounter_client);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to image mounter: %d\n", err);
     lockdownd_client_free(lockdown_client);
-    tcp_provider_free(provider);
+    idevice_provider_free(provider);
     free(image);
     free(trustcache);
     free(build_manifest);
@@ -180,7 +180,7 @@ int main(int argc, char **argv) {
   }
 
   // Mount personalized image with progress callback
-  err = image_mounter_mount_personalized_tcp_with_callback(
+  err = image_mounter_mount_personalized_with_callback(
       mounter_client, provider, image, image_len, trustcache, trustcache_len,
       build_manifest, manifest_len,
       NULL, // info_plist
@@ -195,7 +195,7 @@ int main(int argc, char **argv) {
   // Cleanup
   image_mounter_free(mounter_client);
   lockdownd_client_free(lockdown_client);
-  tcp_provider_free(provider);
+  idevice_provider_free(provider);
   free(image);
   free(trustcache);
   free(build_manifest);

ffi/examples/mounter.c

@@ -112,7 +112,7 @@ int main(int argc, char **argv) {
   }
 
   // Create TCP provider
-  TcpProviderHandle *provider = NULL;
+  IdeviceProviderHandle *provider = NULL;
   err = idevice_tcp_provider_new((struct sockaddr *)&addr, pairing_file,
                                  "ImageMounterTest", &provider);
   if (err != IdeviceSuccess) {
@@ -123,13 +123,13 @@ int main(int argc, char **argv) {
 
   // Connect to image mounter
   ImageMounterHandle *client = NULL;
-  err = image_mounter_connect_tcp(provider, &client);
+  err = image_mounter_connect(provider, &client);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to image mounter: %d\n", err);
-    tcp_provider_free(provider);
+    idevice_provider_free(provider);
     return 1;
   }
-  tcp_provider_free(provider);
+  idevice_provider_free(provider);
 
   // Process command
   int success = 1;

ffi/examples/process_control.c

@@ -43,7 +43,7 @@ int main(int argc, char **argv) {
   printf("=== Setting up CoreDeviceProxy ===\n");
 
   // Create TCP provider
-  TcpProviderHandle *tcp_provider = NULL;
+  IdeviceProviderHandle *tcp_provider = NULL;
   err = idevice_tcp_provider_new((struct sockaddr *)&addr, pairing,
                                  "ProcessControlTest", &tcp_provider);
   if (err != IdeviceSuccess) {
@@ -54,14 +54,14 @@ int main(int argc, char **argv) {
 
   // Connect to CoreDeviceProxy
   CoreDeviceProxyHandle *core_device = NULL;
-  err = core_device_proxy_connect_tcp(tcp_provider, &core_device);
+  err = core_device_proxy_connect(tcp_provider, &core_device);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to CoreDeviceProxy: %d\n", err);
-    tcp_provider_free(tcp_provider);
+    idevice_provider_free(tcp_provider);
     idevice_pairing_file_free(pairing);
     return 1;
   }
-  tcp_provider_free(tcp_provider);
+  idevice_provider_free(tcp_provider);
 
   // Get server RSD port
   uint16_t rsd_port;
@@ -89,89 +89,37 @@ int main(int argc, char **argv) {
   }
 
   // Connect to RSD port
-  err = adapter_connect(adapter, rsd_port);
+  AdapterStreamHandle *stream = NULL;
+  err = adapter_connect(adapter, rsd_port, &stream);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to connect to RSD port: %d\n", err);
     adapter_free(adapter);
-    core_device_proxy_free(core_device);
-    idevice_pairing_file_free(pairing);
     return 1;
   }
-  printf("Successfully connected to RSD port\n");
 
-  /*****************************************************************
+  RsdHandshakeHandle *handshake = NULL;
-   * XPC Device Setup
+  err = rsd_handshake_new(stream, &handshake);
-   *****************************************************************/
-  printf("\n=== Setting up XPC Device ===\n");
-
-  XPCDeviceAdapterHandle *xpc_device = NULL;
-  err = xpc_device_new(adapter, &xpc_device);
   if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to create XPC device: %d\n", err);
+    fprintf(stderr, "Failed to perform RSD handshake: %d\n", err);
+    adapter_close(stream);
     adapter_free(adapter);
-    core_device_proxy_free(core_device);
-    idevice_pairing_file_free(pairing);
     return 1;
   }
 
-  /*****************************************************************
-   * Get DVT Service
-   *****************************************************************/
-  printf("\n=== Getting Debug Proxy Service ===\n");
-
-  XPCServiceHandle *dvt_service = NULL;
-  err = xpc_device_get_service(xpc_device, "com.apple.instruments.dtservicehub",
-                               &dvt_service);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to get DVT service: %d\n", err);
-    xpc_device_free(xpc_device);
-    return 1;
-  }
-  printf("Debug Proxy Service Port: %d\n", dvt_service->port);
-
-  /*****************************************************************
-   * Remote Server Setup
-   *****************************************************************/
-  printf("\n=== Setting up Remote Server ===\n");
-
-  // Get the adapter back from XPC device
-  AdapterHandle *debug_adapter = NULL;
-  err = xpc_device_adapter_into_inner(xpc_device, &debug_adapter);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to extract adapter: %d\n", err);
-    xpc_service_free(dvt_service);
-    xpc_device_free(xpc_device);
-    return 1;
-  }
-
-  // Connect to debug proxy port
-  adapter_close(debug_adapter);
-  err = adapter_connect(debug_adapter, dvt_service->port);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to connect to debug proxy port: %d\n", err);
-    adapter_free(debug_adapter);
-    xpc_service_free(dvt_service);
-    return 1;
-  }
-  printf("Successfully connected to debug proxy port\n");
-
   // Create RemoteServerClient
-  RemoteServerAdapterHandle *remote_server = NULL;
+  RemoteServerHandle *remote_server = NULL;
-  err = remote_server_adapter_new(debug_adapter, &remote_server);
+  err = remote_server_connect_rsd(adapter, handshake, &remote_server);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to create remote server: %d\n", err);
-    adapter_free(debug_adapter);
+    adapter_free(adapter);
-    xpc_service_free(dvt_service);
+    rsd_handshake_free(handshake);
     return 1;
   }
 
-  /*****************************************************************
-   * Process Control Test
-   *****************************************************************/
   printf("\n=== Testing Process Control ===\n");
 
   // Create ProcessControlClient
-  ProcessControlAdapterHandle *process_control = NULL;
+  ProcessControlHandle *process_control = NULL;
   err = process_control_new(remote_server, &process_control);
   if (err != IdeviceSuccess) {
     fprintf(stderr, "Failed to create process control client: %d\n", err);

ffi/examples/remotexpc.c

@@ -1,204 +0,0 @@
-// Jackson Coxson
-
-#include "idevice.h"
-#include <arpa/inet.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-void print_service_details(XPCServiceHandle *service) {
-  printf("  Service Details:\n");
-  printf("    Entitlement: %s\n", service->entitlement);
-  printf("    Port: %d\n", service->port);
-  printf("    Uses Remote XPC: %s\n",
-         service->uses_remote_xpc ? "true" : "false");
-  printf("    Service Version: %lld\n", service->service_version);
-
-  if (service->features_count > 0) {
-    printf("    Features:\n");
-    for (size_t i = 0; i < service->features_count; i++) {
-      printf("      - %s\n", service->features[i]);
-    }
-  }
-}
-
-int main() {
-  // Initialize logger
-  idevice_init_logger(Debug, Disabled, NULL);
-
-  // Create the socket address (replace with your device's IP)
-  struct sockaddr_in addr;
-  memset(&addr, 0, sizeof(addr));
-  addr.sin_family = AF_INET;
-  addr.sin_port = htons(LOCKDOWN_PORT);
-  inet_pton(AF_INET, "10.7.0.2", &addr.sin_addr);
-
-  // Read pairing file (replace with your pairing file path)
-  IdevicePairingFile *pairing_file = NULL;
-  IdeviceErrorCode err =
-      idevice_pairing_file_read("pairing_file.plist", &pairing_file);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to read pairing file: %d\n", err);
-    return 1;
-  }
-
-  /*****************************************************************
-   * TCP Provider and CoreDeviceProxy Test
-   *****************************************************************/
-  printf("=== Testing TCP Provider and CoreDeviceProxy ===\n");
-
-  // Create TCP provider
-  TcpProviderHandle *tcp_provider = NULL;
-  err = idevice_tcp_provider_new((struct sockaddr *)&addr, pairing_file,
-                                 "CoreDeviceProxyTest", &tcp_provider);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to create TCP provider: %d\n", err);
-    idevice_pairing_file_free(pairing_file);
-    return 1;
-  }
-
-  // Connect to CoreDeviceProxy
-  CoreDeviceProxyHandle *core_device = NULL;
-  err = core_device_proxy_connect_tcp(tcp_provider, &core_device);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to connect to CoreDeviceProxy: %d\n", err);
-    tcp_provider_free(tcp_provider);
-    return 1;
-  }
-  tcp_provider_free(tcp_provider);
-
-  // Get client parameters
-  uint16_t mtu;
-  char *address = NULL;
-  char *netmask = NULL;
-  err = core_device_proxy_get_client_parameters(core_device, &mtu, &address,
-                                                &netmask);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to get client parameters: %d\n", err);
-    core_device_proxy_free(core_device);
-    return 1;
-  }
-  printf("Client Parameters:\n");
-  printf("  MTU: %d\n", mtu);
-  printf("  Address: %s\n", address);
-  printf("  Netmask: %s\n", netmask);
-  idevice_string_free(address);
-  idevice_string_free(netmask);
-
-  // Get server address
-  char *server_address = NULL;
-  err = core_device_proxy_get_server_address(core_device, &server_address);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to get server address: %d\n", err);
-    core_device_proxy_free(core_device);
-    return 1;
-  }
-  printf("Server Address: %s\n", server_address);
-  idevice_string_free(server_address);
-
-  // Get server RSD port
-  uint16_t rsd_port;
-  err = core_device_proxy_get_server_rsd_port(core_device, &rsd_port);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to get server RSD port: %d\n", err);
-    core_device_proxy_free(core_device);
-    return 1;
-  }
-  printf("Server RSD Port: %d\n", rsd_port);
-
-  // Create TCP tunnel adapter
-  AdapterHandle *adapter = NULL;
-  err = core_device_proxy_create_tcp_adapter(core_device, &adapter);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to create TCP adapter: %d\n", err);
-  } else {
-    printf("Successfully created TCP tunnel adapter\n");
-  }
-  err = adapter_connect(adapter, rsd_port);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to connect to RSD port: %d\n", err);
-  } else {
-    printf("Successfully connected to RSD port\n");
-  }
-
-  /*****************************************************************
-   * XPC Device Test
-   *****************************************************************/
-  printf("\n=== Testing XPC Device ===\n");
-
-  // Create XPC device
-  XPCDeviceAdapterHandle *xpc_device = NULL;
-  err = xpc_device_new(adapter, &xpc_device);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to create XPC device: %d\n", err);
-    core_device_proxy_free(core_device);
-    return 1;
-  }
-
-  // List all services
-  char **service_names = NULL;
-  size_t service_count = 0;
-  err =
-      xpc_device_get_service_names(xpc_device, &service_names, &service_count);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to get service names: %d\n", err);
-    xpc_device_free(xpc_device);
-    return 1;
-  }
-
-  printf("Available Services (%zu):\n", service_count);
-  for (size_t i = 0; i < service_count; i++) {
-    printf("- %s\n", service_names[i]);
-
-    // Get service details for each service
-    XPCServiceHandle *service = NULL;
-    err = xpc_device_get_service(xpc_device, service_names[i], &service);
-    if (err == IdeviceSuccess) {
-      print_service_details(service);
-      xpc_service_free(service);
-    } else {
-      printf("  Failed to get service details: %d\n", err);
-    }
-  }
-  xpc_device_free_service_names(service_names, service_count);
-
-  // Test getting a specific service
-  const char *test_service_name = "com.apple.internal.dt.remote.debugproxy";
-  XPCServiceHandle *test_service = NULL;
-  err = xpc_device_get_service(xpc_device, test_service_name, &test_service);
-  if (err == IdeviceSuccess) {
-    printf("\nSuccessfully retrieved service '%s':\n", test_service_name);
-    print_service_details(test_service);
-    xpc_service_free(test_service);
-  } else {
-    printf("\nFailed to get service '%s': %d\n", test_service_name, err);
-  }
-
-  /*****************************************************************
-   * Adapter return
-   *****************************************************************/
-  AdapterHandle *adapter_return = NULL;
-  err = xpc_device_adapter_into_inner(xpc_device, &adapter_return);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to extract adapter: %d\n", err);
-  } else {
-    printf("Successfully extracted adapter\n");
-  }
-
-  err = adapter_close(adapter_return);
-  if (err != IdeviceSuccess) {
-    fprintf(stderr, "Failed to close adapter port: %d\n", err);
-  } else {
-    printf("Successfully closed adapter port\n");
-  }
-
-  /*****************************************************************
-   * Cleanup
-   *****************************************************************/
-  adapter_free(adapter_return);
-
-  printf("\nAll tests completed successfully!\n");
-  return 0;
-}