/**
* Mounts an image on the device.
*
* @param client The connected mobile_image_mounter client.
* @param image_path The absolute path of the image to mount. The image must
* be present before calling this function.
* @param image_signature Pointer to a buffer holding the images' signature
* @param signature_length Length of the signature image_signature points to
* @param image_type Type of image to mount
* @param result Pointer to a plist that will receive the result of the
* operation.
*
* @note This function may return MOBILE_IMAGE_MOUNTER_E_SUCCESS even if the
* operation has failed. Check the resulting plist for further information.
* Note that there is no unmounting function. The mount persists until the
* device is rebooted.
*
* @return MOBILE_IMAGE_MOUNTER_E_SUCCESS on success,
* MOBILE_IMAGE_MOUNTER_E_INVALID_ARG if on ore more parameters are
* invalid, or another error code otherwise.
*/
mobile_image_mounter_error_t mobile_image_mounter_mount_image(mobile_image_mounter_client_t client, const char *image_path, const char *image_signature, uint16_t signature_length, const char *image_type, plist_t *result)
{
if (!client || !image_path || !image_signature || (signature_length == 0) || !image_type || !result) {
return MOBILE_IMAGE_MOUNTER_E_INVALID_ARG;
}
mobile_image_mounter_lock(client);
plist_t dict = plist_new_dict();
plist_dict_insert_item(dict, "Command", plist_new_string("MountImage"));
plist_dict_insert_item(dict, "ImagePath", plist_new_string(image_path));
plist_dict_insert_item(dict, "ImageSignature", plist_new_data(image_signature, signature_length));
plist_dict_insert_item(dict, "ImageType", plist_new_string(image_type));
mobile_image_mounter_error_t res = mobile_image_mounter_error(property_list_service_send_xml_plist(client->parent, dict));
plist_free(dict);
if (res != MOBILE_IMAGE_MOUNTER_E_SUCCESS) {
debug_info("%s: Error sending XML plist to device!", __func__);
goto leave_unlock;
}
res = mobile_image_mounter_error(property_list_service_receive_plist(client->parent, result));
if (res != MOBILE_IMAGE_MOUNTER_E_SUCCESS) {
debug_info("%s: Error receiving response from device!", __func__);
}
leave_unlock:
mobile_image_mounter_unlock(client);
return res;
}
/**
* Hangs up the connection to the mobile_image_mounter service.
* This functions has to be called before freeing up a mobile_image_mounter
* instance. If not, errors appear in the device's syslog.
*
* @param client The client to hang up
*
* @return MOBILE_IMAGE_MOUNTER_E_SUCCESS on success,
* MOBILE_IMAGE_MOUNTER_E_INVALID_ARG if client is invalid,
* or another error code otherwise.
*/
mobile_image_mounter_error_t mobile_image_mounter_hangup(mobile_image_mounter_client_t client)
{
if (!client) {
return MOBILE_IMAGE_MOUNTER_E_INVALID_ARG;
}
mobile_image_mounter_lock(client);
plist_t dict = plist_new_dict();
plist_dict_insert_item(dict, "Command", plist_new_string("Hangup"));
mobile_image_mounter_error_t res = mobile_image_mounter_error(property_list_service_send_xml_plist(client->parent, dict));
plist_free(dict);
if (res != MOBILE_IMAGE_MOUNTER_E_SUCCESS) {
debug_info("%s: Error sending XML plist to device!", __func__);
goto leave_unlock;
}
dict = NULL;
res = mobile_image_mounter_error(property_list_service_receive_plist(client->parent, &dict));
if (res != MOBILE_IMAGE_MOUNTER_E_SUCCESS) {
debug_info("%s: Error receiving response from device!", __func__);
}
if (dict) {
debug_plist(dict);
plist_free(dict);
}
leave_unlock:
mobile_image_mounter_unlock(client);
return res;
}
static mobileactivation_error_t mobileactivation_send_command_plist(mobileactivation_client_t client, plist_t command, plist_t *result)
{
if (!client || !command)
return MOBILEACTIVATION_E_INVALID_ARG;
plist_t cmd = plist_dict_get_item(command, "Command");
char* command_str = NULL;
if (cmd) {
plist_get_string_val(cmd, &command_str);
}
if (!command_str)
return MOBILEACTIVATION_E_INVALID_ARG;
mobileactivation_error_t ret = MOBILEACTIVATION_E_UNKNOWN_ERROR;
*result = NULL;
ret = mobileactivation_error(property_list_service_send_binary_plist(client->parent, command));
plist_t dict = NULL;
ret = mobileactivation_error(property_list_service_receive_plist(client->parent, &dict));
if (!dict) {
debug_info("ERROR: Did not get reply for %s command", command_str);
free(command_str);
return MOBILEACTIVATION_E_PLIST_ERROR;
}
*result = dict;
ret = mobileactivation_check_result(dict, command_str);
free(command_str);
return ret;
}
/**
* Get the home screen wallpaper as PNG data.
*
* @param client The connected sbservices client to use.
* @param pngdata Pointer that will point to a newly allocated buffer
* containing the PNG data upon successful return. It is up to the caller
* to free the memory.
* @param pngsize Pointer to a uint64_t that will be set to the size of the
* buffer pngdata points to upon successful return.
*
* @return SBSERVICES_E_SUCCESS on success, SBSERVICES_E_INVALID_ARG when
* client or pngdata are invalid, or an SBSERVICES_E_* error
* code otherwise.
*/
sbservices_error_t sbservices_get_home_screen_wallpaper_pngdata(sbservices_client_t client, char **pngdata, uint64_t *pngsize)
{
if (!client || !client->parent || !pngdata)
return SBSERVICES_E_INVALID_ARG;
sbservices_error_t res = SBSERVICES_E_UNKNOWN_ERROR;
plist_t dict = plist_new_dict();
plist_dict_insert_item(dict, "command", plist_new_string("getHomeScreenWallpaperPNGData"));
sbs_lock(client);
res = sbservices_error(property_list_service_send_binary_plist(client->parent, dict));
if (res != SBSERVICES_E_SUCCESS) {
debug_info("could not send plist, error %d", res);
goto leave_unlock;
}
plist_free(dict);
dict = NULL;
res = sbservices_error(property_list_service_receive_plist(client->parent, &dict));
if (res == SBSERVICES_E_SUCCESS) {
plist_t node = plist_dict_get_item(dict, "pngData");
if (node) {
plist_get_data_val(node, pngdata, pngsize);
}
}
leave_unlock:
if (dict) {
plist_free(dict);
}
sbs_unlock(client);
return res;
}
/**
* List archived applications. This function runs synchronously.
*
* @see instproxy_archive
*
* @param client The connected installation_proxy client
* @param client_options The client options to use, as PLIST_DICT, or NULL.
* Currently there are no known client options, so pass NULL here.
* @param result Pointer that will be set to a plist containing a PLIST_DICT
* holding information about the archived applications found.
*
* @return INSTPROXY_E_SUCCESS on success or an INSTPROXY_E_* error value if
* an error occured.
*/
instproxy_error_t instproxy_lookup_archives(instproxy_client_t client, plist_t client_options, plist_t *result)
{
if (!client || !client->parent || !result)
return INSTPROXY_E_INVALID_ARG;
instproxy_lock(client);
instproxy_error_t res = instproxy_send_command(client, "LookupArchives", client_options, NULL, NULL);
if (res != INSTPROXY_E_SUCCESS) {
debug_info("could not send plist, error %d", res);
goto leave_unlock;
}
res = instproxy_error(property_list_service_receive_plist(client->parent, result));
if (res != INSTPROXY_E_SUCCESS) {
debug_info("could not receive plist, error %d", res);
goto leave_unlock;
}
res = INSTPROXY_E_SUCCESS;
leave_unlock:
instproxy_unlock(client);
return res;
}
/* Generic device link service receive function.
*
* @param client The device link service client to use for sending
* @param plist Pointer that will point to the property list received upon
* successful return.
*
* @return DEVICE_LINK_SERVICE_E_SUCCESS on success,
* DEVICE_LINK_SERVICE_E_INVALID_ARG when client or plist is NULL,
* or DEVICE_LINK_SERVICE_E_MUX_ERROR when no property list could be
* received.
*/
device_link_service_error_t device_link_service_receive(device_link_service_client_t client, plist_t *plist)
{
if (!client || !plist || (plist && *plist)) {
return DEVICE_LINK_SERVICE_E_INVALID_ARG;
}
if (property_list_service_receive_plist(client->parent, plist) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
return DEVICE_LINK_SERVICE_E_MUX_ERROR;
}
return DEVICE_LINK_SERVICE_E_SUCCESS;
}
LIBIMOBILEDEVICE_API np_error_t np_client_free(np_client_t client)
{
plist_t dict;
property_list_service_client_t parent;
if (!client)
return NP_E_INVALID_ARG;
dict = plist_new_dict();
plist_dict_set_item(dict,"Command", plist_new_string("Shutdown"));
property_list_service_send_xml_plist(client->parent, dict);
plist_free(dict);
parent = client->parent;
/* notifies the client->notifier thread that it should terminate */
client->parent = NULL;
if (client->notifier) {
debug_info("joining np callback");
thread_join(client->notifier);
thread_free(client->notifier);
client->notifier = (thread_t)NULL;
} else {
dict = NULL;
property_list_service_receive_plist(parent, &dict);
if (dict) {
#ifndef STRIP_DEBUG_CODE
char *cmd_value = NULL;
plist_t cmd_value_node = plist_dict_get_item(dict, "Command");
if (plist_get_node_type(cmd_value_node) == PLIST_STRING) {
plist_get_string_val(cmd_value_node, &cmd_value);
}
if (cmd_value && !strcmp(cmd_value, "ProxyDeath")) {
// this is the expected answer
} else {
debug_info("Did not get ProxyDeath but:");
debug_plist(dict);
}
if (cmd_value) {
free(cmd_value);
}
#endif
plist_free(dict);
}
}
property_list_service_client_free(parent);
mutex_destroy(&client->mutex);
free(client);
return NP_E_SUCCESS;
}
/**
* Sends a notification to the device's notification_proxy.
*
* @param client The client to send to
* @param notification The notification message to send
*
* @return NP_E_SUCCESS on success, or an error returned by np_plist_send
*/
np_error_t np_post_notification(np_client_t client, const char *notification)
{
if (!client || !notification) {
return NP_E_INVALID_ARG;
}
np_lock(client);
plist_t dict = plist_new_dict();
plist_dict_set_item(dict,"Command", plist_new_string("PostNotification"));
plist_dict_set_item(dict,"Name", plist_new_string(notification));
np_error_t res = np_error(property_list_service_send_xml_plist(client->parent, dict));
plist_free(dict);
dict = plist_new_dict();
plist_dict_set_item(dict,"Command", plist_new_string("Shutdown"));
res = np_error(property_list_service_send_xml_plist(client->parent, dict));
plist_free(dict);
if (res != NP_E_SUCCESS) {
debug_info("Error sending XML plist to device!");
}
// try to read an answer, we just ignore errors here
dict = NULL;
property_list_service_receive_plist(client->parent, &dict);
if (dict) {
#ifndef STRIP_DEBUG_CODE
char *cmd_value = NULL;
plist_t cmd_value_node = plist_dict_get_item(dict, "Command");
if (plist_get_node_type(cmd_value_node) == PLIST_STRING) {
plist_get_string_val(cmd_value_node, &cmd_value);
}
if (cmd_value && !strcmp(cmd_value, "ProxyDeath")) {
// this is the expected answer
} else {
debug_plist(dict);
}
if (cmd_value) {
free(cmd_value);
}
#endif
plist_free(dict);
}
np_unlock(client);
return res;
}
/**
* Receives a DL* message plist
*
* @param client The connected device link service client used for receiving.
* @param msg_plist Pointer to a plist that will be set to the contents of the
* message plist upon successful return.
* @param dlmessage A pointer that will be set to a newly allocated char*
* containing the DL* string from the given plist. It is up to the caller
* to free the allocated memory. If this parameter is NULL
* it will be ignored.
*
* @return DEVICE_LINK_SERVICE_E_SUCCESS if a DL* message was received,
* DEVICE_LINK_SERVICE_E_INVALID_ARG if client or message is invalid,
* DEVICE_LINK_SERVICE_E_PLIST_ERROR if the received plist is invalid
* or is not a DL* message plist, or DEVICE_LINK_SERVICE_E_MUX_ERROR if
* receiving from the device failed.
*/
device_link_service_error_t device_link_service_receive_message(device_link_service_client_t client, plist_t *msg_plist, char **dlmessage)
{
if (!client || !client->parent || !msg_plist)
return DEVICE_LINK_SERVICE_E_INVALID_ARG;
*msg_plist = NULL;
if (property_list_service_receive_plist(client->parent, msg_plist) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
return DEVICE_LINK_SERVICE_E_MUX_ERROR;
}
if (!device_link_service_get_message(*msg_plist, dlmessage)) {
debug_info("Did not receive a DL* message as expected!");
return DEVICE_LINK_SERVICE_E_PLIST_ERROR;
}
return DEVICE_LINK_SERVICE_E_SUCCESS;
}
LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_receive(lockdownd_client_t client, plist_t *plist)
{
if (!client || !plist || (plist && *plist))
return LOCKDOWN_E_INVALID_ARG;
lockdownd_error_t ret = LOCKDOWN_E_SUCCESS;
property_list_service_error_t err;
err = property_list_service_receive_plist(client->parent, plist);
if (err != PROPERTY_LIST_SERVICE_E_SUCCESS) {
ret = LOCKDOWN_E_UNKNOWN_ERROR;
}
if (!*plist)
ret = LOCKDOWN_E_PLIST_ERROR;
return ret;
}
/**
* Retrieves the result of a previously sent house_arrest_request_* request.
*
* @param client The house_arrest client to use
* @param dict Pointer that will be set to a plist containing the result to
* the last performed operation. It holds a key 'Status' with the value
* 'Complete' on success or a key 'Error' with an error description as
* value. The caller is responsible for freeing the returned plist.
*
* @return HOUSE_ARREST_E_SUCCESS if a result plist was retrieved,
* HOUSE_ARREST_E_INVALID_ARG if client is invalid,
* HOUSE_ARREST_E_INVALID_MODE if the client is not in the correct mode,
* or HOUSE_ARREST_E_CONN_FAILED if a connection error occured.
*/
house_arrest_error_t house_arrest_get_result(house_arrest_client_t client, plist_t *dict)
{
if (!client || !client->parent)
return HOUSE_ARREST_E_INVALID_ARG;
if (client->mode != HOUSE_ARREST_CLIENT_MODE_NORMAL)
return HOUSE_ARREST_E_INVALID_MODE;
house_arrest_error_t res = house_arrest_error(property_list_service_receive_plist(client->parent, dict));
if (res != HOUSE_ARREST_E_SUCCESS) {
debug_info("could not get result, error %d", res);
if (*dict) {
plist_free(*dict);
*dict = NULL;
}
}
return res;
}
/**
* Receives a plist from restored.
*
* @param client The restored client
* @param plist The plist to store the received data
*
* @return RESTORE_E_SUCCESS on success, NP_E_INVALID_ARG when client or
* plist is NULL
*/
restored_error_t restored_receive(restored_client_t client, plist_t *plist)
{
if (!client || !plist || (plist && *plist))
return RESTORE_E_INVALID_ARG;
restored_error_t ret = RESTORE_E_SUCCESS;
property_list_service_error_t err;
err = property_list_service_receive_plist(client->parent, plist);
if (err != PROPERTY_LIST_SERVICE_E_SUCCESS) {
ret = RESTORE_E_UNKNOWN_ERROR;
}
if (!*plist)
ret = RESTORE_E_PLIST_ERROR;
return ret;
}
/**
* Receives a plist from the service.
*
* @param client The diagnostics_relay client
* @param plist The plist to store the received data
*
* @return DIAGNOSTICS_RELAY_E_SUCCESS on success,
* DIAGNOSTICS_RELAY_E_INVALID_ARG when client or plist is NULL
*/
static diagnostics_relay_error_t diagnostics_relay_receive(diagnostics_relay_client_t client, plist_t *plist)
{
if (!client || !plist || (plist && *plist))
return DIAGNOSTICS_RELAY_E_INVALID_ARG;
diagnostics_relay_error_t ret = DIAGNOSTICS_RELAY_E_SUCCESS;
property_list_service_error_t err;
err = property_list_service_receive_plist(client->parent, plist);
if (err != PROPERTY_LIST_SERVICE_E_SUCCESS) {
ret = DIAGNOSTICS_RELAY_E_UNKNOWN_ERROR;
}
if (!*plist)
ret = DIAGNOSTICS_RELAY_E_PLIST_ERROR;
return ret;
}
/**
* Receives a DLMessageProcessMessage plist.
*
* @param client The connected device link service client used for receiving.
* @param message Pointer to a plist that will be set to the contents of the
* message contents upon successful return.
*
* @return DEVICE_LINK_SERVICE_E_SUCCESS when a DLMessageProcessMessage was
* received, DEVICE_LINK_SERVICE_E_INVALID_ARG when client or message is
* invalid, DEVICE_LINK_SERVICE_E_PLIST_ERROR if the received plist is
* invalid or is not a DLMessageProcessMessage,
* or DEVICE_LINK_SERVICE_E_MUX_ERROR if receiving from device fails.
*/
device_link_service_error_t device_link_service_receive_process_message(device_link_service_client_t client, plist_t *message)
{
if (!client || !client->parent || !message)
return DEVICE_LINK_SERVICE_E_INVALID_ARG;
plist_t pmsg = NULL;
if (property_list_service_receive_plist(client->parent, &pmsg) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
return DEVICE_LINK_SERVICE_E_MUX_ERROR;
}
device_link_service_error_t err = DEVICE_LINK_SERVICE_E_UNKNOWN_ERROR;
char *msg = NULL;
device_link_service_get_message(pmsg, &msg);
if (!msg || strcmp(msg, "DLMessageProcessMessage")) {
debug_info("Did not receive DLMessageProcessMessage as expected!");
err = DEVICE_LINK_SERVICE_E_PLIST_ERROR;
goto leave;
}
if (plist_array_get_size(pmsg) != 2) {
debug_info("Malformed plist received for DLMessageProcessMessage");
err = DEVICE_LINK_SERVICE_E_PLIST_ERROR;
goto leave;
}
plist_t msg_loc = plist_array_get_item(pmsg, 1);
if (msg_loc) {
*message = plist_copy(msg_loc);
err = DEVICE_LINK_SERVICE_E_SUCCESS;
} else {
*message = NULL;
err = DEVICE_LINK_SERVICE_E_PLIST_ERROR;
}
leave:
if (msg)
free(msg);
if (pmsg)
plist_free(pmsg);
return err;
}
/**
* Retrieves an array of all installed provisioning profiles.
*
* @param client The connected misagent to use.
* @param profiles Pointer to a plist_t that will be set to a PLIST_ARRAY
* if the function is successful.
*
* @return MISAGENT_E_SUCCESS on success, MISAGENT_E_INVALID_ARG when
* client is invalid, or an MISAGENT_E_* error code otherwise.
*
* @note If no provisioning profiles are installed on the device, this function
* still returns MISAGENT_E_SUCCESS and profiles will just point to an
* empty array.
*/
misagent_error_t misagent_copy(misagent_client_t client, plist_t* profiles)
{
if (!client || !client->parent || !profiles)
return MISAGENT_E_INVALID_ARG;
client->last_error = MISAGENT_E_UNKNOWN_ERROR;
plist_t dict = plist_new_dict();
plist_dict_insert_item(dict, "MessageType", plist_new_string("Copy"));
plist_dict_insert_item(dict, "ProfileType", plist_new_string("Provisioning"));
misagent_error_t res = misagent_error(property_list_service_send_xml_plist(client->parent, dict));
plist_free(dict);
dict = NULL;
if (res != MISAGENT_E_SUCCESS) {
debug_info("could not send plist, error %d", res);
return res;
}
res = misagent_error(property_list_service_receive_plist(client->parent, &dict));
if (res != MISAGENT_E_SUCCESS) {
debug_info("could not receive response, error %d", res);
return res;
}
if (!dict) {
debug_info("could not get response plist");
return MISAGENT_E_UNKNOWN_ERROR;
}
res = misagent_check_result(dict, &client->last_error);
if (res == MISAGENT_E_SUCCESS) {
*profiles = plist_copy(plist_dict_get_item(dict, "Payload"));
}
plist_free(dict);
return res;
}
/**
* Gets the icon state of the connected device.
*
* @param client The connected sbservices client to use.
* @param state Pointer that will point to a newly allocated plist containing
* the current icon state. It is up to the caller to free the memory.
* @param format_version A string to be passed as formatVersion along with
* the request, or NULL if no formatVersion should be passed. This is only
* supported since iOS 4.0 so for older firmware versions this must be set
* to NULL.
*
* @return SBSERVICES_E_SUCCESS on success, SBSERVICES_E_INVALID_ARG when
* client or state is invalid, or an SBSERVICES_E_* error code otherwise.
*/
sbservices_error_t sbservices_get_icon_state(sbservices_client_t client, plist_t *state, const char *format_version)
{
if (!client || !client->parent || !state)
return SBSERVICES_E_INVALID_ARG;
sbservices_error_t res = SBSERVICES_E_UNKNOWN_ERROR;
plist_t dict = plist_new_dict();
plist_dict_insert_item(dict, "command", plist_new_string("getIconState"));
if (format_version) {
plist_dict_insert_item(dict, "formatVersion", plist_new_string(format_version));
}
sbs_lock(client);
res = sbservices_error(property_list_service_send_binary_plist(client->parent, dict));
if (res != SBSERVICES_E_SUCCESS) {
debug_info("could not send plist, error %d", res);
goto leave_unlock;
}
plist_free(dict);
dict = NULL;
res = sbservices_error(property_list_service_receive_plist(client->parent, state));
if (res != SBSERVICES_E_SUCCESS) {
debug_info("could not get icon state, error %d", res);
if (*state) {
plist_free(*state);
*state = NULL;
}
}
leave_unlock:
if (dict) {
plist_free(dict);
}
sbs_unlock(client);
return res;
}
/**
* Gets the interface orientation of the device.
*
* @param client The connected sbservices client to use.
* @param interface_orientation The interface orientation upon successful return.
*
* @return SBSERVICES_E_SUCCESS on success, SBSERVICES_E_INVALID_ARG when
* client or state is invalid, or an SBSERVICES_E_* error code otherwise.
*/
sbservices_error_t sbservices_get_interface_orientation(sbservices_client_t client, sbservices_interface_orientation_t* interface_orientation)
{
if (!client || !client->parent || !interface_orientation)
return SBSERVICES_E_INVALID_ARG;
sbservices_error_t res = SBSERVICES_E_UNKNOWN_ERROR;
plist_t dict = plist_new_dict();
plist_dict_insert_item(dict, "command", plist_new_string("getInterfaceOrientation"));
sbs_lock(client);
res = sbservices_error(property_list_service_send_binary_plist(client->parent, dict));
if (res != SBSERVICES_E_SUCCESS) {
debug_info("could not send plist, error %d", res);
goto leave_unlock;
}
plist_free(dict);
dict = NULL;
res = sbservices_error(property_list_service_receive_plist(client->parent, &dict));
if (res == SBSERVICES_E_SUCCESS) {
plist_t node = plist_dict_get_item(dict, "interfaceOrientation");
if (node) {
uint64_t value = SBSERVICES_INTERFACE_ORIENTATION_UNKNOWN;
plist_get_uint_val(node, &value);
*interface_orientation = (sbservices_interface_orientation_t)value;
}
}
leave_unlock:
if (dict) {
plist_free(dict);
}
sbs_unlock(client);
return res;
}
LIBIMOBILEDEVICE_API misagent_error_t misagent_remove(misagent_client_t client, const char* profileID)
{
if (!client || !client->parent || !profileID)
return MISAGENT_E_INVALID_ARG;
client->last_error = MISAGENT_E_UNKNOWN_ERROR;
plist_t dict = plist_new_dict();
plist_dict_set_item(dict, "MessageType", plist_new_string("Remove"));
plist_dict_set_item(dict, "ProfileID", plist_new_string(profileID));
plist_dict_set_item(dict, "ProfileType", plist_new_string("Provisioning"));
misagent_error_t res = misagent_error(property_list_service_send_xml_plist(client->parent, dict));
plist_free(dict);
dict = NULL;
if (res != MISAGENT_E_SUCCESS) {
debug_info("could not send plist, error %d", res);
return res;
}
res = misagent_error(property_list_service_receive_plist(client->parent, &dict));
if (res != MISAGENT_E_SUCCESS) {
debug_info("could not receive response, error %d", res);
return res;
}
if (!dict) {
debug_info("could not get response plist");
return MISAGENT_E_UNKNOWN_ERROR;
}
res = misagent_check_result(dict, &client->last_error);
plist_free(dict);
return res;
}
/**
* Uploads an image to the device.
*
* @param client The connected mobile_image_mounter client.
* @param image_type Type of image that is being uploaded.
* @param image_size Total size of the image.
* @param upload_cb Callback function that gets the data chunks for uploading
* the image.
* @param userdata User defined data for the upload callback function.
*
* @return MOBILE_IMAGE_MOUNTER_E_SUCCESS on succes, or a
* MOBILE_IMAGE_MOUNTER_E_* error code otherwise.
*/
mobile_image_mounter_error_t mobile_image_mounter_upload_image(mobile_image_mounter_client_t client, const char *image_type, size_t image_size, mobile_image_mounter_upload_cb_t upload_cb, void* userdata)
{
if (!client || !image_type || (image_size == 0) || !upload_cb) {
return MOBILE_IMAGE_MOUNTER_E_INVALID_ARG;
}
mobile_image_mounter_lock(client);
plist_t result = NULL;
plist_t dict = plist_new_dict();
plist_dict_set_item(dict, "Command", plist_new_string("ReceiveBytes"));
plist_dict_set_item(dict, "ImageSize", plist_new_uint(image_size));
plist_dict_set_item(dict, "ImageType", plist_new_string(image_type));
mobile_image_mounter_error_t res = mobile_image_mounter_error(property_list_service_send_xml_plist(client->parent, dict));
plist_free(dict);
if (res != MOBILE_IMAGE_MOUNTER_E_SUCCESS) {
debug_info("Error sending XML plist to device!");
goto leave_unlock;
}
res = mobile_image_mounter_error(property_list_service_receive_plist(client->parent, &result));
if (res != MOBILE_IMAGE_MOUNTER_E_SUCCESS) {
debug_info("Error receiving response from device!");
goto leave_unlock;
}
res = MOBILE_IMAGE_MOUNTER_E_COMMAND_FAILED;
char* strval = NULL;
plist_t node = plist_dict_get_item(result, "Status");
if (node && plist_get_node_type(node) == PLIST_STRING) {
plist_get_string_val(node, &strval);
}
if (!strval) {
debug_info("Error: Unexpected response received!");
goto leave_unlock;
}
if (strcmp(strval, "ReceiveBytesAck") != 0) {
debug_info("Error: didn't get ReceiveBytesAck but %s", strval);
free(strval);
goto leave_unlock;
}
free(strval);
size_t tx = 0;
size_t bufsize = 65536;
unsigned char *buf = (unsigned char*)malloc(bufsize);
if (!buf) {
debug_info("Out of memory");
res = MOBILE_IMAGE_MOUNTER_E_UNKNOWN_ERROR;
goto leave_unlock;
}
debug_info("uploading image (%d bytes)", (int)image_size);
while (tx < image_size) {
size_t remaining = image_size - tx;
size_t amount = (remaining < bufsize) ? remaining : bufsize;
ssize_t r = upload_cb(buf, amount, userdata);
if (r < 0) {
debug_info("upload_cb returned %d", (int)r);
break;
}
uint32_t sent = 0;
if (service_send(client->parent->parent, (const char*)buf, (uint32_t)r, &sent) != SERVICE_E_SUCCESS) {
debug_info("service_send failed");
break;
}
tx += r;
}
free(buf);
if (tx < image_size) {
debug_info("Error: failed to upload image");
goto leave_unlock;
}
debug_info("image uploaded");
res = mobile_image_mounter_error(property_list_service_receive_plist(client->parent, &result));
if (res != MOBILE_IMAGE_MOUNTER_E_SUCCESS) {
debug_info("Error receiving response from device!");
goto leave_unlock;
}
res = MOBILE_IMAGE_MOUNTER_E_COMMAND_FAILED;
strval = NULL;
node = plist_dict_get_item(result, "Status");
if (node && plist_get_node_type(node) == PLIST_STRING) {
plist_get_string_val(node, &strval);
}
if (!strval) {
debug_info("Error: Unexpected response received!");
goto leave_unlock;
}
if (strcmp(strval, "Complete") != 0) {
debug_info("Error: didn't get Complete but %s", strval);
free(strval);
goto leave_unlock;
} else {
res = MOBILE_IMAGE_MOUNTER_E_SUCCESS;
}
free(strval);
leave_unlock:
mobile_image_mounter_unlock(client);
if (result)
plist_free(result);
return res;
}
/**
* Performs the DLMessageVersionExchange with the connected device.
* This should be the first operation to be executed by an implemented
* device link service client.
*
* @param client The device_link_service client to use.
* @param version_major The major version number to check.
* @param version_minor The minor version number to check.
*
* @return DEVICE_LINK_SERVICE_E_SUCCESS on success,
* DEVICE_LINK_SERVICE_E_INVALID_ARG when client is NULL,
* DEVICE_LINK_SERVICE_E_MUX_ERROR when a communication error occurs,
* DEVICE_LINK_SERVICE_E_PLIST_ERROR when the received plist has not the
* expected contents, DEVICE_LINK_SERVICE_E_BAD_VERSION when the version
* given by the device is larger than the given version,
* or DEVICE_LINK_SERVICE_E_UNKNOWN_ERROR otherwise.
*/
device_link_service_error_t device_link_service_version_exchange(device_link_service_client_t client, uint64_t version_major, uint64_t version_minor)
{
if (!client)
return DEVICE_LINK_SERVICE_E_INVALID_ARG;
device_link_service_error_t err = DEVICE_LINK_SERVICE_E_UNKNOWN_ERROR;
/* perform version exchange */
plist_t array = NULL;
char *msg = NULL;
/* receive DLMessageVersionExchange from device */
if (property_list_service_receive_plist(client->parent, &array) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
debug_info("Did not receive initial message from device!");
err = DEVICE_LINK_SERVICE_E_MUX_ERROR;
goto leave;
}
msg = device_link_service_get_message(array);
if (!msg || strcmp(msg, "DLMessageVersionExchange")) {
debug_info("Did not receive DLMessageVersionExchange from device!");
err = DEVICE_LINK_SERVICE_E_PLIST_ERROR;
goto leave;
}
free(msg);
msg = NULL;
/* get major and minor version number */
if (plist_array_get_size(array) < 3) {
debug_info("DLMessageVersionExchange has unexpected format!");
err = DEVICE_LINK_SERVICE_E_PLIST_ERROR;
goto leave;
}
plist_t maj = plist_array_get_item(array, 1);
plist_t min = plist_array_get_item(array, 2);
uint64_t vmajor = 0;
uint64_t vminor = 0;
if (maj) {
plist_get_uint_val(maj, &vmajor);
}
if (min) {
plist_get_uint_val(min, &vminor);
}
if (vmajor > version_major) {
debug_info("Version mismatch: device=(%lld,%lld) > expected=(%lld,%lld)", vmajor, vminor, version_major, version_minor);
err = DEVICE_LINK_SERVICE_E_BAD_VERSION;
goto leave;
} else if ((vmajor == version_major) && (vminor > version_minor)) {
debug_info("WARNING: Version mismatch: device=(%lld,%lld) > expected=(%lld,%lld)", vmajor, vminor, version_major, version_minor);
err = DEVICE_LINK_SERVICE_E_BAD_VERSION;
goto leave;
}
plist_free(array);
/* version is ok, send reply */
array = plist_new_array();
plist_array_append_item(array, plist_new_string("DLMessageVersionExchange"));
plist_array_append_item(array, plist_new_string("DLVersionsOk"));
plist_array_append_item(array, plist_new_uint(version_major));
if (property_list_service_send_binary_plist(client->parent, array) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
debug_info("Error when sending DLVersionsOk");
err = DEVICE_LINK_SERVICE_E_MUX_ERROR;
goto leave;
}
plist_free(array);
/* receive DeviceReady message */
array = NULL;
if (property_list_service_receive_plist(client->parent, &array) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
debug_info("Error when receiving DLMessageDeviceReady!");
err = DEVICE_LINK_SERVICE_E_MUX_ERROR;
goto leave;
}
msg = device_link_service_get_message(array);
if (!msg || strcmp(msg, "DLMessageDeviceReady")) {
debug_info("Did not get DLMessageDeviceReady!");
err = DEVICE_LINK_SERVICE_E_PLIST_ERROR;
goto leave;
}
err = DEVICE_LINK_SERVICE_E_SUCCESS;
leave:
if (msg) {
free(msg);
}
if (array) {
plist_free(array);
}
return err;
}
/**
* List installed applications. This function runs synchronously.
*
* @param client The connected installation_proxy client
* @param client_options The client options to use, as PLIST_DICT, or NULL.
* Valid client options include:
* "ApplicationType" -> "User"
* "ApplicationType" -> "System"
* @param result Pointer that will be set to a plist that will hold an array
* of PLIST_DICT holding information about the applications found.
*
* @return INSTPROXY_E_SUCCESS on success or an INSTPROXY_E_* error value if
* an error occured.
*/
instproxy_error_t instproxy_browse(instproxy_client_t client, plist_t client_options, plist_t *result)
{
if (!client || !client->parent || !result)
return INSTPROXY_E_INVALID_ARG;
instproxy_error_t res = INSTPROXY_E_UNKNOWN_ERROR;
instproxy_lock(client);
res = instproxy_send_command(client, "Browse", client_options, NULL, NULL);
if (res != INSTPROXY_E_SUCCESS) {
debug_info("could not send plist");
goto leave_unlock;
}
int browsing = 0;
plist_t apps_array = plist_new_array();
plist_t dict = NULL;
do {
browsing = 0;
dict = NULL;
res = instproxy_error(property_list_service_receive_plist(client->parent, &dict));
if (res != INSTPROXY_E_SUCCESS) {
break;
}
if (dict) {
uint64_t i;
uint64_t current_amount = 0;
char *status = NULL;
plist_t camount = plist_dict_get_item(dict, "CurrentAmount");
plist_t pstatus = plist_dict_get_item(dict, "Status");
if (camount) {
plist_get_uint_val(camount, ¤t_amount);
}
if (current_amount > 0) {
plist_t current_list = plist_dict_get_item(dict, "CurrentList");
for (i = 0; current_list && (i < current_amount); i++) {
plist_t item = plist_array_get_item(current_list, i);
plist_array_append_item(apps_array, plist_copy(item));
}
}
if (pstatus) {
plist_get_string_val(pstatus, &status);
}
if (status) {
if (!strcmp(status, "BrowsingApplications")) {
browsing = 1;
} else if (!strcmp(status, "Complete")) {
debug_info("Browsing applications completed");
res = INSTPROXY_E_SUCCESS;
}
free(status);
}
plist_free(dict);
}
} while (browsing);
if (res == INSTPROXY_E_SUCCESS) {
*result = apps_array;
} else {
plist_free(apps_array);
}
leave_unlock:
instproxy_unlock(client);
return res;
}
