#include <sys/wait.h>
#include <sys/stat.h>
#include <sys/types.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 <pkgmgr-info.h>
#include <pkgmgr/pkgmgr_parser_db.h>
#include <tzplatform_config.h>
-#include <drm-tizen-apps.h>
-#ifdef TIZEN_FEATURE_CSR
-#include <csr-content-screening.h>
-#endif
#include "pkgmgr_installer.h"
#include "pkgmgr-server.h"
#include "queue.h"
#include "package-manager.h"
+#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
*/
static char backend_busy = 0;
extern int num_of_backends;
+bool is_drm_busy = false;
+static bool is_lock_set = false;
-struct signal_info_t {
- pid_t pid;
- int status;
-};
-
-static int pipe_sig[2];
-static GIOChannel *pipe_io;
-static guint pipe_wid;
+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);
backend_busy = backend_busy & ~(1 << position);
}
+static GDBusConnection *_get_system_conn(void)
+{
+ GError *err = NULL;
+
+ if (system_conn)
+ return system_conn;
+
+ 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 system_conn;
+}
+
+#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)
+{
+ GDBusConnection *conn;
+ GDBusMessage *msg;
+ GError *err = NULL;
+ int ret = 0;
+
+ if (is_lock_set)
+ return;
+
+ conn = _get_system_conn();
+ if (conn == NULL)
+ return;
+
+ 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;
+ }
+
+ 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;
+ }
+
+ 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 __release_power_lock(void)
+{
+ GError *err = NULL;
+ GDBusConnection *conn;
+ GDBusMessage *msg;
+ int ret = 0;
+
+ if (!is_lock_set)
+ return;
+
+ conn = _get_system_conn();
+ if (conn == NULL)
+ return;
+
+ 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;
+ }
+
+ 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;
+ }
+
+ 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 gboolean getsize_io_handler(GIOChannel *io, GIOCondition cond,
gpointer data)
{
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;
s = g_io_channel_read_chars(io, (gchar *)buf, sizeof(buf), &len, &err);
if (s != G_IO_STATUS_NORMAL) {
_return_value_to_caller(job->req_id, g_variant_new("(ix)",
(result < 0) ? PKGMGR_R_ERROR : PKGMGR_R_OK, result));
- unlink(job->extra->getsize_fifo);
- free(job->extra->getsize_fifo);
- job->extra->getsize_fifo = NULL;
+ unlink(extra_getsize_info->getsize_fifo);
+ free(extra_getsize_info->getsize_fifo);
+ extra_getsize_info->getsize_fifo = NULL;
return FALSE;
}
static int __setup_size_info_io(struct backend_job *job)
{
guint getsize_wid;
+ struct getsize_sync_extra_info *extra_getsize_info =
+ (struct getsize_sync_extra_info *)job->extra_data;
- job->extra->getsize_fd = open(job->extra->getsize_fifo,
+ extra_getsize_info->getsize_fd = open(extra_getsize_info->getsize_fifo,
O_RDONLY | O_NONBLOCK);
- if (job->extra->getsize_fd < 0) {
+ if (extra_getsize_info->getsize_fd < 0) {
ERR("failed to open the fifo(%s), errno(%d)",
- job->extra->getsize_fifo, errno);
+ extra_getsize_info->getsize_fifo, errno);
return -1;
}
- job->extra->getsize_io = g_io_channel_unix_new(job->extra->getsize_fd);
- if (!job->extra->getsize_io)
+ 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(job->extra->getsize_io, NULL, NULL);
- g_io_channel_set_buffered(job->extra->getsize_io, FALSE);
- getsize_wid = g_io_add_watch(job->extra->getsize_io,
- G_IO_IN, getsize_io_handler, job);
+ 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;
return 0;
}
-static gboolean pipe_io_handler(GIOChannel *io, GIOCondition cond,
+static gboolean __signal_handler(GIOChannel *io, GIOCondition cond,
gpointer data)
{
GError *err = NULL;
GIOStatus s;
gsize len;
- struct signal_info_t info;
+ 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;
}
- job = (struct backend_job *)g_hash_table_lookup(backend_info_table,
- (gconstpointer)info.pid);
- if (job == NULL) {
- ERR("Unknown child exit");
- return -1;
- }
+ 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;
+ }
- __set_backend_free(job->backend_slot);
- if (WIFSIGNALED(info.status)) {
- _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", job->backend_type);
- } else {
- DBG("backend[%s] exit", job->backend_type);
- }
+ __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);
+ }
- if (job->extra) {
- if (job->extra->getsize_fifo) {
- ERR("invalid backend close");
- _return_value_to_caller(job->req_id,
- g_variant_new("(ix)", PKGMGR_R_ERROR, -1));
+ 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_hash_table_remove(backend_info_table, (gconstpointer)info.pid);
g_idle_add(queue_job, NULL);
return TRUE;
g_direct_equal, NULL,
(GDestroyNotify)_free_backend_job);
- 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);
-
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 */
g_hash_table_destroy(backend_info_table);
}
-static void sighandler(int signo)
-{
- struct signal_info_t info;
- char buf[1024] = {0, };
-
- 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)));
-}
-
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);
- act.sa_handler = sighandler;
- sigemptyset(&act.sa_mask);
- act.sa_flags = SA_NOCLDSTOP;
- if (sigaction(SIGCHLD, &act, NULL) < 0) {
- ERR("signal: SIGCHLD failed");
+ if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1) {
+ ERR("sigprocmask failed");
return -1;
}
- g_timeout_add_seconds(2, exit_server, NULL);
+ sfd = signalfd(-1, &mask, SFD_NONBLOCK);
+ if (sfd == -1) {
+ ERR("signalfd failed");
+ return -1;
+ }
+
+ 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;
}
{
DBG("exit_server Start");
if (__check_backend_status_for_exit() &&
- __check_queue_status_for_exit()) {
+ __check_queue_status_for_exit() && !is_drm_busy) {
g_main_loop_quit(mainloop);
+ if (is_lock_set)
+ __release_power_lock();
return FALSE;
}
return TRUE;
}
-#ifdef TIZEN_FEATURE_CSR
static int __check_csr(const char *path)
{
- csr_cs_context_h context = NULL;
- csr_cs_malware_h detected = NULL;
- int ret = -1;
+ int 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;
+ }
- ret = csr_cs_context_create(&context);
- if (ret != CSR_ERROR_NONE) {
- ERR("Failed to create csr context");
- return -1;
+ _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 (!_csr_cs_context_create || !_csr_cs_scan_file ||
+ !_csr_cs_context_destroy) {
+ ERR("Failed to load CSR symbols");
+ ret = -1;
+ goto catch;
+ }
+
+ ret = _csr_cs_context_create(&context);
+ if (ret != 0) {
+ ERR("Failed to create context");
+ ret = -1;
+ goto catch;
}
- if (context) {
- ret = csr_cs_scan_file(context, path, &detected);
+ ret = _csr_cs_scan_file(context, path, &malware);
+ if (ret != 0) {
DBG("CSR result[%d]", ret);
+ ret = 0;
+ goto catch;
+ }
- csr_cs_context_destroy(context);
- if (detected != NULL) {
- ERR("CSR Denied[%s] Installation", path);
- return -1;
- }
+ ret = _csr_cs_context_destroy(context);
+ if (ret != 0) {
+ ERR("Failed to destroy context");
+ ret = -1;
+ goto catch;
}
- return 0;
+ if (malware != NULL) {
+ ERR("CSR detected malware from [%s]", path);
+ ret = -1;
+ }
+
+catch:
+ if (lib_handle)
+ dlclose(lib_handle);
+
+ return ret;
}
-#endif
static int __kill_app(char *appid, uid_t uid)
{
ret = aul_terminate_pid_for_uid(pid, uid);
if (ret != AUL_R_OK) {
- ERR("failed to terminate app(%d)", appid);
+ ERR("failed to terminate app(%s)", appid);
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);
+ 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_context = get_user_context(uid);
if (!user_context) {
- DBG("Failed to getenv");
+ ERR("Failed to getenv");
return -1;
}
char *backend_cmd;
char **argv;
char args[MAX_PKG_ARGS_LEN];
+ gchar *req_id;
+ gchar *pkgid;
int pid;
backend_cmd = job->backend_path;
if (backend_cmd == NULL)
return -1;
+ 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,
- job->req_id, job->pkgid, (int)job->target_uid, job->args);
+ req_id, pkgid, (int)job->target_uid, job->args);
argv = __generate_argv(args);
pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
+ g_free(req_id);
+ g_free(pkgid);
return pid;
}
char *backend_cmd;
char **argv;
char args[MAX_PKG_ARGS_LEN];
+ gchar *req_id;
+ gchar *pkgid;
int pid;
backend_cmd = job->backend_path;
if (backend_cmd == NULL)
return -1;
+ 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,
- job->req_id, job->pkgid, (int)job->target_uid, job->args);
+ req_id, pkgid, (int)job->target_uid, job->args);
argv = __generate_argv(args);
pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
+ g_free(req_id);
+ g_free(pkgid);
return pid;
}
char *backend_cmd;
char **argv;
char args[MAX_PKG_ARGS_LEN];
+ gchar *req_id;
+ gchar *pkgid;
int pid;
backend_cmd = job->backend_path;
if (backend_cmd == NULL)
return -1;
+ 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,
- job->req_id, job->pkgid, (int)job->target_uid);
+ req_id, pkgid, (int)job->target_uid);
argv = __generate_argv(args);
pid = __fork_and_exec_with_args(argv, APPFW_UID);
g_strfreev(argv);
+ g_free(req_id);
+ g_free(pkgid);
return pid;
}
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
+ _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_app(struct backend_job *job)
{
int ret = -1;
char **argv;
char args[MAX_PKG_ARGS_LEN];
char fifo_path[PATH_MAX];
+ struct getsize_sync_extra_info *extra_getsize_info;
int pid;
snprintf(fifo_path, sizeof(fifo_path), "/tmp/pkgmgr/%s",
job->req_id);
- job->extra = calloc(1, sizeof(struct job_extra_info));
- if (!job->extra) {
+ extra_getsize_info = calloc(1, sizeof(struct getsize_sync_extra_info));
+ if (!extra_getsize_info) {
ERR("memory alloc failed");
goto error;
}
- job->extra->getsize_fifo = strdup(fifo_path);
- if (!job->extra->getsize_fifo) {
+ job->extra_data = extra_getsize_info;
+ extra_getsize_info->getsize_fifo = strdup(fifo_path);
+ if (!extra_getsize_info->getsize_fifo) {
ERR("out of memory");
goto error;
}
- if (mkfifo(job->extra->getsize_fifo, 0600) < 0) {
+ if (mkfifo(extra_getsize_info->getsize_fifo, 0600) < 0) {
ERR("failed to mkfifo");
goto error;
}
return 0;
}
+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 = 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(job->req_id, g_variant_new("(iss)",
- PKGMGR_R_ESYSTEM, "", ""));
- return -1;
+ if (__load_drm_library() != 0) {
+ ERR("Failed to load library");
+ goto catch;
}
+ 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(struct backend_job *job)
{
- int ret;
char *resp_data;
+ int ret;
resp_data = job->args;
-
- ret = drm_tizen_register_license(resp_data, strlen(resp_data));
- if (ret != TADC_SUCCESS) {
+ 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(job->req_id,
- g_variant_new("(i)", PKGMGR_R_ESYSTEM));
- return -1;
+ goto catch;
}
-
_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(struct backend_job *job)
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(job->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(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)
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;
/* set current backend job */
DBG("handle request type [%d]", job->req_type);
-#ifdef TIZEN_FEATURE_CSR
if (job->req_type == REQUEST_TYPE_INSTALL ||
job->req_type == REQUEST_TYPE_MOUNT_INSTALL ||
job->req_type == REQUEST_TYPE_REINSTALL) {
return TRUE;
}
}
-#endif
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_power_lock();
ret = __process_mount_install(job);
__post_process(ret, x, job);
break;
case REQUEST_TYPE_REINSTALL:
__set_backend_busy(x);
+ __set_power_lock();
ret = __process_reinstall(job);
__post_process(ret, x, job);
break;
case REQUEST_TYPE_UNINSTALL:
__set_backend_busy(x);
+ __set_power_lock();
ret = __process_uninstall(job);
__post_process(ret, x, job);
break;
case REQUEST_TYPE_MOVE:
__set_backend_busy(x);
+ __set_power_lock();
ret = __process_move(job);
__post_process(ret, x, job);
break;
case REQUEST_TYPE_ENABLE_PKG:
__set_backend_busy(x);
+ __set_power_lock();
ret = __process_enable_pkg(job);
if (ret < 0)
_send_fail_signal(job);
break;
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 REQUEST_TYPE_REGISTER_PKG_UPDATE_INFO:
+ ret = __process_register_pkg_update_info(job);
+ __free_extra_info(job);
+ _free_backend_job(job);
+ break;
+ 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_CLEARDATA:
__set_backend_busy(x);
+ __set_power_lock();
ret = __process_cleardata(job);
__post_process(ret, x, job);
break;
case REQUEST_TYPE_CLEARCACHE:
__set_backend_busy(x);
+ __set_power_lock();
ret = __process_clearcache(job);
__post_process(ret, x, job);
break;
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;
DBG("server start");
+ if (__register_signal_handler()) {
+ ERR("failed to register signal handler");
+ return -1;
+ }
+
r = _init_backend_queue();
if (r) {
- DBG("Queue Initialization Failed");
+ ERR("Queue Initialization Failed");
return -1;
}
r = __init_backend_info();
if (r) {
- DBG("backend info init failed");
+ ERR("backend info init failed");
return -1;
}
return -1;
}
- if (__register_signal_handler()) {
- ERR("failed to register signal handler");
- return -1;
- }
-
#if !GLIB_CHECK_VERSION(2, 35, 0)
g_type_init();
#endif
__fini_backend_info();
_fini_backend_queue();
+ g_source_remove(swid);
+ g_io_channel_unref(sio);
+
DBG("package manager server terminated.");
return 0;
projects / platform / core / appfw / pkgmgr-server.git / blobdiff