StephenDev0/idevice
1
0
Fork 0
mirror of https://github.com/jkcoxson/idevice.git synced 2026-03-02 06:26:15 +01:00
Code Issues Packages Projects Releases Wiki Activity

Update C examples for new FFI

Browse Source
This commit is contained in:
Jackson Coxson
2025-05-26 16:33:58 -06:00
parent f6cc68cb98
commit bc6a1c0503
13 changed files with 302 additions and 659 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
ffi/examples/CMakeLists.txt
View File

@@ -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} )

8
ffi/examples/afc.c
View File

@@ -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;

88
ffi/examples/debug_proxy.c
View File

@@ -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_pairing_file_free(pairing);
idevice_provider_free(tcp_provider);
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;
err = xpc_device_new(adapter, &xpc_device);
RsdHandshakeHandle *handshake = NULL;
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;
err = debug_proxy_adapter_new(debug_adapter, &debug_proxy);
DebugProxyHandle *debug_proxy = NULL;
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);
xpc_service_free(debug_service);
core_device_proxy_free(core_device);
idevice_pairing_file_free(pairing);
rsd_handshake_free(handshake);
adapter_free(adapter);
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;

148
ffi/examples/enable_jit.c
View File

@@ -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;
IdeviceErrorCode err = idevice_pairing_file_read(pairing_file, &pairing);
struct IdevicePairingFile *pairing = NULL;
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;
err = core_device_proxy_connect_tcp(tcp_provider, &core_device);
struct CoreDeviceProxyHandle *core_device = NULL;
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;
err = xpc_device_new(adapter, &xpc_device);
struct RsdHandshakeHandle *rsd_handshake = NULL;
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
XPCServiceHandle *debug_service = NULL;
err = xpc_device_get_service(
xpc_device, "com.apple.internal.dt.remote.debugproxy", &debug_service);
// Get services
struct CRsdServiceArray *services = NULL;
err = rsd_get_services(rsd_handshake, &services);
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
XPCServiceHandle *pc_service = NULL;
err = xpc_device_get_service(xpc_device, "com.apple.instruments.dtservicehub",
&pc_service);
if (err != IdeviceSuccess) {
fprintf(stderr, "Failed to get process control service: %d\n", err);
xpc_device_free(xpc_device);
core_device_proxy_free(core_device);
// Find debug proxy and process control services
uint16_t debug_port = 0;
uint16_t pc_port = 0;
for (size_t i = 0; i < services->count; i++) {
struct CRsdService *service = &services->services[i];
if (strcmp(service->name, "com.apple.internal.dt.remote.debugproxy") == 0) {
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);
xpc_service_free(pc_service);
core_device_proxy_free(core_device);
adapter_free(adapter);
return 1;
}
printf("Successfully connected to process control port\n");
// Create RemoteServerClient
RemoteServerAdapterHandle *remote_server = NULL;
err = remote_server_adapter_new(pc_adapter, &remote_server);
struct RemoteServerHandle *remote_server = NULL;
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);
xpc_service_free(pc_service);
core_device_proxy_free(core_device);
adapter_free(adapter);
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;
err = debug_proxy_adapter_new(debug_adapter, &debug_proxy);
struct DebugProxyHandle *debug_proxy = NULL;
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;

8
ffi/examples/heartbeat.c
View File

@@ -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) {

318
ffi/examples/ipa_installer.c
View File

@@ -7,187 +7,189 @@
#include <unistd.h>
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(" --udid UDID Device UDID (optional)\n");
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(" --udid UDID Device UDID (optional)\n");
}
int read_file(const char *filename, uint8_t **data, size_t *length) {
FILE *file = fopen(filename, "rb");
if (!file) {
perror("Failed to open file");
return 0;
}
FILE *file = fopen(filename, "rb");
if (!file) {
perror("Failed to open file");
return 0;
}
fseek(file, 0, SEEK_END);
*length = ftell(file);
fseek(file, 0, SEEK_SET);
*data = malloc(*length);
if (!*data) {
perror("Failed to allocate memory");
fclose(file);
return 0;
}
if (fread(*data, 1, *length, file) != *length) {
perror("Failed to read file");
free(*data);
fclose(file);
return 0;
}
fseek(file, 0, SEEK_END);
*length = ftell(file);
fseek(file, 0, SEEK_SET);
*data = malloc(*length);
if (!*data) {
perror("Failed to allocate memory");
fclose(file);
return 1;
return 0;
}
if (fread(*data, 1, *length, file) != *length) {
perror("Failed to read file");
free(*data);
fclose(file);
return 0;
}
fclose(file);
return 1;
}
int main(int argc, char **argv) {
// Initialize logger
idevice_init_logger(Debug, Disabled, NULL);
// Initialize logger
idevice_init_logger(Debug, Disabled, NULL);
// Default values
char *ip = "10.7.0.2";
char *pairing_file_path = "pairing_file.plist";
char *udid = NULL;
char *ipa_path = NULL;
// Default values
char *ip = "10.7.0.2";
char *pairing_file_path = "pairing_file.plist";
char *udid = NULL;
char *ipa_path = NULL;
// Parse arguments
for (int i = 1; i < argc; i++) {
if (strcmp(argv[i], "--ip") == 0) {
if (i + 1 >= argc) {
printf("Error: Missing IP address argument\n");
return 1;
}
ip = argv[++i];
} else if (strcmp(argv[i], "--pairing") == 0) {
if (i + 1 >= argc) {
printf("Error: Missing pairing file argument\n");
return 1;
}
pairing_file_path = argv[++i];
} else if (strcmp(argv[i], "--udid") == 0) {
if (i + 1 >= argc) {
printf("Error: Missing UDID argument\n");
return 1;
}
udid = argv[++i];
} else if (strcmp(argv[i], "help") == 0) {
print_usage();
return 0;
} else {
ipa_path = argv[i];
break;
}
}
if (!ipa_path) {
print_usage();
// Parse arguments
for (int i = 1; i < argc; i++) {
if (strcmp(argv[i], "--ip") == 0) {
if (i + 1 >= argc) {
printf("Error: Missing IP address argument\n");
return 1;
}
// Create the socket address
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(LOCKDOWN_PORT);
if (inet_pton(AF_INET, ip, &addr.sin_addr) != 1) {
fprintf(stderr, "Invalid IP address\n");
}
ip = argv[++i];
} else if (strcmp(argv[i], "--pairing") == 0) {
if (i + 1 >= argc) {
printf("Error: Missing pairing file argument\n");
return 1;
}
// Read pairing file
IdevicePairingFile *pairing_file = NULL;
IdeviceErrorCode err = idevice_pairing_file_read(pairing_file_path, &pairing_file);
if (err != IdeviceSuccess) {
fprintf(stderr, "Failed to read pairing file: %d\n", err);
}
pairing_file_path = argv[++i];
} else if (strcmp(argv[i], "--udid") == 0) {
if (i + 1 >= argc) {
printf("Error: Missing UDID argument\n");
return 1;
}
// Create TCP provider
TcpProviderHandle *provider = NULL;
err = idevice_tcp_provider_new((struct sockaddr *)&addr, pairing_file,
"IPAInstaller", &provider);
if (err != IdeviceSuccess) {
fprintf(stderr, "Failed to create TCP provider: %d\n", err);
idevice_pairing_file_free(pairing_file);
return 1;
}
// Connect to AFC service
AfcClientHandle *afc_client = NULL;
err = afc_client_connect_tcp(provider, &afc_client);
if (err != IdeviceSuccess) {
fprintf(stderr, "Failed to connect to AFC service: %d\n", err);
tcp_provider_free(provider);
return 1;
}
// Extract filename from path
char *filename = strrchr(ipa_path, '/');
if (filename == NULL) {
filename = ipa_path;
}
udid = argv[++i];
} else if (strcmp(argv[i], "help") == 0) {
print_usage();
return 0;
} else {
filename++; // Skip the '/'
ipa_path = argv[i];
break;
}
}
// Create destination path
char dest_path[256];
snprintf(dest_path, sizeof(dest_path), "/PublicStaging/%s", filename);
if (!ipa_path) {
print_usage();
return 1;
}
// Upload IPA file
printf("Uploading %s to %s...\n", ipa_path, dest_path);
uint8_t *data = NULL;
size_t length = 0;
if (!read_file(ipa_path, &data, &length)) {
fprintf(stderr, "Failed to read IPA file\n");
afc_client_free(afc_client);
return 1;
}
// Create the socket address
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(LOCKDOWN_PORT);
if (inet_pton(AF_INET, ip, &addr.sin_addr) != 1) {
fprintf(stderr, "Invalid IP address\n");
return 1;
}
AfcFileHandle *file = NULL;
err = afc_file_open(afc_client, dest_path, AfcWrOnly | AfcCreat, &file);
if (err != IdeviceSuccess) {
fprintf(stderr, "Failed to open destination file: %d\n", err);
free(data);
afc_client_free(afc_client);
return 1;
}
// Read pairing file
IdevicePairingFile *pairing_file = NULL;
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;
}
err = afc_file_write(file, data, length);
free(data);
afc_file_close(file);
if (err != IdeviceSuccess) {
fprintf(stderr, "Failed to write file: %d\n", err);
afc_client_free(afc_client);
return 1;
}
printf("Upload completed successfully\n");
// Create TCP provider
IdeviceProviderHandle *provider = NULL;
err = idevice_tcp_provider_new((struct sockaddr *)&addr, pairing_file,
"IPAInstaller", &provider);
if (err != IdeviceSuccess) {
fprintf(stderr, "Failed to create TCP provider: %d\n", err);
idevice_pairing_file_free(pairing_file);
return 1;
}
// Connect to installation proxy
InstallationProxyClientHandle *instproxy_client = NULL;
err = installation_proxy_connect_tcp(provider, &instproxy_client);
if (err != IdeviceSuccess) {
fprintf(stderr, "Failed to connect to installation proxy: %d\n", err);
afc_client_free(afc_client);
return 1;
}
// Connect to AFC service
AfcClientHandle *afc_client = NULL;
err = afc_client_connect(provider, &afc_client);
if (err != IdeviceSuccess) {
fprintf(stderr, "Failed to connect to AFC service: %d\n", err);
idevice_provider_free(provider);
return 1;
}
// Install the uploaded IPA
printf("Installing %s...\n", dest_path);
err = installation_proxy_install(instproxy_client, dest_path, NULL);
if (err != IdeviceSuccess) {
fprintf(stderr, "Failed to install IPA: %d\n", err);
} else {
printf("Installation completed successfully\n");
}
// Extract filename from path
char *filename = strrchr(ipa_path, '/');
if (filename == NULL) {
filename = ipa_path;
} else {
filename++; // Skip the '/'
}
// Cleanup
installation_proxy_client_free(instproxy_client);
// Create destination path
char dest_path[256];
snprintf(dest_path, sizeof(dest_path), "/PublicStaging/%s", filename);
// Upload IPA file
printf("Uploading %s to %s...\n", ipa_path, dest_path);
uint8_t *data = NULL;
size_t length = 0;
if (!read_file(ipa_path, &data, &length)) {
fprintf(stderr, "Failed to read IPA file\n");
afc_client_free(afc_client);
tcp_provider_free(provider);
return 1;
}
return err == IdeviceSuccess ? 0 : 1;
AfcFileHandle *file = NULL;
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);
afc_client_free(afc_client);
return 1;
}
err = afc_file_write(file, data, length);
free(data);
afc_file_close(file);
if (err != IdeviceSuccess) {
fprintf(stderr, "Failed to write file: %d\n", err);
afc_client_free(afc_client);
return 1;
}
printf("Upload completed successfully\n");
// Connect to installation proxy
InstallationProxyClientHandle *instproxy_client = NULL;
err = installation_proxy_connect_tcp(provider, &instproxy_client);
if (err != IdeviceSuccess) {
fprintf(stderr, "Failed to connect to installation proxy: %d\n", err);
afc_client_free(afc_client);
return 1;
}
// Install the uploaded IPA
printf("Installing %s...\n", dest_path);
err = installation_proxy_install(instproxy_client, dest_path, NULL);
if (err != IdeviceSuccess) {
fprintf(stderr, "Failed to install IPA: %d\n", err);
} else {
printf("Installation completed successfully\n");
}
// Cleanup
installation_proxy_client_free(instproxy_client);
afc_client_free(afc_client);
idevice_provider_free(provider);
return err == IdeviceSuccess ? 0 : 1;
}

8
ffi/examples/list_apps.c
View File

@@ -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;
}

56
ffi/examples/location_simulation.c
View File

@@ -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);
tcp_provider_free(tcp_provider);
err = core_device_proxy_connect(tcp_provider, &core_device);
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
XPCDeviceAdapterHandle *xpc_device = NULL;
err = xpc_device_new(adapter, &xpc_device);
RsdHandshakeHandle *handshake = NULL;
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);
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;
err = remote_server_adapter_new(debug_adapter, &remote_server);
RemoteServerHandle *remote_server = NULL;
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);

10
ffi/examples/lockdownd.c
View File

@@ -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;
}

18
ffi/examples/mount_personalized.c
View File

@@ -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);

8
ffi/examples/mounter.c
View File

@@ -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;

82
ffi/examples/process_control.c
View File

@@ -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");
/*****************************************************************
* XPC Device Setup
*****************************************************************/
printf("\n=== Setting up XPC Device ===\n");
XPCDeviceAdapterHandle *xpc_device = NULL;
err = xpc_device_new(adapter, &xpc_device);
RsdHandshakeHandle *handshake = NULL;
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 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;
err = remote_server_adapter_new(debug_adapter, &remote_server);
RemoteServerHandle *remote_server = NULL;
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);
xpc_service_free(dvt_service);
adapter_free(adapter);
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);

204
ffi/examples/remotexpc.c
View File

@@ -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;
}