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

Remove dangerous result/option macros

Browse Source
This commit is contained in:
Jackson Coxson
2025-09-03 19:48:43 -06:00
parent ca56575c6c
commit b0e3c5769a
8 changed files with 215 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
cpp/examples/diagnosticsservice.cpp
View File

@@ -29,18 +29,16 @@ int main() {
idevice_init_logger(Debug, Disabled, NULL);
FfiError err;
// 1) usbmuxd → pick first device
auto mux = IdeviceFFI::UsbmuxdConnection::default_new(/*tag*/ 0);
if_let_err(mux, err, { die("failed to connect to usbmuxd", err); });
// 1) Connect to usbmuxd and pick first device
auto mux = UsbmuxdConnection::default_new(/*tag*/ 0).expect("failed to connect to usbmuxd");
auto devices = mux.unwrap().get_devices();
if_let_err(devices, err, { die("failed to list devices", err); });
if (devices.unwrap().empty()) {
auto devices = mux.get_devices().expect("failed to list devices");
if (devices.empty()) {
std::cerr << "no devices connected\n";
return 1;
}
auto& dev = (devices)[0];
auto& dev = (devices.unwrap())[0];
auto udid = dev.get_udid();
if (udid.is_none()) {
std::cerr << "device has no UDID\n";
@@ -53,58 +51,54 @@ int main() {
}
// 2) Provider via default usbmuxd addr
auto addr = IdeviceFFI::UsbmuxdAddr::default_new();
auto addr = UsbmuxdAddr::default_new();
const uint32_t tag = 0;
const std::string label = "debug-proxy-jkcoxson";
auto provider = IdeviceFFI::Provider::usbmuxd_new(
std::move(addr), tag, udid.unwrap(), mux_id.unwrap(), label);
if_let_err(provider, err, { die("failed to create provider", err); });
const uint32_t tag = 0;
const std::string label = "app_service-jkcoxson";
auto provider =
Provider::usbmuxd_new(std::move(addr), tag, udid.unwrap(), mux_id.unwrap(), label)
.expect("failed to create provider");
// 3) CoreDeviceProxy
auto cdp = CoreDeviceProxy::connect(provider.unwrap())
.unwrap_or_else([](FfiError e) -> CoreDeviceProxy {
die("failed to connect CoreDeviceProxy", e);
});
auto cdp = CoreDeviceProxy::connect(provider).unwrap_or_else(
[](FfiError e) -> CoreDeviceProxy { die("failed to connect CoreDeviceProxy", e); });
auto rsd_port = cdp.get_server_rsd_port().unwrap_or_else(
[](FfiError err) -> uint16_t { die("failed to get server RSD port", err); });
// 4) Create software tunnel adapter (consumes proxy)
auto adapter = std::move(cdp).create_tcp_adapter();
if_let_err(adapter, err, { die("failed to create software tunnel adapter", err); });
auto adapter =
std::move(cdp).create_tcp_adapter().expect("failed to create software tunnel adapter");
// 5) Connect adapter to RSD → ReadWrite stream
auto stream = adapter.unwrap().connect(rsd_port);
if_let_err(stream, err, { die("failed to connect RSD stream", err); });
auto stream = adapter.connect(rsd_port).expect("failed to connect RSD stream");
// 6) RSD handshake (consumes stream)
auto rsd = RsdHandshake::from_socket(std::move(stream.unwrap()));
if_let_err(rsd, err, { die("failed RSD handshake", err); });
auto rsd = RsdHandshake::from_socket(std::move(stream)).expect("failed RSD handshake");
// 6) DebugProxy over RSD
auto diag = DiagnosticsService::connect_rsd(adapter.unwrap(), rsd.unwrap());
if_let_err(diag, err, { die("failed to connect DebugProxy", err); });
// 7) DebugProxy over RSD
auto diag =
DiagnosticsService::connect_rsd(adapter, rsd).expect("failed to connect DebugProxy");
std::cout << "Getting sysdiagnose, this takes a while! iOS is slow...\n";
auto cap = diag.unwrap().capture_sysdiagnose(/*dry_run=*/false);
if_let_err(cap, err, { die("capture_sysdiagnose failed", err); });
auto cap = diag.capture_sysdiagnose(/*dry_run=*/false).expect("capture_sysdiagnose failed");
std::cout << "Got sysdiagnose! Saving to file: " << cap.unwrap().preferred_filename << "\n";
std::cout << "Got sysdiagnose! Saving to file: " << cap.preferred_filename << "\n";
// 7) Stream to file with progress
std::ofstream out(cap.unwrap().preferred_filename, std::ios::binary);
std::ofstream out(cap.preferred_filename, std::ios::binary);
if (!out) {
std::cerr << "failed to open output file\n";
return 1;
}
std::size_t written = 0;
const std::size_t total = cap.unwrap().expected_length;
const std::size_t total = cap.expected_length;
for (;;) {
auto chunk = cap.unwrap().stream.next_chunk();
auto chunk = cap.stream.next_chunk();
match_result(
chunk,
res,
@@ -128,6 +122,6 @@ int main() {
}
out.flush();
std::cout << "\nDone! Saved to " << cap.unwrap().preferred_filename << "\n";
std::cout << "\nDone! Saved to " << cap.preferred_filename << "\n";
return 0;
}