mirror of
https://github.com/jkcoxson/idevice.git
synced 2026-03-02 06:26:15 +01:00
129 lines
3.8 KiB
C++
129 lines
3.8 KiB
C++
// Jackson Coxson
|
|
|
|
#include <cstdint>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <optional>
|
|
#include <string>
|
|
|
|
#include <idevice++/bindings.hpp>
|
|
#include <idevice++/core_device_proxy.hpp>
|
|
#include <idevice++/diagnosticsservice.hpp>
|
|
#include <idevice++/ffi.hpp>
|
|
#include <idevice++/provider.hpp>
|
|
#include <idevice++/rsd.hpp>
|
|
#include <idevice++/usbmuxd.hpp>
|
|
|
|
using namespace IdeviceFFI;
|
|
|
|
static void fail(const char* msg, const FfiError& e) {
|
|
std::cerr << msg;
|
|
if (e)
|
|
std::cerr << ": " << e.message;
|
|
std::cerr << "\n";
|
|
std::exit(1);
|
|
}
|
|
|
|
int main() {
|
|
idevice_init_logger(Debug, Disabled, NULL);
|
|
FfiError err;
|
|
|
|
// 1) usbmuxd, pick first device
|
|
auto mux = UsbmuxdConnection::default_new(/*tag*/ 0, err);
|
|
if (!mux)
|
|
fail("failed to connect to usbmuxd", err);
|
|
|
|
auto devices = mux->get_devices(err);
|
|
if (!devices)
|
|
fail("failed to list devices", err);
|
|
if (devices->empty()) {
|
|
std::cerr << "no devices connected\n";
|
|
return 1;
|
|
}
|
|
|
|
auto& dev = (*devices)[0];
|
|
auto udid = dev.get_udid();
|
|
auto mux_id = dev.get_id();
|
|
if (!udid || !mux_id) {
|
|
std::cerr << "device missing udid or mux id\n";
|
|
return 1;
|
|
}
|
|
|
|
// 2) Provider via default usbmuxd addr
|
|
auto addr = UsbmuxdAddr::default_new();
|
|
|
|
const uint32_t tag = 0;
|
|
const std::string label = "diagnosticsservice-jkcoxson";
|
|
auto provider = Provider::usbmuxd_new(std::move(addr), tag, *udid, *mux_id, label, err);
|
|
if (!provider)
|
|
fail("failed to create provider", err);
|
|
|
|
// 3) CoreDeviceProxy
|
|
auto cdp = CoreDeviceProxy::connect(*provider, err);
|
|
if (!cdp)
|
|
fail("failed CoreDeviceProxy connect", err);
|
|
|
|
auto rsd_port = cdp->get_server_rsd_port(err);
|
|
if (!rsd_port)
|
|
fail("failed to get RSD port", err);
|
|
|
|
// 4) Software tunnel → connect to RSD
|
|
auto adapter = std::move(*cdp).create_tcp_adapter(err);
|
|
if (!adapter)
|
|
fail("failed to create software tunnel adapter", err);
|
|
|
|
auto stream = adapter->connect(*rsd_port, err);
|
|
if (!stream)
|
|
fail("failed to connect RSD stream", err);
|
|
|
|
// 5) RSD handshake
|
|
auto rsd = RsdHandshake::from_socket(std::move(*stream), err);
|
|
if (!rsd)
|
|
fail("failed RSD handshake", err);
|
|
// 6) Diagnostics Service over RSD
|
|
auto diag = DiagnosticsService::connect_rsd(*adapter, *rsd, err);
|
|
if (!diag)
|
|
fail("failed to connect DiagnosticsService", err);
|
|
|
|
std::cout << "Getting sysdiagnose, this takes a while! iOS is slow...\n";
|
|
|
|
auto cap = diag->capture_sysdiagnose(/*dry_run=*/false, err);
|
|
if (!cap)
|
|
fail("capture_sysdiagnose failed", err);
|
|
|
|
std::cout << "Got sysdiagnose! Saving to file: " << cap->preferred_filename << "\n";
|
|
|
|
// 7) Stream to file with progress
|
|
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->expected_length;
|
|
|
|
for (;;) {
|
|
auto chunk = cap->stream.next_chunk(err);
|
|
if (!chunk) {
|
|
if (err)
|
|
fail("stream error", err); // err set only on real error
|
|
break; // nullptr means end-of-stream
|
|
}
|
|
if (!chunk->empty()) {
|
|
out.write(reinterpret_cast<const char*>(chunk->data()),
|
|
static_cast<std::streamsize>(chunk->size()));
|
|
if (!out) {
|
|
std::cerr << "write failed\n";
|
|
return 1;
|
|
}
|
|
written += chunk->size();
|
|
}
|
|
std::cout << "wrote " << written << "/" << total << " bytes\r" << std::flush;
|
|
}
|
|
|
|
out.flush();
|
|
std::cout << "\nDone! Saved to " << cap->preferred_filename << "\n";
|
|
return 0;
|
|
}
|