#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
-#include <dirent.h>
#include <sys/types.h>
-#include <fcntl.h>
+#include <sys/signalfd.h>
#include <signal.h>
+#include <grp.h>
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <fnmatch.h>
#include <glib.h>
#include <gio/gio.h>
+#include <aul.h>
#include <pkgmgr-info.h>
-#include <pkgmgr/pkgmgr_parser.h>
+#include <pkgmgr/pkgmgr_parser_db.h>
#include <tzplatform_config.h>
-#include <drm-tizen-apps.h>
#include "pkgmgr_installer.h"
#include "pkgmgr-server.h"
-#include "pm-queue.h"
-#include "comm_config.h"
+#include "queue.h"
#include "package-manager.h"
-#define BUFMAX 128
-#define NO_MATCHING_FILE 11
+#define USRLIB "/usr/lib"
+#define PATH_LIBDRM_SVC_CORE \
+ "/usr/lib/libdrm-service-core-tizen.so.0"
+#define PATH_LIBCSR_CLIENT \
+ "/usr/lib/libcsr-client.so.2"
#define OWNER_ROOT 0
#define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
+#define APPFW_UID 301
+
+
+#define EXT_STORAGE_GROUP 10001
+#define EXT_STORAGE_APPDATA_GROUP 10002
+#define MEDIA_STORAGE_GROUP 10502
+#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))
+#define MAX_LONGLONG_LENGTH 32
typedef struct {
char **env;
gid_t gid;
} user_ctx;
+typedef struct {
+ uid_t uid;
+ char *cmd;
+ int pid;
+} pkgcmd_data;
/*
8 bit value to represent maximum 8 backends.
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 {
- pid_t pid;
- int status;
-};
-
-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;
+bool is_drm_busy = false;
+static bool is_lock_set = false;
+
+static GIOChannel *sio;
+static guint swid;
+static GHashTable *backend_info_table;
+static GMainLoop *mainloop;
+static GDBusConnection *system_conn;
+
+static int (*_drm_tizen_register_license)
+ (const char *pRespBuf, unsigned int respBufLen);
+static int (*_drm_tizen_decrypt_package)(const char *pTADCFilepath,
+ int tadcFileLen, const char *pDecryptedFile,
+ int decryptedFileLen);
+static int (*_drm_tizen_generate_license_request)(const char *pRespBuf,
+ unsigned int respBufLen, char *pReqBuf,
+ unsigned int *pReqBufLen, char *pLicenseUrl,
+ unsigned int *pLicenseUrlLen);
+static void *drm_lib_handle;
static int __check_backend_status_for_exit(void);
static int __check_queue_status_for_exit(void);
static int __is_backend_busy(int position);
static void __set_backend_busy(int position);
static void __set_backend_free(int position);
-static void sighandler(int signo);
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);
-}
-
-static int __is_global(uid_t uid)
-{
- return (uid == OWNER_ROOT || uid == GLOBAL_USER) ? 1 : 0;
+ backend_busy = backend_busy & ~(1 << position);
}
-static const char *__get_recovery_file_path(uid_t uid)
+static GDBusConnection *_get_system_conn(void)
{
- const char *path;
-
- if (!__is_global(uid))
- tzplatform_set_user(uid);
+ GError *err = NULL;
- path = tzplatform_getenv(__is_global(uid)
- ? TZ_SYS_RW_PACKAGES : TZ_USER_PACKAGES);
+ if (system_conn)
+ return system_conn;
- tzplatform_reset_user();
+ system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+ if (system_conn == NULL) {
+ ERR("Failed to get system bus: %s", err->message);
+ g_error_free(err);
+ return NULL;
+ }
- return path;
+ return system_conn;
}
-static void __set_recovery_mode(uid_t uid, char *pkgid, char *pkg_type)
+#define DEVICED_DBUS_PATH "org.tizen.system.deviced"
+#define DEVICED_DBUS_OBJECT_PATH "/Org/Tizen/System/DeviceD/Display"
+#define DEVICED_DBUS_INTERFACE_NAME "org.tizen.system.deviced.display"
+
+static void __set_power_lock(void)
{
- char recovery_file[MAX_PKG_NAME_LEN] = { 0, };
- char buffer[MAX_PKG_NAME_LEN] = { 0 };
- char *pkgid_tmp = NULL;
- FILE *rev_file = NULL;
+ GDBusConnection *conn;
+ GDBusMessage *msg;
+ GError *err = NULL;
+ int ret = 0;
- if (pkgid == NULL) {
- DBG("pkgid is null\n");
+ if (is_lock_set)
return;
- }
- /*if pkgid has a "/"charactor, that is a path name for installation, then extract pkgid from absolute path*/
- if (strstr(pkgid, "/")) {
- pkgid_tmp = strrchr(pkgid, '/') + 1;
- if (pkgid_tmp == NULL) {
- DBG("pkgid_tmp[%s] is null\n", pkgid);
- return;
- }
- snprintf(recovery_file, sizeof(recovery_file), "%s/%s", __get_recovery_file_path(uid), pkgid_tmp);
- } else {
- snprintf(recovery_file, sizeof(recovery_file), "%s/%s", __get_recovery_file_path(uid), pkgid);
- }
+ conn = _get_system_conn();
+ if (conn == NULL)
+ return;
- rev_file = fopen(recovery_file, "w");
- if (rev_file== NULL) {
- DBG("rev_file[%s] is null\n", recovery_file);
+ msg = g_dbus_message_new_method_call(DEVICED_DBUS_PATH,
+ DEVICED_DBUS_OBJECT_PATH,
+ DEVICED_DBUS_INTERFACE_NAME,
+ "lockstate");
+ if (msg == NULL) {
+ ERR("g_dbus_message_new_method_call() has failed");
return;
}
- snprintf(buffer, MAX_PKG_NAME_LEN, "pkgid : %s\n", pkgid);
- fwrite(buffer, sizeof(char), strlen(buffer), rev_file);
+ g_dbus_message_set_body(msg, g_variant_new("(sssi)", "lcdoff",
+ "staycurstate", "NULL", 0));
+ if (!g_dbus_connection_send_message(conn, msg,
+ G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, &err)) {
+ ERR("Unable to send dbus message for acquring lock as %s",
+ err->message);
+ ret = -1;
+ }
- fclose(rev_file);
+ if (ret == 0)
+ is_lock_set = true;
+ g_object_unref(msg);
+ g_dbus_connection_flush_sync(conn, NULL, NULL);
+ g_clear_error(&err);
}
-static void __unset_recovery_mode(uid_t uid, char *pkgid, char *pkg_type)
+static void __release_power_lock(void)
{
- int ret = -1;
- char recovery_file[MAX_PKG_NAME_LEN] = { 0, };
- char *pkgid_tmp = NULL;
+ GError *err = NULL;
+ GDBusConnection *conn;
+ GDBusMessage *msg;
+ int ret = 0;
+
+ if (!is_lock_set)
+ return;
+
+ conn = _get_system_conn();
+ if (conn == NULL)
+ return;
- if (pkgid == NULL) {
- DBG("pkgid is null\n");
+ msg = g_dbus_message_new_method_call(DEVICED_DBUS_PATH,
+ DEVICED_DBUS_OBJECT_PATH,
+ DEVICED_DBUS_INTERFACE_NAME,
+ "unlockstate");
+ if (msg == NULL) {
+ ERR("g_dbus_message_new_method_call() is failed");
return;
}
- /*if pkgid has a "/"charactor, that is a path name for installation, then extract pkgid from absolute path*/
- if (strstr(pkgid, "/")) {
- pkgid_tmp = strrchr(pkgid, '/') + 1;
- if (pkgid_tmp == NULL) {
- DBG("pkgid_tmp[%s] is null\n", pkgid);
- return;
- }
- snprintf(recovery_file, sizeof(recovery_file), "%s/%s", __get_recovery_file_path(uid), pkgid_tmp);
- } else {
- snprintf(recovery_file, sizeof(recovery_file), "%s/%s", __get_recovery_file_path(uid), pkgid);
+ g_dbus_message_set_body(msg, g_variant_new("(ss)", "lcdoff",
+ "sleepmargin"));
+ if (!g_dbus_connection_send_message(conn, msg,
+ G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, &err)) {
+ ERR("Unable to send dbus message for releasing lock as %s",
+ err->message);
+ ret = -1;
}
- ret = remove(recovery_file);
- if (ret < 0)
- DBG("remove recovery_file[%s] fail\n", recovery_file);
+ if (ret == 0)
+ is_lock_set = false;
+ g_object_unref(msg);
+ g_dbus_connection_flush_sync(conn, NULL, NULL);
+ g_clear_error(&err);
+
+ return;
}
-static void __send_app_signal(uid_t uid, const char *req_id,
- const char *pkg_type, const char *pkgid, const char *appid,
- const char *key, const char *val)
+static gboolean getsize_io_handler(GIOChannel *io, GIOCondition cond,
+ gpointer data)
{
- pkgmgr_installer *pi;
+ GError *err = NULL;
+ GIOStatus s;
+ gsize len;
+ char buf[MAX_LONGLONG_LENGTH];
+ long long result = 0;
+ struct backend_job *job = (struct backend_job *)data;
+ struct getsize_sync_extra_info *extra_getsize_info =
+ (struct getsize_sync_extra_info *)job->extra_data;
- pi = pkgmgr_installer_new();
- if (!pi) {
- DBG("Failure in creating the pkgmgr_installer object");
- return;
+ s = g_io_channel_read_chars(io, (gchar *)buf, sizeof(buf), &len, &err);
+ if (s != G_IO_STATUS_NORMAL) {
+ ERR("getsize fd read failed: %s", err->message);
+ g_error_free(err);
+ result = -1;
+ } else {
+ if (strlen(buf) == 0) {
+ ERR("empty result");
+ result = -1;
+ } else {
+ result = atoll(buf);
+ }
}
- if (pkgmgr_installer_set_request_type(pi,PKGMGR_REQ_ENABLE_DISABLE_APP))
- goto catch;
- if (pkgmgr_installer_set_session_id(pi, req_id))
- goto catch;
- pkgmgr_installer_send_app_signal(pi, pkg_type, pkgid, appid, key, val);
+ _return_value_to_caller(job->req_id, g_variant_new("(ix)",
+ (result < 0) ? PKGMGR_R_ERROR : PKGMGR_R_OK, result));
-catch:
- pkgmgr_installer_free(pi);
+ unlink(extra_getsize_info->getsize_fifo);
+ free(extra_getsize_info->getsize_fifo);
+ extra_getsize_info->getsize_fifo = NULL;
- return;
+ return FALSE;
}
-static void send_fail_signal(char *pname, char *ptype, char *args)
+static int __setup_size_info_io(struct backend_job *job)
{
- DBG("send_fail_signal start\n");
- gboolean ret_parse;
- gint argcp;
- gchar **argvp;
- GError *gerr = NULL;
- pkgmgr_installer *pi;
- pi = pkgmgr_installer_new();
- if (!pi) {
- DBG("Failure in creating the pkgmgr_installer object");
- return;
+ guint getsize_wid;
+ struct getsize_sync_extra_info *extra_getsize_info =
+ (struct getsize_sync_extra_info *)job->extra_data;
+
+ extra_getsize_info->getsize_fd = open(extra_getsize_info->getsize_fifo,
+ O_RDONLY | O_NONBLOCK);
+ if (extra_getsize_info->getsize_fd < 0) {
+ ERR("failed to open the fifo(%s), errno(%d)",
+ extra_getsize_info->getsize_fifo, errno);
+ return -1;
}
- ret_parse = g_shell_parse_argv(args,
- &argcp, &argvp, &gerr);
- if (FALSE == ret_parse) {
- DBG("Failed to split args: %s", args);
- DBG("messsage: %s", gerr->message);
- pkgmgr_installer_free(pi);
- return;
+
+ extra_getsize_info->getsize_io =
+ g_io_channel_unix_new(extra_getsize_info->getsize_fd);
+ if (!extra_getsize_info->getsize_io)
+ return -1;
+ g_io_channel_set_encoding(extra_getsize_info->getsize_io, NULL, NULL);
+ g_io_channel_set_buffered(extra_getsize_info->getsize_io, FALSE);
+ getsize_wid = g_io_add_watch_full(extra_getsize_info->getsize_io,
+ G_PRIORITY_HIGH, G_IO_IN, getsize_io_handler, job, NULL);
+ if (!getsize_wid) {
+ ERR("failed to add io watch");
+ return -1;
}
- pkgmgr_installer_receive_request(pi, argcp, argvp);
- pkgmgr_installer_send_signal(pi, ptype, pname, "end", "fail");
- pkgmgr_installer_free(pi);
- return;
+ return 0;
}
-static gboolean pipe_io_handler(GIOChannel *io, GIOCondition cond, gpointer data)
+static gboolean __signal_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 signalfd_siginfo fdsi;
+ struct backend_job *job;
+ struct getsize_sync_extra_info *extra_getsize_info;
+ pid_t pid;
+ int status;
- 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);
+ s = g_io_channel_read_chars(io, (gchar *)&fdsi,
+ sizeof(struct signalfd_siginfo), &len, &err);
+ if (s != G_IO_STATUS_NORMAL || len != sizeof(struct signalfd_siginfo)) {
+ ERR("Signal read failed");
g_error_free(err);
return TRUE;
}
- for (x = 0; x < num_of_backends; x++, ptr++) {
- if (ptr && ptr->pid == info.pid)
- break;
- }
+ while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
+ job = (struct backend_job *)g_hash_table_lookup(
+ backend_info_table, (gconstpointer)pid);
+ if (job == NULL) {
+ ERR("Unknown child exit");
+ continue;
+ }
- if (x == num_of_backends) {
- ERR("Unknown child exit");
- return -1;
- }
+ __set_backend_free(job->backend_slot);
+ if (WIFSIGNALED(status)) {
+ _send_fail_signal(job);
+ INFO("backend[%s][%d] exit with signal[%d]",
+ job->backend_type, pid, WTERMSIG(status));
+ } else if (WEXITSTATUS(status)) {
+ INFO("backend[%s][%d] exit with error",
+ job->backend_type, pid);
+ } else {
+ INFO("backend[%s][%d] exit", job->backend_type, pid);
+ }
- __set_backend_free(x);
- __unset_recovery_mode(ptr->uid, ptr->pkgid, ptr->pkgtype);
- if (WIFSIGNALED(info.status) || WEXITSTATUS(info.status)) {
- send_fail_signal(ptr->pkgid, ptr->pkgtype, ptr->args);
- DBG("backend[%s] exit with error", ptr->pkgtype);
- } else {
- DBG("backend[%s] exit", ptr->pkgtype);
+ if (job->req_type == REQUEST_TYPE_GETSIZE_SYNC &&
+ job->extra_data) {
+ extra_getsize_info =
+ (struct getsize_sync_extra_info *)job->extra_data;
+ if (extra_getsize_info->getsize_fifo) {
+ ERR("invalid backend close");
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(ix)",
+ PKGMGR_R_ERROR, -1));
+ }
+ }
+ g_hash_table_remove(backend_info_table, (gconstpointer)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;
-
- if (pipe(pipe_sig)) {
- ERR("create pipe failed");
- return -1;
- }
-
- pipe_io = g_io_channel_unix_new(pipe_sig[0]);
- g_io_channel_set_encoding(pipe_io, NULL, NULL);
- g_io_channel_set_buffered(pipe_io, FALSE);
- pipe_wid = g_io_add_watch(pipe_io, G_IO_IN, pipe_io_handler, NULL);
+ backend_info_table = g_hash_table_new_full(g_direct_hash,
+ g_direct_equal, NULL,
+ (GDestroyNotify)_free_backend_job);
return 0;
}
static void __fini_backend_info(void)
{
- g_source_remove(pipe_wid);
- g_io_channel_unref(pipe_io);
- close(pipe_sig[0]);
- close(pipe_sig[1]);
-
/*Free backend info */
- free(begin);
-}
-
-static void sighandler(int signo)
-{
- struct signal_info_t info;
-
- 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(errno));
+ g_hash_table_destroy(backend_info_table);
}
static int __register_signal_handler(void)
{
- static int sig_reg = 0;
- struct sigaction act;
+ sigset_t mask;
+ int sfd;
- if (sig_reg)
- return 0;
+ sigemptyset(&mask);
+ sigaddset(&mask, SIGCHLD);
+
+ if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1) {
+ ERR("sigprocmask failed");
+ return -1;
+ }
- act.sa_handler = sighandler;
- sigemptyset(&act.sa_mask);
- act.sa_flags = SA_NOCLDSTOP;
- if (sigaction(SIGCHLD, &act, NULL) < 0) {
- ERR("signal: SIGCHLD failed\n");
+ sfd = signalfd(-1, &mask, SFD_NONBLOCK);
+ if (sfd == -1) {
+ ERR("signalfd failed");
return -1;
}
- g_timeout_add_seconds(2, exit_server, NULL);
+ sio = g_io_channel_unix_new(sfd);
+ g_io_channel_set_close_on_unref(sio, TRUE);
+ g_io_channel_set_encoding(sio, NULL, NULL);
+ g_io_channel_set_buffered(sio, FALSE);
+ swid = g_io_add_watch(sio, G_IO_IN, __signal_handler, NULL);
+
+ g_timeout_add_seconds_full(G_PRIORITY_LOW, 2, exit_server, NULL, NULL);
- sig_reg = 1;
return 0;
}
static int __check_backend_status_for_exit(void)
{
- int i = 0;
- for(i = 0; i < num_of_backends; i++)
- {
- if (!__is_backend_busy(i))
- continue;
- else
+ int i;
+ for (i = 0; i < num_of_backends; i++) {
+ if (__is_backend_busy(i))
return 0;
}
return 1;
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++;
- continue;
- }
- else {
- head[c] = ptr->head;
- slot = ptr->queue_slot;
- c++;
- ptr++;
- }
- }
- for(i = 0; i < num_of_backends; i++)
- {
- if (!head[i])
- continue;
- else
+ int i;
+ for (i = 0; i < num_of_backends; 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;
- }
+ __check_queue_status_for_exit() && !is_drm_busy) {
+ g_main_loop_quit(mainloop);
+ if (is_lock_set)
+ __release_power_lock();
+ return FALSE;
}
return TRUE;
}
-static int __pkgcmd_read_proc(const char *path, char *buf, int size)
+static int __check_csr(const char *path)
{
- int fd;
int ret;
- if (buf == NULL || path == NULL)
- return -1;
- fd = open(path, O_RDONLY);
- if (fd < 0)
- return -1;
- ret = read(fd, buf, size - 1);
- if (ret <= 0) {
- close(fd);
- return -1;
- } else
- buf[ret] = 0;
- close(fd);
- return ret;
-}
+ void *context;
+ void *malware;
+ void *lib_handle;
+ int (*_csr_cs_context_create)(void **handle);
+ int (*_csr_cs_scan_file)(void *handle, const char *file_path, void **malware);
+ int (*_csr_cs_context_destroy)(void *handle);
+
+ lib_handle = dlopen(PATH_LIBCSR_CLIENT, RTLD_LAZY);
+ if (!lib_handle) {
+ DBG("Unable to open %s", PATH_LIBCSR_CLIENT);
+ return 0;
+ }
-static int __pkgcmd_find_pid_by_cmdline(const char *dname,
- const char *cmdline, const char *apppath)
-{
- int pid = 0;
+ _csr_cs_context_create = dlsym(lib_handle, "csr_cs_context_create");
+ _csr_cs_scan_file = dlsym(lib_handle, "csr_cs_scan_file");
+ _csr_cs_context_destroy = dlsym(lib_handle, "csr_cs_context_destroy");
- if (strcmp(cmdline, apppath) == 0) {
- pid = atoi(dname);
- if (pid != getpgid(pid))
- pid = 0;
+ if (!_csr_cs_context_create || !_csr_cs_scan_file ||
+ !_csr_cs_context_destroy) {
+ ERR("Failed to load CSR symbols");
+ ret = -1;
+ goto catch;
}
- return pid;
-}
-
-static int __pkgcmd_proc_iter_kill_cmdline(const char *apppath, int option)
-{
- DIR *dp;
- struct dirent *dentry;
- int pid;
- int ret;
- char buf[1024] = {'\0'};
- int pgid;
- dp = opendir("/proc");
- if (dp == NULL) {
- return -1;
+ ret = _csr_cs_context_create(&context);
+ if (ret != 0) {
+ ERR("Failed to create context");
+ ret = -1;
+ goto catch;
}
- while ((dentry = readdir(dp)) != NULL) {
- if (!isdigit(dentry->d_name[0]))
- continue;
+ ret = _csr_cs_scan_file(context, path, &malware);
+ if (ret != 0) {
+ DBG("CSR result[%d]", ret);
+ ret = 0;
+ goto catch;
+ }
- snprintf(buf, sizeof(buf), "/proc/%s/cmdline", dentry->d_name);
- ret = __pkgcmd_read_proc(buf, buf, sizeof(buf));
- if (ret <= 0)
- continue;
+ ret = _csr_cs_context_destroy(context);
+ if (ret != 0) {
+ ERR("Failed to destroy context");
+ ret = -1;
+ goto catch;
+ }
- pid = __pkgcmd_find_pid_by_cmdline(dentry->d_name, buf, apppath);
- if (pid > 0) {
- if (option == 0) {
- closedir(dp);
- return pid;
- }
- pgid = getpgid(pid);
- if (pgid <= 1) {
- closedir(dp);
- return -1;
- }
- if (killpg(pgid, SIGKILL) < 0) {
- closedir(dp);
- return -1;
- }
- closedir(dp);
- return pid;
- }
+ if (malware != NULL) {
+ ERR("CSR detected malware from [%s]", path);
+ ret = -1;
}
- closedir(dp);
- return 0;
+
+catch:
+ if (lib_handle)
+ dlclose(lib_handle);
+
+ return ret;
}
-static void __make_pid_info_file(char *req_key, int pid)
+static int __kill_app(char *appid, uid_t uid)
{
- FILE* file;
- int fd;
- char buf[MAX_PKG_TYPE_LEN] = {0};
- char info_file[PATH_MAX] = {'\0'};
+ int ret;
+ int pid;
+ int is_running;
- if(req_key == NULL)
- return;
+ is_running = aul_app_is_running_for_uid(appid, uid);
+ /* app is not running */
+ if (!is_running)
+ return 0;
- snprintf(info_file, PATH_MAX, "/tmp/pkgmgr/%s", req_key);
+ pid = aul_app_get_pid_for_uid(appid, uid);
+ if (pid == -1)
+ return -1;
- DBG("info_path(%s)", info_file);
- file = fopen(info_file, "w");
- if (file == NULL) {
- ERR("Couldn't open the file(%s)", info_file);
- return;
+ ret = aul_terminate_pid_for_uid(pid, uid);
+ if (ret != AUL_R_OK) {
+ ERR("failed to terminate app(%s)", appid);
+ return -1;
}
- snprintf(buf, MAX_PKG_TYPE_LEN, "%d\n", pid);
- fwrite(buf, 1, strlen(buf), file);
+ return 0;
+}
+
+static int __check_app(char *appid, uid_t uid)
+{
+ int pid;
+ int is_running;
+
+ is_running = aul_app_is_running_for_uid(appid, uid);
+ if (!is_running)
+ return 0;
- fflush(file);
- fd = fileno(file);
- fsync(fd);
- fclose(file);
+ pid = aul_app_get_pid_for_uid(appid, uid);
+
+ return pid;
}
static int __pkgcmd_app_cb(const pkgmgrinfo_appinfo_h handle, void *user_data)
{
char *pkgid;
+ char *appid;
char *exec;
int ret;
- int pid = -1;
+ pkgcmd_data *pdata = (pkgcmd_data *)user_data;
if (handle == NULL) {
perror("appinfo handle is NULL\n");
perror("Failed to get app exec path\n");
exit(1);
}
+ ret = pkgmgrinfo_appinfo_get_appid(handle, &appid);
+ if (ret) {
+ perror("Failed to get appid\n");
+ exit(1);
+ }
ret = pkgmgrinfo_appinfo_get_pkgid(handle, &pkgid);
if (ret) {
perror("Failed to get pkgid\n");
exit(1);
}
- if (strcmp(user_data, "kill") == 0)
- pid = __pkgcmd_proc_iter_kill_cmdline(exec, 1);
- else if(strcmp(user_data, "check") == 0)
- pid = __pkgcmd_proc_iter_kill_cmdline(exec, 0);
-
- __make_pid_info_file(pkgid, pid);
+ if (strcmp(pdata->cmd, "kill") == 0) {
+ pdata->pid = __check_app(appid, pdata->uid);
+ if (pdata->pid > 0)
+ ret = __kill_app(appid, pdata->uid);
+ } else if (strcmp(pdata->cmd, "check") == 0) {
+ pdata->pid = __check_app(appid, pdata->uid);
+ }
return 0;
}
-void free_user_context(user_ctx* ctx)
+void free_user_context(user_ctx *ctx)
{
char **env = NULL;
int i = 0;
if (!ctx)
return;
env = ctx->env;
- //env variable ends by NULL element
+ /* env variable ends by NULL element */
while (env[i]) {
free(env[i]);
i++;
int i = 0;
int res = 0;
char **env = NULL;
+ int n;
+ gid_t *groups;
+
if (!ctx)
- return -1;;
- if (setgid(ctx->gid)) {
- ERR("setgid failed: %d", errno);
+ return -1;
+
+ if (ctx->uid != APPFW_UID) {
+ if (setuid(ctx->uid)) {
+ ERR("setuid failed: %d", errno);
+ return -1;
+ }
+
+ if (setgid(ctx->gid)) {
+ ERR("setgid failed: %d", errno);
+ return -1;
+ }
+ }
+
+ n = getgroups(0, NULL);
+ if (n < 0) {
+ ERR("Failed to get the number of supplementary group IDs");
+ return -1;
+ }
+
+ groups = (gid_t *)calloc(1, sizeof(gid_t) * (n + 3));
+ if (groups == NULL) {
+ ERR("out of memory");
+ return -1;
+ }
+
+ n = getgroups(n, groups);
+ if (n < 0) {
+ ERR("Failed to get list of supplementary group IDs");
+ free(groups);
return -1;
}
- if (setuid(ctx->uid)) {
- ERR("setuid failed: %d", errno);
+
+ groups[n++] = EXT_STORAGE_GROUP;
+ groups[n++] = EXT_STORAGE_APPDATA_GROUP;
+ groups[n++] = MEDIA_STORAGE_GROUP;
+
+ if (setgroups(n, groups) < 0) {
+ ERR("setgroups failed: %d", errno);
+ free(groups);
return -1;
}
+ free(groups);
+
env = ctx->env;
- //env variable ends by NULL element
+ /* env variable ends by NULL element */
while (env[i]) {
if (putenv(env[i]) != 0)
res = -1;
return res;
}
-user_ctx* get_user_context(uid_t uid)
+user_ctx *get_user_context(uid_t uid)
{
/* we can use getpwnam because this is used only after a
* fork and just before an execv
*/
user_ctx *context_res;
char **env = NULL;
- struct passwd * pwd;
+ char buf[1024] = {0, };
+ struct passwd pwd, *result;
int len;
int ret = 0;
+ int i;
- pwd = getpwuid(uid);
- if (!pwd)
+ ret = getpwuid_r(uid, &pwd, buf, sizeof(buf), &result);
+ if (ret != 0 || result == NULL)
return NULL;
do {
ret = -1;
break;
}
- env = (char**)malloc(3* sizeof(char *));
+ env = (char **)malloc(3 * sizeof(char *));
if (!env) {
ret = -1;
break;
}
- // Build environment context
- len = snprintf(NULL,0, "HOME=%s", pwd->pw_dir);
- env[0] = (char*)malloc((len + 1)* sizeof(char));
- if(env[0] == NULL) {
+ /* Build environment context */
+ len = snprintf(NULL, 0, "HOME=%s", pwd.pw_dir);
+ env[0] = (char *)malloc((len + 1) * sizeof(char));
+ if (env[0] == NULL) {
ret = -1;
break;
}
- sprintf(env[0], "HOME=%s", pwd->pw_dir);
- len = snprintf(NULL,0, "USER=%s", pwd->pw_name);
- env[1] = (char*)malloc((len + 1)* sizeof(char));
- if(env[1] == NULL) {
+ snprintf(env[0], len + 1, "HOME=%s", pwd.pw_dir);
+ len = snprintf(NULL, 0, "USER=%s", pwd.pw_name);
+ env[1] = (char *)malloc((len + 1) * sizeof(char));
+ if (env[1] == NULL) {
ret = -1;
break;
}
-
- sprintf(env[1], "USER=%s", pwd->pw_name);
+ snprintf(env[1], len + 1, "USER=%s", pwd.pw_name);
env[2] = NULL;
} while (0);
if (ret == -1) {
free(context_res);
context_res = NULL;
- int i = 0;
- //env variable ends by NULL element
+ i = 0;
+ /* env variable ends by NULL element */
while (env && env[i]) {
free(env[i]);
i++;
} else {
context_res->env = env;
context_res->uid = uid;
- context_res->gid = pwd->pw_gid;
+ context_res->gid = pwd.pw_gid;
}
return context_res;
}
GError *gerr = NULL;
int i;
- ret_parse = g_shell_parse_argv(args,
- &argcp, &argvp, &gerr);
+ ret_parse = g_shell_parse_argv(args, &argcp, &argvp, &gerr);
if (FALSE == ret_parse) {
- DBG("Failed to split args: %s", args);
- DBG("messsage: %s", gerr->message);
+ ERR("Failed to split args: %s", args);
+ ERR("messsage: %s", gerr->message);
exit(1);
}
user_ctx *ctx = (user_ctx *)user_data;
if (set_environement(ctx))
- DBG("Failed to set env for the user : %d", ctx->uid);
+ ERR("Failed to set env for the user : %d", ctx->uid);
}
static int __fork_and_exec_with_args(char **argv, uid_t uid)
{
- user_ctx* user_context;
+ user_ctx *user_context;
GError *error = NULL;
gboolean ret;
int pid;
user_context = get_user_context(uid);
if (!user_context) {
- DBG("Failed to getenv for the user : %d", uid);
+ ERR("Failed to getenv");
return -1;
}
if (ret != TRUE) {
ERR("Failed to excute backend: %s", error->message);
g_error_free(error);
+ free_user_context(user_context);
+ return -1;
}
free_user_context(user_context);
return pid;
}
-void __change_item_info(pm_dbus_msg *item, uid_t uid)
+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;
+ if (job->req_type != REQUEST_TYPE_DISABLE_APP &&
+ job->req_type != REQUEST_TYPE_DISABLE_GLOBAL_APP_FOR_UID &&
+ job->req_type != REQUEST_TYPE_ENABLE_APP_SPLASH_SCREEN &&
+ job->req_type != REQUEST_TYPE_DISABLE_APP_SPLASH_SCREEN &&
+ job->req_type != REQUEST_TYPE_ENABLE_APP &&
+ job->req_type != REQUEST_TYPE_ENABLE_GLOBAL_APP_FOR_UID)
+ return PMINFO_R_ERROR;
+
+ ret = pkgmgrinfo_appinfo_get_usr_all_appinfo(job->pkgid, uid, &handle);
+ if (ret != PMINFO_R_OK)
+ return PMINFO_R_ERROR;
- switch (item->req_type) {
- case PKGMGR_REQUEST_TYPE_DISABLE_APP:
- case PKGMGR_REQUEST_TYPE_DISABLE_GLOBAL_APP_FOR_UID:
- ret = pkgmgrinfo_appinfo_get_usr_appinfo(item->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);
- break;
+ ret = pkgmgrinfo_appinfo_is_global(handle, is_global);
+ if (ret != PMINFO_R_OK)
+ goto catch;
- default:
- return;
+ 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;
}
- if (ret != PMINFO_R_OK)
- return;
-
ret = pkgmgrinfo_appinfo_get_pkgid(handle, &pkgid);
- if (ret != PMINFO_R_OK) {
- pkgmgrinfo_appinfo_destroy_appinfo(handle);
- return;
- }
+ 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];
+ gchar *req_id;
+ gchar *pkgid;
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 %s", backend_cmd,
- item->req_id, item->pkgid, item->args);
+ req_id = g_shell_quote(job->req_id);
+ if (!req_id)
+ return -1;
+ pkgid = g_shell_quote(job->pkgid);
+ if (!pkgid) {
+ g_free(req_id);
+ return -1;
+ }
+
+ snprintf(args, sizeof(args), "%s -k %s -i %s -u %d %s", backend_cmd,
+ req_id, pkgid, (int)job->target_uid, job->args);
argv = __generate_argv(args);
- pid = __fork_and_exec_with_args(argv, item->uid);
+ pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
- free(backend_cmd);
+ g_free(req_id);
+ g_free(pkgid);
return pid;
}
-static int __process_reinstall(pm_dbus_msg *item)
+static int __process_mount_install(struct backend_job *job)
{
char *backend_cmd;
char **argv;
char args[MAX_PKG_ARGS_LEN];
+ gchar *req_id;
+ gchar *pkgid;
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", backend_cmd,
- item->req_id, item->pkgid);
- argv = __generate_argv(args);
+ req_id = g_shell_quote(job->req_id);
+ if (!req_id)
+ return -1;
+ pkgid = g_shell_quote(job->pkgid);
+ if (!pkgid) {
+ g_free(req_id);
+ return -1;
+ }
+ snprintf(args, sizeof(args), "%s -k %s -w %s -u %d %s", backend_cmd,
+ req_id, pkgid, (int)job->target_uid, job->args);
- pid = __fork_and_exec_with_args(argv, item->uid);
+ argv = __generate_argv(args);
+ pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
- free(backend_cmd);
+ g_free(req_id);
+ g_free(pkgid);
return pid;
}
-static int __process_uninstall(pm_dbus_msg *item)
+static int __process_reinstall(struct backend_job *job)
{
char *backend_cmd;
char **argv;
char args[MAX_PKG_ARGS_LEN];
+ gchar *req_id;
+ gchar *pkgid;
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", backend_cmd,
- item->req_id, item->pkgid);
+ req_id = g_shell_quote(job->req_id);
+ if (!req_id)
+ return -1;
+ pkgid = g_shell_quote(job->pkgid);
+ if (!pkgid) {
+ g_free(req_id);
+ return -1;
+ }
+
+ snprintf(args, sizeof(args), "%s -k %s -r %s -u %d", backend_cmd,
+ req_id, pkgid, (int)job->target_uid);
argv = __generate_argv(args);
- pid = __fork_and_exec_with_args(argv, item->uid);
+ pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
- free(backend_cmd);
+ g_free(req_id);
+ g_free(pkgid);
return pid;
}
-static int __process_move(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;
- /* TODO: set movetype */
- snprintf(args, sizeof(args), "%s -k %s -m %s -t %s", backend_cmd,
- item->req_id, item->pkgid, item->args);
+ snprintf(args, sizeof(args), "%s -k %s -d %s -u %d", backend_cmd,
+ job->req_id, job->pkgid, (int)job->target_uid);
argv = __generate_argv(args);
- pid = __fork_and_exec_with_args(argv, item->uid);
+ 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)
-{
- /* TODO */
- return 0;
-}
-
-static int __process_disable_pkg(pm_dbus_msg *item)
+static int __process_move(struct backend_job *job)
{
- /* TODO */
- return 0;
-}
+ char *backend_cmd;
+ char **argv;
+ char args[MAX_PKG_ARGS_LEN];
+ int pid;
-static int __process_enable_app(pm_dbus_msg *item)
-{
- int ret = -1;
+ backend_cmd = job->backend_path;
+ if (backend_cmd == NULL)
+ return -1;
- __send_app_signal(item->uid, item->req_id, item->pkg_type, item->pkgid, item->pkgid, "start", "enable_app");
+ snprintf(args, sizeof(args), "%s -k %s -m %s -u %d -t %s", backend_cmd,
+ job->req_id, job->pkgid, (int)job->target_uid, job->args);
+ argv = __generate_argv(args);
- /* get actual pkgid and replace it to appid which is currently stored at pkgid variable */
- __change_item_info(item, item->uid);
- if (strlen(item->appid) == 0) {
- __send_app_signal(item->uid, item->req_id, item->pkg_type, item->pkgid, item->pkgid, "end", "fail");
- return ret;
- }
+ pid = __fork_and_exec_with_args(argv, APPFW_UID);
- ret = pkgmgr_parser_update_app_disable_info_in_usr_db(item->appid, item->uid, 0);
- if (ret != PMINFO_R_OK)
- __send_app_signal(item->uid, item->req_id, item->pkg_type, item->pkgid, item->appid, "end", "fail");
- else
- __send_app_signal(item->uid, item->req_id, item->pkg_type, item->pkgid, item->appid, "end", "ok");
+ g_strfreev(argv);
- return ret;
+ return pid;
}
-static int __process_disable_app(pm_dbus_msg *item)
+static int __process_enable_pkg(struct backend_job *job)
{
- int ret = -1;
+ char *backend_cmd;
+ char **argv;
+ char args[MAX_PKG_ARGS_LEN];
+ pkgmgrinfo_pkginfo_h pkginfo_h;
+ bool is_readonly;
+ bool is_global;
+ int ret;
+ int pid;
- __send_app_signal(item->uid, item->req_id, item->pkg_type, item->pkgid, item->pkgid, "start", "disable_app");
+ backend_cmd = job->backend_path;
+ if (backend_cmd == NULL)
+ return -1;
- /* get actual pkgid and replace it to appid which is currently stored at pkgid variable */
- __change_item_info(item, item->uid);
- if (strlen(item->appid) == 0) {
- __send_app_signal(item->uid, item->req_id, item->pkg_type, item->pkgid, item->pkgid, "end", "fail");
- return ret;
+ ret = pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(
+ job->pkgid, job->target_uid, &pkginfo_h);
+ if (ret != PMINFO_R_OK) {
+ ERR("Failed to get appinfo");
+ return -1;
}
- ret = pkgmgr_parser_update_app_disable_info_in_usr_db(item->appid, item->uid, 1);
- if (ret != PMINFO_R_OK)
- __send_app_signal(item->uid, item->req_id, item->pkg_type, item->pkgid, item->appid, "end", "fail");
+ ret = pkgmgrinfo_pkginfo_is_global(pkginfo_h, &is_global);
+ if (ret != PMINFO_R_OK) {
+ ERR("Failed to get global value");
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
+ return -1;
+ }
+
+ if ((is_global && job->target_uid != GLOBAL_USER) ||
+ (!is_global && job->target_uid == GLOBAL_USER)) {
+ ERR("Invalid attempt to enable pkg");
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
+ return -1;
+ }
+
+ ret = pkgmgrinfo_pkginfo_is_readonly(pkginfo_h, &is_readonly);
+ if (ret != PMINFO_R_OK) {
+ ERR("Failed to get readonly value");
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
+ return -1;
+ }
+
+ snprintf(args, sizeof(args), "%s -k %s -u %d -A %s %s",
+ backend_cmd, job->req_id, (int)job->target_uid,
+ job->pkgid, (is_readonly) ? "--preload" : "");
+ argv = __generate_argv(args);
+ pid = __fork_and_exec_with_args(argv, APPFW_UID);
+
+ g_strfreev(argv);
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
+
+ return pid;
+}
+
+static int __process_disable_pkg(struct backend_job *job)
+{
+ char *backend_cmd;
+ char **argv;
+ char args[MAX_PKG_ARGS_LEN];
+ pkgmgrinfo_pkginfo_h pkginfo_h;
+ bool is_readonly;
+ bool is_global;
+ int ret;
+ int pid;
+
+ backend_cmd = job->backend_path;
+ if (backend_cmd == NULL)
+ return -1;
+
+ ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(
+ job->pkgid, job->target_uid, &pkginfo_h);
+ if (ret != PMINFO_R_OK) {
+ ERR("Failed to get appinfo");
+ return -1;
+ }
+
+ ret = pkgmgrinfo_pkginfo_is_global(pkginfo_h, &is_global);
+ if (ret != PMINFO_R_OK) {
+ ERR("Failed to get global value");
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
+ return -1;
+ }
+
+ if ((is_global && job->target_uid != GLOBAL_USER) ||
+ (!is_global && job->target_uid == GLOBAL_USER)) {
+ ERR("Invalid attempt to disable pkg");
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
+ return -1;
+ }
+
+ ret = pkgmgrinfo_pkginfo_is_readonly(pkginfo_h, &is_readonly);
+ if (ret != PMINFO_R_OK) {
+ ERR("Failed to get readonly value");
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
+ return -1;
+ }
+
+ snprintf(args, sizeof(args), "%s -k %s -u %d -D %s %s",
+ backend_cmd, job->req_id, (int)job->target_uid,
+ job->pkgid, (is_readonly) ? "--preload" : "");
+ argv = __generate_argv(args);
+
+ pid = __fork_and_exec_with_args(argv, APPFW_UID);
+
+ g_strfreev(argv);
+
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
+ return pid;
+}
+
+static int __process_register_pkg_update_info(struct backend_job *job)
+{
+ int ret;
+
+ if (!job->extra_data) {
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(i)", PKGMGR_R_ESYSTEM));
+ return -1;
+ }
+
+ ret = pkgmgr_parser_register_pkg_update_info_in_usr_db(
+ (pkgmgrinfo_updateinfo_h)job->extra_data, job->target_uid);
+ if (ret == PMINFO_R_OK)
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(i)", PKGMGR_R_OK));
else
- __send_app_signal(item->uid, item->req_id, item->pkg_type, item->pkgid, item->appid, "end", "ok");
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(i)", PKGMGR_R_ESYSTEM));
+
+ pkgmgrinfo_updateinfo_destroy(job->extra_data);
+ job->extra_data = NULL;
+
+ return ret;
+}
+
+static int __process_unregister_pkg_update_info(struct backend_job *job)
+{
+ int ret = pkgmgr_parser_unregister_pkg_update_info_in_usr_db
+ (job->pkgid, job->target_uid);
+
+ if (ret == PMINFO_R_OK)
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(i)", PKGMGR_R_OK));
+ else
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(i)", PKGMGR_R_ESYSTEM));
+ return ret;
+}
+
+static int __process_unregister_all_pkg_update_info(struct backend_job *job)
+{
+ int ret = pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(
+ job->target_uid);
+
+ if (ret != PMINFO_R_OK) {
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(i)", PKGMGR_R_ESYSTEM));
+ return ret;
+ }
+
+ if (__is_admin_user(job->caller_uid)) {
+ ret = pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(
+ GLOBAL_USER);
+ if (ret != PMINFO_R_OK) {
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(i)", PKGMGR_R_ESYSTEM));
+ return ret;
+ }
+ }
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(i)", PKGMGR_R_OK));
return ret;
}
-static int __process_enable_global_app_for_uid(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_job_info(job, job->target_uid, &is_global);
+ if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
+ _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
+ PKGMGR_INSTALLER_START_KEY_STR,
+ PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR,
+ job->req_type);
+ _send_app_signal(job->target_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(job->target_uid, job->req_id, job->pkgid, job->appid,
+ PKGMGR_INSTALLER_START_KEY_STR,
+ PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR, job->req_type);
- __send_app_signal(item->uid, item->req_id, item->pkg_type, item->pkgid, item->pkgid, "start", "enable_global_app_for_uid");
+ ret = pkgmgr_parser_update_app_disable_info_in_usr_db(job->appid,
+ job->target_uid, 0);
+ if (ret != PMINFO_R_OK)
+ _send_app_signal(job->target_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(job->target_uid, job->req_id, job->pkgid, job->appid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_OK_EVENT_STR,
+ job->req_type);
+
+ return ret;
+}
- /* get actual pkgid and replace it to appid which is currently stored at pkgid variable */
- __change_item_info(item, GLOBAL_USER);
- if (strlen(item->appid) == 0) {
- __send_app_signal(item->uid, item->req_id, item->pkg_type, item->pkgid, item->pkgid, "end", "fail");
+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_job_info(job, job->target_uid, &is_global);
+ if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
+ _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
+ PKGMGR_INSTALLER_START_KEY_STR,
+ PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR,
+ job->req_type);
+ _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_FAIL_EVENT_STR,
+ job->req_type);
return ret;
}
- ret = pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(item->appid, item->uid, 0);
+ _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
+ PKGMGR_INSTALLER_START_KEY_STR,
+ PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR, job->req_type);
+
+ ret = __kill_app(job->appid, job->target_uid);
+ if (ret != 0) {
+ _send_app_signal(job->target_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(job->appid,
+ job->target_uid, 1);
if (ret != PMINFO_R_OK)
- __send_app_signal(item->uid, item->req_id, item->pkg_type, item->pkgid, item->appid, "end", "fail");
+ _send_app_signal(job->target_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->pkg_type, item->pkgid, item->appid, "end", "ok");
+ _send_app_signal(job->target_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_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_job_info(job, job->target_uid, &is_global);
+ if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
+ _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
+ PKGMGR_INSTALLER_START_KEY_STR,
+ PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR,
+ job->req_type);
+ _send_app_signal(job->target_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(job->target_uid, job->req_id, job->pkgid, job->appid,
+ PKGMGR_INSTALLER_START_KEY_STR,
+ PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR,
+ job->req_type);
- __send_app_signal(item->uid, item->req_id, item->pkg_type, item->pkgid, item->pkgid, "start", "disable_global_app_for_uid");
+ ret = pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(
+ job->appid, job->target_uid, 0);
+ if (ret != PMINFO_R_OK)
+ _send_app_signal(job->target_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(job->target_uid, job->req_id, job->pkgid, job->appid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_OK_EVENT_STR,
+ job->req_type);
- /* get actual pkgid and replace it to appid which is currently stored at pkgid variable */
- __change_item_info(item, GLOBAL_USER);
- if (strlen(item->appid) == 0) {
- __send_app_signal(item->uid, item->req_id, item->pkg_type, item->pkgid, item->pkgid, "end", "fail");
+ return ret;
+}
+
+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_job_info(job, GLOBAL_USER, &is_global);
+ if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
+ _send_app_signal(job->target_uid, job->req_id,
+ job->pkgid, job->pkgid,
+ PKGMGR_INSTALLER_START_KEY_STR,
+ PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR,
+ job->req_type);
+ _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
+ PKGMGR_INSTALLER_END_KEY_STR,
+ PKGMGR_INSTALLER_FAIL_EVENT_STR,
+ job->req_type);
return ret;
}
- ret = pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(item->appid, item->uid, 1);
+ _send_app_signal(job->target_uid, job->req_id,
+ job->pkgid, job->appid,
+ PKGMGR_INSTALLER_START_KEY_STR,
+ PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR,
+ job->req_type);
+
+ ret = __kill_app(job->appid, job->target_uid);
+ ret = pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(
+ job->appid, job->target_uid, 1);
+
if (ret != PMINFO_R_OK)
- __send_app_signal(item->uid, item->req_id, item->pkg_type, item->pkgid, item->appid, "end", "fail");
+ _send_app_signal(job->target_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->pkg_type, item->pkgid, item->appid, "end", "ok");
+ _send_app_signal(job->target_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";
+ 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 %d -k %s -u %d",
+ backend_cmd, job->pkgid, job->args, job->caller_uid,
+ job->req_id, job->target_uid);
argv = __generate_argv(args);
- pid = __fork_and_exec_with_args(argv, item->uid);
+ pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
return pid;
}
-static int __process_cleardata(pm_dbus_msg *item)
+static int __process_getsize_sync(struct backend_job *job)
{
- char *backend_cmd;
+ static const char backend_cmd[] = "/usr/bin/pkg_getsize";
char **argv;
char args[MAX_PKG_ARGS_LEN];
+ char fifo_path[PATH_MAX];
+ struct getsize_sync_extra_info *extra_getsize_info;
int pid;
- backend_cmd = _get_backend_cmd(item->pkg_type);
- if (backend_cmd == NULL)
- return -1;
+ snprintf(fifo_path, sizeof(fifo_path), "/tmp/pkgmgr/%s",
+ job->req_id);
- /* TODO: set movetype */
- snprintf(args, sizeof(args), "%s -k %s -c %s", backend_cmd,
- item->req_id, item->pkgid);
- argv = __generate_argv(args);
+ extra_getsize_info = calloc(1, sizeof(struct getsize_sync_extra_info));
+ if (!extra_getsize_info) {
+ ERR("memory alloc failed");
+ goto error;
+ }
- pid = __fork_and_exec_with_args(argv, item->uid);
+ extra_getsize_info->getsize_fifo = strdup(fifo_path);
+ if (!extra_getsize_info->getsize_fifo) {
+ ERR("out of memory");
+ goto error;
+ }
+
+ job->extra_data = extra_getsize_info;
+
+ if (mkfifo(extra_getsize_info->getsize_fifo, 0600) < 0) {
+ ERR("failed to mkfifo");
+ goto error;
+ }
+
+ snprintf(args, sizeof(args), "%s %s %s %d -k %s -u %d --sync",
+ backend_cmd, job->pkgid, job->args, job->caller_uid,
+ job->req_id, job->target_uid);
+ argv = __generate_argv(args);
+ pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
- free(backend_cmd);
+
+ if (pid < 0) {
+ ERR("failed to execute backend");
+ goto error;
+ }
+ if (__setup_size_info_io(job) < 0) {
+ ERR("failed to setup io handler");
+ goto error;
+ }
return pid;
+
+error:
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(ix)", PKGMGR_R_ERROR, -1));
+ return -1;
}
-static int __process_clearcache(pm_dbus_msg *item)
+static int __process_cleardata(struct backend_job *job)
{
- static const char *backend_cmd = "/usr/bin/pkg_clearcache";
+ static const char *backend_cmd = "/usr/bin/pkg_cleardata";
char **argv;
char args[MAX_PKG_ARGS_LEN];
int pid;
- snprintf(args, sizeof(args), "%s %s", backend_cmd, item->pkgid);
+ if ((int)job->target_uid < REGULAR_USER)
+ return -1;
+
+ snprintf(args, sizeof(args), "%s -d -n %s -u %d",
+ backend_cmd, job->pkgid, job->target_uid);
argv = __generate_argv(args);
- pid = __fork_and_exec_with_args(argv, item->uid);
+ pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
+ return pid;
+}
+static int __process_clearcache(struct backend_job *job)
+{
+ static const char *backend_cmd = "/usr/bin/pkg_cleardata";
+ char **argv;
+ char args[MAX_PKG_ARGS_LEN];
+ int pid;
+
+ if ((int)job->target_uid < REGULAR_USER)
+ return -1;
+
+ snprintf(args, sizeof(args), "%s -c -n %s -u %d",
+ backend_cmd, job->pkgid, job->target_uid);
+ argv = __generate_argv(args);
+ pid = __fork_and_exec_with_args(argv, APPFW_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->target_uid,
&handle);
if (ret < 0) {
ERR("Failed to get handle");
+ _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(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(job->req_id,
+ g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
+ free(pdata);
+ return -1;
+ }
+ pdata->uid = job->target_uid;
ret = pkgmgrinfo_appinfo_get_usr_list(handle, PMINFO_ALL_APP,
- __pkgcmd_app_cb, "kill", item->uid);
+ __pkgcmd_app_cb, pdata, job->target_uid);
+
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(ii)", PKGMGR_R_OK, pdata->pid));
+
+ free(pdata->cmd);
+ free(pdata);
pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
if (ret < 0) {
ERR("pkgmgrinfo_appinfo_get_list() failed");
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->target_uid,
&handle);
if (ret < 0) {
ERR("Failed to get handle");
+ _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(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(job->req_id,
+ g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
+ free(pdata);
+ return -1;
+ }
+ pdata->uid = job->target_uid;
ret = pkgmgrinfo_appinfo_get_usr_list(handle, PMINFO_ALL_APP,
- __pkgcmd_app_cb, "check", item->uid);
+ __pkgcmd_app_cb, pdata, job->target_uid);
+
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(ii)", PKGMGR_R_OK, pdata->pid));
+
+ free(pdata->cmd);
+ free(pdata);
pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
if (ret < 0) {
ERR("pkgmgrinfo_appinfo_get_list() failed");
return 0;
}
-static int __process_generate_license_request(pm_dbus_msg *item)
+static int __load_drm_library(void)
+{
+ if (drm_lib_handle)
+ return 0;
+
+ drm_lib_handle = dlopen(PATH_LIBDRM_SVC_CORE, RTLD_LAZY);
+ if (!drm_lib_handle) {
+ DBG("Unable to open %s", PATH_LIBDRM_SVC_CORE);
+ return -1;
+ }
+
+ _drm_tizen_generate_license_request =
+ dlsym(drm_lib_handle, "drm_tizen_generate_license_request");
+ if (_drm_tizen_generate_license_request == NULL) {
+ ERR("_drm_tizen_generate_license_request() failed");
+ goto catch;
+ }
+
+ _drm_tizen_register_license =
+ dlsym(drm_lib_handle, "drm_tizen_register_license");
+ if (_drm_tizen_register_license == NULL) {
+ ERR("_register_license() failed");
+ goto catch;
+ }
+
+ _drm_tizen_decrypt_package =
+ dlsym(drm_lib_handle, "drm_tizen_decrypt_package");
+ if (_drm_tizen_decrypt_package == NULL) {
+ ERR("_drm_tizen_decrypt_package() failed");
+ goto catch;
+ }
+
+ return 0;
+catch:
+ if (drm_lib_handle) {
+ dlclose(drm_lib_handle);
+ drm_lib_handle = NULL;
+ }
+ return -1;
+}
+
+static void __unload_drm_library(void)
+{
+ if (drm_lib_handle) {
+ dlclose(drm_lib_handle);
+ drm_lib_handle = NULL;
+ }
+}
+
+static int __process_generate_license_request(struct backend_job *job)
{
- int ret;
char *resp_data;
char req_data[MAX_PKG_ARGS_LEN];
unsigned int req_data_len;
char license_url[MAX_PKG_ARGS_LEN];
unsigned int license_url_len;
+ int ret;
- resp_data = item->args;
+ resp_data = job->args;
req_data_len = sizeof(req_data);
license_url_len = sizeof(license_url);
- ret = drm_tizen_generate_license_request(resp_data, strlen(resp_data),
- 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)",
- PKGMGR_R_ESYSTEM, "", ""));
- return -1;
+ if (__load_drm_library() != 0) {
+ ERR("Failed to load library");
+ goto catch;
}
- __return_value_to_caller(item->req_id,
+ ret = _drm_tizen_generate_license_request(resp_data, strlen(resp_data),
+ req_data, &req_data_len,
+ license_url, &license_url_len);
+ if (ret != 1) {
+ ERR("drm_tizen_generate_license_request failed");
+ goto catch;
+ }
+ _return_value_to_caller(job->req_id,
g_variant_new("(iss)", PKGMGR_R_OK, req_data,
license_url));
-
+ is_drm_busy = true;
return 0;
+
+catch:
+ _return_value_to_caller(job->req_id, g_variant_new("(iss)",
+ PKGMGR_R_ESYSTEM, "", ""));
+ is_drm_busy = false;
+ __unload_drm_library();
+ return -1;
}
-static int __process_register_license(pm_dbus_msg *item)
+static int __process_register_license(struct backend_job *job)
{
- int ret;
char *resp_data;
+ int ret;
- resp_data = item->args;
-
- ret = drm_tizen_register_license(resp_data, strlen(resp_data));
- if (ret != TADC_SUCCESS) {
+ resp_data = job->args;
+ if (!_drm_tizen_register_license) {
+ ERR("_drm_tizen_register_license is not loaded");
+ goto catch;
+ }
+ ret = _drm_tizen_register_license(resp_data, strlen(resp_data));
+ if (ret != 1) {
ERR("drm_tizen_register_license failed: %d", ret);
- __return_value_to_caller(item->req_id,
- g_variant_new("(i)", PKGMGR_R_ESYSTEM));
- return -1;
+ goto catch;
}
-
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(i)", PKGMGR_R_OK));
-
return 0;
+
+catch:
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(i)", PKGMGR_R_ESYSTEM));
+ is_drm_busy = false;
+ __unload_drm_library();
+
+ return -1;
}
-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),
+ if (!_drm_tizen_decrypt_package) {
+ ERR("drm_tizen_decrypt_package is not loaded");
+
+ goto catch;
+ }
+ 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,
- g_variant_new("(i)", PKGMGR_R_ESYSTEM));
- return -1;
+ if (ret != 1) {
+ ERR("drm_tizen_decrypt_package failed: %d", ret);
+ goto catch;
}
-
- __return_value_to_caller(item->req_id,
+ _return_value_to_caller(job->req_id,
g_variant_new("(i)", PKGMGR_R_OK));
-
return 0;
+
+catch:
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(i)", PKGMGR_R_ESYSTEM));
+ is_drm_busy = false;
+ __unload_drm_library();
+
+ return -1;
+}
+
+static int __process_update_app_splash_screen(struct backend_job *job, int flag)
+{
+ int ret;
+ bool is_global = false;
+ const char *val;
+
+ ret = __change_job_info(job, job->target_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(job->target_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(job->appid, job->target_uid, flag);
+ else
+ ret = pkgmgr_parser_update_app_splash_screen_display_info_in_usr_db(
+ job->appid, job->target_uid, flag);
+ if (ret != PMINFO_R_OK)
+ _send_app_signal(job->target_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(job->target_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_add_blacklist(pm_dbus_msg *item)
+static int __process_set_restriction_mode(struct backend_job *job)
{
int ret;
+ int mode;
- ret = __add_blacklist(item->uid, item->pkgid);
+ mode = atoi(job->args);
+ ret = _set_restriction_mode(job->target_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_remove_blacklist(pm_dbus_msg *item)
+static int __process_unset_restriction_mode(struct backend_job *job)
{
int ret;
+ int mode;
- ret = __remove_blacklist(item->uid, item->pkgid);
+ mode = atoi(job->args);
+ ret = _unset_restriction_mode(job->target_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_check_blacklist(pm_dbus_msg *item)
+static int __process_get_restriction_mode(struct backend_job *job)
{
int ret;
- int result = 0;
+ int mode = -1;
- ret = __check_blacklist(item->uid, item->pkgid, &result);
+ ret = _get_restriction_mode(job->target_uid, job->pkgid, &mode);
- __return_value_to_caller(item->req_id,
- g_variant_new("(ii)", result, ret));
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(ii)", mode, ret));
return ret;
}
+static int __process_set_app_label(struct backend_job *job)
+{
+ int ret;
+
+ ret = pkgmgr_parser_update_app_label_info_in_usr_db(job->pkgid,
+ job->target_uid, job->args);
+ _return_value_to_caller(job->req_id, g_variant_new("(i)", ret));
+
+ return ret;
+}
+
+static int __process_set_app_icon(struct backend_job *job)
+{
+ int ret;
+
+ ret = pkgmgr_parser_update_app_icon_info_in_usr_db(job->pkgid,
+ job->target_uid, job->args);
+ _return_value_to_caller(job->req_id, g_variant_new("(i)", ret));
+
+ return ret;
+}
+
+static int __process_migrate_external_image(struct backend_job *job)
+{
+ char *backend_cmd;
+ char **argv;
+ char args[MAX_PKG_ARGS_LEN];
+ int pid;
+
+ backend_cmd = job->backend_path;
+ if (backend_cmd == NULL)
+ return -1;
+
+ snprintf(args, sizeof(args), "%s -k %s --migrate-extimg %s -u %d %s",
+ backend_cmd, job->req_id, job->pkgid,
+ (int)job->target_uid, job->args);
+
+ argv = __generate_argv(args);
+
+ pid = __fork_and_exec_with_args(argv, APPFW_UID);
+ g_strfreev(argv);
+
+ return pid;
+}
+
+static int __post_process(int ret, int x, struct backend_job *job)
+{
+ if (ret < 0) {
+ __set_backend_free(x);
+ _free_backend_job(job);
+ } else {
+ g_hash_table_insert(backend_info_table, (gpointer)ret,
+ (gpointer)job);
+ }
+ return 0;
+}
+
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 available");
return FALSE;
+ }
- /*save pkg type and pkg name for future*/
- strncpy(ptr->pkgtype, item->pkg_type, MAX_PKG_TYPE_LEN-1);
- strncpy(ptr->pkgid, item->pkgid, MAX_PKG_NAME_LEN-1);
- strncpy(ptr->args, item->args, MAX_PKG_ARGS_LEN-1);
- memset((item->appid),0,MAX_PKG_NAME_LEN);
- ptr->uid = item->uid;
- DBG("handle request type [%d]", item->req_type);
+ /* set current backend job */
+ DBG("handle request type [%d]", job->req_type);
+
+ 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(job);
+ _free_backend_job(job);
+ return TRUE;
+ }
+ }
- switch (item->req_type) {
- case PKGMGR_REQUEST_TYPE_INSTALL:
+ switch (job->req_type) {
+ case REQUEST_TYPE_INSTALL:
+ __set_backend_busy(x);
+ __set_power_lock();
+ ret = __process_install(job);
+ __post_process(ret, x, job);
+ break;
+ case REQUEST_TYPE_MOUNT_INSTALL:
__set_backend_busy(x);
- __set_recovery_mode(item->uid, item->pkgid, item->pkg_type);
- ret = __process_install(item);
+ __set_power_lock();
+ ret = __process_mount_install(job);
+ __post_process(ret, x, job);
break;
- case PKGMGR_REQUEST_TYPE_REINSTALL:
+ case REQUEST_TYPE_REINSTALL:
__set_backend_busy(x);
- __set_recovery_mode(item->uid, item->pkgid, item->pkg_type);
- ret = __process_reinstall(item);
+ __set_power_lock();
+ ret = __process_reinstall(job);
+ __post_process(ret, x, job);
break;
- case PKGMGR_REQUEST_TYPE_UNINSTALL:
+ case REQUEST_TYPE_UNINSTALL:
__set_backend_busy(x);
- __set_recovery_mode(item->uid, item->pkgid, item->pkg_type);
- ret = __process_uninstall(item);
+ __set_power_lock();
+ ret = __process_uninstall(job);
+ __post_process(ret, x, job);
break;
- case PKGMGR_REQUEST_TYPE_MOVE:
+ case REQUEST_TYPE_MOVE:
__set_backend_busy(x);
- __set_recovery_mode(item->uid, item->pkgid, item->pkg_type);
- ret = __process_move(item);
+ __set_power_lock();
+ ret = __process_move(job);
+ __post_process(ret, x, job);
break;
- case PKGMGR_REQUEST_TYPE_ENABLE_PKG:
- ret = __process_enable_pkg(item);
+ case REQUEST_TYPE_ENABLE_PKG:
+ __set_backend_busy(x);
+ __set_power_lock();
+ ret = __process_enable_pkg(job);
+ if (ret < 0)
+ _send_fail_signal(job);
+ __post_process(ret, x, job);
break;
- case PKGMGR_REQUEST_TYPE_DISABLE_PKG:
- ret = __process_disable_pkg(item);
+ case REQUEST_TYPE_DISABLE_PKG:
+ __set_backend_busy(x);
+ __set_power_lock();
+ ret = __process_disable_pkg(job);
+ if (ret < 0)
+ _send_fail_signal(job);
+ __post_process(ret, x, job);
break;
- case PKGMGR_REQUEST_TYPE_ENABLE_APP:
- ret = __process_enable_app(item);
+ case REQUEST_TYPE_REGISTER_PKG_UPDATE_INFO:
+ ret = __process_register_pkg_update_info(job);
+ __free_extra_info(job);
+ _free_backend_job(job);
break;
- case PKGMGR_REQUEST_TYPE_DISABLE_APP:
- ret = __process_disable_app(item);
+ case REQUEST_TYPE_UNREGISTER_PKG_UPDATE_INFO:
+ ret = __process_unregister_pkg_update_info(job);
+ _free_backend_job(job);
+ break;
+ case REQUEST_TYPE_UNREGISTER_ALL_PKG_UPDATE_INFO:
+ ret = __process_unregister_all_pkg_update_info(job);
+ _free_backend_job(job);
+ break;
+ case REQUEST_TYPE_ENABLE_APP:
+ ret = __process_enable_app(job);
+ _free_backend_job(job);
+ break;
+ case REQUEST_TYPE_DISABLE_APP:
+ ret = __process_disable_app(job);
+ _free_backend_job(job);
+ break;
+ case REQUEST_TYPE_GETSIZE:
+ __set_backend_busy(x);
+ ret = __process_getsize(job);
+ __post_process(ret, x, job);
break;
- case PKGMGR_REQUEST_TYPE_GETSIZE:
+ case REQUEST_TYPE_GETSIZE_SYNC:
__set_backend_busy(x);
- ret = __process_getsize(item);
+ ret = __process_getsize_sync(job);
+ if (ret < 0)
+ __free_extra_info(job);
+ __post_process(ret, x, job);
break;
- case PKGMGR_REQUEST_TYPE_CLEARDATA:
+ case REQUEST_TYPE_CLEARDATA:
__set_backend_busy(x);
- ret = __process_cleardata(item);
+ __set_power_lock();
+ ret = __process_cleardata(job);
+ __post_process(ret, x, job);
break;
- case PKGMGR_REQUEST_TYPE_CLEARCACHE:
+ case REQUEST_TYPE_CLEARCACHE:
__set_backend_busy(x);
- ret = __process_clearcache(item);
+ __set_power_lock();
+ ret = __process_clearcache(job);
+ __post_process(ret, x, 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_ADD_BLACKLIST:
- ret = __process_add_blacklist(item);
+ case REQUEST_TYPE_ENABLE_APP_SPLASH_SCREEN:
+ ret = __process_update_app_splash_screen(job, 1);
+ _free_backend_job(job);
break;
- case PKGMGR_REQUEST_TYPE_REMOVE_BLACKLIST:
- ret = __process_remove_blacklist(item);
+ case REQUEST_TYPE_DISABLE_APP_SPLASH_SCREEN:
+ ret = __process_update_app_splash_screen(job, 0);
+ _free_backend_job(job);
break;
- case PKGMGR_REQUEST_TYPE_CHECK_BLACKLIST:
- ret = __process_check_blacklist(item);
+ case REQUEST_TYPE_SET_RESTRICTION_MODE:
+ ret = __process_set_restriction_mode(job);
+ _free_backend_job(job);
+ break;
+ case REQUEST_TYPE_UNSET_RESTRICTION_MODE:
+ ret = __process_unset_restriction_mode(job);
+ _free_backend_job(job);
+ break;
+ case REQUEST_TYPE_GET_RESTRICTION_MODE:
+ ret = __process_get_restriction_mode(job);
+ _free_backend_job(job);
+ break;
+ case REQUEST_TYPE_SET_APP_LABEL:
+ ret = __process_set_app_label(job);
+ _free_backend_job(job);
+ break;
+ case REQUEST_TYPE_SET_APP_ICON:
+ ret = __process_set_app_icon(job);
+ _free_backend_job(job);
+ break;
+ case REQUEST_TYPE_MIGRATE_EXTERNAL_IMAGE:
+ __set_backend_busy(x);
+ __set_power_lock();
+ ret = __process_migrate_external_image(job);
+ __post_process(ret, x, job);
break;
default:
ret = -1;
break;
}
- 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 */
+ return TRUE;
}
int main(int argc, char *argv[])
{
- FILE *fp_status = NULL;
- char buf[32] = { 0, };
- pid_t pid;
- char *backend_cmd = NULL;
- char *backend_name = NULL;
int r;
DBG("server start");
- if (argv[1] && (strcmp(argv[1], "init") == 0)) {
- /* if current status is "processing",
- execute related backend with '-r' option */
- if (!(fp_status = fopen(STATUS_FILE, "r")))
- return 0; /*if file is not exist, terminated. */
- /* if processing <-- unintended termination */
- if (fgets(buf, 32, fp_status) &&
- strcmp(buf, "processing") == 0) {
- pid = fork();
- if (pid == 0) { /* child */
- if (fgets(buf, 32, fp_status))
- backend_cmd = _get_backend_cmd(buf);
- if (!backend_cmd) { /* if NULL, */
- DBG("fail to get backend command");
- goto err;
- }
- backend_name =
- strrchr(backend_cmd, '/');
- if (!backend_name) {
- DBG("fail to get backend name");
- goto err;
- }
-
- execl(backend_cmd, backend_name, "-r",
- NULL);
- if (backend_cmd)
- free(backend_cmd);
- fprintf(fp_status, " ");
-err:
- fclose(fp_status);
- exit(13);
- } else if (pid < 0) { /* error */
- DBG("fork fail");
- fclose(fp_status);
- return 0;
- } else { /* parent */
-
- DBG("parent end\n");
- fprintf(fp_status, " ");
- fclose(fp_status);
- return 0;
- }
- }
+ if (__register_signal_handler()) {
+ ERR("failed to register signal handler");
+ return -1;
}
- r = _pm_queue_init();
+ r = _init_backend_queue();
if (r) {
- DBG("Queue Initialization Failed\n");
+ ERR("Queue Initialization Failed");
return -1;
}
r = __init_backend_info();
if (r) {
- DBG("backend info init failed");
+ ERR("backend info init failed");
return -1;
}
- r = __init_request_handler();
+ r = _init_request_handler();
if (r) {
ERR("dbus init failed");
return -1;
}
- if (__register_signal_handler()) {
- ERR("failed to register signal handler");
- return -1;
- }
-
-#if !GLIB_CHECK_VERSION(2,35,0)
+#if !GLIB_CHECK_VERSION(2, 35, 0)
g_type_init();
#endif
mainloop = g_main_loop_new(NULL, FALSE);
g_main_loop_run(mainloop);
DBG("Quit main loop.");
- __fini_request_handler();
+ _fini_request_handler();
__fini_backend_info();
- _pm_queue_final();
+ _fini_backend_queue();
+
+ g_source_remove(swid);
+ g_io_channel_unref(sio);
DBG("package manager server terminated.");
projects / platform / core / appfw / pkgmgr-server.git / blobdiff