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