debugserver_error_t debugserver_client_new(idevice_t device, lockdownd_service_descriptor_t service, debugserver_client_t* client) { *client = NULL; if (!device || !service || service->port == 0 || !client || *client) { debug_info("Incorrect parameter passed to debugserver_client_new."); return DEBUGSERVER_E_INVALID_ARG; } debug_info("Creating debugserver_client, port = %d.", service->port); service_client_t parent = NULL; debugserver_error_t ret = debugserver_error(service_client_new(device, service, &parent)); if (ret != DEBUGSERVER_E_SUCCESS) { debug_info("Creating base service client failed. Error: %i", ret); return ret; } debugserver_client_t client_loc = (debugserver_client_t) malloc(sizeof(struct debugserver_client_private)); client_loc->parent = parent; client_loc->noack_mode = 0; *client = client_loc; debug_info("debugserver_client successfully created."); return 0; }
LIBIMOBILEDEVICE_API syslog_relay_error_t syslog_relay_client_new(idevice_t device, lockdownd_service_descriptor_t service, syslog_relay_client_t * client) { *client = NULL; if (!device || !service || service->port == 0 || !client || *client) { debug_info("Incorrect parameter passed to syslog_relay_client_new."); return SYSLOG_RELAY_E_INVALID_ARG; } debug_info("Creating syslog_relay_client, port = %d.", service->port); service_client_t parent = NULL; syslog_relay_error_t ret = syslog_relay_error(service_client_new(device, service, &parent)); if (ret != SYSLOG_RELAY_E_SUCCESS) { debug_info("Creating base service client failed. Error: %i", ret); return ret; } syslog_relay_client_t client_loc = (syslog_relay_client_t) malloc(sizeof(struct syslog_relay_client_private)); client_loc->parent = parent; client_loc->worker = (thread_t)NULL; *client = client_loc; debug_info("syslog_relay_client successfully created."); return SYSLOG_RELAY_E_SUCCESS; }
/** * Makes a connection to the AFC service on the device. * * @param device The device to connect to. * @param service The service descriptor returned by lockdownd_start_service. * @param client Pointer that will be set to a newly allocated afc_client_t * upon successful return. * * @return AFC_E_SUCCESS on success, AFC_E_INVALID_ARG if device or port is * invalid, AFC_E_MUX_ERROR if the connection cannot be established, * or AFC_E_NO_MEM if there is a memory allocation problem. */ afc_error_t afc_client_new(idevice_t device, lockdownd_service_descriptor_t service, afc_client_t * client) { if (!device || service->port == 0) return AFC_E_INVALID_ARG; service_client_t parent = NULL; if (service_client_new(device, service, &parent) != SERVICE_E_SUCCESS) { return AFC_E_MUX_ERROR; } afc_error_t err = afc_client_new_with_service_client(parent, client); if (err != AFC_E_SUCCESS) { service_client_free(parent); } else { (*client)->free_parent = 1; } return err; }
LIBIMOBILEDEVICE_API property_list_service_error_t property_list_service_client_new(idevice_t device, lockdownd_service_descriptor_t service, property_list_service_client_t *client) { if (!device || !service || service->port == 0 || !client || *client) return PROPERTY_LIST_SERVICE_E_INVALID_ARG; service_client_t parent = NULL; service_error_t rerr = service_client_new(device, service, &parent); if (rerr != SERVICE_E_SUCCESS) { return service_to_property_list_service_error(rerr); } /* create client object */ property_list_service_client_t client_loc = (property_list_service_client_t)malloc(sizeof(struct property_list_service_client_private)); client_loc->parent = parent; /* all done, return success */ *client = client_loc; return PROPERTY_LIST_SERVICE_E_SUCCESS; }
/** * 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; }