static int itdb_iphone_post_notification(idevice_t device,
lockdownd_client_t client,
const char *notification)
{
np_client_t np = NULL;
uint16_t nport = 0;
lockdownd_start_service(client, "com.apple.mobile.notification_proxy", &nport);
if (!nport) {
fprintf(stderr, "notification_proxy could not be started!\n");
return -1;
}
np_client_new(device, nport, &np);
if(!np) {
fprintf(stderr, "connection to notification_proxy failed!\n");
return -1;
}
if(np_post_notification(np, notification)) {
fprintf(stderr, "failed to post notification!\n");
np_client_free(np);
return -1;
}
np_client_free(np);
return 0;
}
/*
* Class: com_att_aro_libimobiledevice_Screencapture
* Method: startService
* Signature: ()V
*/
JNIEXPORT jstring JNICALL Java_com_att_aro_libimobiledevice_ScreencaptureImpl_startService
(JNIEnv * env, jobject obj) {
const char * str;// = "SUCCESS";
if (IDEVICE_E_SUCCESS != idevice_new(&device, udid)) {
str = "No device found, is it plugged in?\n";
return outPut(env, str);
}
if(!device) {
str = "No device mounted";
return outPut(env, str);
}
if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(device, &lckd, NULL)) {
idevice_free(device);
str = "Failed to acquire lock service.";
return outPut(env, str);
}
lockdownd_start_service(lckd, "com.apple.mobile.screenshotr", &service);
lockdownd_client_free(lckd);
if (service && service->port > 0) {
if (screenshotr_client_new(device, service, &shotr) != SCREENSHOTR_E_SUCCESS) {
str = "Could not connect to screenshotr service!";
} else {
str = "SUCCESS";
}
} else {
str = "Could not start screenshotr service! Try running Instruments tool from XCode on this device and see if it work, then try this again.";
}
return outPut(env, str);
}
int main(int argc, char *argv[])
{
lockdownd_client_t client = NULL;
idevice_t phone = NULL;
GError *err;
uint16_t port = 0;
afc_client_t afc = NULL;
if (argc > 1 && !strcasecmp(argv[1], "--debug")) {
idevice_set_debug_level(1);
} else {
idevice_set_debug_level(0);
}
if (IDEVICE_E_SUCCESS != idevice_new(&phone, NULL)) {
printf("No device found, is it plugged in?\n");
return 1;
}
if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(phone, &client, "afccheck")) {
idevice_free(phone);
return 1;
}
if (LOCKDOWN_E_SUCCESS == lockdownd_start_service(client, "com.apple.afc", &port) && !port) {
lockdownd_client_free(client);
idevice_free(phone);
fprintf(stderr, "Something went wrong when starting AFC.");
return 1;
}
afc_client_new(phone, port, &afc);
//makes sure thread environment is available
if (!g_thread_supported())
g_thread_init(NULL);
GThread *threads[NB_THREADS];
param data[NB_THREADS];
int i = 0;
for (i = 0; i < NB_THREADS; i++) {
data[i].afc = afc;
data[i].id = i + 1;
threads[i] = g_thread_create((GThreadFunc) check_afc, data + i, TRUE, &err);
}
for (i = 0; i < NB_THREADS; i++) {
g_thread_join(threads[i]);
}
lockdownd_client_free(client);
idevice_free(phone);
return 0;
}
static int itdb_iphone_post_notification(idevice_t device,
lockdownd_client_t client,
const char *notification)
{
np_client_t np = NULL;
#ifdef HAVE_LIBIMOBILEDEVICE_1_1_5
lockdownd_service_descriptor_t service = NULL;
lockdownd_start_service(client, "com.apple.mobile.notification_proxy", &service);
if (!service || !service->port) {
fprintf(stderr, "notification_proxy could not be started!\n");
return -1;
}
np_client_new(device, service, &np);
#else
uint16_t nport = 0;
lockdownd_start_service(client, "com.apple.mobile.notification_proxy", &nport);
if (!nport) {
fprintf(stderr, "notification_proxy could not be started!\n");
return -1;
}
np_client_new(device, nport, &np);
#endif
if(!np) {
fprintf(stderr, "connection to notification_proxy failed!\n");
return -1;
}
if(np_post_notification(np, notification)) {
fprintf(stderr, "failed to post notification!\n");
np_client_free(np);
return -1;
}
np_client_free(np);
return 0;
}
int startAFC() {
// start AFC service on lockdownd.
printf(" afc service\n");
lderr = lockdownd_start_service(gLockdown, "com.apple.afc", &port);
if (lderr != LOCKDOWN_E_SUCCESS) {
printf("%s afc service error%s\n", KRED, KNRM);
return -1;
}
return 0;
}
SWIGEXPORT jshort JNICALL Java_org_robovm_libimobiledevice_binding_libimobiledeviceJNI_lockdownd_1start_1service(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) {
jshort jresult = 0 ;
lockdownd_client_t arg1 = (lockdownd_client_t) 0 ;
char *arg2 = (char *) 0 ;
lockdownd_service_descriptor_t *arg3 = (lockdownd_service_descriptor_t *) 0 ;
lockdownd_error_t result;
(void)jenv;
(void)jcls;
arg1 = *(lockdownd_client_t *)&jarg1;
arg2 = 0;
if (jarg2) {
arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
if (!arg2) return 0;
}
arg3 = *(lockdownd_service_descriptor_t **)&jarg3;
result = (lockdownd_error_t)lockdownd_start_service(arg1,(char const *)arg2,arg3);
jresult = (jshort)result;
if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
return jresult;
}
/**
* Starts a new service on the specified device with given name and
* connects to it.
*
* @param device The device to connect to.
* @param service_name The name of the service to start.
* @param client Pointer that will point to a newly allocated service_client_t
* upon successful return. Must be freed using service_client_free() after
* use.
* @param label The label to use for communication. Usually the program name.
* Pass NULL to disable sending the label in requests to lockdownd.
*
* @return SERVICE_E_SUCCESS on success, or a SERVICE_E_* error code
* otherwise.
*/
service_error_t service_client_factory_start_service(idevice_t device, const char* service_name, void **client, const char* label, int16_t (*constructor_func)(idevice_t, lockdownd_service_descriptor_t, void**), int16_t *error_code)
{
*client = NULL;
lockdownd_client_t lckd = NULL;
if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(device, &lckd, label)) {
debug_info("Could not create a lockdown client.");
return SERVICE_E_START_SERVICE_ERROR;
}
lockdownd_service_descriptor_t service = NULL;
lockdownd_start_service(lckd, service_name, &service);
lockdownd_client_free(lckd);
if (!service || service->port == 0) {
debug_info("Could not start service %s!", service_name);
return SERVICE_E_START_SERVICE_ERROR;
}
int16_t ec;
if (constructor_func) {
ec = (int16_t)constructor_func(device, service, client);
} else {
ec = service_client_new(device, service, (service_client_t*)client);
}
if (error_code) {
*error_code = ec;
}
if (ec != SERVICE_E_SUCCESS) {
debug_info("Could not connect to service %s! Port: %i, error: %i", service_name, service->port, ec);
}
lockdownd_service_descriptor_free(service);
service = NULL;
return (ec == SERVICE_E_SUCCESS) ? SERVICE_E_SUCCESS : SERVICE_E_START_SERVICE_ERROR;
}
static void perform_notification(idevice_t phone, lockdownd_client_t client, const char *notification)
{
lockdownd_service_descriptor_t service = NULL;
np_client_t np;
lockdownd_start_service(client, "com.apple.mobile.notification_proxy", &service);
if (service && service->port) {
printf("::::::::::::::: np was started ::::::::::::\n");
np_client_new(phone, service, &np);
if (np) {
printf("::::::::: PostNotification %s\n", notification);
np_post_notification(np, notification);
np_client_free(np);
}
} else {
printf("::::::::::::::: np was NOT started ::::::::::::\n");
}
if (service) {
lockdownd_service_descriptor_free(service);
service = NULL;
}
}
int main(int argc, const char **argv)
{
char *errmsg = "";
idevice_t device = NULL;
lockdownd_client_t client = NULL;
lockdownd_service_descriptor_t service = NULL;
house_arrest_client_t hac = NULL;
const char *service_name = "com.apple.afc";
const char *appid = NULL;
char *device_name = NULL;
int result = 0;
char* udid = NULL;
int cmd = CMD_INTERACTIVE;
const char *cmdstr = NULL;
int i;
cwd = strdup("/");
/* parse cmdline args */
for (i = 1; i < argc; i++) {
if (str_is_equal(argv[i], "-d") || str_is_equal(argv[i], "--debug")) {
idevice_set_debug_level(1);
continue;
}
else if (str_is_equal(argv[i], "-u") || str_is_equal(argv[i], "--udid")) {
i++;
if (!argv[i] || (strlen(argv[i]) != 40)) {
print_usage(argc, argv);
exit(EXIT_FAILURE);
}
udid = strdup(argv[i]);
continue;
}
else if (str_is_equal(argv[i], "-2") || str_is_equal(argv[i], "--afc2")) {
service_name = "com.apple.afc2";
continue;
}
else if (str_is_equal(argv[i], "-a") || str_is_equal(argv[i], "--appid")) {
if (++i >= argc) {
print_usage(argc, argv);
exit(EXIT_FAILURE);
}
appid = argv[i];
}
else if (str_is_equal(argv[i], "-h") || str_is_equal(argv[i], "--help")) {
print_usage(argc, argv);
exit(EXIT_SUCCESS);
}
else if ((cmd = str_to_cmd(argv[i])) != CMD_UNKNOWN) {
cmdstr = argv[i];
i++;
break;
}
}
argc -= i;
argv += i;
/* Connect to device */
if (udid) {
result = idevice_new(&device, udid);
if (result != IDEVICE_E_SUCCESS)
errx(EXIT_FAILURE, "No device found with udid %s, is it plugged in?", udid);
}
else {
result = idevice_new(&device, NULL);
if (result != IDEVICE_E_SUCCESS)
errx(EXIT_FAILURE, "No device found, is it plugged in?");
idevice_get_udid(device, &udid);
}
/* Connect to lockdownd */
result = lockdownd_client_new_with_handshake(device, &client, "afccl");
if (result != LOCKDOWN_E_SUCCESS) {
asprintf(&errmsg, "ERROR: Connecting to lockdownd service failed!");
goto bail;
}
result = lockdownd_get_device_name(client, &device_name);
if ((result != LOCKDOWN_E_SUCCESS) || !device_name) {
asprintf(&errmsg, "ERROR: Could not get device name!");
goto bail;
}
if (appid) {
result = lockdownd_start_service(client, "com.apple.mobile.house_arrest", &service);
if (result != LOCKDOWN_E_SUCCESS || !service || !service->port) {
asprintf(&errmsg, "error starting house arrest service: (%d) %s", result, afc_strerror(result));
goto bail;
}
if (client) {
lockdownd_client_free(client);
client = NULL;
}
if (house_arrest_client_new(device, service, &hac) != HOUSE_ARREST_E_SUCCESS) {
asprintf(&errmsg, "could not connect to house_arrest service!\n");
goto bail;
}
if (service) {
lockdownd_service_descriptor_free(service);
service = NULL;
}
result = house_arrest_send_command(hac, "VendDocuments", appid);
if (result != HOUSE_ARREST_E_SUCCESS) {
asprintf(&errmsg, "error %d when trying to get VendDocuments\n", result);
goto bail;
}
plist_t dict = NULL;
if (house_arrest_get_result(hac, &dict) != HOUSE_ARREST_E_SUCCESS) {
if (house_arrest_get_result(hac, &dict) != HOUSE_ARREST_E_SUCCESS) {
asprintf(&errmsg, "hmmm....\n");
goto bail;
}
}
plist_t node = plist_dict_get_item(dict, "Error");
if (node) {
char *str = NULL;
plist_get_string_val(node, &str);
asprintf(&errmsg, "Error: %s\n", str);
if (str) free(str);
plist_free(dict);
dict = NULL;
goto bail;
}
node = plist_dict_get_item(dict, "Status");
if (node) {
char *str = NULL;
plist_get_string_val(node, &str);
if (str && (strcmp(str, "Complete") != 0)) {
printf("Warning: Status is not 'Complete' but '%s'\n", str);
}
if (str) free(str);
}
if (dict) {
plist_free(dict);
}
afc_error_t ae = afc_client_new_from_house_arrest_client(hac, &afc);
if (ae != AFC_E_SUCCESS) {
printf("afc error %d\n", ae);
}
}
else {
result = lockdownd_start_service(client, service_name, &service);
if (result != LOCKDOWN_E_SUCCESS || !service || !service->port) {
asprintf(&errmsg, "error starting AFC service: (%d) %s", result, afc_strerror(result));
goto bail;
}
/* Connect to AFC */
result = afc_client_new(device, service, &afc);
lockdownd_client_free(client);
idevice_free(device);
if (result != AFC_E_SUCCESS) {
errx(EXIT_FAILURE, "AFC connection failed (%d) %s", result, afc_strerror(result));
}
}
result = do_cmd(cmd, argc, argv);
if (hac)
house_arrest_client_free(hac);
afc_client_free(afc);
exit(result == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
bail:
if (hac)
house_arrest_client_free(hac);
if (service)
lockdownd_service_descriptor_free(service);
if (client)
lockdownd_client_free(client);
if (device)
idevice_free(device);
errx(EXIT_FAILURE, "%s", errmsg);
}
bool ibrowserAPI::init(F_SUCC,F_ERRO)
{
lockdownd_service_descriptor_t service = NULL;
if (NULL == device)
{
if (IDEVICE_E_SUCCESS != idevice_new(&device, NULL)) {
ERRO("idevice_new");
}
idevice_set_debug_level(1);
}
if (NULL == lockdownd_client)
{
if (LOCKDOWN_E_SUCCESS != (lockdownd_client_new_with_handshake(device, &lockdownd_client, CLIENT_LABEL))) {
ERRO("lockdownd_client_new_with_handshake");
}
}
if (NULL == instproxy_client)
{
if(LOCKDOWN_E_SUCCESS != (lockdownd_start_service(lockdownd_client,"com.apple.mobile.installation_proxy",&service) || !service->port))
{
ERRO("lockdownd_start_service com.apple.mobile.installation_proxy");
}
if(INSTPROXY_E_SUCCESS != instproxy_client_new(device,service,&instproxy_client) )
{
ERRO("instproxy_client_new");
}
}
if (NULL == afc_client)
{
if(LOCKDOWN_E_SUCCESS != (lockdownd_start_service(lockdownd_client,"com.apple.afc",&service)) || !service->port)
{
ERRO("lockdownd_start_service com.apple.afc");
}
if (afc_client_new(device, service, &afc_client) != AFC_E_SUCCESS) {
ERRO("afc_client_new");
}
}
if (NULL == sbservices_client)
{
if(LOCKDOWN_E_SUCCESS != (lockdownd_start_service(lockdownd_client,"com.apple.springboardservices",&service)) || !service->port)
{
ERRO("lockdownd_start_service com.apple.springboardservices");
}
if (sbservices_client_new(device, service, &sbservices_client) != AFC_E_SUCCESS) {
ERRO("sbservices_client_new");
}
}
return true;
}
int main(int argc, char *argv[])
{
int res = EXIT_FAILURE;
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
struct stat mst;
lockdownd_error_t ret = LOCKDOWN_E_SUCCESS;
memset(&opts, 0, sizeof(opts));
opts.service_name = AFC_SERVICE_NAME;
if (fuse_opt_parse(&args, NULL, ifuse_opts, ifuse_opt_proc) == -1) {
return EXIT_FAILURE;
}
if (!opts.mount_point) {
fprintf(stderr, "ERROR: No mount point specified\n");
return EXIT_FAILURE;
}
if (opts.device_udid && strlen(opts.device_udid) != 40) {
fprintf(stderr, "Invalid device UDID specified, length needs to be 40 characters\n");
return EXIT_FAILURE;
}
if (stat(opts.mount_point, &mst) < 0) {
if (errno == ENOENT) {
fprintf(stderr, "ERROR: the mount point specified does not exist\n");
return EXIT_FAILURE;
}
fprintf(stderr, "There was an error accessing the mount point: %s\n", strerror(errno));
return EXIT_FAILURE;
}
idevice_new(&phone, opts.device_udid ? opts.device_udid : NULL);
if (!phone) {
fprintf(stderr, "No device found, is it connected?\n");
fprintf(stderr, "If it is make sure that your user has permissions to access the raw usb device.\n");
fprintf(stderr, "If you're still having issues try unplugging the device and reconnecting it.\n");
return EXIT_FAILURE;
}
ret = lockdownd_client_new_with_handshake(phone, &control, "ifuse");
if (ret != LOCKDOWN_E_SUCCESS) {
idevice_free(phone);
if (ret == LOCKDOWN_E_PASSWORD_PROTECTED) {
fprintf(stderr, "Please disable the password protection on your device and try again.\n");
fprintf(stderr, "The device does not allow pairing as long as a password has been set.\n");
fprintf(stderr, "You can enable it again after the connection succeeded.\n");
} else {
fprintf(stderr, "Failed to connect to lockdownd service on the device.\n");
fprintf(stderr, "Try again. If it still fails try rebooting your device.\n");
}
return EXIT_FAILURE;
}
if (
#ifdef HAVE_LIBIMOBILEDEVICE_1_1_5
(lockdownd_start_service(control, opts.service_name, &opts.service) != LOCKDOWN_E_SUCCESS) || !opts.service
#else
(lockdownd_start_service(control, opts.service_name, &opts.port) != LOCKDOWN_E_SUCCESS) || !opts.port
#endif
) {
lockdownd_client_free(control);
idevice_free(phone);
fprintf(stderr, "Failed to start AFC service '%s' on the device.\n", opts.service_name);
if (!strcmp(opts.service_name, AFC2_SERVICE_NAME)) {
fprintf(stderr, "This service enables access to the root filesystem of your device.\n");
fprintf(stderr, "Your device needs to be jailbroken and have the AFC2 service installed.\n");
}
return EXIT_FAILURE;
}
#ifdef HAVE_LIBIMOBILEDEVICE_1_1
if (!strcmp(opts.service_name, HOUSE_ARREST_SERVICE_NAME)) {
#ifdef HAVE_LIBIMOBILEDEVICE_1_1_5
house_arrest_client_new(phone, opts.service, &house_arrest);
#else
house_arrest_client_new(phone, opts.port, &house_arrest);
#endif
if (!house_arrest) {
fprintf(stderr, "Could not start document sharing service!\n");
return EXIT_FAILURE;
}
if (house_arrest_send_command(house_arrest, "VendContainer", opts.appid) != HOUSE_ARREST_E_SUCCESS) {
fprintf(stderr, "Could not send VendContainer command!\n");
goto leave_err;
}
plist_t dict = NULL;
if (house_arrest_get_result(house_arrest, &dict) != HOUSE_ARREST_E_SUCCESS) {
fprintf(stderr, "Could not get result from document sharing service!\n");
goto leave_err;
}
plist_t node = plist_dict_get_item(dict, "Error");
if (node) {
char *str = NULL;
plist_get_string_val(node, &str);
fprintf(stderr, "ERROR: %s\n", str);
if (str) free(str);
goto leave_err;
}
plist_free(dict);
fuse_opt_add_arg(&args, "-omodules=subdir");
fuse_opt_add_arg(&args, "-osubdir=Documents");
}
#endif
res = fuse_main(args.argc, args.argv, &ifuse_oper, NULL);
#ifdef HAVE_LIBIMOBILEDEVICE_1_1
leave_err:
if (house_arrest) {
house_arrest_client_free(house_arrest);
}
#endif
return res;
}
int main(int argc, char **argv)
{
idevice_t device = NULL;
lockdownd_client_t lckd = NULL;
mobile_image_mounter_client_t mim = NULL;
afc_client_t afc = NULL;
lockdownd_service_descriptor_t service = NULL;
int res = -1;
char *image_path = NULL;
char *image_sig_path = NULL;
parse_opts(argc, argv);
argc -= optind;
argv += optind;
if (!list_mode) {
if (argc < 1) {
printf("ERROR: No IMAGE_FILE has been given!\n");
return -1;
}
image_path = strdup(argv[0]);
if (argc >= 2) {
image_sig_path = strdup(argv[1]);
} else {
if (asprintf(&image_sig_path, "%s.signature", image_path) < 0) {
printf("Out of memory?!\n");
return -1;
}
}
}
if (IDEVICE_E_SUCCESS != idevice_new(&device, udid)) {
printf("No device found, is it plugged in?\n");
return -1;
}
if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(device, &lckd, "ideviceimagemounter")) {
printf("ERROR: could not connect to lockdown. Exiting.\n");
goto leave;
}
lockdownd_start_service(lckd, "com.apple.mobile.mobile_image_mounter", &service);
if (!service || service->port == 0) {
printf("ERROR: Could not start mobile_image_mounter service!\n");
goto leave;
}
if (mobile_image_mounter_new(device, service, &mim) != MOBILE_IMAGE_MOUNTER_E_SUCCESS) {
printf("ERROR: Could not connect to mobile_image_mounter!\n");
goto leave;
}
if (service) {
lockdownd_service_descriptor_free(service);
service = NULL;
}
if (!list_mode) {
struct stat fst;
if ((lockdownd_start_service(lckd, "com.apple.afc", &service) !=
LOCKDOWN_E_SUCCESS) || !service || !service->port) {
fprintf(stderr, "Could not start com.apple.afc!\n");
goto leave;
}
if (afc_client_new(device, service, &afc) != AFC_E_SUCCESS) {
fprintf(stderr, "Could not connect to AFC!\n");
goto leave;
}
if (service) {
lockdownd_service_descriptor_free(service);
service = NULL;
}
if (stat(image_path, &fst) != 0) {
fprintf(stderr, "ERROR: stat: %s: %s\n", image_path, strerror(errno));
goto leave;
}
if (stat(image_sig_path, &fst) != 0) {
fprintf(stderr, "ERROR: stat: %s: %s\n", image_sig_path, strerror(errno));
goto leave;
}
}
lockdownd_client_free(lckd);
lckd = NULL;
mobile_image_mounter_error_t err;
plist_t result = NULL;
if (list_mode) {
/* list mounts mode */
if (!imagetype) {
imagetype = strdup("Developer");
}
err = mobile_image_mounter_lookup_image(mim, imagetype, &result);
free(imagetype);
if (err == MOBILE_IMAGE_MOUNTER_E_SUCCESS) {
res = 0;
if (xml_mode) {
print_xml(result);
} else {
plist_dict_to_string(result);
}
} else {
printf("Error: lookup_image returned %d\n", err);
}
} else {
char sig[8192];
size_t sig_length = 0;
FILE *f = fopen(image_sig_path, "rb");
if (!f) {
fprintf(stderr, "Error opening signature file '%s': %s\n", image_sig_path, strerror(errno));
goto leave;
}
sig_length = fread(sig, 1, sizeof(sig), f);
fclose(f);
if (sig_length == 0) {
fprintf(stderr, "Could not read signature from file '%s'\n", image_sig_path);
goto leave;
}
f = fopen(image_path, "rb");
if (!f) {
fprintf(stderr, "Error opening image file '%s': %s\n", image_path, strerror(errno));
goto leave;
}
char *targetname = NULL;
if (asprintf(&targetname, "%s/%s", PKG_PATH, "staging.dimage") < 0) {
fprintf(stderr, "Out of memory!?\n");
goto leave;
}
char *mountname = NULL;
if (asprintf(&mountname, "%s/%s", PATH_PREFIX, targetname) < 0) {
fprintf(stderr, "Out of memory!?\n");
goto leave;
}
printf("Copying '%s' --> '%s'\n", image_path, targetname);
char **strs = NULL;
if (afc_get_file_info(afc, PKG_PATH, &strs) != AFC_E_SUCCESS) {
if (afc_make_directory(afc, PKG_PATH) != AFC_E_SUCCESS) {
fprintf(stderr, "WARNING: Could not create directory '%s' on device!\n", PKG_PATH);
}
}
if (strs) {
int i = 0;
while (strs[i]) {
free(strs[i]);
i++;
}
free(strs);
}
uint64_t af = 0;
if ((afc_file_open(afc, targetname, AFC_FOPEN_WRONLY, &af) !=
AFC_E_SUCCESS) || !af) {
fclose(f);
fprintf(stderr, "afc_file_open on '%s' failed!\n", targetname);
goto leave;
}
char buf[8192];
size_t amount = 0;
do {
amount = fread(buf, 1, sizeof(buf), f);
if (amount > 0) {
uint32_t written, total = 0;
while (total < amount) {
written = 0;
if (afc_file_write(afc, af, buf, amount, &written) !=
AFC_E_SUCCESS) {
fprintf(stderr, "AFC Write error!\n");
break;
}
total += written;
}
if (total != amount) {
fprintf(stderr, "Error: wrote only %d of %d\n", total,
(unsigned int)amount);
afc_file_close(afc, af);
fclose(f);
goto leave;
}
}
}
while (amount > 0);
afc_file_close(afc, af);
fclose(f);
printf("done.\n");
printf("Mounting...\n");
if (!imagetype) {
imagetype = strdup("Developer");
}
err = mobile_image_mounter_mount_image(mim, mountname, sig, sig_length, imagetype, &result);
free(imagetype);
if (err == MOBILE_IMAGE_MOUNTER_E_SUCCESS) {
if (result) {
plist_t node = plist_dict_get_item(result, "Status");
if (node) {
char *status = NULL;
plist_get_string_val(node, &status);
if (status) {
if (!strcmp(status, "Complete")) {
printf("Done.\n");
res = 0;
} else {
printf("unexpected status value:\n");
if (xml_mode) {
print_xml(result);
} else {
plist_dict_to_string(result);
}
}
free(status);
} else {
printf("unexpected result:\n");
if (xml_mode) {
print_xml(result);
} else {
plist_dict_to_string(result);
}
}
}
node = plist_dict_get_item(result, "Error");
if (node) {
char *error = NULL;
plist_get_string_val(node, &error);
if (error) {
printf("Error: %s\n", error);
free(error);
} else {
printf("unexpected result:\n");
if (xml_mode) {
print_xml(result);
} else {
plist_dict_to_string(result);
}
}
} else {
if (xml_mode) {
print_xml(result);
} else {
plist_dict_to_string(result);
}
}
}
} else {
printf("Error: mount_image returned %d\n", err);
}
}
if (result) {
plist_free(result);
}
/* perform hangup command */
mobile_image_mounter_hangup(mim);
/* free client */
mobile_image_mounter_free(mim);
leave:
if (afc) {
afc_client_free(afc);
}
if (lckd) {
lockdownd_client_free(lckd);
}
idevice_free(device);
if (image_path)
free(image_path);
if (image_sig_path)
free(image_sig_path);
return res;
}
int main(int argc, char *argv[]) {
printf(" exVasi0n, tihmstar will pwn you :O\n");
printf(" waiting for device\n");
while (deviceConnect() != 0) {
sleep(1);
}
printf(" device found!\n");
// start lockdownd client.
if (startLockdownd() != 0) {
return -1;
}
// start AFC service on lockdownd.
if (startAFC() != 0) {
return -1;
}
// create an AFC client and connect to AFC service.
if (connectAFC() != 0) {
return -1;
}
afcerr = afc_make_directory(gAfc, "/evasi0n-install");
if (afcerr != AFC_E_SUCCESS) {
printf("%s Error creating dir %s\n\n", KRED, KNRM);
afc_client_free(gAfc);
idevice_free(gDevice);
return -1;
}
afcerr = afc_send_file(gAfc, "mylittlesecret.tar", "evasi0n-install/Cydia.tar");
if (afcerr != AFC_E_SUCCESS) {
printf("%s Error putting file.%s\n\n", KRED, KNRM);
return -1;
}
//reboot
// start lockdownd client.
printf(" lockdownd...\n");
lderr = lockdownd_client_new_with_handshake(gDevice, &gLockdown, "exVasi0n");
if (lderr != LOCKDOWN_E_SUCCESS) {
printf("%s [*] Unable to connect to lockdownd. Please reboot your device and try again.%s\n", KRED, KNRM);
return -1;
}
printf(" gonna reboot\n");
lderr = lockdownd_start_service(gLockdown, "com.apple.mobile.diagnostics_relay", &port);
if (lderr != LOCKDOWN_E_SUCCESS) {
printf("%s diag service error%s\n", KRED, KNRM);
return -1;
}
diagerr = diagnostics_relay_client_new(gDevice, port, &gDiag);
if (diagerr != DIAGNOSTICS_RELAY_E_SUCCESS) {
printf("%s diag client error %s %d\n", KRED, KNRM,diagerr);
lockdownd_client_free(gLockdown);
idevice_free(gDevice);
return -1;
}
diagerr = diagnostics_relay_restart(gDiag, DIAGNOSTICS_RELAY_ACTION_FLAG_DISPLAY_PASS);
if (diagerr != DIAGNOSTICS_RELAY_E_SUCCESS && diagerr != -2) {
printf("%s reboot error, reboot manually %d %s\n", KNRM,diagerr, KNRM);
lockdownd_client_free(gLockdown);
idevice_free(gDevice);
return -1;
}
printf(" done :P \n");
// thanks a lot to DarkMalloc allowing me to use parts of his breakout JB code <3
return 0;
}
int main(int argc, char **argv)
{
idevice_t dev = NULL;
lockdownd_client_t client = NULL;
house_arrest_client_t hac = NULL;
house_arrest_error_t res;
int i;
char *udid = NULL;
const char *appid = NULL;
int test_file_io = 0;
/* parse cmdline args */
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")) {
idevice_set_debug_level(1);
continue;
}
else if (!strcmp(argv[i], "-u") || !strcmp(argv[i], "--udid")) {
i++;
if (!argv[i] || (strlen(argv[i]) != 40)) {
print_usage(argc, argv);
return 0;
}
udid = strdup(argv[i]);
continue;
}
else if (!strcmp(argv[i], "-t") || !strcmp(argv[i], "--test")) {
test_file_io = 1;
continue;
}
else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
print_usage(argc, argv);
return 0;
}
else {
appid = argv[i];
break;
}
}
if (!appid) {
print_usage(argc, argv);
return 0;
}
if (idevice_new(&dev, udid) != IDEVICE_E_SUCCESS) {
printf("no device connected?!\n");
goto leave_cleanup;
}
if (lockdownd_client_new_with_handshake(dev, &client, NULL) != LOCKDOWN_E_SUCCESS) {
printf("could not connect to lockdownd!\n");
goto leave_cleanup;
}
uint16_t port = 0;
if (lockdownd_start_service(client, "com.apple.mobile.house_arrest", &port) != LOCKDOWN_E_SUCCESS) {
printf("could not start house_arrest service!\n");
goto leave_cleanup;
}
if (client) {
lockdownd_client_free(client);
client = NULL;
}
if (house_arrest_client_new(dev, port, &hac) != HOUSE_ARREST_E_SUCCESS) {
printf("could not connect to house_arrest service!\n");
goto leave_cleanup;
}
res = house_arrest_send_command(hac, "VendDocuments", appid);
if (res != HOUSE_ARREST_E_SUCCESS) {
printf("error %d when trying to get VendDocuments\n", res);
goto leave_cleanup;
}
plist_t dict = NULL;
if (house_arrest_get_result(hac, &dict) != HOUSE_ARREST_E_SUCCESS) {
if (house_arrest_get_result(hac, &dict) != HOUSE_ARREST_E_SUCCESS) {
printf("hmmm....\n");
goto leave_cleanup;
}
}
plist_t node = plist_dict_get_item(dict, "Error");
if (node) {
char *str = NULL;
plist_get_string_val(node, &str);
printf("Error: %s\n", str);
if (str) free(str);
plist_free(dict);
dict = NULL;
goto leave_cleanup;
}
node = plist_dict_get_item(dict, "Status");
if (node) {
char *str = NULL;
plist_get_string_val(node, &str);
if (str && (strcmp(str, "Complete") != 0)) {
printf("Warning: Status is not 'Complete' but '%s'\n", str);
}
if (str) free(str);
plist_free(dict);
dict = NULL;
}
if (dict) {
plist_free(dict);
}
afc_client_t afc = NULL;
afc_error_t ae = afc_client_new_from_house_arrest_client(hac, &afc);
if (ae != AFC_E_SUCCESS) {
printf("afc error %d\n", ae);
}
if (ae == AFC_E_SUCCESS) {
char **list = NULL;
afc_read_directory(afc, "/", &list);
printf("Directory contents:\n");
if (list) {
while (list[0]) {
if (strcmp(list[0], ".") && strcmp(list[0], "..")) {
puts(list[0]);
}
list++;
}
}
if (test_file_io) {
uint64_t tf = 0;
printf("\n==== Performing file tests ====\n");
printf("Opening file 'foobar' for writing: ");
if (afc_file_open(afc, "/foobar", AFC_FOPEN_RW, &tf) == AFC_E_SUCCESS) {
uint32_t wb = 0;
printf("OK\n");
printf("Writing to file: ");
if (afc_file_write(afc, tf, "test\r\n", 6, &wb) != AFC_E_SUCCESS) {
printf("ERROR\n");
} else {
printf("OK\n");
}
afc_file_close(afc, tf);
printf("Deleting file 'foobar': ");
if (afc_remove_path(afc, "/foobar") == AFC_E_SUCCESS) {
printf("OK\n");
} else {
printf("ERROR\n");
}
} else {
printf("ERROR\n");
}
}
afc_client_free(afc);
} else {
printf("failed to connect to afc service, error %d\n", ae);
}
leave_cleanup:
if (hac) {
house_arrest_client_free(hac);
}
if (client) {
lockdownd_client_free(client);
}
if (dev) {
idevice_free(dev);
}
return 0;
}
int main(int argc, char *argv[])
{
lockdownd_client_t client = NULL;
idevice_t phone = NULL;
idevice_set_debug_level(1);
if (IDEVICE_E_SUCCESS != idevice_new(&phone, NULL)) {
printf("No device found, is it plugged in?\n");
return -1;
}
char *udid = NULL;
if (IDEVICE_E_SUCCESS == idevice_get_udid(phone, &udid)) {
printf("DeviceUniqueID : %s\n", udid);
}
if (udid)
free(udid);
if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(phone, &client, "lckdclient")) {
idevice_free(phone);
return -1;
}
using_history();
int loop = 1;
while (loop) {
char *cmd = readline("> ");
if (cmd) {
char **args = get_tokens(cmd);
int len = 0;
while (args && args[len]) {
len++;
}
if (len > 0) {
add_history(cmd);
if (!strcmp(*args, "quit"))
loop = 0;
if (!strcmp(*args, "get") && len >= 2) {
plist_t value = NULL;
if (LOCKDOWN_E_SUCCESS == lockdownd_get_value(client, len == 3 ? *(args + 1):NULL, len == 3 ? *(args + 2):*(args + 1), &value))
{
char *xml = NULL;
uint32_t length;
plist_to_xml(value, &xml, &length);
printf("Success : value = %s\n", xml);
free(xml);
}
else
printf("Error\n");
if (value)
plist_free(value);
}
if (!strcmp(*args, "start") && len == 2) {
uint16_t port = 0;
if(LOCKDOWN_E_SUCCESS == lockdownd_start_service(client, *(args + 1), &port)) {
printf("started service %s on port %i\n", *(args + 1), port);
}
else
{
printf("failed to start service %s on device.\n", *(args + 1));
}
}
}
strfreev(args);
}
free(cmd);
cmd = NULL;
}
clear_history();
lockdownd_client_free(client);
idevice_free(phone);
return 0;
}
static void* preflight_worker_handle_device_add(void* userdata)
{
struct device_info *info = (struct device_info*)userdata;
struct idevice_private *_dev = (struct idevice_private*)malloc(sizeof(struct idevice_private));
_dev->udid = strdup(info->serial);
_dev->conn_type = CONNECTION_USBMUXD;
_dev->conn_data = (void*)(long)info->id;
idevice_t dev = (idevice_t)_dev;
lockdownd_client_t lockdown = NULL;
lockdownd_error_t lerr;
plist_t value = NULL;
char* version_str = NULL;
usbmuxd_log(LL_INFO, "%s: Starting preflight on device %s...", __func__, _dev->udid);
retry:
lerr = lockdownd_client_new(dev, &lockdown, "usbmuxd");
if (lerr != LOCKDOWN_E_SUCCESS) {
usbmuxd_log(LL_ERROR, "%s: ERROR: Could not connect to lockdownd on device %s, lockdown error %d", __func__, _dev->udid, lerr);
goto leave;
}
char *type = NULL;
lerr = lockdownd_query_type(lockdown, &type);
if (!type) {
usbmuxd_log(LL_ERROR, "%s: ERROR: Could not get lockdownd type from device %s, lockdown error %d", __func__, _dev->udid, lerr);
goto leave;
}
if (strcmp(type, "com.apple.mobile.lockdown") != 0) {
// make restore mode devices visible
free(type);
usbmuxd_log(LL_INFO, "%s: Finished preflight on device %s", __func__, _dev->udid);
client_device_add(info);
goto leave;
}
free(type);
int is_device_paired = 0;
char *host_id = NULL;
if (config_has_device_record(dev->udid)) {
config_device_record_get_host_id(dev->udid, &host_id);
lerr = lockdownd_start_session(lockdown, host_id, NULL, NULL);
if (host_id)
free(host_id);
if (lerr == LOCKDOWN_E_SUCCESS) {
usbmuxd_log(LL_INFO, "%s: StartSession success for device %s", __func__, _dev->udid);
usbmuxd_log(LL_INFO, "%s: Finished preflight on device %s", __func__, _dev->udid);
client_device_add(info);
goto leave;
}
usbmuxd_log(LL_INFO, "%s: StartSession failed on device %s, lockdown error %d", __func__, _dev->udid, lerr);
} else {
lerr = LOCKDOWN_E_INVALID_HOST_ID;
}
switch (lerr) {
case LOCKDOWN_E_INVALID_HOST_ID:
usbmuxd_log(LL_INFO, "%s: Device %s is not paired with this host.", __func__, _dev->udid);
break;
case LOCKDOWN_E_SSL_ERROR:
usbmuxd_log(LL_ERROR, "%s: The stored pair record for device %s is invalid. Removing.", __func__, _dev->udid);
if (config_remove_device_record(_dev->udid) == 0) {
lockdownd_client_free(lockdown);
lockdown = NULL;
goto retry;
} else {
usbmuxd_log(LL_ERROR, "%s: Could not remove pair record for device %s", __func__, _dev->udid);
}
break;
default:
is_device_paired = 1;
break;
}
lerr = lockdownd_get_value(lockdown, NULL, "ProductVersion", &value);
if (lerr != LOCKDOWN_E_SUCCESS) {
usbmuxd_log(LL_ERROR, "%s: ERROR: Could not get ProductVersion from device %s, lockdown error %d", __func__, _dev->udid, lerr);
goto leave;
}
if (value && plist_get_node_type(value) == PLIST_STRING) {
plist_get_string_val(value, &version_str);
}
if (!version_str) {
usbmuxd_log(LL_ERROR, "%s: Could not get ProductVersion string from device %s handle %d", __func__, _dev->udid, (int)(long)_dev->conn_data);
goto leave;
}
int version_major = strtol(version_str, NULL, 10);
if (version_major >= 7) {
/* iOS 7.0 and later */
usbmuxd_log(LL_INFO, "%s: Found ProductVersion %s device %s", __func__, version_str, _dev->udid);
lockdownd_set_untrusted_host_buid(lockdown);
/* if not paired, trigger the trust dialog to make sure it appears */
if (!is_device_paired) {
if (lockdownd_pair(lockdown, NULL) == LOCKDOWN_E_SUCCESS) {
/* if device is still showing the setup screen it will pair even without trust dialog */
usbmuxd_log(LL_INFO, "%s: Pair success for device %s", __func__, _dev->udid);
usbmuxd_log(LL_INFO, "%s: Finished preflight on device %s", __func__, _dev->udid);
client_device_add(info);
goto leave;
}
}
lockdownd_service_descriptor_t service = NULL;
lerr = lockdownd_start_service(lockdown, "com.apple.mobile.insecure_notification_proxy", &service);
if (lerr != LOCKDOWN_E_SUCCESS) {
usbmuxd_log(LL_ERROR, "%s: ERROR: Could not start insecure_notification_proxy on %s, lockdown error %d", __func__, _dev->udid, lerr);
goto leave;
}
np_client_t np = NULL;
np_client_new(dev, service, &np);
lockdownd_service_descriptor_free(service);
service = NULL;
lockdownd_client_free(lockdown);
lockdown = NULL;
struct cb_data cbdata;
cbdata.dev = dev;
cbdata.np = np;
cbdata.is_device_connected = 1;
np_set_notify_callback(np, np_callback, (void*)&cbdata);
device_set_preflight_cb_data(info->id, (void*)&cbdata);
const char* spec[] = {
"com.apple.mobile.lockdown.request_pair",
"com.apple.mobile.lockdown.request_host_buid",
NULL
};
np_observe_notifications(np, spec);
/* TODO send notification to user's desktop */
usbmuxd_log(LL_INFO, "%s: Waiting for user to trust this computer on device %s", __func__, _dev->udid);
/* make device visible anyways */
client_device_add(info);
while (cbdata.np && cbdata.is_device_connected == 1) {
sleep(1);
}
device_set_preflight_cb_data(info->id, NULL);
usbmuxd_log(LL_INFO, "%s: Finished waiting for notification from device %s, is_device_connected %d", __func__, _dev->udid, cbdata.is_device_connected);
if (cbdata.np) {
np_client_free(cbdata.np);
}
} else {
/* iOS 6.x and earlier */
lerr = lockdownd_pair(lockdown, NULL);
if (lerr != LOCKDOWN_E_SUCCESS) {
if (lerr == LOCKDOWN_E_PASSWORD_PROTECTED) {
usbmuxd_log(LL_INFO, "%s: Device %s is locked with a passcode. Cannot pair.", __func__, _dev->udid);
/* TODO send notification to user's desktop */
} else {
usbmuxd_log(LL_ERROR, "%s: ERROR: Pair failed for device %s, lockdown error %d", __func__, _dev->udid, lerr);
}
usbmuxd_log(LL_INFO, "%s: Finished preflight on device %s", __func__, _dev->udid);
/* make device visible anyways */
client_device_add(info);
goto leave;
}
host_id = NULL;
config_device_record_get_host_id(dev->udid, &host_id);
lerr = lockdownd_start_session(lockdown, host_id, NULL, NULL);
free(host_id);
if (lerr != LOCKDOWN_E_SUCCESS) {
usbmuxd_log(LL_ERROR, "%s: ERROR StartSession failed on device %s, lockdown error %d", __func__, _dev->udid, lerr);
goto leave;
}
lerr = lockdownd_validate_pair(lockdown, NULL);
if (lerr != LOCKDOWN_E_SUCCESS) {
usbmuxd_log(LL_ERROR, "%s: ERROR: ValidatePair failed for device %s, lockdown error %d", __func__, _dev->udid, lerr);
goto leave;
}
usbmuxd_log(LL_INFO, "%s: Finished preflight on device %s", __func__, _dev->udid);
/* emit device added event and thus make device visible to clients */
client_device_add(info);
}
leave:
if (value)
plist_free(value);
if (version_str)
free(version_str);
if (lockdown)
lockdownd_client_free(lockdown);
if (dev)
idevice_free(dev);
free(info);
return NULL;
}
int main(int argc, char **argv)
{
idevice_t device = NULL;
lockdownd_client_t lckd = NULL;
lockdownd_error_t ldret = LOCKDOWN_E_UNKNOWN_ERROR;
screenshotr_client_t shotr = NULL;
lockdownd_service_descriptor_t service = NULL;
int result = -1;
int i;
const char *udid = NULL;
char *filename = NULL;
/* parse cmdline args */
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")) {
idevice_set_debug_level(1);
continue;
}
else if (!strcmp(argv[i], "-u") || !strcmp(argv[i], "--udid")) {
i++;
if (!argv[i] || (strlen(argv[i]) != 40)) {
print_usage(argc, argv);
return 0;
}
udid = argv[i];
continue;
}
else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
print_usage(argc, argv);
return 0;
}
else if (argv[i][0] != '-' && !filename) {
filename = strdup(argv[i]);
continue;
}
else {
print_usage(argc, argv);
return 0;
}
}
if (IDEVICE_E_SUCCESS != idevice_new(&device, udid)) {
if (udid) {
printf("No device found with udid %s, is it plugged in?\n", udid);
} else {
printf("No device found, is it plugged in?\n");
}
return -1;
}
if (LOCKDOWN_E_SUCCESS != (ldret = lockdownd_client_new_with_handshake(device, &lckd, NULL))) {
idevice_free(device);
printf("ERROR: Could not connect to lockdownd, error code %d\n", ldret);
return -1;
}
lockdownd_start_service(lckd, "com.apple.mobile.screenshotr", &service);
lockdownd_client_free(lckd);
if (service && service->port > 0) {
if (screenshotr_client_new(device, service, &shotr) != SCREENSHOTR_E_SUCCESS) {
printf("Could not connect to screenshotr!\n");
} else {
char *imgdata = NULL;
uint64_t imgsize = 0;
if (screenshotr_take_screenshot(shotr, &imgdata, &imgsize) == SCREENSHOTR_E_SUCCESS) {
if (!filename) {
const char *fileext = NULL;
if (memcmp(imgdata, "\x89PNG", 4) == 0) {
fileext = ".png";
} else if (memcmp(imgdata, "MM\x00*", 4) == 0) {
fileext = ".tiff";
} else {
printf("WARNING: screenshot data has unexpected image format.\n");
fileext = ".dat";
}
time_t now = time(NULL);
filename = (char*)malloc(36);
size_t pos = strftime(filename, 36, "screenshot-%Y-%m-%d-%H-%M-%S", gmtime(&now));
sprintf(filename+pos, "%s", fileext);
}
FILE *f = fopen(filename, "wb");
if (f) {
if (fwrite(imgdata, 1, (size_t)imgsize, f) == (size_t)imgsize) {
printf("Screenshot saved to %s\n", filename);
result = 0;
} else {
printf("Could not save screenshot to file %s!\n", filename);
}
fclose(f);
} else {
printf("Could not open %s for writing: %s\n", filename, strerror(errno));
}
} else {
printf("Could not get screenshot!\n");
}
screenshotr_client_free(shotr);
}
} else {
printf("Could not start screenshotr service! Remember that you have to mount the Developer disk image on your device if you want to use the screenshotr service.\n");
}
if (service)
lockdownd_service_descriptor_free(service);
idevice_free(device);
free(filename);
return result;
}
int main(int argc, char *argv[])
{
lockdownd_client_t client = NULL;
lockdownd_error_t ldret = LOCKDOWN_E_UNKNOWN_ERROR;
lockdownd_service_descriptor_t service = NULL;
idevice_t device = NULL;
idevice_error_t ret = IDEVICE_E_UNKNOWN_ERROR;
int i;
int op = -1;
int output_xml = 0;
const char* udid = NULL;
const char* param = NULL;
/* parse cmdline args */
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")) {
idevice_set_debug_level(1);
continue;
}
else if (!strcmp(argv[i], "-u") || !strcmp(argv[i], "--udid")) {
i++;
if (!argv[i] || (strlen(argv[i]) != 40)) {
print_usage(argc, argv);
return 0;
}
udid = argv[i];
continue;
}
else if (!strcmp(argv[i], "install")) {
i++;
if (!argv[i] || (strlen(argv[i]) < 1)) {
print_usage(argc, argv);
return 0;
}
param = argv[i];
op = OP_INSTALL;
continue;
}
else if (!strcmp(argv[i], "list")) {
op = OP_LIST;
}
else if (!strcmp(argv[i], "copy")) {
i++;
if (!argv[i] || (strlen(argv[i]) < 1)) {
print_usage(argc, argv);
return 0;
}
param = argv[i];
op = OP_COPY;
continue;
}
else if (!strcmp(argv[i], "remove")) {
i++;
if (!argv[i] || (strlen(argv[i]) < 1)) {
print_usage(argc, argv);
return 0;
}
param = argv[i];
op = OP_REMOVE;
continue;
}
else if (!strcmp(argv[i], "dump")) {
i++;
if (!argv[i] || (strlen(argv[i]) < 1)) {
print_usage(argc, argv);
return 0;
}
param = argv[i];
op = OP_DUMP;
continue;
}
else if (!strcmp(argv[i], "-x") || !strcmp(argv[i], "--xml")) {
output_xml = 1;
continue;
}
else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
print_usage(argc, argv);
return 0;
}
else {
print_usage(argc, argv);
return 0;
}
}
if ((op == -1) || (op >= NUM_OPS)) {
print_usage(argc, argv);
return 0;
}
if (op == OP_DUMP) {
int res = 0;
unsigned char* profile_data = NULL;
unsigned int profile_size = 0;
if (profile_read_from_file(param, &profile_data, &profile_size) != 0) {
return -1;
}
plist_t pdata = plist_new_data((char*)profile_data, profile_size);
plist_t pl = profile_get_embedded_plist(pdata);
plist_free(pdata);
free(profile_data);
if (pl) {
if (output_xml) {
char* xml = NULL;
uint32_t xlen = 0;
plist_to_xml(pl, &xml, &xlen);
if (xml) {
printf("%s\n", xml);
free(xml);
}
} else {
if (pl && (plist_get_node_type(pl) == PLIST_DICT)) {
plist_print_to_stream(pl, stdout);
} else {
fprintf(stderr, "ERROR: unexpected node type in profile plist (not PLIST_DICT)\n");
res = -1;
}
}
} else {
fprintf(stderr, "ERROR: could not extract embedded plist from profile!\n");
}
plist_free(pl);
return res;
}
ret = idevice_new(&device, udid);
if (ret != IDEVICE_E_SUCCESS) {
if (udid) {
printf("No device found with udid %s, is it plugged in?\n", udid);
} else {
printf("No device found, is it plugged in?\n");
}
return -1;
}
if (LOCKDOWN_E_SUCCESS != (ldret = lockdownd_client_new_with_handshake(device, &client, "ideviceprovision"))) {
fprintf(stderr, "ERROR: Could not connect to lockdownd, error code %d\n", ldret);
idevice_free(device);
return -1;
}
if (LOCKDOWN_E_SUCCESS != lockdownd_start_service(client, "com.apple.misagent", &service)) {
fprintf(stderr, "Could not start service \"com.apple.misagent\"\n");
lockdownd_client_free(client);
idevice_free(device);
return -1;
}
lockdownd_client_free(client);
client = NULL;
misagent_client_t mis = NULL;
if (misagent_client_new(device, service, &mis) != MISAGENT_E_SUCCESS) {
fprintf(stderr, "Could not connect to \"com.apple.misagent\" on device\n");
if (service)
lockdownd_service_descriptor_free(service);
lockdownd_client_free(client);
idevice_free(device);
return -1;
}
if (service)
lockdownd_service_descriptor_free(service);
switch (op) {
case OP_INSTALL:
{
unsigned char* profile_data = NULL;
unsigned int profile_size = 0;
if (profile_read_from_file(param, &profile_data, &profile_size) != 0) {
break;
}
uint64_t psize = profile_size;
plist_t pdata = plist_new_data((const char*)profile_data, psize);
free(profile_data);
if (misagent_install(mis, pdata) == MISAGENT_E_SUCCESS) {
printf("Profile '%s' installed successfully.\n", param);
} else {
int sc = misagent_get_status_code(mis);
fprintf(stderr, "Could not install profile '%s', status code: 0x%x\n", param, sc);
}
}
break;
case OP_LIST:
case OP_COPY:
{
plist_t profiles = NULL;
if (misagent_copy(mis, &profiles) == MISAGENT_E_SUCCESS) {
uint32_t num_profiles = plist_array_get_size(profiles);
printf("Device has %d provisioning %s installed:\n", num_profiles, (num_profiles == 1) ? "profile" : "profiles");
uint32_t j;
for (j = 0; j < num_profiles; j++) {
char* p_name = NULL;
char* p_uuid = NULL;
plist_t profile = plist_array_get_item(profiles, j);
plist_t pl = profile_get_embedded_plist(profile);
if (pl && (plist_get_node_type(pl) == PLIST_DICT)) {
plist_t node;
node = plist_dict_get_item(pl, "Name");
if (node && (plist_get_node_type(node) == PLIST_STRING)) {
plist_get_string_val(node, &p_name);
}
node = plist_dict_get_item(pl, "UUID");
if (node && (plist_get_node_type(node) == PLIST_STRING)) {
plist_get_string_val(node, &p_uuid);
}
}
printf("%s - %s\n", (p_uuid) ? p_uuid : "(unknown id)", (p_name) ? p_name : "(no name)");
if (op == OP_COPY) {
char pfname[512];
if (p_uuid) {
sprintf(pfname, "%s/%s.mobileprovision", param, p_uuid);
} else {
sprintf(pfname, "%s/profile%d.mobileprovision", param, j);
}
FILE* f = fopen(pfname, "wb");
if (f) {
char* dt = NULL;
uint64_t ds = 0;
plist_get_data_val(profile, &dt, &ds);
fwrite(dt, 1, ds, f);
fclose(f);
printf(" => %s\n", pfname);
} else {
fprintf(stderr, "Could not open '%s' for writing\n", pfname);
}
}
if (p_uuid) {
free(p_uuid);
}
if (p_name) {
free(p_name);
}
}
} else {
int sc = misagent_get_status_code(mis);
fprintf(stderr, "Could not get installed profiles from device, status code: 0x%x\n", sc);
}
}
break;
case OP_REMOVE:
if (misagent_remove(mis, param) == MISAGENT_E_SUCCESS) {
printf("Profile '%s' removed.\n", param);
} else {
int sc = misagent_get_status_code(mis);
fprintf(stderr, "Could not remove profile '%s', status code 0x%x\n", param, sc);
}
break;
default:
break;
}
misagent_client_free(mis);
idevice_free(device);
return 0;
}
int main(int argc, char **argv) {
idevice_t phone = NULL;
lockdownd_client_t client = NULL;
uint16_t port = 0;
char* crashLogFile;
if(argc != 2) {
print_usage(argc, argv);
return -1;
}
crashLogFile = argv[1];
if (idevice_new(&phone, NULL) != IDEVICE_E_SUCCESS) {
printf("No device found, is it plugged in?\n");
return -1;
}
if (lockdownd_client_new_with_handshake(phone, &client, "idevicecrashlog") != LOCKDOWN_E_SUCCESS) {
fprintf(stderr, "Could not connect to lockdownd. Exiting.\n");
return -1;
}
if ((lockdownd_start_service(client, "com.apple.mobile.file_relay", &port) !=
LOCKDOWN_E_SUCCESS) || !port) {
fprintf(stderr, "Could not start com.apple.mobile.file_relay!\n");
return -1;
}
const char *sources[] = {"CrashReporter", NULL};
idevice_connection_t dump = NULL;
file_relay_client_t frc = NULL;
if (file_relay_client_new(phone, port, &frc) != FILE_RELAY_E_SUCCESS) {
printf("could not connect to file_relay service!\n");
return -1;
}
if (file_relay_request_sources(frc, sources, &dump) != FILE_RELAY_E_SUCCESS) {
printf("could not get sources\n");
return -1;
}
if (!dump) {
printf("did not get connection!\n");
return -1;
}
uint32_t cnt = 0;
uint32_t len = 0;
char buf[4096];
char* dumpTmpFile = tmpnam(NULL);
FILE *f = fopen(dumpTmpFile, "w");
//receiving file
while (idevice_connection_receive(dump, buf, 4096, &len) == IDEVICE_E_SUCCESS) {
fwrite(buf, 1, len, f);
cnt += len;
len = 0;
}
fclose(f);
extract_file(dumpTmpFile, crashLogFile);
lockdownd_client_free(client);
}
int main(int argc, char *argv[])
{
lockdownd_client_t lockdown = NULL;
idevice_t device = NULL;
idevice_connection_t connection = NULL;
idevice_error_t ret = IDEVICE_E_UNKNOWN_ERROR;
thread_t th;
const char* udid = NULL;
lockdownd_service_descriptor_t service = NULL;
uint16_t local_port = 0;
int result = EXIT_SUCCESS;
int i;
/* bind signals */
signal(SIGINT, clean_exit);
signal(SIGTERM, clean_exit);
#ifndef WIN32
signal(SIGQUIT, clean_exit);
signal(SIGPIPE, SIG_IGN);
#endif
/* parse cmdline arguments */
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")) {
debug_mode = 1;
idevice_set_debug_level(1);
socket_set_verbose(3);
continue;
}
else if (!strcmp(argv[i], "-u") || !strcmp(argv[i], "--udid")) {
i++;
if (!argv[i] || (strlen(argv[i]) != 40)) {
print_usage(argc, argv);
return 0;
}
udid = argv[i];
continue;
}
else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
print_usage(argc, argv);
return EXIT_SUCCESS;
}
else if (atoi(argv[i]) > 0) {
local_port = atoi(argv[i]);
continue;
}
else {
print_usage(argc, argv);
return EXIT_SUCCESS;
}
}
/* a PORT is mandatory */
if (!local_port) {
fprintf(stderr, "Please specify a PORT.\n");
print_usage(argc, argv);
goto leave_cleanup;
}
/* start services and connect to device */
ret = idevice_new(&device, udid);
if (ret != IDEVICE_E_SUCCESS) {
if (udid) {
fprintf(stderr, "No device found with udid %s, is it plugged in?\n", udid);
} else {
fprintf(stderr, "No device found, is it plugged in?\n");
}
result = EXIT_FAILURE;
goto leave_cleanup;
}
if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(device, &lockdown, "idevicedebugserverproxy")) {
fprintf(stderr, "Could not connect to lockdownd. Exiting.\n");
result = EXIT_FAILURE;
goto leave_cleanup;
}
if ((lockdownd_start_service(lockdown, "com.apple.debugserver", &service) != LOCKDOWN_E_SUCCESS) || !service || !service->port) {
fprintf(stderr, "Could not start com.apple.debugserver!\nPlease make sure to mount the developer disk image first.\n");
result = EXIT_FAILURE;
goto leave_cleanup;
}
if (idevice_connect(device, service->port, &connection) != IDEVICE_E_SUCCESS) {
fprintf(stderr, "Connection to debugserver port %d failed!\n", (int)service->port);
result = EXIT_FAILURE;
goto leave_cleanup;
}
/* free lockdown connection if running as it is not needed anymore */
if (lockdown) {
lockdownd_client_free(lockdown);
lockdown = NULL;
}
/* setup and create socket endpoint */
socket_info_t socket_info;
socket_info.device_connection = connection;
socket_info.local_port = local_port;
socket_info.remote_port = service->port;
if (service) {
lockdownd_service_descriptor_free(service);
service = NULL;
}
/* create local socket */
socket_info.server_fd = socket_create(socket_info.local_port);
if (socket_info.server_fd < 0) {
fprintf(stderr, "Could not create socket\n");
result = EXIT_FAILURE;
goto leave_cleanup;
}
while (!quit_flag) {
debug("%s: Waiting for connection on local port %d\n", __func__, socket_info.local_port);
/* wait for client */
socket_info.client_fd = socket_accept(socket_info.server_fd, socket_info.local_port);
if (socket_info.client_fd < 0) {
debug("%s: Continuing...\n", __func__);
continue;
}
debug("%s: Handling new client connection...\n", __func__);
if (thread_create(&th, connection_handler, (void*)&socket_info) != 0) {
fprintf(stderr, "Could not start connection handler.\n");
socket_shutdown(socket_info.server_fd, SHUT_RDWR);
socket_close(socket_info.server_fd);
}
}
debug("%s: Shutting down debugserver proxy...\n", __func__);
leave_cleanup:
if (connection) {
idevice_disconnect(connection);
}
if (lockdown) {
lockdownd_client_free(lockdown);
}
if (device) {
idevice_free(device);
}
return result;
}
int wi_connect(const char *device_id, char **to_device_id,
char **to_device_name, int recv_timeout) {
int ret = -1;
idevice_t phone = NULL;
plist_t node = NULL;
lockdownd_service_descriptor_t service = NULL;
lockdownd_client_t client = NULL;
idevice_connection_t connection = NULL;
int fd = -1;
// get phone
if (idevice_new(&phone, device_id)) {
perror("No iPhone found, is it plugged in?");
goto leave_cleanup;
}
// connect to lockdownd
if (lockdownd_client_new_with_handshake(
phone, &client, "ios_webkit_debug_proxy")) {
perror("Could not connect to lockdownd. Exiting.");
goto leave_cleanup;
}
// get device info
if (to_device_id &&
!lockdownd_get_value(client, NULL, "UniqueDeviceID", &node)) {
plist_get_string_val(node, to_device_id);
plist_free(node);
node = NULL;
}
if (to_device_name &&
!lockdownd_get_value(client, NULL, "DeviceName", &node)) {
plist_get_string_val(node, to_device_name);
}
// start webinspector, get port
if (lockdownd_start_service(client, "com.apple.webinspector", &service) ||
!service->port) {
perror("Could not start com.apple.webinspector!");
goto leave_cleanup;
}
// connect to webinspector
if (idevice_connect(phone, service->port, &connection)) {
perror("idevice_connect failed!");
goto leave_cleanup;
}
if (client) {
// not needed anymore
lockdownd_client_free(client);
client = NULL;
}
// extract the connection fd
if (idevice_connection_get_fd(connection, &fd)) {
perror("Unable to get connection file descriptor.");
goto leave_cleanup;
}
if (recv_timeout < 0) {
int opts = fcntl(fd, F_GETFL);
if (!opts || fcntl(fd, F_SETFL, (opts | O_NONBLOCK)) < 0) {
perror("Could not set socket to non-blocking");
goto leave_cleanup;
}
} else {
long millis = (recv_timeout > 0 ? recv_timeout : 5000);
struct timeval tv;
tv.tv_sec = (time_t) (millis / 1000);
tv.tv_usec = (time_t) ((millis - (tv.tv_sec * 1000)) * 1000);
if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv,
sizeof(tv))) {
perror("Could not set socket receive timeout");
goto leave_cleanup;
}
}
// success
ret = fd;
leave_cleanup:
if (ret < 0 && fd > 0) {
close(fd);
}
// don't call usbmuxd_disconnect(fd)!
//idevice_disconnect(connection);
free(connection);
lockdownd_client_free(client);
plist_free(node);
idevice_free(phone);
return ret;
}
int main(int argc, char *argv[])
{
unsigned int bytes = 0;
uint16_t i = 0;
lockdownd_service_descriptor_t service = NULL;
lockdownd_client_t client = NULL;
idevice_t phone = NULL;
uint64_t lockfile = 0;
np_client_t gnp = NULL;
if (argc > 1 && !strcasecmp(argv[1], "--debug")) {
idevice_set_debug_level(1);
} else {
idevice_set_debug_level(0);
}
if (IDEVICE_E_SUCCESS != idevice_new(&phone, NULL)) {
printf("No device found, is it plugged in?\n");
return -1;
}
char *udid = NULL;
if (IDEVICE_E_SUCCESS == idevice_get_udid(phone, &udid)) {
printf("DeviceUniqueID : %s\n", udid);
}
if (udid)
free(udid);
if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(phone, &client, "ideviceclient")) {
idevice_free(phone);
printf("Exiting.\n");
return -1;
}
char *nnn = NULL;
if (LOCKDOWN_E_SUCCESS == lockdownd_get_device_name(client, &nnn)) {
printf("DeviceName : %s\n", nnn);
free(nnn);
}
lockdownd_start_service(client, "com.apple.afc", &service);
if (service && service->port) {
afc_client_t afc = NULL;
afc_client_new(phone, service, &afc);
if (afc) {
service->port = 0;
service->ssl_enabled = 0;
lockdownd_start_service(client, "com.apple.mobile.notification_proxy", &service);
if (service->port) {
printf("Notification Proxy started.\n");
np_client_new(phone, service, &gnp);
} else {
printf("ERROR: Notification proxy could not be started.\n");
}
if (gnp) {
const char *nspec[5] = {
NP_SYNC_CANCEL_REQUEST,
NP_SYNC_SUSPEND_REQUEST,
NP_SYNC_RESUME_REQUEST,
NP_ITDBPREP_DID_END,
NULL
};
np_observe_notifications(gnp, nspec);
np_set_notify_callback(gnp, notifier, NULL);
}
perform_notification(phone, client, NP_SYNC_WILL_START);
afc_file_open(afc, "/com.apple.itunes.lock_sync", AFC_FOPEN_RW, &lockfile);
if (lockfile) {
printf("locking file\n");
afc_file_lock(afc, lockfile, AFC_LOCK_EX);
perform_notification(phone, client, NP_SYNC_DID_START);
}
char **dirs = NULL;
afc_read_directory(afc, "/eafaedf", &dirs);
if (!dirs)
afc_read_directory(afc, "/", &dirs);
printf("Directory time.\n");
for (i = 0; dirs[i]; i++) {
printf("/%s\n", dirs[i]);
free(dirs[i]);
}
if (dirs)
free(dirs);
dirs = NULL;
afc_get_device_info(afc, &dirs);
if (dirs) {
for (i = 0; dirs[i]; i += 2) {
printf("%s: %s\n", dirs[i], dirs[i + 1]);
free(dirs[i]);
}
free(dirs);
}
uint64_t my_file = 0;
char **info = NULL;
uint64_t fsize = 0;
if (AFC_E_SUCCESS == afc_get_file_info(afc, "/readme.libimobiledevice.fx", &info) && info) {
for (i = 0; info[i]; i += 2) {
printf("%s: %s\n", info[i], info[i+1]);
if (!strcmp(info[i], "st_size")) {
fsize = atoll(info[i+1]);
}
}
}
if (AFC_E_SUCCESS ==
afc_file_open(afc, "/readme.libimobiledevice.fx", AFC_FOPEN_RDONLY, &my_file) && my_file) {
printf("A file size: %llu\n", (long long)fsize);
char *file_data = (char *) malloc(sizeof(char) * fsize);
afc_file_read(afc, my_file, file_data, fsize, &bytes);
if (bytes > 0) {
printf("The file's data:\n");
fwrite(file_data, 1, bytes, stdout);
}
printf("\nClosing my file.\n");
afc_file_close(afc, my_file);
free(file_data);
} else
printf("couldn't open a file\n");
afc_file_open(afc, "/readme.libimobiledevice.fx", AFC_FOPEN_WR, &my_file);
if (my_file) {
char *outdatafile = strdup("this is a bitchin text file\n");
afc_file_write(afc, my_file, outdatafile, strlen(outdatafile), &bytes);
free(outdatafile);
if (bytes > 0)
printf("Wrote a surprise. ;)\n");
else
printf("I wanted to write a surprise, but... :(\n");
afc_file_close(afc, my_file);
}
printf("Deleting a file...\n");
bytes = afc_remove_path(afc, "/delme");
if (bytes)
printf("Success.\n");
else
printf("Failure. (expected unless you have a /delme file on your phone)\n");
printf("Renaming a file...\n");
bytes = afc_rename_path(afc, "/renme", "/renme2");
if (bytes > 0)
printf("Success.\n");
else
printf("Failure. (expected unless you have a /renme file on your phone)\n");
printf("Seek & read\n");
afc_file_open(afc, "/readme.libimobiledevice.fx", AFC_FOPEN_RDONLY, &my_file);
if (AFC_E_SUCCESS != afc_file_seek(afc, my_file, 5, SEEK_CUR))
printf("WARN: SEEK DID NOT WORK\n");
char *threeletterword = (char *) malloc(sizeof(char) * 5);
afc_file_read(afc, my_file, threeletterword, 3, &bytes);
threeletterword[3] = '\0';
if (bytes > 0)
printf("Result: %s\n", threeletterword);
else
printf("Couldn't read!\n");
free(threeletterword);
afc_file_close(afc, my_file);
}
if (gnp && lockfile) {
printf("XXX sleeping\n");
sleep(5);
printf("XXX unlocking file\n");
afc_file_lock(afc, lockfile, AFC_LOCK_UN);
printf("XXX closing file\n");
afc_file_close(afc, lockfile);
printf("XXX sleeping\n");
sleep(5);
//perform_notification(phone, client, NP_SYNC_DID_FINISH);
}
if (gnp) {
np_client_free(gnp);
gnp = NULL;
}
afc_client_free(afc);
lockdownd_service_descriptor_free(service);
service = NULL;
} else {
printf("Start service failure.\n");
}
printf("All done.\n");
lockdownd_client_free(client);
idevice_free(phone);
return 0;
}
int main(int argc, char *argv[])
{
lockdownd_client_t client = NULL;
lockdownd_service_descriptor_t service = NULL;
idevice_t device = NULL;
idevice_error_t ret = IDEVICE_E_UNKNOWN_ERROR;
int i;
int op = -1;
const char* udid = NULL;
const char* param = NULL;
/* parse cmdline args */
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")) {
idevice_set_debug_level(1);
continue;
}
else if (!strcmp(argv[i], "-u") || !strcmp(argv[i], "--udid")) {
i++;
if (!argv[i] || (strlen(argv[i]) != 40)) {
print_usage(argc, argv);
return 0;
}
udid = argv[i];
continue;
}
else if (!strcmp(argv[i], "install")) {
i++;
if (!argv[i] || (strlen(argv[i]) < 1)) {
print_usage(argc, argv);
return 0;
}
param = argv[i];
op = OP_INSTALL;
continue;
}
else if (!strcmp(argv[i], "list")) {
op = OP_LIST;
}
else if (!strcmp(argv[i], "copy")) {
i++;
if (!argv[i] || (strlen(argv[i]) < 1)) {
print_usage(argc, argv);
return 0;
}
param = argv[i];
op = OP_COPY;
continue;
}
else if (!strcmp(argv[i], "remove")) {
i++;
if (!argv[i] || (strlen(argv[i]) < 1)) {
print_usage(argc, argv);
return 0;
}
param = argv[i];
op = OP_REMOVE;
continue;
}
else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
print_usage(argc, argv);
return 0;
}
else {
print_usage(argc, argv);
return 0;
}
}
if ((op == -1) || (op >= NUM_OPS)) {
print_usage(argc, argv);
return 0;
}
ret = idevice_new(&device, udid);
if (ret != IDEVICE_E_SUCCESS) {
if (udid) {
printf("No device found with udid %s, is it plugged in?\n", udid);
} else {
printf("No device found, is it plugged in?\n");
}
return -1;
}
if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(device, &client, "ideviceprovision")) {
idevice_free(device);
return -1;
}
if (LOCKDOWN_E_SUCCESS != lockdownd_start_service(client, "com.apple.misagent", &service)) {
fprintf(stderr, "Could not start service \"com.apple.misagent\"\n");
lockdownd_client_free(client);
idevice_free(device);
return -1;
}
lockdownd_client_free(client);
client = NULL;
misagent_client_t mis = NULL;
if (misagent_client_new(device, service, &mis) != MISAGENT_E_SUCCESS) {
fprintf(stderr, "Could not connect to \"com.apple.misagent\" on device\n");
if (service)
lockdownd_service_descriptor_free(service);
lockdownd_client_free(client);
idevice_free(device);
return -1;
}
if (service)
lockdownd_service_descriptor_free(service);
switch (op) {
case OP_INSTALL:
{
FILE* f = fopen(param, "rb");
if (!f) {
fprintf(stderr, "Could not open file '%s'\n", param);
break;
}
fseek(f, 0, SEEK_END);
long int size = ftell(f);
fseek(f, 0, SEEK_SET);
if (size >= 0x1000000) {
fprintf(stderr, "The file '%s' is too large for processing.\n", param);
fclose(f);
break;
}
char* buf = (char *)malloc(size);
if (!buf) {
fprintf(stderr, "Could not allocate memory...\n");
fclose(f);
break;
}
long int cur = 0;
while (cur < size) {
ssize_t r = fread(buf+cur, 1, 512, f);
if (r <= 0) {
break;
}
cur += r;
}
fclose(f);
if (cur != size) {
free(buf);
fprintf(stderr, "Could not read in file '%s' (size %ld read %ld)\n", param, size, cur);
break;
}
uint64_t psize = size;
plist_t pdata = plist_new_data(buf, psize);
if (misagent_install(mis, pdata) == MISAGENT_E_SUCCESS) {
printf("Profile '%s' installed successfully.\n", param);
} else {
int sc = misagent_get_status_code(mis);
fprintf(stderr, "Could not install profile '%s', status code: 0x%x\n", param, sc);
}
free(buf);
}
break;
case OP_LIST:
case OP_COPY:
{
plist_t profiles = NULL;
if (misagent_copy(mis, &profiles) == MISAGENT_E_SUCCESS) {
uint32_t num_profiles = plist_array_get_size(profiles);
printf("Device has %d provisioning %s installed:\n", num_profiles, (num_profiles == 1) ? "profile" : "profiles");
uint32_t j;
for (j = 0; j < num_profiles; j++) {
char* p_name = NULL;
char* p_uuid = NULL;
plist_t profile = plist_array_get_item(profiles, j);
plist_t pl = profile_get_embedded_plist(profile);
if (pl && (plist_get_node_type(pl) == PLIST_DICT)) {
plist_t node;
node = plist_dict_get_item(pl, "Name");
if (node && (plist_get_node_type(node) == PLIST_STRING)) {
plist_get_string_val(node, &p_name);
}
node = plist_dict_get_item(pl, "UUID");
if (node && (plist_get_node_type(node) == PLIST_STRING)) {
plist_get_string_val(node, &p_uuid);
}
}
printf("%s - %s\n", (p_uuid) ? p_uuid : "(unknown id)", (p_name) ? p_name : "(no name)");
if (op == OP_COPY) {
char pfname[512];
if (p_uuid) {
sprintf(pfname, "%s/%s.mobileprovision", param, p_uuid);
} else {
sprintf(pfname, "%s/profile%d.mobileprovision", param, j);
}
FILE* f = fopen(pfname, "wb");
if (f) {
char* dt = NULL;
uint64_t ds = 0;
plist_get_data_val(profile, &dt, &ds);
fwrite(dt, 1, (size_t) ds, f);
fclose(f);
printf(" => %s\n", pfname);
} else {
fprintf(stderr, "Could not open '%s' for writing\n", pfname);
}
}
if (p_uuid) {
free(p_uuid);
}
if (p_name) {
free(p_name);
}
}
} else {
int sc = misagent_get_status_code(mis);
fprintf(stderr, "Could not get installed profiles from device, status code: 0x%x\n", sc);
}
}
break;
case OP_REMOVE:
if (misagent_remove(mis, param) == MISAGENT_E_SUCCESS) {
printf("Profile '%s' removed.\n", param);
} else {
int sc = misagent_get_status_code(mis);
fprintf(stderr, "Could not remove profile '%s', status code 0x%x\n", param, sc);
}
break;
default:
break;
}
misagent_client_free(mis);
idevice_free(device);
return 0;
}
static gboolean gst_afc_src_start(GstBaseSrc* src) {
GstAfcSrc* self = GST_AFCSRC(src);
// Don't connect again
if (self->connected_)
return TRUE;
// Check that a URI has been passed
if (!self->location_ || self->location_[0] == '\0') {
GST_ELEMENT_ERROR(src, RESOURCE, NOT_FOUND, ("No URI specified"), (NULL));
return FALSE;
}
// Parse the URI
// HERE BE DRAGONS
gchar* location = gst_uri_get_location(self->location_);
char* path_pos = strstr(location, "/");
self->uuid_ = (char*) malloc(path_pos - location + 1);
memcpy(self->uuid_, location, path_pos - location);
self->uuid_[path_pos - location] = '\0';
self->path_ = g_strdup(path_pos);
g_free(location);
// Open the device
idevice_error_t err = idevice_new(&self->device_, self->uuid_);
if (err != IDEVICE_E_SUCCESS) {
GST_ELEMENT_ERROR(src, RESOURCE, NOT_FOUND, ("idevice error: %d", err), (NULL));
return FALSE;
}
lockdownd_client_t lockdown;
lockdownd_error_t lockdown_err =
lockdownd_client_new_with_handshake(self->device_, &lockdown, "GstAfcSrc");
if (lockdown_err != LOCKDOWN_E_SUCCESS) {
GST_ELEMENT_ERROR(src, RESOURCE, NOT_FOUND, ("lockdown error: %d", lockdown_err), (NULL));
return FALSE;
}
lockdown_err = lockdownd_start_service(lockdown, "com.apple.afc", &self->afc_port_);
if (lockdown_err != LOCKDOWN_E_SUCCESS) {
GST_ELEMENT_ERROR(src, RESOURCE, NOT_FOUND, ("lockdown error: %d", lockdown_err), (NULL));
lockdownd_client_free(lockdown);
return FALSE;
}
afc_error_t afc_err = afc_client_new(self->device_, self->afc_port_, &self->afc_);
if (afc_err != 0) {
GST_ELEMENT_ERROR(src, RESOURCE, NOT_FOUND, ("afc error: %d", afc_err), (NULL));
lockdownd_client_free(lockdown);
return FALSE;
}
lockdownd_client_free(lockdown);
// Try opening the file
afc_err = afc_file_open(self->afc_, self->path_, AFC_FOPEN_RDONLY, &self->file_handle_);
if (afc_err != 0) {
GST_ELEMENT_ERROR(src, RESOURCE, NOT_FOUND, ("afc error: %d", afc_err), (NULL));
return FALSE;
}
self->connected_ = TRUE;
return TRUE;
}
G_GNUC_INTERNAL gboolean
iphone_write_sysinfo_extended (const char *uuid, const char *xml)
{
lockdownd_client_t client = NULL;
idevice_t device = NULL;
afc_client_t afc = NULL;
idevice_error_t ret = IDEVICE_E_UNKNOWN_ERROR;
afc_error_t afc_ret;
uint16_t afcport = 0;
uint64_t handle;
uint32_t bytes_written;
const char device_dir[] = "/iTunes_Control/Device";
const char sysinfoextended_path[] = "/iTunes_Control/Device/SysInfoExtended";
ret = idevice_new(&device, uuid);
if (IDEVICE_E_SUCCESS != ret) {
printf("No device found with uuid %s, is it plugged in?\n", uuid);
return FALSE;
}
if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(device, &client, "libgpod")) {
idevice_free(device);
return FALSE;
}
if (LOCKDOWN_E_SUCCESS != lockdownd_start_service(client, "com.apple.afc", &afcport)) {
lockdownd_client_free(client);
idevice_free(device);
return FALSE;
}
g_assert (afcport != 0);
if (AFC_E_SUCCESS != afc_client_new(device, afcport, &afc)) {
lockdownd_client_free(client);
idevice_free(device);
return FALSE;
}
afc_ret = afc_make_directory(afc, device_dir);
if ((AFC_E_SUCCESS != afc_ret) && (AFC_E_OBJECT_EXISTS != afc_ret)) {
afc_client_free(afc);
lockdownd_client_free(client);
idevice_free(device);
return FALSE;
}
if (AFC_E_SUCCESS != afc_file_open(afc, sysinfoextended_path,
AFC_FOPEN_WRONLY, &handle)) {
afc_client_free(afc);
lockdownd_client_free(client);
idevice_free(device);
return FALSE;
}
if (AFC_E_SUCCESS != afc_file_write(afc, handle, xml, strlen(xml), &bytes_written)) {
afc_file_close(afc, handle);
afc_client_free(afc);
lockdownd_client_free(client);
idevice_free(device);
return FALSE;
}
afc_file_close(afc, handle);
afc_client_free(afc);
lockdownd_client_free(client);
idevice_free(device);
return TRUE;
}
int main(int argc, char* argv[]) {
idevice_t device = NULL;
lockdownd_client_t lockdownd = NULL;
afc_client_t afc = NULL;
idevice_error_t device_error = IDEVICE_E_SUCCESS;
lockdownd_error_t lockdownd_error = LOCKDOWN_E_SUCCESS;
afc_error_t afc_error = AFC_E_SUCCESS;
int i;
const char* udid = NULL;
/* parse cmdline args */
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")) {
idevice_set_debug_level(1);
continue;
}
else if (!strcmp(argv[i], "-u") || !strcmp(argv[i], "--udid")) {
i++;
if (!argv[i] || (strlen(argv[i]) != 40)) {
print_usage(argc, argv);
return 0;
}
udid = argv[i];
continue;
}
else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
print_usage(argc, argv);
return 0;
}
else if (!strcmp(argv[i], "-e") || !strcmp(argv[i], "--extract")) {
extract_raw_crash_reports = 1;
continue;
}
else if (!strcmp(argv[i], "-k") || !strcmp(argv[i], "--keep")) {
keep_crash_reports = 1;
continue;
}
else if (target_directory == NULL) {
target_directory = argv[i];
continue;
}
else {
print_usage(argc, argv);
return 0;
}
}
/* ensure a target directory was supplied */
if (!target_directory) {
print_usage(argc, argv);
return 0;
}
/* check if target directory exists */
if (!file_exists(target_directory)) {
fprintf(stderr, "ERROR: Directory '%s' does not exist.\n", target_directory);
print_usage(argc, argv);
return 0;
}
device_error = idevice_new(&device, udid);
if (device_error != IDEVICE_E_SUCCESS) {
if (udid) {
printf("No device found with udid %s, is it plugged in?\n", udid);
} else {
printf("No device found, is it plugged in?\n");
}
return -1;
}
lockdownd_error = lockdownd_client_new_with_handshake(device, &lockdownd, "idevicecrashreport");
if (lockdownd_error != LOCKDOWN_E_SUCCESS) {
fprintf(stderr, "ERROR: Could not connect to lockdownd, error code %d\n", lockdownd_error);
idevice_free(device);
return -1;
}
/* start crash log mover service */
lockdownd_service_descriptor_t service = NULL;
lockdownd_error = lockdownd_start_service(lockdownd, "com.apple.crashreportmover", &service);
if (lockdownd_error != LOCKDOWN_E_SUCCESS) {
lockdownd_client_free(lockdownd);
idevice_free(device);
return -1;
}
/* trigger move operation on device */
idevice_connection_t connection = NULL;
device_error = idevice_connect(device, service->port, &connection);
if(device_error != IDEVICE_E_SUCCESS) {
lockdownd_client_free(lockdownd);
idevice_free(device);
return -1;
}
/* read "ping" message which indicates the crash logs have been moved to a safe harbor */
char *ping = malloc(4);
int attempts = 0;
while ((strncmp(ping, "ping", 4) != 0) && (attempts > 10)) {
uint32_t bytes = 0;
device_error = idevice_connection_receive_timeout(connection, ping, 4, &bytes, 2000);
if ((bytes == 0) && (device_error == IDEVICE_E_SUCCESS)) {
attempts++;
continue;
} else if (device_error < 0) {
fprintf(stderr, "ERROR: Crash logs could not be moved. Connection interrupted.\n");
break;
}
}
idevice_disconnect(connection);
free(ping);
if (service) {
lockdownd_service_descriptor_free(service);
service = NULL;
}
if (device_error != IDEVICE_E_SUCCESS || attempts > 10) {
fprintf(stderr, "ERROR: Failed to receive ping message from crash report mover.\n");
lockdownd_client_free(lockdownd);
idevice_free(device);
return -1;
}
lockdownd_error = lockdownd_start_service(lockdownd, "com.apple.crashreportcopymobile", &service);
if (lockdownd_error != LOCKDOWN_E_SUCCESS) {
lockdownd_client_free(lockdownd);
idevice_free(device);
return -1;
}
lockdownd_client_free(lockdownd);
afc = NULL;
afc_error = afc_client_new(device, service, &afc);
if(afc_error != AFC_E_SUCCESS) {
lockdownd_client_free(lockdownd);
idevice_free(device);
return -1;
}
if (service) {
lockdownd_service_descriptor_free(service);
service = NULL;
}
/* recursively copy crash reports from the device to a local directory */
if (afc_client_copy_and_remove_crash_reports(afc, ".", target_directory) < 0) {
fprintf(stderr, "ERROR: Failed to get crash reports from device.\n");
afc_client_free(afc);
idevice_free(device);
return -1;
}
printf("Done.\n");
afc_client_free(afc);
idevice_free(device);
return 0;
}
int main(int argc, char **argv)
{
idevice_t device = NULL;
lockdownd_client_t lockdown_client = NULL;
diagnostics_relay_client_t diagnostics_client = NULL;
lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
uint16_t port = 0;
int result = -1;
int i;
const char *udid = NULL;
int cmd = CMD_NONE;
char* cmd_arg = NULL;
plist_t node = NULL;
plist_t keys = NULL;
/* parse cmdline args */
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")) {
idevice_set_debug_level(1);
continue;
}
else if (!strcmp(argv[i], "-u") || !strcmp(argv[i], "--udid")) {
i++;
if (!argv[i] || (strlen(argv[i]) != 40)) {
print_usage(argc, argv);
result = 0;
goto cleanup;
}
udid = argv[i];
continue;
}
else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
print_usage(argc, argv);
result = 0;
goto cleanup;
}
else if (!strcmp(argv[i], "sleep")) {
cmd = CMD_SLEEP;
}
else if (!strcmp(argv[i], "restart")) {
cmd = CMD_RESTART;
}
else if (!strcmp(argv[i], "shutdown")) {
cmd = CMD_SHUTDOWN;
}
else if (!strcmp(argv[i], "diagnostics")) {
cmd = CMD_DIAGNOSTICS;
/* read type */
i++;
if (!argv[i] || ((strcmp(argv[i], "All") != 0) && (strcmp(argv[i], "WiFi") != 0) && (strcmp(argv[i], "GasGauge") != 0) && (strcmp(argv[i], "NAND") != 0))) {
if (argv[i] == NULL) {
cmd_arg = strdup("All");
continue;
}
if (!strncmp(argv[i], "-", 1)) {
cmd_arg = strdup("All");
i--;
continue;
}
printf("Unknown TYPE %s\n", argv[i]);
print_usage(argc, argv);
goto cleanup;
}
cmd_arg = strdup(argv[i]);
continue;
}
else if (!strcmp(argv[i], "mobilegestalt")) {
cmd = CMD_MOBILEGESTALT;
/* read keys */
i++;
if (!argv[i] || argv[i] == NULL || (!strncmp(argv[i], "-", 1))) {
printf("Please supply the key to query.\n");
print_usage(argc, argv);
goto cleanup;
}
keys = plist_new_array();
while(1) {
if (argv[i] && (strlen(argv[i]) >= 2) && (strncmp(argv[i], "-", 1) != 0)) {
plist_array_append_item(keys, plist_new_string(argv[i]));
i++;
} else {
i--;
break;
}
}
continue;
}
else if (!strcmp(argv[i], "ioreg")) {
cmd = CMD_IOREGISTRY;
/* read plane */
i++;
if (argv[i]) {
cmd_arg = strdup(argv[i]);
}
continue;
}
else {
print_usage(argc, argv);
return 0;
}
}
/* verify options */
if (cmd == CMD_NONE) {
print_usage(argc, argv);
goto cleanup;
}
if (IDEVICE_E_SUCCESS != idevice_new(&device, udid)) {
if (udid) {
printf("No device found with udid %s, is it plugged in?\n", udid);
} else {
printf("No device found, is it plugged in?\n");
}
goto cleanup;
}
if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(device, &lockdown_client, NULL)) {
idevice_free(device);
printf("Unable to connect to lockdownd.\n");
goto cleanup;
}
/* attempt to use newer diagnostics service available on iOS 5 and later */
ret = lockdownd_start_service(lockdown_client, "com.apple.mobile.diagnostics_relay", &port);
if (ret != LOCKDOWN_E_SUCCESS) {
/* attempt to use older diagnostics service */
ret = lockdownd_start_service(lockdown_client, "com.apple.iosdiagnostics.relay", &port);
}
lockdownd_client_free(lockdown_client);
if ((ret == LOCKDOWN_E_SUCCESS) && (port > 0)) {
if (diagnostics_relay_client_new(device, port, &diagnostics_client) != DIAGNOSTICS_RELAY_E_SUCCESS) {
printf("Could not connect to diagnostics_relay!\n");
result = -1;
} else {
switch (cmd) {
case CMD_SLEEP:
if (diagnostics_relay_sleep(diagnostics_client) == DIAGNOSTICS_RELAY_E_SUCCESS) {
printf("Putting device into deep sleep mode.\n");
result = EXIT_SUCCESS;
} else {
printf("Failed to put device into deep sleep mode.\n");
}
break;
case CMD_RESTART:
if (diagnostics_relay_restart(diagnostics_client, 0) == DIAGNOSTICS_RELAY_E_SUCCESS) {
printf("Restarting device.\n");
result = EXIT_SUCCESS;
} else {
printf("Failed to restart device.\n");
}
break;
case CMD_SHUTDOWN:
if (diagnostics_relay_shutdown(diagnostics_client, 0) == DIAGNOSTICS_RELAY_E_SUCCESS) {
printf("Shutting down device.\n");
result = EXIT_SUCCESS;
} else {
printf("Failed to shutdown device.\n");
}
break;
case CMD_MOBILEGESTALT:
if (diagnostics_relay_query_mobilegestalt(diagnostics_client, keys, &node) == DIAGNOSTICS_RELAY_E_SUCCESS) {
if (node) {
print_xml(node);
result = EXIT_SUCCESS;
}
} else {
printf("Unable to query mobilegestalt keys.\n");
}
break;
case CMD_IOREGISTRY:
if (diagnostics_relay_query_ioregistry_plane(diagnostics_client, cmd_arg == NULL ? "": cmd_arg, &node) == DIAGNOSTICS_RELAY_E_SUCCESS) {
if (node) {
print_xml(node);
result = EXIT_SUCCESS;
}
} else {
printf("Unable to retrieve IORegistry from device.\n");
}
break;
case CMD_DIAGNOSTICS:
default:
if (diagnostics_relay_request_diagnostics(diagnostics_client, cmd_arg, &node) == DIAGNOSTICS_RELAY_E_SUCCESS) {
if (node) {
print_xml(node);
result = EXIT_SUCCESS;
}
} else {
printf("Unable to retrieve diagnostics from device.\n");
}
break;
}
diagnostics_relay_goodbye(diagnostics_client);
diagnostics_relay_client_free(diagnostics_client);
}
} else {
printf("Could not start diagnostics service!\n");
}
idevice_free(device);
cleanup:
if (node) {
plist_free(node);
}
if (keys) {
plist_free(keys);
}
if (cmd_arg) {
free(cmd_arg);
}
return result;
}
int main(int argc, char *argv[]) {
home();
if(argc == 2 && strcmp(argv[1], "--help")==0)
{
help();
return -1;
}
else if(argc == 2 && strcmp(argv[1], "-help")==0) {
help();
return -1;
}
else if(argc == 2 && strcmp(argv[1], "-h")==0) {
help();
return -1;
}
if(argc == 3)
{
char *dotipa = argv[1];
char *dotipa2 = argv[2];
char *var="Downloads/";
char name[255];
strcpy(name, var);
strcat(name, dotipa2);
idevice_error_t idevice_error = 0;
idevice_error = idevice_new(&idevice, NULL);
if (idevice_error != IDEVICE_E_SUCCESS) {
return -1;
}
lockdownd_error_t lockdown_error = 0;
lockdown_error = lockdownd_client_new_with_handshake(idevice, &lockdownd_client, "openiapp");
if (lockdown_error != LOCKDOWN_E_SUCCESS) {
return -1;
}
lockdownd_service_descriptor_t lsd = NULL;
lockdown_error = lockdownd_start_service(lockdownd_client, "com.apple.afc", &lsd);
if (lockdown_error != LOCKDOWN_E_SUCCESS) {
return -1;
}
afc_error_t afc_do_it = 0;
afc_do_it = afc_client_new(idevice, lsd, &afc_client);
if (afc_do_it != AFC_E_SUCCESS) {
lockdownd_client_free(lockdownd_client);
idevice_free(idevice);
return -1;
}
lockdownd_client_free(lockdownd_client);
lockdownd_client = NULL;
afc_do_it = afc_send_file(afc_client, dotipa, name);
if (afc_do_it != AFC_E_SUCCESS) {
printf("%s [*] Error with sending file!\n", KRED);
printf("%s", KNRM);
}
else {
printf("%s [*] Successfully sended file\n", KGRN);
printf("%s", KNRM);
}
lockdown_error = lockdownd_client_new_with_handshake(idevice, &lockdownd_client,
"openiapp");
if (lockdown_error != LOCKDOWN_E_SUCCESS) {
return -1;
}
lockdown_error = lockdownd_start_service(lockdownd_client, "com.apple.mobile.installation_proxy", &lsd);
if (lockdown_error != LOCKDOWN_E_SUCCESS) {
lockdownd_client_free(lockdownd_client);
return -1;
}
instproxy_error_t install_error = 0;
instproxy_client_t install_proxy = NULL;
install_error = instproxy_client_new(idevice, lsd, &install_proxy);
if (install_error != INSTPROXY_E_SUCCESS) {
return -1;
}
plist_t plist = instproxy_client_options_new();
install_error = instproxy_install(install_proxy, name, plist, &minst_client, NULL );
if (install_error != INSTPROXY_E_SUCCESS) {
printf("%s [*] Error with installing App\n", KRED);
printf("%s", KNRM);
return -1;
instproxy_client_options_free(plist);
instproxy_client_free(install_proxy);
}
if (installError) {
return -1;
}
while (installing) {
printf("%s [*] Check if the app is installed successfully.\n", KGRN);
printf("%s [*] If the app is not installed, the installing proccess is running now and you must wait a short time\n", KGRN);
printf("%s", KNRM);
return -1;
}
}
return 0;
}
int itdb_iphone_start_sync(Itdb_Device *device, void **prepdata)
{
int res = 0;
int sync_starting = 0;
itdbprep_t pdata_loc = NULL;
const char *uuid;
lockdownd_client_t client = NULL;
#ifdef HAVE_LIBIMOBILEDEVICE_1_1_5
lockdownd_service_descriptor_t service = NULL;
#else
uint16_t afcport = 0;
#endif
int i;
uuid = itdb_device_get_uuid (device);
if (!uuid) {
fprintf(stderr, "Couldn't find get device UUID itdbprep processing won't work!");
return -ENODEV;
}
printf("libitdbprep: %s called with uuid=%s\n", __func__, uuid);
*prepdata = NULL;
pdata_loc = g_new0 (struct itdbprep_int, 1);
res = idevice_new(&pdata_loc->device, uuid);
if (IDEVICE_E_SUCCESS != res) {
fprintf(stderr, "No iPhone found, is it plugged in?\n");
res = -ENODEV;
goto leave_with_err;
}
if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(pdata_loc->device, &client, "libgpod")) {
fprintf(stderr, "Error: Could not establish lockdownd connection!\n");
res = -1;
goto leave_with_err;
}
#ifdef HAVE_LIBIMOBILEDEVICE_1_1_5
lockdownd_start_service(client, "com.apple.afc", &service);
if (!service || !service->port) {
fprintf(stderr, "Error: Could not start AFC service!\n");
res = -1;
goto leave_with_err;
}
afc_client_new(pdata_loc->device, service, &pdata_loc->afc);
#else
lockdownd_start_service(client, "com.apple.afc", &afcport);
if (!afcport) {
fprintf(stderr, "Error: Could not start AFC service!\n");
res = -1;
goto leave_with_err;
}
afc_client_new(pdata_loc->device, afcport, &pdata_loc->afc);
#endif
if (!pdata_loc->afc) {
fprintf(stderr, "Error: Could not start AFC client!\n");
res = -1;
goto leave_with_err;
}
if (itdb_iphone_post_notification(pdata_loc->device, client, NP_SYNC_WILL_START)) {
fprintf(stderr, "could not post syncWillStart notification!\n");
res = -1;
goto leave_with_err;
}
printf("%s: posted syncWillStart\n", __func__);
sync_starting = 1;
/* OPEN AND LOCK /com.apple.itunes.lock_sync */
afc_file_open(pdata_loc->afc, "/com.apple.itunes.lock_sync", AFC_FOPEN_RW, &pdata_loc->lockfile);
if (!pdata_loc->lockfile) {
fprintf(stderr, "could not open lockfile\n");
res = -1;
goto leave_with_err;
}
if (itdb_iphone_post_notification(pdata_loc->device, client, "com.apple.itunes-mobdev.syncLockRequest")) {
fprintf(stderr, "could not post syncLockRequest\n");
res = -1;
goto leave_with_err;
}
printf("%s: posted syncLockRequest\n", __func__);
for (i=0; i<LOCK_ATTEMPTS; i++) {
fprintf(stderr, "Locking for sync, attempt %d...\n", i);
res = afc_file_lock(pdata_loc->afc, pdata_loc->lockfile, AFC_LOCK_EX);
if (res == AFC_E_SUCCESS) {
break;
} else if (res == AFC_E_OP_WOULD_BLOCK) {
usleep(LOCK_WAIT);
continue;
} else {
fprintf(stderr, "ERROR: could not lock file! error code: %d\n", res);
res = -1;
goto leave_with_err;
}
}
if (i == LOCK_ATTEMPTS) {
fprintf(stderr, "ERROR: timeout while locking for sync\n");
res = -1;
goto leave_with_err;
}
if (itdb_iphone_post_notification(pdata_loc->device, client, NP_SYNC_DID_START)) {
fprintf(stderr, "could not post syncDidStart\n");
res = -1;
goto leave_with_err;
}
printf("%s: posted syncDidStart\n", __func__);
lockdownd_client_free(client);
client = NULL;
*prepdata = pdata_loc;
return 0;
leave_with_err:
if (client && sync_starting) {
itdb_iphone_post_notification(pdata_loc->device, client, "com.apple.itunes-mobdev.syncFailedToStart");
printf("%s: posted syncFailedToStart\n", __func__);
}
if (pdata_loc) {
if (pdata_loc->afc) {
if (pdata_loc->lockfile) {
afc_file_lock(pdata_loc->afc, pdata_loc->lockfile, AFC_LOCK_UN);
afc_file_close(pdata_loc->afc, pdata_loc->lockfile);
pdata_loc->lockfile = 0;
}
afc_client_free(pdata_loc->afc);
pdata_loc->afc = NULL;
}
if (pdata_loc->device) {
idevice_free(pdata_loc->device);
pdata_loc->device = NULL;
}
g_free(pdata_loc);
pdata_loc = NULL;
}
if (client) {
lockdownd_client_free(client);
client = NULL;
}
*prepdata = NULL;
return res;
}
int main(int argc, char **argv)
{
idevice_t device = NULL;
lockdownd_client_t lckd = NULL;
screenshotr_client_t shotr = NULL;
uint16_t port = 0;
int result = -1;
int i;
const char *udid = NULL;
/* parse cmdline args */
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")) {
idevice_set_debug_level(1);
continue;
}
else if (!strcmp(argv[i], "-u") || !strcmp(argv[i], "--udid")) {
i++;
if (!argv[i] || (strlen(argv[i]) != 40)) {
print_usage(argc, argv);
return 0;
}
udid = argv[i];
continue;
}
else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
print_usage(argc, argv);
return 0;
}
else {
print_usage(argc, argv);
return 0;
}
}
if (IDEVICE_E_SUCCESS != idevice_new(&device, udid)) {
if (udid) {
printf("No device found with udid %s, is it plugged in?\n", udid);
} else {
printf("No device found, is it plugged in?\n");
}
return -1;
}
if (LOCKDOWN_E_SUCCESS != lockdownd_client_new_with_handshake(device, &lckd, NULL)) {
idevice_free(device);
printf("Exiting.\n");
return -1;
}
lockdownd_start_service(lckd, "com.apple.mobile.screenshotr", &port);
lockdownd_client_free(lckd);
if (port > 0) {
if (screenshotr_client_new(device, port, &shotr) != SCREENSHOTR_E_SUCCESS) {
printf("Could not connect to screenshotr!\n");
} else {
char *imgdata = NULL;
char filename[36];
uint64_t imgsize = 0;
time_t now = time(NULL);
strftime(filename, 36, "screenshot-%Y-%m-%d-%H-%M-%S.tiff", gmtime(&now));
if (screenshotr_take_screenshot(shotr, &imgdata, &imgsize) == SCREENSHOTR_E_SUCCESS) {
FILE *f = fopen(filename, "wb");
if (f) {
if (fwrite(imgdata, 1, (size_t)imgsize, f) == (size_t)imgsize) {
printf("Screenshot saved to %s\n", filename);
result = 0;
} else {
printf("Could not save screenshot to file %s!\n", filename);
}
fclose(f);
} else {
printf("Could not open %s for writing: %s\n", filename, strerror(errno));
}
} else {
printf("Could not get screenshot!\n");
}
screenshotr_client_free(shotr);
}
} else {
printf("Could not start screenshotr service! Remember that you have to mount the Developer disk image on your device if you want to use the screenshotr service.\n");
}
idevice_free(device);
return result;
}
