#include "pkgmgr_installer.h"
#include "pkgmgr-server.h"
-#include "pm-queue.h"
+#include "queue.h"
#include "package-manager.h"
-#define BUFMAX 128
-#define NO_MATCHING_FILE 11
-
#define OWNER_ROOT 0
#define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
#define APPFW_UID 301
Each bit position corresponds to a queue slot which
is dynamically determined.
*/
-char backend_busy = 0;
+static char backend_busy = 0;
extern int num_of_backends;
struct signal_info_t {
static int pipe_sig[2];
static GIOChannel *pipe_io;
static guint pipe_wid;
-
-backend_info *begin;
-extern queue_info_map *start;
-extern int entries;
-
-GMainLoop *mainloop = NULL;
-
-
-/* operation_type */
-typedef enum {
- OPERATION_INSTALL = 0,
- OPERATION_UNINSTALL,
- OPERATION_ACTIVATE,
- OPERATION_REINSTALL,
- OPERATION_MAX
-} OPERATION_TYPE;
+static GHashTable *backend_info_table;
+static GMainLoop *mainloop = NULL;
static int __check_backend_status_for_exit(void);
static int __check_queue_status_for_exit(void);
gboolean exit_server(void *data);
-/* To check whether a particular backend is free/busy*/
+/* To check whether a particular backend is free/busy */
static int __is_backend_busy(int position)
{
- return backend_busy & 1<<position;
+ return backend_busy & (1 << position);
}
-/*To set a particular backend as busy*/
+/* To set a particular backend as busy */
static void __set_backend_busy(int position)
{
- backend_busy = backend_busy | 1<<position;
+ backend_busy = backend_busy | (1 << position);
}
-/*To set a particular backend as free */
+/* To set a particular backend as free */
static void __set_backend_free(int position)
{
- backend_busy = backend_busy & ~(1<<position);
+ backend_busy = backend_busy & ~(1 << position);
}
-static gboolean pipe_io_handler(GIOChannel *io, GIOCondition cond, gpointer data)
+static gboolean pipe_io_handler(GIOChannel *io, GIOCondition cond,
+ gpointer data)
{
- int x;
GError *err = NULL;
GIOStatus s;
gsize len;
struct signal_info_t info;
- backend_info *ptr = begin;
+ struct backend_job *job;
- s = g_io_channel_read_chars(io, (gchar *)&info, sizeof(struct signal_info_t), &len, &err);
+ s = g_io_channel_read_chars(io, (gchar *)&info,
+ sizeof(struct signal_info_t), &len, &err);
if (s != G_IO_STATUS_NORMAL) {
ERR("Signal pipe read failed: %s", err->message);
g_error_free(err);
return TRUE;
}
- for (x = 0; x < num_of_backends; x++, ptr++) {
- if (ptr && ptr->pid == info.pid)
- break;
- }
-
- if (x == num_of_backends) {
+ job = (struct backend_job *)g_hash_table_lookup(backend_info_table,
+ (gconstpointer)info.pid);
+ if (job == NULL) {
ERR("Unknown child exit");
return -1;
}
- __set_backend_free(x);
+ __set_backend_free(job->backend_slot);
if (WIFSIGNALED(info.status)) {
- __send_fail_signal(ptr);
- DBG("backend[%s] exit with signal[%d]", ptr->pkgtype,
+ _send_fail_signal(job);
+ DBG("backend[%s] exit with signal[%d]", job->backend_type,
WTERMSIG(info.status));
} else if (WEXITSTATUS(info.status)) {
- DBG("backend[%s] exit with error", ptr->pkgtype);
+ DBG("backend[%s] exit with error", job->backend_type);
} else {
- DBG("backend[%s] exit", ptr->pkgtype);
+ DBG("backend[%s] exit", job->backend_type);
}
+ g_hash_table_remove(backend_info_table, (gconstpointer)info.pid);
g_idle_add(queue_job, NULL);
return TRUE;
static int __init_backend_info(void)
{
- backend_info *ptr;
-
- /*Allocate memory for holding pid, pkgtype and pkgid*/
- ptr = (backend_info*)calloc(num_of_backends, sizeof(backend_info));
- if (ptr == NULL) {
- DBG("Malloc Failed\n");
- return -1;
- }
- begin = ptr;
+ backend_info_table = g_hash_table_new_full(g_direct_hash,
+ g_direct_equal, NULL,
+ (GDestroyNotify)_free_backend_job);
if (pipe(pipe_sig)) {
ERR("create pipe failed");
close(pipe_sig[1]);
/*Free backend info */
- free(begin);
+ g_hash_table_destroy(backend_info_table);
}
static void sighandler(int signo)
info.pid = waitpid(-1, &info.status, WNOHANG);
if (write(pipe_sig[1], &info, sizeof(struct signal_info_t)) < 0)
- ERR("failed to write result: %s", strerror_r(errno, buf, sizeof(buf)));
+ ERR("failed to write result: %s",
+ strerror_r(errno, buf, sizeof(buf)));
}
static int __register_signal_handler(void)
sigemptyset(&act.sa_mask);
act.sa_flags = SA_NOCLDSTOP;
if (sigaction(SIGCHLD, &act, NULL) < 0) {
- ERR("signal: SIGCHLD failed\n");
+ ERR("signal: SIGCHLD failed");
return -1;
}
static int __check_backend_status_for_exit(void)
{
- int i = 0;
+ int i;
for (i = 0; i < num_of_backends; i++) {
if (__is_backend_busy(i))
return 0;
static int __check_queue_status_for_exit(void)
{
- pm_queue_data *head[MAX_QUEUE_NUM] = {NULL,};
- queue_info_map *ptr = NULL;
- ptr = start;
- int i = 0;
- int c = 0;
- int slot = -1;
- for (i = 0; i < entries; i++) {
- if (ptr->queue_slot <= slot) {
- ptr++;
- } else {
- head[c] = ptr->head;
- slot = ptr->queue_slot;
- c++;
- ptr++;
- }
- }
+ int i;
for (i = 0; i < num_of_backends; i++) {
- if (head[i])
+ if (_is_queue_empty(i) == 0)
return 0;
}
return 1;
gboolean exit_server(void *data)
{
- DBG("exit_server Start\n");
+ DBG("exit_server Start");
if (__check_backend_status_for_exit() &&
__check_queue_status_for_exit()) {
- if (!getenv("PMS_STANDALONE")) {
- g_main_loop_quit(mainloop);
- return FALSE;
- }
+ g_main_loop_quit(mainloop);
+ return FALSE;
}
return TRUE;
}
#ifdef TIZEN_FEATURE_CSR
-static int __check_csr(backend_info *ptr)
+static int __check_csr(const char *path)
{
csr_cs_context_h context = NULL;
csr_cs_malware_h detected = NULL;
}
if (context) {
- ret = csr_cs_scan_file(context, ptr->pkgid, &detected);
+ ret = csr_cs_scan_file(context, path, &detected);
DBG("CSR result[%d]", ret);
csr_cs_context_destroy(context);
if (detected != NULL) {
- ERR("CSR Denied[%s] Installation", ptr->pkgid);
+ ERR("CSR Denied[%s] Installation", path);
return -1;
}
}
return pid;
}
-static int __change_item_info(pm_dbus_msg *item, uid_t uid, bool *is_global)
+static int __change_job_info(struct backend_job *job, uid_t uid,
+ bool *is_global)
{
int ret = 0;
char *pkgid = NULL;
pkgmgrinfo_appinfo_h handle = NULL;
- switch (item->req_type) {
- case PKGMGR_REQUEST_TYPE_DISABLE_APP:
- case PKGMGR_REQUEST_TYPE_DISABLE_GLOBAL_APP_FOR_UID:
- case PKGMGR_REQUEST_TYPE_ENABLE_APP_SPLASH_SCREEN:
- case PKGMGR_REQUEST_TYPE_DISABLE_APP_SPLASH_SCREEN:
- ret = pkgmgrinfo_appinfo_get_usr_appinfo(item->pkgid, uid, &handle);
+ switch (job->req_type) {
+ case REQUEST_TYPE_DISABLE_APP:
+ case REQUEST_TYPE_DISABLE_GLOBAL_APP_FOR_UID:
+ case REQUEST_TYPE_ENABLE_APP_SPLASH_SCREEN:
+ case REQUEST_TYPE_DISABLE_APP_SPLASH_SCREEN:
+ ret = pkgmgrinfo_appinfo_get_usr_appinfo(job->pkgid, uid,
+ &handle);
break;
- case PKGMGR_REQUEST_TYPE_ENABLE_APP:
- case PKGMGR_REQUEST_TYPE_ENABLE_GLOBAL_APP_FOR_UID:
- ret = pkgmgrinfo_appinfo_get_usr_disabled_appinfo(item->pkgid, uid, &handle);
+ case REQUEST_TYPE_ENABLE_APP:
+ case REQUEST_TYPE_ENABLE_GLOBAL_APP_FOR_UID:
+ ret = pkgmgrinfo_appinfo_get_usr_disabled_appinfo(job->pkgid,
+ uid, &handle);
break;
default:
return PMINFO_R_ERROR;
if (ret != PMINFO_R_OK)
goto catch;
- if ((item->req_type == PKGMGR_REQUEST_TYPE_DISABLE_APP
- || item->req_type == PKGMGR_REQUEST_TYPE_ENABLE_APP)
- && *is_global) {
- ret = PMINFO_R_ERROR;
- goto catch;
- } else if ((item->req_type == PKGMGR_REQUEST_TYPE_DISABLE_GLOBAL_APP_FOR_UID
- || item->req_type == PKGMGR_REQUEST_TYPE_ENABLE_GLOBAL_APP_FOR_UID)
- && !*is_global) {
- ret = PMINFO_R_ERROR;
- goto catch;
+ if ((job->req_type == REQUEST_TYPE_DISABLE_APP ||
+ job->req_type == REQUEST_TYPE_ENABLE_APP) &&
+ *is_global) {
+ ret = PMINFO_R_ERROR;
+ goto catch;
+ } else if ((job->req_type == REQUEST_TYPE_DISABLE_GLOBAL_APP_FOR_UID ||
+ job->req_type ==
+ REQUEST_TYPE_ENABLE_GLOBAL_APP_FOR_UID) &&
+ !*is_global) {
+ ret = PMINFO_R_ERROR;
+ goto catch;
}
ret = pkgmgrinfo_appinfo_get_pkgid(handle, &pkgid);
if (ret != PMINFO_R_OK)
goto catch;
- strncpy(item->appid, item->pkgid, sizeof(item->pkgid) - 1);
- memset((item->pkgid), 0, MAX_PKG_NAME_LEN);
- strncpy(item->pkgid, pkgid, sizeof(item->pkgid) - 1);
+ free(job->appid);
+ job->appid = strdup(job->pkgid);
+ free(job->pkgid);
+ job->pkgid = strdup(pkgid);
catch:
pkgmgrinfo_appinfo_destroy_appinfo(handle);
return ret;
}
-static int __process_install(pm_dbus_msg *item)
+static int __process_install(struct backend_job *job)
{
char *backend_cmd;
char **argv;
- char args[MAX_PKG_ARGS_LEN] = {'\0', };
+ char args[MAX_PKG_ARGS_LEN];
int pid;
- backend_cmd = _get_backend_cmd(item->pkg_type);
+ backend_cmd = job->backend_path;
if (backend_cmd == NULL)
return -1;
snprintf(args, sizeof(args), "%s -k %s -i %s -u %d %s", backend_cmd,
- item->req_id, item->pkgid, (int)item->uid, item->args);
+ job->req_id, job->pkgid, (int)job->uid, job->args);
argv = __generate_argv(args);
pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
- free(backend_cmd);
return pid;
}
-static int __process_mount_install(pm_dbus_msg *item)
+static int __process_mount_install(struct backend_job *job)
{
char *backend_cmd;
char **argv;
- char args[MAX_PKG_ARGS_LEN] = {'\0', };
+ char args[MAX_PKG_ARGS_LEN];
int pid;
- backend_cmd = _get_backend_cmd(item->pkg_type);
+ backend_cmd = job->backend_path;
if (backend_cmd == NULL)
return -1;
snprintf(args, sizeof(args), "%s -k %s -w %s -u %d %s", backend_cmd,
- item->req_id, item->pkgid, (int)item->uid, item->args);
+ job->req_id, job->pkgid, (int)job->uid, job->args);
argv = __generate_argv(args);
pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
- free(backend_cmd);
return pid;
}
-static int __process_reinstall(pm_dbus_msg *item)
+static int __process_reinstall(struct backend_job *job)
{
char *backend_cmd;
char **argv;
char args[MAX_PKG_ARGS_LEN];
int pid;
- backend_cmd = _get_backend_cmd(item->pkg_type);
+ backend_cmd = job->backend_path;
if (backend_cmd == NULL)
return -1;
snprintf(args, sizeof(args), "%s -k %s -r %s -u %d", backend_cmd,
- item->req_id, item->pkgid, (int)item->uid);
+ job->req_id, job->pkgid, (int)job->uid);
argv = __generate_argv(args);
pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
- free(backend_cmd);
return pid;
}
-static int __process_uninstall(pm_dbus_msg *item)
+static int __process_uninstall(struct backend_job *job)
{
char *backend_cmd;
char **argv;
char args[MAX_PKG_ARGS_LEN];
int pid;
- backend_cmd = _get_backend_cmd(item->pkg_type);
+ backend_cmd = job->backend_path;
if (backend_cmd == NULL)
return -1;
snprintf(args, sizeof(args), "%s -k %s -d %s -u %d", backend_cmd,
- item->req_id, item->pkgid, (int)item->uid);
+ job->req_id, job->pkgid, (int)job->uid);
argv = __generate_argv(args);
pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
- free(backend_cmd);
return pid;
}
-static int __process_move(pm_dbus_msg *item)
+static int __process_move(struct backend_job *job)
{
char *backend_cmd;
char **argv;
char args[MAX_PKG_ARGS_LEN];
int pid;
- backend_cmd = _get_backend_cmd(item->pkg_type);
+ backend_cmd = job->backend_path;
if (backend_cmd == NULL)
return -1;
snprintf(args, sizeof(args), "%s -k %s -m %s -u %d -t %s", backend_cmd,
- item->req_id, item->pkgid, (int)item->uid, item->args);
+ job->req_id, job->pkgid, (int)job->uid, job->args);
argv = __generate_argv(args);
pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
- free(backend_cmd);
return pid;
}
-static int __process_enable_pkg(pm_dbus_msg *item)
+static int __process_enable_pkg(struct backend_job *job)
{
char *backend_cmd;
char **argv;
char args[MAX_PKG_ARGS_LEN];
int pid;
- backend_cmd = _get_backend_cmd(item->pkg_type);
+ backend_cmd = job->backend_path;
if (backend_cmd == NULL)
return -1;
snprintf(args, sizeof(args), "%s -k %s -u %d -A %s", backend_cmd,
- item->req_id, (int)item->uid, item->pkgid);
+ job->req_id, (int)job->uid, job->pkgid);
argv = __generate_argv(args);
pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
- free(backend_cmd);
return pid;
}
-static int __process_disable_pkg(pm_dbus_msg *item)
+static int __process_disable_pkg(struct backend_job *job)
{
char *backend_cmd;
char **argv;
char args[MAX_PKG_ARGS_LEN];
int pid;
- backend_cmd = _get_backend_cmd(item->pkg_type);
+ backend_cmd = job->backend_path;
if (backend_cmd == NULL)
return -1;
snprintf(args, sizeof(args), "%s -k %s -u %d -D %s", backend_cmd,
- item->req_id, (int)item->uid, item->pkgid);
+ job->req_id, (int)job->uid, job->pkgid);
argv = __generate_argv(args);
pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
- free(backend_cmd);
return pid;
}
-static int __process_enable_app(pm_dbus_msg *item)
+static int __process_enable_app(struct backend_job *job)
{
int ret = -1;
bool is_global = false;
- /* get actual pkgid and replace it to appid which is currently stored at pkgid variable */
- ret = __change_item_info(item, item->uid, &is_global);
- if (ret != PMINFO_R_OK || strlen(item->appid) == 0) {
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->pkgid,
+ /* get actual pkgid and replace it to appid which is currently stored
+ * at pkgid variable
+ */
+ ret = __change_job_info(job, job->uid, &is_global);
+ if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->pkgid,
PKGMGR_INSTALLER_START_KEY_STR,
- PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR, item->req_type);
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->pkgid,
- PKGMGR_INSTALLER_END_KEY_STR, PKGMGR_INSTALLER_FAIL_EVENT_STR,
- item->req_type);
+ PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR,
+ job->req_type);
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->pkgid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_FAIL_EVENT_STR,
+ job->req_type);
return ret;
}
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->appid,
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->appid,
PKGMGR_INSTALLER_START_KEY_STR,
- PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR, item->req_type);
+ PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR, job->req_type);
- ret = pkgmgr_parser_update_app_disable_info_in_usr_db(item->appid, item->uid, 0);
+ ret = pkgmgr_parser_update_app_disable_info_in_usr_db(job->appid,
+ job->uid, 0);
if (ret != PMINFO_R_OK)
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->appid,
- PKGMGR_INSTALLER_END_KEY_STR, PKGMGR_INSTALLER_FAIL_EVENT_STR,
- item->req_type);
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->appid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_FAIL_EVENT_STR,
+ job->req_type);
else
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->appid,
- PKGMGR_INSTALLER_END_KEY_STR, PKGMGR_INSTALLER_OK_EVENT_STR,
- item->req_type);
-
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->appid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_OK_EVENT_STR,
+ job->req_type);
return ret;
}
-static int __process_disable_app(pm_dbus_msg *item)
+static int __process_disable_app(struct backend_job *job)
{
int ret = -1;
bool is_global = false;
- /* get actual pkgid and replace it to appid which is currently stored at pkgid variable */
- ret = __change_item_info(item, item->uid, &is_global);
- if (ret != PMINFO_R_OK || strlen(item->appid) == 0) {
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->pkgid,
+ /* get actual pkgid and replace it to appid which is currently stored
+ * at pkgid variable
+ */
+ ret = __change_job_info(job, job->uid, &is_global);
+ if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->pkgid,
PKGMGR_INSTALLER_START_KEY_STR,
- PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR, item->req_type);
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->pkgid,
- PKGMGR_INSTALLER_END_KEY_STR, PKGMGR_INSTALLER_FAIL_EVENT_STR,
- item->req_type);
+ PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR,
+ job->req_type);
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->pkgid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_FAIL_EVENT_STR,
+ job->req_type);
return ret;
}
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->appid,
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->appid,
PKGMGR_INSTALLER_START_KEY_STR,
- PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR, item->req_type);
+ PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR, job->req_type);
- ret = __kill_app(item->appid, item->uid);
+ ret = __kill_app(job->appid, job->uid);
if (ret != 0) {
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->appid,
- PKGMGR_INSTALLER_END_KEY_STR, PKGMGR_INSTALLER_FAIL_EVENT_STR,
- item->req_type);
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->appid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_FAIL_EVENT_STR,
+ job->req_type);
}
- ret = pkgmgr_parser_update_app_disable_info_in_usr_db(item->appid, item->uid, 1);
+ ret = pkgmgr_parser_update_app_disable_info_in_usr_db(job->appid,
+ job->uid, 1);
if (ret != PMINFO_R_OK)
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->appid,
- PKGMGR_INSTALLER_END_KEY_STR, PKGMGR_INSTALLER_FAIL_EVENT_STR,
- item->req_type);
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->appid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_FAIL_EVENT_STR,
+ job->req_type);
else
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->appid,
- PKGMGR_INSTALLER_END_KEY_STR, PKGMGR_INSTALLER_OK_EVENT_STR,
- item->req_type);
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->appid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_OK_EVENT_STR,
+ job->req_type);
return ret;
}
-static int __process_enable_global_app_for_uid(pm_dbus_msg *item)
+static int __process_enable_global_app_for_uid(struct backend_job *job)
{
int ret = -1;
bool is_global = true;
- /* get actual pkgid and replace it to appid which is currently stored at pkgid variable */
- ret = __change_item_info(item, item->uid, &is_global);
- if (ret != PMINFO_R_OK || strlen(item->appid) == 0) {
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->pkgid,
+ /* get actual pkgid and replace it to appid which is currently stored
+ * at pkgid variable
+ */
+ ret = __change_job_info(job, job->uid, &is_global);
+ if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->pkgid,
PKGMGR_INSTALLER_START_KEY_STR,
- PKGMGR_INSTALLER_GLOBAL_APP_ENABLE_FOR_UID, item->req_type);
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->pkgid,
- PKGMGR_INSTALLER_END_KEY_STR, PKGMGR_INSTALLER_FAIL_EVENT_STR,
- item->req_type);
+ PKGMGR_INSTALLER_GLOBAL_APP_ENABLE_FOR_UID,
+ job->req_type);
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->pkgid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_FAIL_EVENT_STR,
+ job->req_type);
return ret;
}
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->appid,
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->appid,
PKGMGR_INSTALLER_START_KEY_STR,
- PKGMGR_INSTALLER_GLOBAL_APP_ENABLE_FOR_UID, item->req_type);
+ PKGMGR_INSTALLER_GLOBAL_APP_ENABLE_FOR_UID,
+ job->req_type);
- ret = pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(item->appid, item->uid, 0);
+ ret = pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(
+ job->appid, job->uid, 0);
if (ret != PMINFO_R_OK)
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->appid,
- PKGMGR_INSTALLER_END_KEY_STR, PKGMGR_INSTALLER_FAIL_EVENT_STR,
- item->req_type);
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->appid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_FAIL_EVENT_STR,
+ job->req_type);
else
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->appid,
- PKGMGR_INSTALLER_END_KEY_STR, PKGMGR_INSTALLER_OK_EVENT_STR,
- item->req_type);
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->appid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_OK_EVENT_STR,
+ job->req_type);
return ret;
}
-static int __process_disable_global_app_for_uid(pm_dbus_msg *item)
+static int __process_disable_global_app_for_uid(struct backend_job *job)
{
int ret = -1;
bool is_global = true;
- /* get actual pkgid and replace it to appid which is currently stored at pkgid variable */
- ret = __change_item_info(item, GLOBAL_USER, &is_global);
- if (ret != PMINFO_R_OK || strlen(item->appid) == 0) {
- __send_app_signal(item->uid, item->req_id,
- item->pkgid, item->pkgid,
+ /* get actual pkgid and replace it to appid which is currently stored
+ * at pkgid variable
+ */
+ ret = __change_job_info(job, GLOBAL_USER, &is_global);
+ if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
+ _send_app_signal(job->uid, job->req_id,
+ job->pkgid, job->pkgid,
PKGMGR_INSTALLER_START_KEY_STR,
- PKGMGR_INSTALLER_GLOBAL_APP_DISABLE_FOR_UID, item->req_type);
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->pkgid,
- PKGMGR_INSTALLER_END_KEY_STR, PKGMGR_INSTALLER_FAIL_EVENT_STR,
- item->req_type);
+ PKGMGR_INSTALLER_GLOBAL_APP_DISABLE_FOR_UID,
+ job->req_type);
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->pkgid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_FAIL_EVENT_STR,
+ job->req_type);
return ret;
}
- __send_app_signal(item->uid, item->req_id,
- item->pkgid, item->appid,
+ _send_app_signal(job->uid, job->req_id,
+ job->pkgid, job->appid,
PKGMGR_INSTALLER_START_KEY_STR,
- PKGMGR_INSTALLER_GLOBAL_APP_DISABLE_FOR_UID, item->req_type);
+ PKGMGR_INSTALLER_GLOBAL_APP_DISABLE_FOR_UID,
+ job->req_type);
- ret = __kill_app(item->appid, item->uid);
- ret = pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(item->appid,
- item->uid, 1);
+ ret = __kill_app(job->appid, job->uid);
+ ret = pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(
+ job->appid, job->uid, 1);
if (ret != PMINFO_R_OK)
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->appid,
- PKGMGR_INSTALLER_END_KEY_STR, PKGMGR_INSTALLER_FAIL_EVENT_STR,
- item->req_type);
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->appid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_FAIL_EVENT_STR,
+ job->req_type);
else
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->appid,
- PKGMGR_INSTALLER_END_KEY_STR, PKGMGR_INSTALLER_OK_EVENT_STR,
- item->req_type);
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->appid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_OK_EVENT_STR,
+ job->req_type);
return ret;
}
-static int __process_getsize(pm_dbus_msg *item)
+static int __process_getsize(struct backend_job *job)
{
static const char *backend_cmd = "/usr/bin/pkg_getsize";
char **argv;
char args[MAX_PKG_ARGS_LEN];
int pid;
- snprintf(args, sizeof(args), "%s %s %s -k %s", backend_cmd, item->pkgid,
- item->args, item->req_id);
+ snprintf(args, sizeof(args), "%s %s %s -k %s", backend_cmd, job->pkgid,
+ job->args, job->req_id);
argv = __generate_argv(args);
- pid = __fork_and_exec_with_args(argv, item->uid);
+ pid = __fork_and_exec_with_args(argv, job->uid);
g_strfreev(argv);
return pid;
}
-static int __process_cleardata(pm_dbus_msg *item)
+static int __process_cleardata(struct backend_job *job)
{
char *backend_cmd;
char **argv;
char args[MAX_PKG_ARGS_LEN];
int pid;
- backend_cmd = _get_backend_cmd(item->pkg_type);
+ backend_cmd = job->backend_path;
if (backend_cmd == NULL)
return -1;
/* TODO: set movetype */
snprintf(args, sizeof(args), "%s -k %s -c %s -u %d", backend_cmd,
- item->req_id, item->pkgid, (int)item->uid);
+ job->req_id, job->pkgid, (int)job->uid);
argv = __generate_argv(args);
pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
- free(backend_cmd);
return pid;
}
-static int __process_clearcache(pm_dbus_msg *item)
+static int __process_clearcache(struct backend_job *job)
{
static const char *backend_cmd = "/usr/bin/pkg_clearcache";
char **argv;
char args[MAX_PKG_ARGS_LEN];
int pid;
- snprintf(args, sizeof(args), "%s %s", backend_cmd, item->pkgid);
+ snprintf(args, sizeof(args), "%s %s", backend_cmd, job->pkgid);
argv = __generate_argv(args);
- pid = __fork_and_exec_with_args(argv, item->uid);
+ pid = __fork_and_exec_with_args(argv, job->uid);
g_strfreev(argv);
return pid;
}
-static int __process_kill(pm_dbus_msg *item)
+static int __process_kill(struct backend_job *job)
{
int ret;
pkgmgrinfo_pkginfo_h handle;
pkgcmd_data *pdata;
- ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(item->pkgid, item->uid,
+ ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(job->pkgid, job->uid,
&handle);
if (ret < 0) {
ERR("Failed to get handle");
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(ii)", PKGMGR_R_ERROR, 0));
return -1;
}
pdata = calloc(1, sizeof(pkgcmd_data));
if (pdata == NULL) {
ERR("memory alloc failed");
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
return -1;
}
pdata->cmd = strdup("kill");
if (pdata->cmd == NULL) {
ERR("out of memory");
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
free(pdata);
return -1;
}
- pdata->uid = item->uid;
+ pdata->uid = job->uid;
ret = pkgmgrinfo_appinfo_get_usr_list(handle, PMINFO_ALL_APP,
- __pkgcmd_app_cb, pdata, item->uid);
+ __pkgcmd_app_cb, pdata, job->uid);
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(ii)", PKGMGR_R_OK, pdata->pid));
free(pdata->cmd);
return 0;
}
-static int __process_check(pm_dbus_msg *item)
+static int __process_check(struct backend_job *job)
{
int ret;
pkgmgrinfo_pkginfo_h handle;
pkgcmd_data *pdata;
- ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(item->pkgid, item->uid,
+ ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(job->pkgid, job->uid,
&handle);
if (ret < 0) {
ERR("Failed to get handle");
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(ii)", PKGMGR_R_ERROR, 0));
return -1;
}
pdata = calloc(1, sizeof(pkgcmd_data));
if (pdata == NULL) {
ERR("memory alloc failed");
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
return -1;
}
pdata->cmd = strdup("check");
if (pdata->cmd == NULL) {
ERR("out of memory");
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
free(pdata);
return -1;
}
- pdata->uid = item->uid;
+ pdata->uid = job->uid;
ret = pkgmgrinfo_appinfo_get_usr_list(handle, PMINFO_ALL_APP,
- __pkgcmd_app_cb, pdata, item->uid);
+ __pkgcmd_app_cb, pdata, job->uid);
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(ii)", PKGMGR_R_OK, pdata->pid));
free(pdata->cmd);
return 0;
}
-static int __process_generate_license_request(pm_dbus_msg *item)
+static int __process_generate_license_request(struct backend_job *job)
{
int ret;
char *resp_data;
char license_url[MAX_PKG_ARGS_LEN];
unsigned int license_url_len;
- resp_data = item->args;
+ resp_data = job->args;
req_data_len = sizeof(req_data);
license_url_len = sizeof(license_url);
req_data, &req_data_len, license_url, &license_url_len);
if (ret != TADC_SUCCESS) {
ERR("drm_tizen_generate_license_request failed: %d", ret);
- __return_value_to_caller(item->req_id, g_variant_new("(iss)",
+ _return_value_to_caller(job->req_id, g_variant_new("(iss)",
PKGMGR_R_ESYSTEM, "", ""));
return -1;
}
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(iss)", PKGMGR_R_OK, req_data,
license_url));
return 0;
}
-static int __process_register_license(pm_dbus_msg *item)
+static int __process_register_license(struct backend_job *job)
{
int ret;
char *resp_data;
- resp_data = item->args;
+ resp_data = job->args;
ret = drm_tizen_register_license(resp_data, strlen(resp_data));
if (ret != TADC_SUCCESS) {
ERR("drm_tizen_register_license failed: %d", ret);
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(i)", PKGMGR_R_ESYSTEM));
return -1;
}
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(i)", PKGMGR_R_OK));
return 0;
}
-static int __process_decrypt_package(pm_dbus_msg *item)
+static int __process_decrypt_package(struct backend_job *job)
{
int ret;
char *drm_file_path;
char *decrypted_file_path;
- drm_file_path = item->pkgid;
- decrypted_file_path = item->args;
+ drm_file_path = job->pkgid;
+ decrypted_file_path = job->args;
/* TODO: check ownership of decrypted file */
ret = drm_tizen_decrypt_package(drm_file_path, strlen(drm_file_path),
decrypted_file_path, strlen(decrypted_file_path));
if (ret != TADC_SUCCESS) {
ERR("drm_tizen_register_license failed: %d", ret);
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(i)", PKGMGR_R_ESYSTEM));
return -1;
}
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(i)", PKGMGR_R_OK));
return 0;
}
-static int __process_update_app_splash_screen(pm_dbus_msg *item, int flag)
+static int __process_update_app_splash_screen(struct backend_job *job, int flag)
{
int ret;
bool is_global = false;
const char *val;
- ret = __change_item_info(item, item->uid, &is_global);
- if (ret != PMINFO_R_OK || strlen(item->appid) == 0)
+ ret = __change_job_info(job, job->uid, &is_global);
+ if (ret != PMINFO_R_OK || strlen(job->appid) == 0)
return -1;
val = flag ? PKGMGR_INSTALLER_APP_ENABLE_SPLASH_SCREEN_EVENT_STR :
PKGMGR_INSTALLER_APP_DISABLE_SPLASH_SCREEN_EVENT_STR;
- __send_app_signal(item->uid, item->req_id, item->pkgid, item->appid,
- PKGMGR_INSTALLER_START_KEY_STR, val, item->req_type);
+ _send_app_signal(job->uid, job->req_id, job->pkgid, job->appid,
+ PKGMGR_INSTALLER_START_KEY_STR, val, job->req_type);
if (is_global)
- ret = pkgmgr_parser_update_global_app_splash_screen_display_info_in_usr_db(
- item->appid, item->uid, flag);
+ ret = pkgmgr_parser_update_global_app_splash_screen_display_info_in_usr_db(job->appid, job->uid, flag);
else
ret = pkgmgr_parser_update_app_splash_screen_display_info_in_usr_db(
- item->appid, item->uid, flag);
+ job->appid, job->uid, flag);
if (ret != PMINFO_R_OK)
- __send_app_signal(item->uid, item->req_id, item->pkgid,
- item->appid, PKGMGR_INSTALLER_END_KEY_STR,
+ _send_app_signal(job->uid, job->req_id, job->pkgid,
+ job->appid, PKGMGR_INSTALLER_END_KEY_STR,
PKGMGR_INSTALLER_FAIL_EVENT_STR,
- item->req_type);
+ job->req_type);
else
- __send_app_signal(item->uid, item->req_id, item->pkgid,
- item->appid, PKGMGR_INSTALLER_END_KEY_STR,
+ _send_app_signal(job->uid, job->req_id, job->pkgid,
+ job->appid, PKGMGR_INSTALLER_END_KEY_STR,
PKGMGR_INSTALLER_OK_EVENT_STR,
- item->req_type);
+ job->req_type);
return ret;
}
-static int __process_set_restriction_mode(pm_dbus_msg *item)
+static int __process_set_restriction_mode(struct backend_job *job)
{
int ret;
int mode;
- mode = atoi(item->args);
- ret = _restriction_mode_set(item->uid, item->pkgid, mode);
+ mode = atoi(job->args);
+ ret = _set_restriction_mode(job->uid, job->pkgid, mode);
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(i)", ret));
return ret;
}
-static int __process_unset_restriction_mode(pm_dbus_msg *item)
+static int __process_unset_restriction_mode(struct backend_job *job)
{
int ret;
int mode;
- mode = atoi(item->args);
- ret = _restriction_mode_unset(item->uid, item->pkgid, mode);
+ mode = atoi(job->args);
+ ret = _unset_restriction_mode(job->uid, job->pkgid, mode);
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(i)", ret));
return ret;
}
-static int __process_get_restriction_mode(pm_dbus_msg *item)
+static int __process_get_restriction_mode(struct backend_job *job)
{
int ret;
int mode = -1;
- ret = _restriction_mode_get(item->uid, item->pkgid, &mode);
+ ret = _get_restriction_mode(job->uid, job->pkgid, &mode);
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(ii)", mode, ret));
return ret;
gboolean queue_job(void *data)
{
- pm_dbus_msg *item = NULL;
- backend_info *ptr;
+ struct backend_job *job = NULL;
int x;
int ret;
/* Pop a job from queue */
- for (x = 0, ptr = begin; x < num_of_backends; x++, ptr++) {
+ for (x = 0; x < num_of_backends; x++) {
if (__is_backend_busy(x))
continue;
- item = _pm_queue_pop(x);
- if (item && item->req_type != -1)
+ job = _pop_queue(x);
+ if (job)
break;
- free(item);
}
/* all backend messages queue are empty or busy */
- if (x == num_of_backends)
+ if (x == num_of_backends || job == NULL) {
+ DBG("no job left");
return FALSE;
+ }
- /*save pkg type and pkg name for future*/
- strncpy(ptr->req_id, item->req_id, MAX_REQ_ID_LEN - 1);
- strncpy(ptr->pkgtype, item->pkg_type, MAX_PKG_TYPE_LEN - 1);
- strncpy(ptr->pkgid, item->pkgid, MAX_PKG_NAME_LEN - 1);
- free(ptr->args);
- if (item->args)
- ptr->args = strdup(item->args);
- memset((item->appid), 0, MAX_PKG_NAME_LEN);
- ptr->uid = item->uid;
- ptr->req_type = item->req_type;
- DBG("handle request type [%d]", item->req_type);
+ /* set current backend job */
+ DBG("handle request type [%d]", job->req_type);
#ifdef TIZEN_FEATURE_CSR
- if (item->req_type == PKGMGR_REQUEST_TYPE_INSTALL ||
- item->req_type == PKGMGR_REQUEST_TYPE_MOUNT_INSTALL ||
- item->req_type == PKGMGR_REQUEST_TYPE_REINSTALL) {
- ret = __check_csr(ptr);
+ if (job->req_type == REQUEST_TYPE_INSTALL ||
+ job->req_type == REQUEST_TYPE_MOUNT_INSTALL ||
+ job->req_type == REQUEST_TYPE_REINSTALL) {
+ ret = __check_csr(job->pkgid);
if (ret != 0) {
ret = -1;
- __send_fail_signal(ptr);
- goto end;
+ _send_fail_signal(job);
+ _free_backend_job(job);
+ return FALSE;
}
}
#endif
- switch (item->req_type) {
- case PKGMGR_REQUEST_TYPE_INSTALL:
+ switch (job->req_type) {
+ case REQUEST_TYPE_INSTALL:
__set_backend_busy(x);
- ret = __process_install(item);
+ ret = __process_install(job);
+ g_hash_table_insert(backend_info_table, (gpointer)ret,
+ (gpointer)job);
break;
- case PKGMGR_REQUEST_TYPE_MOUNT_INSTALL:
+ case REQUEST_TYPE_MOUNT_INSTALL:
__set_backend_busy(x);
- ret = __process_mount_install(item);
+ ret = __process_mount_install(job);
+ g_hash_table_insert(backend_info_table, (gpointer)ret,
+ (gpointer)job);
break;
- case PKGMGR_REQUEST_TYPE_REINSTALL:
+ case REQUEST_TYPE_REINSTALL:
__set_backend_busy(x);
- ret = __process_reinstall(item);
+ ret = __process_reinstall(job);
+ g_hash_table_insert(backend_info_table, (gpointer)ret,
+ (gpointer)job);
break;
- case PKGMGR_REQUEST_TYPE_UNINSTALL:
+ case REQUEST_TYPE_UNINSTALL:
__set_backend_busy(x);
- ret = __process_uninstall(item);
+ ret = __process_uninstall(job);
+ g_hash_table_insert(backend_info_table, (gpointer)ret,
+ (gpointer)job);
break;
- case PKGMGR_REQUEST_TYPE_MOVE:
+ case REQUEST_TYPE_MOVE:
__set_backend_busy(x);
- ret = __process_move(item);
+ ret = __process_move(job);
+ g_hash_table_insert(backend_info_table, (gpointer)ret,
+ (gpointer)job);
break;
- case PKGMGR_REQUEST_TYPE_ENABLE_PKG:
+ case REQUEST_TYPE_ENABLE_PKG:
__set_backend_busy(x);
- ret = __process_enable_pkg(item);
+ ret = __process_enable_pkg(job);
+ g_hash_table_insert(backend_info_table, (gpointer)ret,
+ (gpointer)job);
break;
- case PKGMGR_REQUEST_TYPE_DISABLE_PKG:
+ case REQUEST_TYPE_DISABLE_PKG:
__set_backend_busy(x);
- ret = __process_disable_pkg(item);
+ ret = __process_disable_pkg(job);
+ g_hash_table_insert(backend_info_table, (gpointer)ret,
+ (gpointer)job);
break;
- case PKGMGR_REQUEST_TYPE_ENABLE_APP:
- ret = __process_enable_app(item);
+ case REQUEST_TYPE_ENABLE_APP:
+ ret = __process_enable_app(job);
break;
- case PKGMGR_REQUEST_TYPE_DISABLE_APP:
- ret = __process_disable_app(item);
+ case REQUEST_TYPE_DISABLE_APP:
+ ret = __process_disable_app(job);
break;
- case PKGMGR_REQUEST_TYPE_GETSIZE:
+ case REQUEST_TYPE_GETSIZE:
__set_backend_busy(x);
- ret = __process_getsize(item);
+ ret = __process_getsize(job);
break;
- case PKGMGR_REQUEST_TYPE_CLEARDATA:
+ case REQUEST_TYPE_CLEARDATA:
__set_backend_busy(x);
- ret = __process_cleardata(item);
+ ret = __process_cleardata(job);
break;
- case PKGMGR_REQUEST_TYPE_CLEARCACHE:
+ case REQUEST_TYPE_CLEARCACHE:
__set_backend_busy(x);
- ret = __process_clearcache(item);
+ ret = __process_clearcache(job);
+ _free_backend_job(job);
break;
- case PKGMGR_REQUEST_TYPE_ENABLE_GLOBAL_APP_FOR_UID:
- ret = __process_enable_global_app_for_uid(item);
+ case REQUEST_TYPE_ENABLE_GLOBAL_APP_FOR_UID:
+ ret = __process_enable_global_app_for_uid(job);
+ _free_backend_job(job);
break;
- case PKGMGR_REQUEST_TYPE_DISABLE_GLOBAL_APP_FOR_UID:
- ret = __process_disable_global_app_for_uid(item);
+ case REQUEST_TYPE_DISABLE_GLOBAL_APP_FOR_UID:
+ ret = __process_disable_global_app_for_uid(job);
+ _free_backend_job(job);
break;
- case PKGMGR_REQUEST_TYPE_KILL:
- ret = __process_kill(item);
+ case REQUEST_TYPE_KILL:
+ ret = __process_kill(job);
+ _free_backend_job(job);
break;
- case PKGMGR_REQUEST_TYPE_CHECK:
- ret = __process_check(item);
+ case REQUEST_TYPE_CHECK:
+ ret = __process_check(job);
+ _free_backend_job(job);
break;
- case PKGMGR_REQUEST_TYPE_GENERATE_LICENSE_REQUEST:
- ret = __process_generate_license_request(item);
+ case REQUEST_TYPE_GENERATE_LICENSE_REQUEST:
+ ret = __process_generate_license_request(job);
+ _free_backend_job(job);
break;
- case PKGMGR_REQUEST_TYPE_REGISTER_LICENSE:
- ret = __process_register_license(item);
+ case REQUEST_TYPE_REGISTER_LICENSE:
+ ret = __process_register_license(job);
+ _free_backend_job(job);
break;
- case PKGMGR_REQUEST_TYPE_DECRYPT_PACKAGE:
- ret = __process_decrypt_package(item);
+ case REQUEST_TYPE_DECRYPT_PACKAGE:
+ ret = __process_decrypt_package(job);
+ _free_backend_job(job);
break;
- case PKGMGR_REQUEST_TYPE_ENABLE_APP_SPLASH_SCREEN:
- ret = __process_update_app_splash_screen(item, 1);
+ case REQUEST_TYPE_ENABLE_APP_SPLASH_SCREEN:
+ ret = __process_update_app_splash_screen(job, 1);
+ _free_backend_job(job);
break;
- case PKGMGR_REQUEST_TYPE_DISABLE_APP_SPLASH_SCREEN:
- ret = __process_update_app_splash_screen(item, 0);
+ case REQUEST_TYPE_DISABLE_APP_SPLASH_SCREEN:
+ ret = __process_update_app_splash_screen(job, 0);
+ _free_backend_job(job);
break;
- case PKGMGR_REQUEST_TYPE_SET_RESTRICTION_MODE:
- ret = __process_set_restriction_mode(item);
+ case REQUEST_TYPE_SET_RESTRICTION_MODE:
+ ret = __process_set_restriction_mode(job);
+ _free_backend_job(job);
break;
- case PKGMGR_REQUEST_TYPE_UNSET_RESTRICTION_MODE:
- ret = __process_unset_restriction_mode(item);
+ case REQUEST_TYPE_UNSET_RESTRICTION_MODE:
+ ret = __process_unset_restriction_mode(job);
+ _free_backend_job(job);
break;
- case PKGMGR_REQUEST_TYPE_GET_RESTRICTION_MODE:
- ret = __process_get_restriction_mode(item);
+ case REQUEST_TYPE_GET_RESTRICTION_MODE:
+ ret = __process_get_restriction_mode(job);
+ _free_backend_job(job);
break;
default:
ret = -1;
break;
}
-#ifdef TIZEN_FEATURE_CSR
-end:
-#endif
- ptr->pid = ret;
- free(item);
-
return FALSE;
}
-#define IS_WHITESPACE(CHAR) \
-((CHAR == ' ' || CHAR == '\t' || CHAR == '\r' || CHAR == '\n') ? TRUE : FALSE)
-
-void _app_str_trim(char *input)
-{
- char *trim_str = input;
-
- if (input == NULL)
- return;
-
- while (*input != 0) {
- if (!IS_WHITESPACE(*input)) {
- *trim_str = *input;
- trim_str++;
- }
- input++;
- }
-
- *trim_str = 0;
- return;
-}
-
-char *_get_backend_cmd(char *type)
-{
- FILE *fp = NULL;
- char buffer[1024] = { 0 };
- char *command = NULL;
- int size = 0;
-
- fp = fopen(PKG_CONF_PATH, "r");
- if (fp == NULL)
- return NULL;
-
- char *path = NULL;
- while (fgets(buffer, 1024, fp) != NULL) {
- if (buffer[0] == '#')
- continue;
-
- _app_str_trim(buffer);
-
- if ((path = strstr(buffer, PKG_BACKEND)) != NULL) {
- DBG("buffer [%s]", buffer);
- path = path + strlen(PKG_BACKEND);
- DBG("path [%s]", path);
-
- command =
- (char *)malloc(sizeof(char) * strlen(path) +
- strlen(type) + 1);
- if (command == NULL) {
- fclose(fp);
- return NULL;
- }
-
- size = strlen(path) + strlen(type) + 1;
- snprintf(command, size, "%s%s", path, type);
- command[strlen(path) + strlen(type)] = '\0';
- DBG("command [%s]", command);
-
- if (fp != NULL)
- fclose(fp);
-
- return command;
- }
-
- memset(buffer, 0x00, 1024);
- }
-
- if (fp != NULL)
- fclose(fp);
-
- return NULL; /* cannot find proper command */
-}
-
int main(int argc, char *argv[])
{
int r;
DBG("server start");
- r = _pm_queue_init();
+ r = _init_backend_queue();
if (r) {
- DBG("Queue Initialization Failed\n");
+ DBG("Queue Initialization Failed");
return -1;
}
return -1;
}
- r = __init_request_handler();
+ r = _init_request_handler();
if (r) {
ERR("dbus init failed");
return -1;
g_main_loop_run(mainloop);
DBG("Quit main loop.");
- __fini_request_handler();
+ _fini_request_handler();
__fini_backend_info();
- _pm_queue_final();
+ _fini_backend_queue();
DBG("package manager server terminated.");
+++ /dev/null
-/*
- * slp-pkgmgr
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <dirent.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <ctype.h>
-
-#include "pkgmgr-server.h"
-#include "pm-queue.h"
-
-#ifndef BACKEND_DIR
-#define BACKEND_DIR "/etc/package-manager/backend"
-#endif
-
-static pm_queue_data *__get_head_from_pkgtype(const char *pkg_type);
-static void __update_head_from_pkgtype(pm_queue_data *data);
-static int __entry_exist(char *backend);
-static int __is_pkg_supported(const char *pkgtype);
-
-queue_info_map *start = NULL;
-int entries = 0;
-int slot = 0;
-int num_of_backends = 0;
-
-/*Function to check whether a particular package type
-is supported or not. It parses the queue info map
-to get the information.
-It will prevent the accidental hanging of server.
-Returns 1 if found.*/
-static int __is_pkg_supported(const char *pkgtype)
-{
- queue_info_map *ptr = NULL;
- ptr = start;
- int i = 0;
- for (i = 0; i < entries; i++) {
- if (!strncmp(ptr->pkgtype, pkgtype, MAX_PKG_TYPE_LEN))
- return 1;
- else
- ptr++;
- }
- return 0;
-}
-
-/*tells whether a particular backend exists in the
-* info map or not.
-* on Success it return the queue slot of the already present entry
-* on Failure -1 is returned*/
-static int __entry_exist(char *backend)
-{
- queue_info_map *ptr = NULL;
- ptr = start;
- int i = 0;
- for (i = 0; i < entries; i++) {
- if (!strncmp(ptr->backend, backend, MAX_PKG_NAME_LEN))
- return ptr->queue_slot;
- else
- ptr++;
- }
- return -1;
-}
-
-/*In case of first push, it updates the queue head
-and copies it to all duplicate entries in queue info map*/
-static void __update_head_from_pkgtype(pm_queue_data *data)
-{
- queue_info_map *ptr = NULL;
- ptr = start;
- int slot = -1;
- int i = 0;
- for (i = 0; i < entries; i++) {
- if (!strncmp(ptr->pkgtype, data->msg->pkg_type, MAX_PKG_TYPE_LEN)) {
- ptr->head = data;
- slot = ptr->queue_slot;
- } else {
- ptr++;
- }
- }
- /*update head for each duplicate entry*/
- ptr = start;
- for (i = 0; i < entries; i++) {
- if (ptr->queue_slot == slot && !ptr->head)
- ptr->head = data;
-
- ptr++;
- }
- return;
-}
-
-/*Gets the queue head based on pkg type*/
-static pm_queue_data *__get_head_from_pkgtype(const char *pkg_type)
-{
- queue_info_map *ptr = NULL;
- ptr = start;
- int i = 0;
- for (i = 0; i < entries; i++) {
- if (!strncmp(ptr->pkgtype, pkg_type, MAX_PKG_TYPE_LEN))
- return ptr->head;
- else
- ptr++;
- }
- return NULL;
-
-}
-
-int _pm_queue_init(void)
-{
- /*Find the num of backends currently supported and initialize
- that many queues. It is dynamically determined.*/
- struct dirent **namelist;
- struct stat fileinfo = {0};
- queue_info_map *ptr = NULL;
- int n = 0;
- int c = 0;
- int i = 0;
- int ret = 0;
- char abs_filename[MAX_PKG_NAME_LEN] = {'\0'};
- char buf[MAX_PKG_NAME_LEN] = {'\0'};
- n = scandir(BACKEND_DIR, &namelist, NULL, alphasort);
- if (n < 0) {
- perror("scandir");
- return -1;
- }
- i = n;
- /* Find number of backends (symlinks + executables)
- The backend dir should not conatin any other file except the backends. */
- while (n--) {
- if (!strcmp(namelist[n]->d_name, ".") ||
- !strcmp(namelist[n]->d_name, ".."))
- continue;
- snprintf(abs_filename, MAX_PKG_NAME_LEN, "%s/%s",
- BACKEND_DIR, namelist[n]->d_name);
- if (lstat(abs_filename, &fileinfo)) {
- perror("lstat");
- continue;
- }
- if (S_ISDIR(fileinfo.st_mode))
- continue;
- c++;
- memset(abs_filename, 0x00, MAX_PKG_NAME_LEN);
- }
- /* Add entries to info map. */
- ptr = (queue_info_map*)calloc(c , sizeof(queue_info_map));
- memset(ptr, '\0', c * sizeof(queue_info_map));
- start = ptr;
- for (n = 0; n < c ; n++) {
- ptr->backend[0] = '\0';
- ptr->head = NULL;
- ptr->queue_slot = -2; /* -1 can be error return */
- ptr->pkgtype[0] = '\0';
- ptr++;
- }
- n = i;
- ptr = start;
- while (n--) {
- if (!strcmp(namelist[n]->d_name, ".") ||
- !strcmp(namelist[n]->d_name, ".."))
- continue;
- snprintf(abs_filename, MAX_PKG_NAME_LEN, "%s/%s",
- BACKEND_DIR, namelist[n]->d_name);
- if (lstat(abs_filename, &fileinfo) < 0) {
- perror(abs_filename);
- return -1;
- }
- if (S_ISDIR(fileinfo.st_mode))
- continue;
- /*Found backend*/
- if (S_ISLNK(fileinfo.st_mode)) {
- /*found a symlink*/
- ret = readlink(abs_filename, buf, MAX_PKG_NAME_LEN - 1);
- if (ret == -1) {
- perror("readlink");
- return -1;
- }
- buf[ret] = '\0';
- } else {
- /*executable*/
- snprintf(buf, sizeof(buf), "%s", abs_filename);
- }
- ret = __entry_exist(buf);
- if (ret == -1) {
- snprintf(ptr->backend, sizeof(ptr->backend), "%s", buf);
- snprintf(ptr->pkgtype, sizeof(ptr->pkgtype), "%s", namelist[n]->d_name);
- ptr->queue_slot = slot;
- ptr->head = NULL;
- entries++;
- slot++;
- ptr++;
- } else {
- snprintf(ptr->backend, sizeof(ptr->backend), "%s", buf);
- snprintf(ptr->pkgtype, sizeof(ptr->pkgtype), "%s", namelist[n]->d_name);
- ptr->queue_slot = ret;
- ptr->head = NULL;
- entries++;
- ptr++;
- }
- free(namelist[n]);
- memset(buf, 0x00, MAX_PKG_NAME_LEN);
- continue;
- }
- free(namelist);
- num_of_backends = slot;
-
-#ifdef DEBUG_INFO
- /*Debug info*/
- DBG("Queue Info Map");
- DBG("Number of Backends is %d", num_of_backends);
- DBG("Number of Entries is %d", entries);
- DBG("Backend\tType\tSlot\tHead");
- ptr = start;
- for (n = 0; n < entries; n++) {
- DBG("%s\t%s\t%d\t%p", ptr->backend, ptr->pkgtype, ptr->queue_slot, ptr->head);
- ptr++;
- }
-#endif
-
- return 0;
-}
-
-static void __convert_to_lower_case(char *dst, const char *src)
-{
- int i;
-
- for (i = 0; src[i] != '\0'; i++)
- dst[i] = tolower(src[i]);
- dst[i] = '\0';
-}
-
-int _pm_queue_push(uid_t uid, const char *req_id, int req_type,
- const char *queue_type, const char *pkgid, const char *args)
-{
- pm_queue_data *data = NULL;
- pm_queue_data *cur = NULL;
- pm_queue_data *tmp = NULL;
- char type[MAX_PKG_NAME_LEN];
- int ret;
-
- __convert_to_lower_case(type, queue_type);
-
- ret = __is_pkg_supported(type);
- if (ret == 0)
- return -1;
-
- cur = __get_head_from_pkgtype(type);
- tmp = cur;
-
- /* TODO: use glist */
- data = _add_node();
- if (!data) { /* fail to allocate mem */
- ERR("Fail to allocate memory\n");
- return -1;
- }
-
- snprintf(data->msg->req_id, sizeof(data->msg->req_id), "%s", req_id);
- data->msg->req_type = req_type;
- data->msg->uid = uid;
- snprintf(data->msg->pkg_type, sizeof(data->msg->pkg_type), "%s", type);
- snprintf(data->msg->pkgid, sizeof(data->msg->pkgid), "%s", pkgid);
- if (args)
- data->msg->args = strdup(args);
-
- data->next = NULL;
-
- if (cur == NULL) {
- /* first push */
- cur = data;
- __update_head_from_pkgtype(data);
- } else {
- while (tmp->next)
- tmp = tmp->next;
-
- tmp->next = data;
- }
- return 0;
-}
-
-/*pop request from queue slot "position" */
-pm_dbus_msg *_pm_queue_pop(int position)
-{
- pm_dbus_msg *ret;
- pm_queue_data *cur = NULL;
- pm_queue_data *saveptr = NULL;
- queue_info_map *ptr = NULL;
- int i = 0;
-
- ret = (pm_dbus_msg *) malloc(sizeof(pm_dbus_msg));
- if (!ret) {
- ERR("Mem alloc error");
- return NULL;
- }
- memset(ret, 0x00, sizeof(pm_dbus_msg));
- ptr = start;
- for (i = 0; i < entries; i++) {
- if (ptr->queue_slot == position) {
- cur = ptr->head;
- break;
- }
- ptr++;
- }
-
- if (!cur) { /* queue is empty */
- ret->req_type = -1;
- return ret;
- }
-
- snprintf(ret->req_id, sizeof(ret->req_id), "%s", cur->msg->req_id);
- ret->req_type = cur->msg->req_type;
- ret->uid = cur->msg->uid;
- snprintf(ret->pkg_type, sizeof(ret->pkg_type), "%s", cur->msg->pkg_type);
- snprintf(ret->pkgid, sizeof(ret->pkgid), "%s", cur->msg->pkgid);
- if (cur->msg->args)
- ret->args = strdup(cur->msg->args);
-
- ptr->head = cur->next;
- saveptr = ptr->head;
- cur->next = NULL;
- free(cur->msg);
- free(cur);
- /* update head for each duplicate queue entry */
- ptr = start;
- for (i = 0; i < entries; i++) {
- if (ptr->queue_slot == position)
- ptr->head = saveptr;
-
- ptr++;
- }
- return ret;
-}
-
-/* populate an array of all queue heads and delete them one by one */
-void _pm_queue_final()
-{
- int c = 0;
- int i = 0;
- int slot = -1;
- pm_queue_data *cur = NULL;
- pm_queue_data *tail = NULL;
- pm_queue_data *prev = NULL;
- pm_queue_data *head[MAX_QUEUE_NUM] = {NULL,};
- queue_info_map *ptr = NULL;
- ptr = start;
-
- for (i = 0; i < num_of_backends; i++)
- head[i] = NULL;
-
- for (i = 0; i < entries; i++) {
- if (ptr->queue_slot <= slot) {
- ptr++;
- } else {
- head[c] = ptr->head;
- slot = ptr->queue_slot;
- c++;
- ptr++;
- }
- }
-
- c = 0;
- while (c < num_of_backends) {
- if (!head[c]) { /* in case of head is NULL */
- c = c + 1;
- continue;
- }
-
- while (head[c]->next) {
- cur = head[c]->next;
-
- while (cur->next) {
- prev = cur;
- cur = cur->next;
- }
-
- tail = cur;
-
- free(tail->msg);
- free(tail);
- prev->next = NULL;
- }
-
- free(head[c]->msg->args);
- free(head[c]->msg);
- free(head[c]);
-
- head[c] = NULL;
- c = c + 1;
- }
- /*Free the info map*/
- if (start) {
- free(start);
- start = NULL;
- }
-}
-
-pm_queue_data *_add_node()
-{
- pm_queue_data *newnode = NULL;
-
- newnode = (pm_queue_data *) malloc(sizeof(pm_queue_data));
- if (!newnode) { /* if NULL */
- ERR("Mem alloc error");
- return NULL;
- }
- memset(newnode, 0x00, sizeof(pm_queue_data));
-
- newnode->msg = (pm_dbus_msg *) malloc(sizeof(pm_dbus_msg));
- if (!newnode->msg) {
- ERR("Mem alloc error");
- free(newnode);
- return NULL;
- }
- memset(newnode->msg, 0x00, sizeof(pm_dbus_msg));
-
- return newnode;
-}
-
-void _pm_queue_delete(pm_dbus_msg *item)
-{
- /* Assume that pacakge name is unique */
- pm_queue_data *cur = NULL;
- pm_queue_data *prev = NULL;
- cur = __get_head_from_pkgtype(item->pkg_type);
- prev = cur;
- if (cur) {
- while (cur->next) {
- if (!strcmp(item->pkgid, cur->msg->pkgid)) {
- prev->next = cur->next;
- free(cur->msg);
- free(cur);
- break;
- }
- prev = cur;
- cur = cur->next;
- }
- }
-}
-
-void _print_queue(int position)
-{
- pm_queue_data *cur = NULL;
- queue_info_map *ptr = start;
- int i = 0;
- for (i = 0; i < entries; i++) {
- if (ptr->queue_slot == position) {
- cur = ptr->head;
- break;
- }
- ptr++;
- }
- int index = 1;
- if (!cur)
- return;
-
- while (cur) {
- index++;
- cur = cur->next;
- }
-}
#include <gum/gum-user.h>
#include <gum/common/gum-user-types.h>
-#include "pm-queue.h"
+#include "queue.h"
#include "pkgmgr-server.h"
#include "package-manager.h"
int i = 0;
int len = 0;
- g_variant_get(parameters, "(u&s&s@as)", &target_uid, &pkgtype, &pkgpath, &value);
+ g_variant_get(parameters, "(u&s&s@as)", &target_uid, &pkgtype, &pkgpath,
+ &value);
tmp_args = (gchar **)g_variant_get_strv(value, &args_count);
for (i = 0; i < args_count; i++)
goto catch;
}
- if (_pm_queue_push(target_uid, reqkey, PKGMGR_REQUEST_TYPE_INSTALL, pkgtype,
+ if (_push_queue(target_uid, reqkey, REQUEST_TYPE_INSTALL, pkgtype,
pkgpath, args)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(is)", PKGMGR_R_ESYSTEM, ""));
int i = 0;
int len = 0;
- g_variant_get(parameters, "(u&s&s@as)", &target_uid, &pkgtype, &pkgpath, &value);
+ g_variant_get(parameters, "(u&s&s@as)", &target_uid, &pkgtype, &pkgpath,
+ &value);
tmp_args = (gchar **)g_variant_get_strv(value, &args_count);
for (i = 0; i < args_count; i++)
goto catch;
}
- if (_pm_queue_push(target_uid, reqkey, PKGMGR_REQUEST_TYPE_MOUNT_INSTALL,
- pkgtype, pkgpath, args)) {
+ if (_push_queue(target_uid, reqkey, REQUEST_TYPE_MOUNT_INSTALL,
+ pkgtype, pkgpath, args)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(is)", PKGMGR_R_ESYSTEM, ""));
ret = -1;
g_variant_new("(is)", PKGMGR_R_ENOMEM, ""));
return -1;
}
- if (_pm_queue_push(target_uid, reqkey, PKGMGR_REQUEST_TYPE_REINSTALL, pkgtype,
- pkgid, "")) {
+ if (_push_queue(target_uid, reqkey, REQUEST_TYPE_REINSTALL, pkgtype,
+ pkgid, NULL)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(is)", PKGMGR_R_ESYSTEM, ""));
free(reqkey);
g_variant_new("(is)", PKGMGR_R_ENOMEM, ""));
return -1;
}
- if (_pm_queue_push(target_uid, reqkey, PKGMGR_REQUEST_TYPE_UNINSTALL, pkgtype,
- pkgid, "")) {
+ if (_push_queue(target_uid, reqkey, REQUEST_TYPE_UNINSTALL, pkgtype,
+ pkgid, NULL)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(is)", PKGMGR_R_ESYSTEM, ""));
free(reqkey);
int move_type = -1;
char buf[4] = { '\0' };
- g_variant_get(parameters, "(u&s&si)", &target_uid, &pkgtype, &pkgid, &move_type);
+ g_variant_get(parameters, "(u&s&si)", &target_uid, &pkgtype, &pkgid,
+ &move_type);
if (target_uid == (uid_t)-1 || pkgtype == NULL || pkgid == NULL) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(is)", PKGMGR_R_ECOMM, ""));
}
snprintf(buf, sizeof(buf), "%d", move_type);
- if (_pm_queue_push(target_uid, reqkey, PKGMGR_REQUEST_TYPE_MOVE, pkgtype,
+ if (_push_queue(target_uid, reqkey, REQUEST_TYPE_MOVE, pkgtype,
pkgid, buf)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(is)", PKGMGR_R_ESYSTEM, ""));
return -1;
}
- if (_pm_queue_push(target_uid, reqkey,
- PKGMGR_REQUEST_TYPE_ENABLE_PKG,
- pkgtype, pkgid, "")) {
+ if (_push_queue(target_uid, reqkey, REQUEST_TYPE_ENABLE_PKG,
+ pkgtype, pkgid, NULL)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(i)", PKGMGR_R_ESYSTEM));
free(reqkey);
return -1;
}
- if (_pm_queue_push(target_uid, reqkey,
- PKGMGR_REQUEST_TYPE_DISABLE_PKG,
- pkgtype, pkgid, "")) {
+ if (_push_queue(target_uid, reqkey, REQUEST_TYPE_DISABLE_PKG,
+ pkgtype, pkgid, NULL)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(i)", PKGMGR_R_ESYSTEM));
free(reqkey);
goto catch;
}
- if (_pm_queue_push(target_uid, reqkey, PKGMGR_REQUEST_TYPE_ENABLE_APP, "default",
- appid, "")) {
+ if (_push_queue(target_uid, reqkey, REQUEST_TYPE_ENABLE_APP, "default",
+ appid, NULL)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(is)", PKGMGR_R_ESYSTEM, ""));
ret = -1;
goto catch;
}
- if (_pm_queue_push(target_uid, reqkey, PKGMGR_REQUEST_TYPE_DISABLE_APP, "default",
- appid, "")) {
+ if (_push_queue(target_uid, reqkey, REQUEST_TYPE_DISABLE_APP, "default",
+ appid, NULL)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(is)", PKGMGR_R_ESYSTEM, ""));
ret = -1;
goto catch;
}
- if (_pm_queue_push(target_uid, reqkey, PKGMGR_REQUEST_TYPE_ENABLE_GLOBAL_APP_FOR_UID, "default",
- appid, "")) {
+ if (_push_queue(target_uid, reqkey,
+ REQUEST_TYPE_ENABLE_GLOBAL_APP_FOR_UID,
+ "default", appid, NULL)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(is)", PKGMGR_R_ESYSTEM, ""));
ret = -1;
goto catch;
}
- if (_pm_queue_push(target_uid, reqkey, PKGMGR_REQUEST_TYPE_DISABLE_GLOBAL_APP_FOR_UID, "default",
- appid, "")) {
+ if (_push_queue(target_uid, reqkey,
+ REQUEST_TYPE_DISABLE_GLOBAL_APP_FOR_UID,
+ "default", appid, NULL)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(is)", PKGMGR_R_ESYSTEM, ""));
ret = -1;
}
snprintf(buf, sizeof(buf), "%d", get_type);
- if (_pm_queue_push(target_uid, reqkey, PKGMGR_REQUEST_TYPE_GETSIZE, "pkgtool",
+ if (_push_queue(target_uid, reqkey, REQUEST_TYPE_GETSIZE, "pkgtool",
pkgid, buf)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(is)", PKGMGR_R_ESYSTEM, ""));
return -1;
}
- if (_pm_queue_push(target_uid, reqkey, PKGMGR_REQUEST_TYPE_CLEARDATA, pkgtype,
- pkgid, "")) {
+ if (_push_queue(target_uid, reqkey, REQUEST_TYPE_CLEARDATA, pkgtype,
+ pkgid, NULL)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(i)", PKGMGR_R_ESYSTEM));
free(reqkey);
return -1;
}
- if (_pm_queue_push(target_uid, "", PKGMGR_REQUEST_TYPE_CLEARCACHE,
- "pkgtool", pkgid, "")) {
+ if (_push_queue(target_uid, NULL, REQUEST_TYPE_CLEARCACHE,
+ "pkgtool", pkgid, NULL)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(i)", PKGMGR_R_ESYSTEM));
return -1;
return -1;
}
- if (_pm_queue_push(target_uid, reqkey, PKGMGR_REQUEST_TYPE_KILL,
- "default", pkgid, "")) {
+ if (_push_queue(target_uid, reqkey, REQUEST_TYPE_KILL,
+ "default", pkgid, NULL)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(ii)", PKGMGR_R_ESYSTEM, 0));
free(reqkey);
return -1;
}
- if (_pm_queue_push(target_uid, reqkey, PKGMGR_REQUEST_TYPE_CHECK,
- "default", pkgid, "")) {
+ if (_push_queue(target_uid, reqkey, REQUEST_TYPE_CHECK,
+ "default", pkgid, NULL)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(ii)", PKGMGR_R_ESYSTEM, 0));
free(reqkey);
return -1;
}
- if (_pm_queue_push(uid, reqkey,
- PKGMGR_REQUEST_TYPE_GENERATE_LICENSE_REQUEST,
- "default", "", resp_data)) {
+ if (_push_queue(uid, reqkey,
+ REQUEST_TYPE_GENERATE_LICENSE_REQUEST,
+ "default", NULL, resp_data)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(iss)", PKGMGR_R_ESYSTEM, "",
""));
return -1;
}
- if (_pm_queue_push(uid, reqkey, PKGMGR_REQUEST_TYPE_REGISTER_LICENSE,
- "default", "", resp_data)) {
+ if (_push_queue(uid, reqkey, REQUEST_TYPE_REGISTER_LICENSE,
+ "default", NULL, resp_data)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(i)", PKGMGR_R_ESYSTEM));
free(reqkey);
return -1;
}
- if (_pm_queue_push(uid, reqkey, PKGMGR_REQUEST_TYPE_DECRYPT_PACKAGE,
- "default", drm_file_path, decrypted_file_path)) {
+ if (_push_queue(uid, reqkey, REQUEST_TYPE_DECRYPT_PACKAGE,
+ "default", drm_file_path,
+ decrypted_file_path)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(i)", PKGMGR_R_ESYSTEM));
free(reqkey);
return -1;
}
- if (_pm_queue_push(target_uid, reqkey, req_type, "default",
- appid, "")) {
+ if (_push_queue(target_uid, reqkey, req_type, "default",
+ appid, NULL)) {
ERR("Failed to push request");
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(i)", PKGMGR_R_ESYSTEM));
GDBusMethodInvocation *invocation, GVariant *parameters)
{
return __update_app_splash_screen(uid, invocation, parameters,
- PKGMGR_REQUEST_TYPE_ENABLE_APP_SPLASH_SCREEN);
+ REQUEST_TYPE_ENABLE_APP_SPLASH_SCREEN);
}
static int __handle_request_disable_app_splash_screen(uid_t uid,
GDBusMethodInvocation *invocation, GVariant *parameters)
{
return __update_app_splash_screen(uid, invocation, parameters,
- PKGMGR_REQUEST_TYPE_DISABLE_APP_SPLASH_SCREEN);
+ REQUEST_TYPE_DISABLE_APP_SPLASH_SCREEN);
}
static int __handle_request_set_restriction_mode(uid_t uid,
}
snprintf(buf, sizeof(buf), "%d", mode);
- if (_pm_queue_push(target_uid, reqkey,
- PKGMGR_REQUEST_TYPE_SET_RESTRICTION_MODE,
+ if (_push_queue(target_uid, reqkey,
+ REQUEST_TYPE_SET_RESTRICTION_MODE,
"default", pkgid, buf)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(i)", PKGMGR_R_ESYSTEM));
}
snprintf(buf, sizeof(buf), "%d", mode);
- if (_pm_queue_push(target_uid, reqkey,
- PKGMGR_REQUEST_TYPE_UNSET_RESTRICTION_MODE,
+ if (_push_queue(target_uid, reqkey,
+ REQUEST_TYPE_UNSET_RESTRICTION_MODE,
"default", pkgid, buf)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(i)", PKGMGR_R_ESYSTEM));
return -1;
}
- if (_pm_queue_push(target_uid, reqkey,
- PKGMGR_REQUEST_TYPE_GET_RESTRICTION_MODE,
- "default", pkgid, "")) {
+ if (_push_queue(target_uid, reqkey,
+ REQUEST_TYPE_GET_RESTRICTION_MODE,
+ "default", pkgid, NULL)) {
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(ii)", -1, PKGMGR_R_ESYSTEM));
free(reqkey);
if (g_strcmp0(method_name, "install") == 0)
ret = __handle_request_install(uid, invocation, parameters);
else if (g_strcmp0(method_name, "mount_install") == 0)
- ret = __handle_request_mount_install(uid, invocation, parameters);
+ ret = __handle_request_mount_install(uid, invocation,
+ parameters);
else if (g_strcmp0(method_name, "reinstall") == 0)
ret = __handle_request_reinstall(uid, invocation, parameters);
else if (g_strcmp0(method_name, "uninstall") == 0)
else if (g_strcmp0(method_name, "disable_app") == 0)
ret = __handle_request_disable_app(uid, invocation, parameters);
else if (g_strcmp0(method_name, "enable_global_app_for_uid") == 0)
- ret = __handle_request_enable_global_app_for_uid(uid, invocation, parameters);
+ ret = __handle_request_enable_global_app_for_uid(uid,
+ invocation, parameters);
else if (g_strcmp0(method_name, "disable_global_app_for_uid") == 0)
- ret = __handle_request_disable_global_app_for_uid(uid, invocation, parameters);
+ ret = __handle_request_disable_global_app_for_uid(uid,
+ invocation, parameters);
else if (g_strcmp0(method_name, "kill") == 0)
ret = __handle_request_kill(uid, invocation, parameters);
else if (g_strcmp0(method_name, "check") == 0)
g_idle_add(queue_job, NULL);
}
-int __return_value_to_caller(const char *req_key, GVariant *result)
+int _return_value_to_caller(const char *req_key, GVariant *result)
{
GDBusMethodInvocation *invocation;
DBG("on name lost: %s", name);
}
-int __init_request_handler(void)
+int _init_request_handler(void)
{
- instropection_data = g_dbus_node_info_new_for_xml(instropection_xml, NULL);
+ instropection_data = g_dbus_node_info_new_for_xml(instropection_xml,
+ NULL);
owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM, PKGMGR_DBUS_SERVICE,
G_BUS_NAME_OWNER_FLAGS_NONE, __on_bus_acquired,
return 0;
}
-void __fini_request_handler(void)
+void _fini_request_handler(void)
{
g_hash_table_destroy(req_table);
g_bus_unown_name(owner_id);
projects / platform / core / appfw / pkgmgr-server.git / commitdiff