/**
* 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;
}
/**
* Uninstall an application from the device.
*
* @param client The connected installation proxy client
* @param appid ApplicationIdentifier of the app to uninstall
* @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 status_cb Callback function for progress and status information. If
* NULL is passed, this function will run synchronously.
* @param user_data Callback data passed to status_cb.
*
* @return INSTPROXY_E_SUCCESS on success or an INSTPROXY_E_* error value if
* an error occured.
*
* @note If a callback function is given (async mode), this function returns
* INSTPROXY_E_SUCCESS immediately if the status updater thread has been
* created successfully; any error occuring during the operation has to be
* handled inside the specified callback function.
*/
instproxy_error_t instproxy_uninstall(instproxy_client_t client, const char *appid, plist_t client_options, instproxy_status_cb_t status_cb, void *user_data)
{
if (!client || !client->parent || !appid) {
return INSTPROXY_E_INVALID_ARG;
}
if (client->status_updater) {
return INSTPROXY_E_OP_IN_PROGRESS;
}
instproxy_error_t res = INSTPROXY_E_UNKNOWN_ERROR;
plist_t dict = plist_new_dict();
plist_dict_insert_item(dict, "ApplicationIdentifier", plist_new_string(appid));
plist_dict_insert_item(dict, "Command", plist_new_string("Uninstall"));
instproxy_lock(client);
res = instproxy_send_command(client, "Uninstall", client_options, appid, NULL);
instproxy_unlock(client);
plist_free(dict);
if (res != INSTPROXY_E_SUCCESS) {
debug_info("could not send plist, error %d", res);
return res;
}
return instproxy_create_status_updater(client, status_cb, "Uninstall", user_data);
}
/**
* Internally used "receive status" thread function that will call the specified
* callback function when status update messages (or error messages) are
* received.
*
* @param arg Pointer to an allocated struct instproxy_status_data that holds
* the required data about the connected client and the callback function.
*
* @return Always NULL.
*/
static void* instproxy_receive_status_loop_thread(void* arg)
{
struct instproxy_status_data *data = (struct instproxy_status_data*)arg;
/* run until the command is complete or an error occurs */
(void)instproxy_receive_status_loop(data->client, data->command, data->cbfunc, data->user_data);
/* cleanup */
instproxy_lock(data->client);
debug_info("done, cleaning up.");
if (data->command) {
plist_free(data->command);
}
if (data->client->receive_status_thread) {
thread_free(data->client->receive_status_thread);
data->client->receive_status_thread = (thread_t)NULL;
}
instproxy_unlock(data->client);
free(data);
return NULL;
}
/**
* Removes a previously archived application from the device.
* This function removes the ZIP archive from the 'ApplicationArchives'
* directory.
*
* @param client The connected installation proxy client
* @param appid ApplicationIdentifier of the archived app to remove.
* @param client_options The client options to use, as PLIST_DICT, or NULL.
* Currently there are no known client options, so passing NULL is fine.
* @param status_cb Callback function for progress and status information. If
* NULL is passed, this function will run synchronously.
* @param user_data Callback data passed to status_cb.
*
* @return INSTPROXY_E_SUCCESS on success or an INSTPROXY_E_* error value if
* an error occured.
*
* @note If a callback function is given (async mode), this function returns
* INSTPROXY_E_SUCCESS immediately if the status updater thread has been
* created successfully; any error occuring during the operation has to be
* handled inside the specified callback function.
*/
instproxy_error_t instproxy_remove_archive(instproxy_client_t client, const char *appid, plist_t client_options, instproxy_status_cb_t status_cb, void *user_data)
{
if (!client || !client->parent || !appid)
return INSTPROXY_E_INVALID_ARG;
if (client->status_updater) {
return INSTPROXY_E_OP_IN_PROGRESS;
}
instproxy_lock(client);
instproxy_error_t res = instproxy_send_command(client, "RemoveArchive", client_options, appid, NULL);
instproxy_unlock(client);
if (res != INSTPROXY_E_SUCCESS) {
debug_info("could not send plist, error %d", res);
return res;
}
return instproxy_create_status_updater(client, status_cb, "RemoveArchive", user_data);
}
/**
* Internally used status updater thread function that will call the specified
* callback function when status update messages (or error messages) are
* received.
*
* @param arg Pointer to an allocated struct instproxy_status_data that holds
* the required data about the connected client and the callback function.
*
* @return Always NULL.
*/
static void* instproxy_status_updater(void* arg)
{
struct instproxy_status_data *data = (struct instproxy_status_data*)arg;
/* run until the operation is complete or an error occurs */
(void)instproxy_perform_operation(data->client, data->cbfunc, data->operation, data->user_data);
/* cleanup */
instproxy_lock(data->client);
debug_info("done, cleaning up.");
if (data->operation) {
free(data->operation);
}
data->client->status_updater = (thread_t)NULL;
instproxy_unlock(data->client);
free(data);
return NULL;
}
/**
* Internal function used by instproxy_install and instproxy_upgrade.
*
* @param client The connected installation_proxy client
* @param pkg_path Path of the installation package (inside the AFC jail)
* @param client_options The client options to use, as PLIST_DICT, or NULL.
* @param status_cb Callback function for progress and status information. If
* NULL is passed, this function will run synchronously.
* @param command The command to execute.
* @param user_data Callback data passed to status_cb.
*
* @return INSTPROXY_E_SUCCESS on success or an INSTPROXY_E_* error value if
* an error occured.
*/
static instproxy_error_t instproxy_install_or_upgrade(instproxy_client_t client, const char *pkg_path, plist_t client_options, instproxy_status_cb_t status_cb, const char *command, void *user_data)
{
if (!client || !client->parent || !pkg_path) {
return INSTPROXY_E_INVALID_ARG;
}
if (client->status_updater) {
return INSTPROXY_E_OP_IN_PROGRESS;
}
instproxy_lock(client);
instproxy_error_t res = instproxy_send_command(client, command, client_options, NULL, pkg_path);
instproxy_unlock(client);
if (res != INSTPROXY_E_SUCCESS) {
debug_info("could not send plist, error %d", res);
return res;
}
return instproxy_create_status_updater(client, status_cb, command, user_data);
}
/**
* Internal core function to send a command and process the response.
*
* @param client The connected installation_proxy client
* @param command The command specification dictionary.
* @param async A boolean indicating whether the receive loop should be run
* asynchronously or block until completing the command.
* @param status_cb Callback function to call if a command status is received.
* @param user_data Callback data passed to status_cb.
*
* @return INSTPROXY_E_SUCCESS on success or an INSTPROXY_E_* error value if
* an error occured.
*/
static instproxy_error_t instproxy_perform_command(instproxy_client_t client, plist_t command, instproxy_command_type_t async, instproxy_status_cb_t status_cb, void *user_data)
{
if (!client || !client->parent || !command) {
return INSTPROXY_E_INVALID_ARG;
}
if (client->receive_status_thread) {
return INSTPROXY_E_OP_IN_PROGRESS;
}
instproxy_error_t res = INSTPROXY_E_UNKNOWN_ERROR;
/* send command */
instproxy_lock(client);
res = instproxy_send_command(client, command);
instproxy_unlock(client);
/* loop until status or error is received */
res = instproxy_receive_status_loop_with_callback(client, command, async, status_cb, user_data);
return res;
}
LIBIMOBILEDEVICE_API instproxy_error_t instproxy_uninstall(instproxy_client_t client, const char *appid, plist_t client_options, instproxy_status_cb_t status_cb, void *user_data)
{
if (!client || !client->parent || !appid) {
return INSTPROXY_E_INVALID_ARG;
}
if (client->status_updater) {
return INSTPROXY_E_OP_IN_PROGRESS;
}
instproxy_error_t res = INSTPROXY_E_UNKNOWN_ERROR;
instproxy_lock(client);
res = instproxy_send_command(client, "Uninstall", client_options, appid, NULL);
instproxy_unlock(client);
if (res != INSTPROXY_E_SUCCESS) {
debug_info("could not send plist, error %d", res);
return res;
}
return instproxy_create_status_updater(client, status_cb, "Uninstall", user_data);
}
/**
* Internally used function that will synchronously receive messages from
* the specified installation_proxy until it completes or an error occurs.
*
* If status_cb is not NULL, the callback function will be called each time
* a status update or error message is received.
*
* @param client The connected installation proxy client
* @param status_cb Pointer to a callback function or NULL
* @param operation Operation name. Will be passed to the callback function
* in async mode or shown in debug messages in sync mode.
* @param user_data Callback data passed to status_cb.
*/
static instproxy_error_t instproxy_perform_operation(instproxy_client_t client, instproxy_status_cb_t status_cb, const char *operation, void *user_data)
{
instproxy_error_t res = INSTPROXY_E_UNKNOWN_ERROR;
int ok = 1;
plist_t dict = NULL;
do {
instproxy_lock(client);
res = instproxy_error(property_list_service_receive_plist_with_timeout(client->parent, &dict, 30000));
instproxy_unlock(client);
if (res != INSTPROXY_E_SUCCESS) {
debug_info("could not receive plist, error %d", res);
break;
}
if (dict) {
/* invoke callback function */
if (status_cb) {
status_cb(operation, dict, user_data);
}
/* check for 'Error', so we can abort cleanly */
plist_t err = plist_dict_get_item(dict, "Error");
if (err) {
#ifndef STRIP_DEBUG_CODE
char *err_msg = NULL;
plist_get_string_val(err, &err_msg);
if (err_msg) {
debug_info("(%s): ERROR: %s", operation, err_msg);
free(err_msg);
}
#endif
ok = 0;
res = INSTPROXY_E_OP_FAILED;
}
/* get 'Status' */
plist_t status = plist_dict_get_item(dict, "Status");
if (status) {
char *status_msg = NULL;
plist_get_string_val(status, &status_msg);
if (status_msg) {
if (!strcmp(status_msg, "Complete")) {
ok = 0;
res = INSTPROXY_E_SUCCESS;
}
#ifndef STRIP_DEBUG_CODE
plist_t npercent = plist_dict_get_item(dict, "PercentComplete");
if (npercent) {
uint64_t val = 0;
int percent;
plist_get_uint_val(npercent, &val);
percent = val;
debug_info("(%s): %s (%d%%)", operation, status_msg, percent);
} else {
debug_info("(%s): %s", operation, status_msg);
}
#endif
free(status_msg);
}
}
plist_free(dict);
dict = NULL;
}
} while (ok && client->parent);
return res;
}
/**
* 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;
}
/**
* Internally used function that will synchronously receive messages from
* the specified installation_proxy until it completes or an error occurs.
*
* If status_cb is not NULL, the callback function will be called each time
* a status update or error message is received.
*
* @param client The connected installation proxy client
* @param status_cb Pointer to a callback function or NULL
* @param command Operation specificiation in plist. Will be passed to the
* status_cb callback.
* @param user_data Callback data passed to status_cb.
*/
static instproxy_error_t instproxy_receive_status_loop(instproxy_client_t client, plist_t command, instproxy_status_cb_t status_cb, void *user_data)
{
instproxy_error_t res = INSTPROXY_E_UNKNOWN_ERROR;
int complete = 0;
plist_t node = NULL;
char* command_name = NULL;
char* status_name = NULL;
char* error_name = NULL;
char* error_description = NULL;
uint64_t error_code = 0;
#ifndef STRIP_DEBUG_CODE
int percent_complete = 0;
#endif
instproxy_command_get_name(command, &command_name);
do {
/* receive status response */
instproxy_lock(client);
res = instproxy_error(property_list_service_receive_plist_with_timeout(client->parent, &node, 1000));
instproxy_unlock(client);
/* break out if we have a communication problem */
if (res != INSTPROXY_E_SUCCESS && res != INSTPROXY_E_RECEIVE_TIMEOUT) {
debug_info("could not receive plist, error %d", res);
break;
}
/* parse status response */
if (node) {
/* check status for possible error to allow reporting it and aborting it gracefully */
res = instproxy_status_get_error(node, &error_name, &error_description, &error_code);
if (res != INSTPROXY_E_SUCCESS) {
debug_info("command: %s, error %d, code 0x%08"PRIx64", name: %s, description: \"%s\"", command_name, res, error_code, error_name, error_description ? error_description: "N/A");
complete = 1;
}
if (error_name) {
free(error_name);
error_name = NULL;
}
if (error_description) {
free(error_description);
error_description = NULL;
}
/* check status from response */
instproxy_status_get_name(node, &status_name);
if (!status_name) {
debug_info("failed to retrieve name from status response with error %d.", res);
complete = 1;
}
if (status_name) {
if (!strcmp(status_name, "Complete")) {
complete = 1;
} else {
res = INSTPROXY_E_OP_IN_PROGRESS;
}
#ifndef STRIP_DEBUG_CODE
percent_complete = -1;
instproxy_status_get_percent_complete(node, &percent_complete);
if (percent_complete >= 0) {
debug_info("command: %s, status: %s, percent (%d%%)", command_name, status_name, percent_complete);
} else {
debug_info("command: %s, status: %s", command_name, status_name);
}
#endif
free(status_name);
status_name = NULL;
}
/* invoke status callback function */
if (status_cb) {
status_cb(command, node, user_data);
}
plist_free(node);
node = NULL;
}
} while (!complete && client->parent);
if (command_name)
free(command_name);
return res;
}
