4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
7 * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
29 #include <sys/types.h>
32 #include <sys/types.h>
33 #include <sys/signalfd.h>
44 #include <pkgmgr-info.h>
45 #include <pkgmgr/pkgmgr_parser_db.h>
46 #include <tzplatform_config.h>
48 #include "pkgmgr_installer.h"
49 #include "pkgmgr-server.h"
51 #include "package-manager.h"
53 #define USRLIB "/usr/lib"
55 #define PATH_LIBDRM_SVC_CORE \
56 "/usr/lib/libdrm-service-core-tizen.so.0"
57 #define PATH_LIBCSR_CLIENT \
58 "/usr/lib/libcsr-client.so.2"
60 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
64 #define EXT_STORAGE_GROUP 10001
65 #define EXT_STORAGE_APPDATA_GROUP 10002
66 #define MEDIA_STORAGE_GROUP 10502
67 #define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))
68 #define MAX_LONGLONG_LENGTH 32
83 8 bit value to represent maximum 8 backends.
84 Each bit position corresponds to a queue slot which
85 is dynamically determined.
87 static char backend_busy = 0;
88 extern int num_of_backends;
89 bool is_drm_busy = false;
90 static bool is_lock_set = false;
92 static GIOChannel *sio;
94 static GHashTable *backend_info_table;
95 static GMainLoop *mainloop;
96 static GDBusConnection *system_conn;
98 static int (*_drm_tizen_register_license)
99 (const char *pRespBuf, unsigned int respBufLen);
100 static int (*_drm_tizen_decrypt_package)(const char *pTADCFilepath,
101 int tadcFileLen, const char *pDecryptedFile,
102 int decryptedFileLen);
103 static int (*_drm_tizen_generate_license_request)(const char *pRespBuf,
104 unsigned int respBufLen, char *pReqBuf,
105 unsigned int *pReqBufLen, char *pLicenseUrl,
106 unsigned int *pLicenseUrlLen);
107 static void *drm_lib_handle;
109 static int __check_backend_status_for_exit(void);
110 static int __check_queue_status_for_exit(void);
111 static int __is_backend_busy(int position);
112 static void __set_backend_busy(int position);
113 static void __set_backend_free(int position);
115 gboolean exit_server(void *data);
117 /* To check whether a particular backend is free/busy */
118 static int __is_backend_busy(int position)
120 return backend_busy & (1 << position);
122 /* To set a particular backend as busy */
123 static void __set_backend_busy(int position)
125 backend_busy = backend_busy | (1 << position);
127 /* To set a particular backend as free */
128 static void __set_backend_free(int position)
130 backend_busy = backend_busy & ~(1 << position);
133 static GDBusConnection *_get_system_conn(void)
140 system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
141 if (system_conn == NULL) {
142 ERR("Failed to get system bus: %s", err->message);
150 #define DEVICED_DBUS_PATH "org.tizen.system.deviced"
151 #define DEVICED_DBUS_OBJECT_PATH "/Org/Tizen/System/DeviceD/Display"
152 #define DEVICED_DBUS_INTERFACE_NAME "org.tizen.system.deviced.display"
154 static void __set_power_lock(void)
156 GDBusConnection *conn;
164 conn = _get_system_conn();
168 msg = g_dbus_message_new_method_call(DEVICED_DBUS_PATH,
169 DEVICED_DBUS_OBJECT_PATH,
170 DEVICED_DBUS_INTERFACE_NAME,
173 ERR("g_dbus_message_new_method_call() has failed");
177 g_dbus_message_set_body(msg, g_variant_new("(sssi)", "lcdoff",
178 "staycurstate", "NULL", 0));
179 if (!g_dbus_connection_send_message(conn, msg,
180 G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, &err)) {
181 ERR("Unable to send dbus message for acquring lock as %s",
189 g_dbus_connection_flush_sync(conn, NULL, NULL);
193 static void __release_power_lock(void)
196 GDBusConnection *conn;
203 conn = _get_system_conn();
207 msg = g_dbus_message_new_method_call(DEVICED_DBUS_PATH,
208 DEVICED_DBUS_OBJECT_PATH,
209 DEVICED_DBUS_INTERFACE_NAME,
212 ERR("g_dbus_message_new_method_call() is failed");
216 g_dbus_message_set_body(msg, g_variant_new("(ss)", "lcdoff",
218 if (!g_dbus_connection_send_message(conn, msg,
219 G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, &err)) {
220 ERR("Unable to send dbus message for releasing lock as %s",
228 g_dbus_connection_flush_sync(conn, NULL, NULL);
234 static gboolean getsize_io_handler(GIOChannel *io, GIOCondition cond,
240 char buf[MAX_LONGLONG_LENGTH];
241 long long result = 0;
242 struct backend_job *job = (struct backend_job *)data;
243 struct getsize_sync_extra_info *extra_getsize_info =
244 (struct getsize_sync_extra_info *)job->extra_data;
246 s = g_io_channel_read_chars(io, (gchar *)buf, sizeof(buf), &len, &err);
247 if (s != G_IO_STATUS_NORMAL) {
248 ERR("getsize fd read failed: %s", err->message);
252 if (strlen(buf) == 0) {
260 _return_value_to_caller(job->req_id, g_variant_new("(ix)",
261 (result < 0) ? PKGMGR_R_ERROR : PKGMGR_R_OK, result));
263 unlink(extra_getsize_info->getsize_fifo);
264 free(extra_getsize_info->getsize_fifo);
265 extra_getsize_info->getsize_fifo = NULL;
270 static int __setup_size_info_io(struct backend_job *job)
273 struct getsize_sync_extra_info *extra_getsize_info =
274 (struct getsize_sync_extra_info *)job->extra_data;
276 extra_getsize_info->getsize_fd = open(extra_getsize_info->getsize_fifo,
277 O_RDONLY | O_NONBLOCK);
278 if (extra_getsize_info->getsize_fd < 0) {
279 ERR("failed to open the fifo(%s), errno(%d)",
280 extra_getsize_info->getsize_fifo, errno);
284 extra_getsize_info->getsize_io =
285 g_io_channel_unix_new(extra_getsize_info->getsize_fd);
286 if (!extra_getsize_info->getsize_io)
288 g_io_channel_set_encoding(extra_getsize_info->getsize_io, NULL, NULL);
289 g_io_channel_set_buffered(extra_getsize_info->getsize_io, FALSE);
290 getsize_wid = g_io_add_watch_full(extra_getsize_info->getsize_io,
291 G_PRIORITY_HIGH, G_IO_IN, getsize_io_handler, job, NULL);
293 ERR("failed to add io watch");
300 static gboolean __signal_handler(GIOChannel *io, GIOCondition cond,
306 struct signalfd_siginfo fdsi;
307 struct backend_job *job;
308 struct getsize_sync_extra_info *extra_getsize_info;
312 s = g_io_channel_read_chars(io, (gchar *)&fdsi,
313 sizeof(struct signalfd_siginfo), &len, &err);
314 if (s != G_IO_STATUS_NORMAL || len != sizeof(struct signalfd_siginfo)) {
315 ERR("Signal read failed");
320 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
321 job = (struct backend_job *)g_hash_table_lookup(
322 backend_info_table, (gconstpointer)pid);
324 ERR("Unknown child exit");
328 __set_backend_free(job->backend_slot);
329 if (WIFSIGNALED(status)) {
330 _send_fail_signal(job);
331 INFO("backend[%s][%d] exit with signal[%d]",
332 job->backend_type, pid, WTERMSIG(status));
333 } else if (WEXITSTATUS(status)) {
334 INFO("backend[%s][%d] exit with error",
335 job->backend_type, pid);
337 INFO("backend[%s][%d] exit", job->backend_type, pid);
340 if (job->req_type == REQUEST_TYPE_GETSIZE_SYNC &&
343 (struct getsize_sync_extra_info *)job->extra_data;
344 if (extra_getsize_info->getsize_fifo) {
345 ERR("invalid backend close");
346 _return_value_to_caller(job->req_id,
347 g_variant_new("(ix)",
348 PKGMGR_R_ERROR, -1));
351 g_hash_table_remove(backend_info_table, (gconstpointer)pid);
353 g_idle_add(queue_job, NULL);
358 static int __init_backend_info(void)
360 backend_info_table = g_hash_table_new_full(g_direct_hash,
361 g_direct_equal, NULL,
362 (GDestroyNotify)_free_backend_job);
367 static void __fini_backend_info(void)
369 /*Free backend info */
370 g_hash_table_destroy(backend_info_table);
373 static int __register_signal_handler(void)
379 sigaddset(&mask, SIGCHLD);
381 if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1) {
382 ERR("sigprocmask failed");
386 sfd = signalfd(-1, &mask, SFD_NONBLOCK);
388 ERR("signalfd failed");
392 sio = g_io_channel_unix_new(sfd);
393 g_io_channel_set_close_on_unref(sio, TRUE);
394 g_io_channel_set_encoding(sio, NULL, NULL);
395 g_io_channel_set_buffered(sio, FALSE);
396 swid = g_io_add_watch(sio, G_IO_IN, __signal_handler, NULL);
398 g_timeout_add_seconds_full(G_PRIORITY_LOW, 2, exit_server, NULL, NULL);
403 static int __check_backend_status_for_exit(void)
406 for (i = 0; i < num_of_backends; i++) {
407 if (__is_backend_busy(i))
413 static int __check_queue_status_for_exit(void)
416 for (i = 0; i < num_of_backends; i++) {
417 if (_is_queue_empty(i) == 0)
423 gboolean exit_server(void *data)
425 DBG("exit_server Start");
426 if (__check_backend_status_for_exit() &&
427 __check_queue_status_for_exit() && !is_drm_busy) {
428 g_main_loop_quit(mainloop);
430 __release_power_lock();
436 static int __check_csr(const char *path)
442 int (*_csr_cs_context_create)(void **handle);
443 int (*_csr_cs_scan_file)(void *handle, const char *file_path, void **malware);
444 int (*_csr_cs_context_destroy)(void *handle);
446 lib_handle = dlopen(PATH_LIBCSR_CLIENT, RTLD_LAZY);
448 DBG("Unable to open %s", PATH_LIBCSR_CLIENT);
452 _csr_cs_context_create = dlsym(lib_handle, "csr_cs_context_create");
453 _csr_cs_scan_file = dlsym(lib_handle, "csr_cs_scan_file");
454 _csr_cs_context_destroy = dlsym(lib_handle, "csr_cs_context_destroy");
456 if (!_csr_cs_context_create || !_csr_cs_scan_file ||
457 !_csr_cs_context_destroy) {
458 ERR("Failed to load CSR symbols");
463 ret = _csr_cs_context_create(&context);
465 ERR("Failed to create context");
470 ret = _csr_cs_scan_file(context, path, &malware);
472 DBG("CSR result[%d]", ret);
477 ret = _csr_cs_context_destroy(context);
479 ERR("Failed to destroy context");
484 if (malware != NULL) {
485 ERR("CSR denied[%d] installation", path);
496 static int __kill_app(char *appid, uid_t uid)
502 is_running = aul_app_is_running_for_uid(appid, uid);
503 /* app is not running */
507 pid = aul_app_get_pid_for_uid(appid, uid);
511 ret = aul_terminate_pid_for_uid(pid, uid);
512 if (ret != AUL_R_OK) {
513 ERR("failed to terminate app(%d)", appid);
520 static int __check_app(char *appid, uid_t uid)
525 is_running = aul_app_is_running_for_uid(appid, uid);
529 pid = aul_app_get_pid_for_uid(appid, uid);
534 static int __pkgcmd_app_cb(const pkgmgrinfo_appinfo_h handle, void *user_data)
540 pkgcmd_data *pdata = (pkgcmd_data *)user_data;
542 if (handle == NULL) {
543 perror("appinfo handle is NULL\n");
546 ret = pkgmgrinfo_appinfo_get_exec(handle, &exec);
548 perror("Failed to get app exec path\n");
551 ret = pkgmgrinfo_appinfo_get_appid(handle, &appid);
553 perror("Failed to get appid\n");
556 ret = pkgmgrinfo_appinfo_get_pkgid(handle, &pkgid);
558 perror("Failed to get pkgid\n");
562 if (strcmp(pdata->cmd, "kill") == 0) {
563 pdata->pid = __check_app(appid, pdata->uid);
565 ret = __kill_app(appid, pdata->uid);
566 } else if (strcmp(pdata->cmd, "check") == 0) {
567 pdata->pid = __check_app(appid, pdata->uid);
573 void free_user_context(user_ctx *ctx)
580 /* env variable ends by NULL element */
590 int set_environement(user_ctx *ctx)
601 if (ctx->uid != APPFW_UID) {
602 if (setuid(ctx->uid)) {
603 ERR("setuid failed: %d", errno);
607 if (setgid(ctx->gid)) {
608 ERR("setgid failed: %d", errno);
613 n = getgroups(0, NULL);
615 ERR("Failed to get the number of supplementary group IDs");
619 groups = (gid_t *)calloc(1, sizeof(gid_t) * (n + 3));
620 if (groups == NULL) {
621 ERR("out of memory");
625 n = getgroups(n, groups);
627 ERR("Failed to get list of supplementary group IDs");
632 groups[n++] = EXT_STORAGE_GROUP;
633 groups[n++] = EXT_STORAGE_APPDATA_GROUP;
634 groups[n++] = MEDIA_STORAGE_GROUP;
636 if (setgroups(n, groups) < 0) {
637 ERR("setgroups failed: %d", errno);
644 /* env variable ends by NULL element */
646 if (putenv(env[i]) != 0)
653 user_ctx *get_user_context(uid_t uid)
655 /* we can use getpwnam because this is used only after a
656 * fork and just before an execv
657 * No concurrencial call can corrupt the data
658 * returned by getpwuid
660 user_ctx *context_res;
662 char buf[1024] = {0, };
663 struct passwd pwd, *result;
668 ret = getpwuid_r(uid, &pwd, buf, sizeof(buf), &result);
669 if (ret != 0 || result == NULL)
673 context_res = (user_ctx *)malloc(sizeof(user_ctx));
678 env = (char **)malloc(3 * sizeof(char *));
683 /* Build environment context */
684 len = snprintf(NULL, 0, "HOME=%s", pwd.pw_dir);
685 env[0] = (char *)malloc((len + 1) * sizeof(char));
686 if (env[0] == NULL) {
690 snprintf(env[0], len + 1, "HOME=%s", pwd.pw_dir);
691 len = snprintf(NULL, 0, "USER=%s", pwd.pw_name);
692 env[1] = (char *)malloc((len + 1) * sizeof(char));
693 if (env[1] == NULL) {
697 snprintf(env[1], len + 1, "USER=%s", pwd.pw_name);
705 /* env variable ends by NULL element */
706 while (env && env[i]) {
713 context_res->env = env;
714 context_res->uid = uid;
715 context_res->gid = pwd.pw_gid;
720 static char **__generate_argv(const char *args)
722 /* Create args vector
723 * req_id + pkgid + args
725 * vector size = # of args +
726 *(req_id + pkgid + NULL termination = 3)
727 * Last value must be NULL for execv.
735 ret_parse = g_shell_parse_argv(args, &argcp, &argvp, &gerr);
736 if (FALSE == ret_parse) {
737 ERR("Failed to split args: %s", args);
738 ERR("messsage: %s", gerr->message);
743 for (i = 0; i < argcp; i++)
744 DBG(">>>>>> argsv[%d]=%s", i, argvp[i]);
749 void __set_environment(gpointer user_data)
751 user_ctx *ctx = (user_ctx *)user_data;
753 if (set_environement(ctx))
754 ERR("Failed to set env for the user : %d", ctx->uid);
757 static int __fork_and_exec_with_args(char **argv, uid_t uid)
759 user_ctx *user_context;
760 GError *error = NULL;
764 user_context = get_user_context(uid);
766 ERR("Failed to getenv");
770 ret = g_spawn_async(NULL, argv, NULL, G_SPAWN_DO_NOT_REAP_CHILD,
771 __set_environment, (gpointer)user_context, &pid,
774 ERR("Failed to excute backend: %s", error->message);
776 free_user_context(user_context);
780 free_user_context(user_context);
785 static int __change_job_info(struct backend_job *job, uid_t uid,
790 pkgmgrinfo_appinfo_h handle = NULL;
791 if (job->req_type != REQUEST_TYPE_DISABLE_APP &&
792 job->req_type != REQUEST_TYPE_DISABLE_GLOBAL_APP_FOR_UID &&
793 job->req_type != REQUEST_TYPE_ENABLE_APP_SPLASH_SCREEN &&
794 job->req_type != REQUEST_TYPE_DISABLE_APP_SPLASH_SCREEN &&
795 job->req_type != REQUEST_TYPE_ENABLE_APP &&
796 job->req_type != REQUEST_TYPE_ENABLE_GLOBAL_APP_FOR_UID)
797 return PMINFO_R_ERROR;
799 ret = pkgmgrinfo_appinfo_get_usr_all_appinfo(job->pkgid, uid, &handle);
800 if (ret != PMINFO_R_OK)
801 return PMINFO_R_ERROR;
803 ret = pkgmgrinfo_appinfo_is_global(handle, is_global);
804 if (ret != PMINFO_R_OK)
807 if ((job->req_type == REQUEST_TYPE_DISABLE_GLOBAL_APP_FOR_UID ||
809 REQUEST_TYPE_ENABLE_GLOBAL_APP_FOR_UID) &&
811 ret = PMINFO_R_ERROR;
815 ret = pkgmgrinfo_appinfo_get_pkgid(handle, &pkgid);
816 if (ret != PMINFO_R_OK)
820 job->appid = strdup(job->pkgid);
822 job->pkgid = strdup(pkgid);
825 pkgmgrinfo_appinfo_destroy_appinfo(handle);
830 static int __process_install(struct backend_job *job)
834 char args[MAX_PKG_ARGS_LEN];
839 backend_cmd = job->backend_path;
840 if (backend_cmd == NULL)
843 req_id = g_shell_quote(job->req_id);
844 pkgid = g_shell_quote(job->pkgid);
845 if (!req_id || !pkgid)
848 snprintf(args, sizeof(args), "%s -k %s -i %s -u %d %s", backend_cmd,
849 req_id, pkgid, (int)job->target_uid, job->args);
851 argv = __generate_argv(args);
853 pid = __fork_and_exec_with_args(argv, APPFW_UID);
861 static int __process_mount_install(struct backend_job *job)
865 char args[MAX_PKG_ARGS_LEN];
870 backend_cmd = job->backend_path;
871 if (backend_cmd == NULL)
874 req_id = g_shell_quote(job->req_id);
875 pkgid = g_shell_quote(job->pkgid);
876 if (!req_id || !pkgid)
879 snprintf(args, sizeof(args), "%s -k %s -w %s -u %d %s", backend_cmd,
880 req_id, pkgid, (int)job->target_uid, job->args);
882 argv = __generate_argv(args);
884 pid = __fork_and_exec_with_args(argv, APPFW_UID);
892 static int __process_reinstall(struct backend_job *job)
896 char args[MAX_PKG_ARGS_LEN];
901 backend_cmd = job->backend_path;
902 if (backend_cmd == NULL)
905 req_id = g_shell_quote(job->req_id);
906 pkgid = g_shell_quote(job->pkgid);
907 if (!req_id || !pkgid)
910 snprintf(args, sizeof(args), "%s -k %s -r %s -u %d", backend_cmd,
911 req_id, pkgid, (int)job->target_uid);
912 argv = __generate_argv(args);
914 pid = __fork_and_exec_with_args(argv, APPFW_UID);
923 static int __process_uninstall(struct backend_job *job)
927 char args[MAX_PKG_ARGS_LEN];
930 backend_cmd = job->backend_path;
931 if (backend_cmd == NULL)
934 snprintf(args, sizeof(args), "%s -k %s -d %s -u %d", backend_cmd,
935 job->req_id, job->pkgid, (int)job->target_uid);
936 argv = __generate_argv(args);
938 pid = __fork_and_exec_with_args(argv, APPFW_UID);
945 static int __process_move(struct backend_job *job)
949 char args[MAX_PKG_ARGS_LEN];
952 backend_cmd = job->backend_path;
953 if (backend_cmd == NULL)
956 snprintf(args, sizeof(args), "%s -k %s -m %s -u %d -t %s", backend_cmd,
957 job->req_id, job->pkgid, (int)job->target_uid, job->args);
958 argv = __generate_argv(args);
960 pid = __fork_and_exec_with_args(argv, APPFW_UID);
967 static int __process_enable_pkg(struct backend_job *job)
971 char args[MAX_PKG_ARGS_LEN];
972 pkgmgrinfo_pkginfo_h pkginfo_h;
978 backend_cmd = job->backend_path;
979 if (backend_cmd == NULL)
982 ret = pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(
983 job->pkgid, job->target_uid, &pkginfo_h);
984 if (ret != PMINFO_R_OK) {
985 ERR("Failed to get appinfo");
989 ret = pkgmgrinfo_pkginfo_is_global(pkginfo_h, &is_global);
990 if (ret != PMINFO_R_OK) {
991 ERR("Failed to get global value");
992 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
996 if ((is_global && job->target_uid != GLOBAL_USER) ||
997 (!is_global && job->target_uid == GLOBAL_USER)) {
998 ERR("Invalid attempt to enable pkg");
999 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
1003 ret = pkgmgrinfo_pkginfo_is_readonly(pkginfo_h, &is_readonly);
1004 if (ret != PMINFO_R_OK) {
1005 ERR("Failed to get readonly value");
1006 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
1010 snprintf(args, sizeof(args), "%s -k %s -u %d -A %s %s",
1011 backend_cmd, job->req_id, (int)job->target_uid,
1012 job->pkgid, (is_readonly) ? "--preload" : "");
1013 argv = __generate_argv(args);
1014 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1017 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
1022 static int __process_disable_pkg(struct backend_job *job)
1026 char args[MAX_PKG_ARGS_LEN];
1027 pkgmgrinfo_pkginfo_h pkginfo_h;
1033 backend_cmd = job->backend_path;
1034 if (backend_cmd == NULL)
1037 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(
1038 job->pkgid, job->target_uid, &pkginfo_h);
1039 if (ret != PMINFO_R_OK) {
1040 ERR("Failed to get appinfo");
1044 ret = pkgmgrinfo_pkginfo_is_global(pkginfo_h, &is_global);
1045 if (ret != PMINFO_R_OK) {
1046 ERR("Failed to get global value");
1047 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
1051 if ((is_global && job->target_uid != GLOBAL_USER) ||
1052 (!is_global && job->target_uid == GLOBAL_USER)) {
1053 ERR("Invalid attempt to disable pkg");
1054 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
1058 ret = pkgmgrinfo_pkginfo_is_readonly(pkginfo_h, &is_readonly);
1059 if (ret != PMINFO_R_OK) {
1060 ERR("Failed to get readonly value");
1061 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
1065 snprintf(args, sizeof(args), "%s -k %s -u %d -D %s %s",
1066 backend_cmd, job->req_id, (int)job->target_uid,
1067 job->pkgid, (is_readonly) ? "--preload" : "");
1068 argv = __generate_argv(args);
1070 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1074 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
1078 static int __process_register_pkg_update_info(struct backend_job *job)
1082 if (!job->extra_data) {
1083 _return_value_to_caller(job->req_id,
1084 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1088 ret = pkgmgr_parser_register_pkg_update_info_in_usr_db(
1089 (pkgmgrinfo_updateinfo_h)job->extra_data, job->target_uid);
1090 if (ret == PMINFO_R_OK)
1091 _return_value_to_caller(job->req_id,
1092 g_variant_new("(i)", PKGMGR_R_OK));
1094 _return_value_to_caller(job->req_id,
1095 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1097 pkgmgrinfo_updateinfo_destroy(job->extra_data);
1098 job->extra_data = NULL;
1103 static int __process_unregister_pkg_update_info(struct backend_job *job)
1105 int ret = pkgmgr_parser_unregister_pkg_update_info_in_usr_db
1106 (job->pkgid, job->target_uid);
1108 if (ret == PMINFO_R_OK)
1109 _return_value_to_caller(job->req_id,
1110 g_variant_new("(i)", PKGMGR_R_OK));
1112 _return_value_to_caller(job->req_id,
1113 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1117 static int __process_unregister_all_pkg_update_info(struct backend_job *job)
1119 int ret = pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(
1122 if (ret != PMINFO_R_OK) {
1123 _return_value_to_caller(job->req_id,
1124 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1128 if (__is_admin_user(job->caller_uid)) {
1129 ret = pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(
1131 if (ret != PMINFO_R_OK) {
1132 _return_value_to_caller(job->req_id,
1133 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1137 _return_value_to_caller(job->req_id,
1138 g_variant_new("(i)", PKGMGR_R_OK));
1143 static int __process_enable_app(struct backend_job *job)
1146 bool is_global = false;
1148 /* get actual pkgid and replace it to appid which is currently stored
1151 ret = __change_job_info(job, job->target_uid, &is_global);
1152 if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
1153 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
1154 PKGMGR_INSTALLER_START_KEY_STR,
1155 PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR,
1157 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
1158 PKGMGR_INSTALLER_END_KEY_STR,
1159 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1164 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1165 PKGMGR_INSTALLER_START_KEY_STR,
1166 PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR, job->req_type);
1168 ret = pkgmgr_parser_update_app_disable_info_in_usr_db(job->appid,
1169 job->target_uid, 0);
1170 if (ret != PMINFO_R_OK)
1171 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1172 PKGMGR_INSTALLER_END_KEY_STR,
1173 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1176 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1177 PKGMGR_INSTALLER_END_KEY_STR,
1178 PKGMGR_INSTALLER_OK_EVENT_STR,
1184 static int __process_disable_app(struct backend_job *job)
1187 bool is_global = false;
1189 /* get actual pkgid and replace it to appid which is currently stored
1192 ret = __change_job_info(job, job->target_uid, &is_global);
1193 if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
1194 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
1195 PKGMGR_INSTALLER_START_KEY_STR,
1196 PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR,
1198 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
1199 PKGMGR_INSTALLER_END_KEY_STR,
1200 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1205 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1206 PKGMGR_INSTALLER_START_KEY_STR,
1207 PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR, job->req_type);
1209 ret = __kill_app(job->appid, job->target_uid);
1211 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1212 PKGMGR_INSTALLER_END_KEY_STR,
1213 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1217 ret = pkgmgr_parser_update_app_disable_info_in_usr_db(job->appid,
1218 job->target_uid, 1);
1219 if (ret != PMINFO_R_OK)
1220 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1221 PKGMGR_INSTALLER_END_KEY_STR,
1222 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1225 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1226 PKGMGR_INSTALLER_END_KEY_STR,
1227 PKGMGR_INSTALLER_OK_EVENT_STR,
1233 static int __process_enable_global_app_for_uid(struct backend_job *job)
1236 bool is_global = true;
1238 /* get actual pkgid and replace it to appid which is currently stored
1241 ret = __change_job_info(job, job->target_uid, &is_global);
1242 if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
1243 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
1244 PKGMGR_INSTALLER_START_KEY_STR,
1245 PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR,
1247 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
1248 PKGMGR_INSTALLER_END_KEY_STR,
1249 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1254 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1255 PKGMGR_INSTALLER_START_KEY_STR,
1256 PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR,
1259 ret = pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(
1260 job->appid, job->target_uid, 0);
1261 if (ret != PMINFO_R_OK)
1262 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1263 PKGMGR_INSTALLER_END_KEY_STR,
1264 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1267 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1268 PKGMGR_INSTALLER_END_KEY_STR,
1269 PKGMGR_INSTALLER_OK_EVENT_STR,
1275 static int __process_disable_global_app_for_uid(struct backend_job *job)
1278 bool is_global = true;
1280 /* get actual pkgid and replace it to appid which is currently stored
1283 ret = __change_job_info(job, GLOBAL_USER, &is_global);
1284 if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
1285 _send_app_signal(job->target_uid, job->req_id,
1286 job->pkgid, job->pkgid,
1287 PKGMGR_INSTALLER_START_KEY_STR,
1288 PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR,
1290 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
1291 PKGMGR_INSTALLER_END_KEY_STR,
1292 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1297 _send_app_signal(job->target_uid, job->req_id,
1298 job->pkgid, job->appid,
1299 PKGMGR_INSTALLER_START_KEY_STR,
1300 PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR,
1303 ret = __kill_app(job->appid, job->target_uid);
1304 ret = pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(
1305 job->appid, job->target_uid, 1);
1307 if (ret != PMINFO_R_OK)
1308 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1309 PKGMGR_INSTALLER_END_KEY_STR,
1310 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1313 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1314 PKGMGR_INSTALLER_END_KEY_STR,
1315 PKGMGR_INSTALLER_OK_EVENT_STR,
1321 static int __process_getsize(struct backend_job *job)
1323 static const char backend_cmd[] = "/usr/bin/pkg_getsize";
1325 char args[MAX_PKG_ARGS_LEN];
1328 snprintf(args, sizeof(args), "%s %s %s %d -k %s -u %d",
1329 backend_cmd, job->pkgid, job->args, job->caller_uid,
1330 job->req_id, job->target_uid);
1331 argv = __generate_argv(args);
1332 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1339 static int __process_getsize_sync(struct backend_job *job)
1341 static const char backend_cmd[] = "/usr/bin/pkg_getsize";
1343 char args[MAX_PKG_ARGS_LEN];
1344 char fifo_path[PATH_MAX];
1345 struct getsize_sync_extra_info *extra_getsize_info;
1348 snprintf(fifo_path, sizeof(fifo_path), "/tmp/pkgmgr/%s",
1351 extra_getsize_info = calloc(1, sizeof(struct getsize_sync_extra_info));
1352 if (!extra_getsize_info) {
1353 ERR("memory alloc failed");
1357 extra_getsize_info->getsize_fifo = strdup(fifo_path);
1358 if (!extra_getsize_info->getsize_fifo) {
1359 ERR("out of memory");
1363 if (mkfifo(extra_getsize_info->getsize_fifo, 0600) < 0) {
1364 ERR("failed to mkfifo");
1367 job->extra_data = extra_getsize_info;
1369 snprintf(args, sizeof(args), "%s %s %s %d -k %s -u %d --sync",
1370 backend_cmd, job->pkgid, job->args, job->caller_uid,
1371 job->req_id, job->target_uid);
1372 argv = __generate_argv(args);
1373 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1378 ERR("failed to execute backend");
1381 if (__setup_size_info_io(job) < 0) {
1382 ERR("failed to setup io handler");
1389 _return_value_to_caller(job->req_id,
1390 g_variant_new("(ix)", PKGMGR_R_ERROR, -1));
1394 static int __process_cleardata(struct backend_job *job)
1396 static const char *backend_cmd = "/usr/bin/pkg_cleardata";
1398 char args[MAX_PKG_ARGS_LEN];
1401 if ((int)job->target_uid < REGULAR_USER)
1404 snprintf(args, sizeof(args), "%s -d -n %s -u %d",
1405 backend_cmd, job->pkgid, job->target_uid);
1406 argv = __generate_argv(args);
1407 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1413 static int __process_clearcache(struct backend_job *job)
1415 static const char *backend_cmd = "/usr/bin/pkg_cleardata";
1417 char args[MAX_PKG_ARGS_LEN];
1420 if ((int)job->target_uid < REGULAR_USER)
1423 snprintf(args, sizeof(args), "%s -c -n %s -u %d",
1424 backend_cmd, job->pkgid, job->target_uid);
1425 argv = __generate_argv(args);
1426 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1432 static int __process_kill(struct backend_job *job)
1435 pkgmgrinfo_pkginfo_h handle;
1438 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(job->pkgid, job->target_uid,
1441 ERR("Failed to get handle");
1442 _return_value_to_caller(job->req_id,
1443 g_variant_new("(ii)", PKGMGR_R_ERROR, 0));
1447 pdata = calloc(1, sizeof(pkgcmd_data));
1448 if (pdata == NULL) {
1449 ERR("memory alloc failed");
1450 _return_value_to_caller(job->req_id,
1451 g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
1454 pdata->cmd = strdup("kill");
1455 if (pdata->cmd == NULL) {
1456 ERR("out of memory");
1457 _return_value_to_caller(job->req_id,
1458 g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
1462 pdata->uid = job->target_uid;
1463 ret = pkgmgrinfo_appinfo_get_usr_list(handle, PMINFO_ALL_APP,
1464 __pkgcmd_app_cb, pdata, job->target_uid);
1466 _return_value_to_caller(job->req_id,
1467 g_variant_new("(ii)", PKGMGR_R_OK, pdata->pid));
1471 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1473 ERR("pkgmgrinfo_appinfo_get_list() failed");
1480 static int __process_check(struct backend_job *job)
1483 pkgmgrinfo_pkginfo_h handle;
1486 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(job->pkgid, job->target_uid,
1489 ERR("Failed to get handle");
1490 _return_value_to_caller(job->req_id,
1491 g_variant_new("(ii)", PKGMGR_R_ERROR, 0));
1495 pdata = calloc(1, sizeof(pkgcmd_data));
1496 if (pdata == NULL) {
1497 ERR("memory alloc failed");
1498 _return_value_to_caller(job->req_id,
1499 g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
1502 pdata->cmd = strdup("check");
1503 if (pdata->cmd == NULL) {
1504 ERR("out of memory");
1505 _return_value_to_caller(job->req_id,
1506 g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
1510 pdata->uid = job->target_uid;
1511 ret = pkgmgrinfo_appinfo_get_usr_list(handle, PMINFO_ALL_APP,
1512 __pkgcmd_app_cb, pdata, job->target_uid);
1514 _return_value_to_caller(job->req_id,
1515 g_variant_new("(ii)", PKGMGR_R_OK, pdata->pid));
1519 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1521 ERR("pkgmgrinfo_appinfo_get_list() failed");
1528 static int __load_drm_library(void)
1533 drm_lib_handle = dlopen(PATH_LIBDRM_SVC_CORE, RTLD_LAZY);
1534 if (!drm_lib_handle) {
1535 DBG("Unable to open %s", PATH_LIBDRM_SVC_CORE);
1539 _drm_tizen_generate_license_request =
1540 dlsym(drm_lib_handle, "drm_tizen_generate_license_request");
1541 if (_drm_tizen_generate_license_request == NULL) {
1542 ERR("_drm_tizen_generate_license_request() failed");
1546 _drm_tizen_register_license =
1547 dlsym(drm_lib_handle, "drm_tizen_register_license");
1548 if (_drm_tizen_register_license == NULL) {
1549 ERR("_register_license() failed");
1553 _drm_tizen_decrypt_package =
1554 dlsym(drm_lib_handle, "drm_tizen_decrypt_package");
1555 if (_drm_tizen_decrypt_package == NULL) {
1556 ERR("_drm_tizen_decrypt_package() failed");
1562 if (drm_lib_handle) {
1563 dlclose(drm_lib_handle);
1564 drm_lib_handle = NULL;
1569 static void __unload_drm_library(void)
1571 if (drm_lib_handle) {
1572 dlclose(drm_lib_handle);
1573 drm_lib_handle = NULL;
1577 static int __process_generate_license_request(struct backend_job *job)
1580 char req_data[MAX_PKG_ARGS_LEN];
1581 unsigned int req_data_len;
1582 char license_url[MAX_PKG_ARGS_LEN];
1583 unsigned int license_url_len;
1586 resp_data = job->args;
1587 req_data_len = sizeof(req_data);
1588 license_url_len = sizeof(license_url);
1590 if (__load_drm_library() != 0) {
1591 ERR("Failed to load library");
1595 ret = _drm_tizen_generate_license_request(resp_data, strlen(resp_data),
1596 req_data, &req_data_len,
1597 license_url, &license_url_len);
1599 ERR("drm_tizen_generate_license_request failed");
1602 _return_value_to_caller(job->req_id,
1603 g_variant_new("(iss)", PKGMGR_R_OK, req_data,
1609 _return_value_to_caller(job->req_id, g_variant_new("(iss)",
1610 PKGMGR_R_ESYSTEM, "", ""));
1611 is_drm_busy = false;
1612 __unload_drm_library();
1616 static int __process_register_license(struct backend_job *job)
1621 resp_data = job->args;
1622 if (!_drm_tizen_register_license) {
1623 ERR("_drm_tizen_register_license is not loaded");
1626 ret = _drm_tizen_register_license(resp_data, strlen(resp_data));
1628 ERR("drm_tizen_register_license failed: %d", ret);
1631 _return_value_to_caller(job->req_id,
1632 g_variant_new("(i)", PKGMGR_R_OK));
1636 _return_value_to_caller(job->req_id,
1637 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1638 is_drm_busy = false;
1639 __unload_drm_library();
1644 static int __process_decrypt_package(struct backend_job *job)
1647 char *drm_file_path;
1648 char *decrypted_file_path;
1650 drm_file_path = job->pkgid;
1651 decrypted_file_path = job->args;
1653 /* TODO: check ownership of decrypted file */
1654 if (!_drm_tizen_decrypt_package) {
1655 ERR("drm_tizen_decrypt_package is not loaded");
1659 ret = _drm_tizen_decrypt_package(drm_file_path, strlen(drm_file_path),
1660 decrypted_file_path, strlen(decrypted_file_path));
1662 ERR("drm_tizen_decrypt_package failed: %d", ret);
1665 _return_value_to_caller(job->req_id,
1666 g_variant_new("(i)", PKGMGR_R_OK));
1670 _return_value_to_caller(job->req_id,
1671 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1672 is_drm_busy = false;
1673 __unload_drm_library();
1678 static int __process_update_app_splash_screen(struct backend_job *job, int flag)
1681 bool is_global = false;
1684 ret = __change_job_info(job, job->target_uid, &is_global);
1685 if (ret != PMINFO_R_OK || strlen(job->appid) == 0)
1688 val = flag ? PKGMGR_INSTALLER_APP_ENABLE_SPLASH_SCREEN_EVENT_STR :
1689 PKGMGR_INSTALLER_APP_DISABLE_SPLASH_SCREEN_EVENT_STR;
1690 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1691 PKGMGR_INSTALLER_START_KEY_STR, val, job->req_type);
1694 ret = pkgmgr_parser_update_global_app_splash_screen_display_info_in_usr_db(job->appid, job->target_uid, flag);
1696 ret = pkgmgr_parser_update_app_splash_screen_display_info_in_usr_db(
1697 job->appid, job->target_uid, flag);
1698 if (ret != PMINFO_R_OK)
1699 _send_app_signal(job->target_uid, job->req_id, job->pkgid,
1700 job->appid, PKGMGR_INSTALLER_END_KEY_STR,
1701 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1704 _send_app_signal(job->target_uid, job->req_id, job->pkgid,
1705 job->appid, PKGMGR_INSTALLER_END_KEY_STR,
1706 PKGMGR_INSTALLER_OK_EVENT_STR,
1712 static int __process_set_restriction_mode(struct backend_job *job)
1717 mode = atoi(job->args);
1718 ret = _set_restriction_mode(job->target_uid, job->pkgid, mode);
1720 _return_value_to_caller(job->req_id,
1721 g_variant_new("(i)", ret));
1726 static int __process_unset_restriction_mode(struct backend_job *job)
1731 mode = atoi(job->args);
1732 ret = _unset_restriction_mode(job->target_uid, job->pkgid, mode);
1734 _return_value_to_caller(job->req_id,
1735 g_variant_new("(i)", ret));
1740 static int __process_get_restriction_mode(struct backend_job *job)
1745 ret = _get_restriction_mode(job->target_uid, job->pkgid, &mode);
1747 _return_value_to_caller(job->req_id,
1748 g_variant_new("(ii)", mode, ret));
1753 static int __process_set_app_label(struct backend_job *job)
1757 ret = pkgmgr_parser_update_app_label_info_in_usr_db(job->pkgid,
1758 job->target_uid, job->args);
1759 _return_value_to_caller(job->req_id, g_variant_new("(i)", ret));
1764 static int __process_migrate_external_image(struct backend_job *job)
1768 char args[MAX_PKG_ARGS_LEN];
1771 backend_cmd = job->backend_path;
1772 if (backend_cmd == NULL)
1775 snprintf(args, sizeof(args), "%s -k %s --migrate-extimg %s -u %d %s",
1776 backend_cmd, job->req_id, job->pkgid,
1777 (int)job->target_uid, job->args);
1779 argv = __generate_argv(args);
1781 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1787 static int __post_process(int ret, int x, struct backend_job *job)
1790 __set_backend_free(x);
1791 _free_backend_job(job);
1793 g_hash_table_insert(backend_info_table, (gpointer)ret,
1799 gboolean queue_job(void *data)
1801 struct backend_job *job = NULL;
1805 /* Pop a job from queue */
1806 for (x = 0; x < num_of_backends; x++) {
1807 if (__is_backend_busy(x))
1810 job = _pop_queue(x);
1815 /* all backend messages queue are empty or busy */
1816 if (x == num_of_backends || job == NULL) {
1817 DBG("no job available");
1821 /* set current backend job */
1822 DBG("handle request type [%d]", job->req_type);
1824 if (job->req_type == REQUEST_TYPE_INSTALL ||
1825 job->req_type == REQUEST_TYPE_MOUNT_INSTALL ||
1826 job->req_type == REQUEST_TYPE_REINSTALL) {
1827 ret = __check_csr(job->pkgid);
1830 _send_fail_signal(job);
1831 _free_backend_job(job);
1836 switch (job->req_type) {
1837 case REQUEST_TYPE_INSTALL:
1838 __set_backend_busy(x);
1840 ret = __process_install(job);
1841 __post_process(ret, x, job);
1843 case REQUEST_TYPE_MOUNT_INSTALL:
1844 __set_backend_busy(x);
1846 ret = __process_mount_install(job);
1847 __post_process(ret, x, job);
1849 case REQUEST_TYPE_REINSTALL:
1850 __set_backend_busy(x);
1852 ret = __process_reinstall(job);
1853 __post_process(ret, x, job);
1855 case REQUEST_TYPE_UNINSTALL:
1856 __set_backend_busy(x);
1858 ret = __process_uninstall(job);
1859 __post_process(ret, x, job);
1861 case REQUEST_TYPE_MOVE:
1862 __set_backend_busy(x);
1864 ret = __process_move(job);
1865 __post_process(ret, x, job);
1867 case REQUEST_TYPE_ENABLE_PKG:
1868 __set_backend_busy(x);
1870 ret = __process_enable_pkg(job);
1872 _send_fail_signal(job);
1873 __post_process(ret, x, job);
1875 case REQUEST_TYPE_DISABLE_PKG:
1876 __set_backend_busy(x);
1878 ret = __process_disable_pkg(job);
1880 _send_fail_signal(job);
1881 __post_process(ret, x, job);
1883 case REQUEST_TYPE_REGISTER_PKG_UPDATE_INFO:
1884 ret = __process_register_pkg_update_info(job);
1885 __free_extra_info(job);
1886 _free_backend_job(job);
1888 case REQUEST_TYPE_UNREGISTER_PKG_UPDATE_INFO:
1889 ret = __process_unregister_pkg_update_info(job);
1890 _free_backend_job(job);
1892 case REQUEST_TYPE_UNREGISTER_ALL_PKG_UPDATE_INFO:
1893 ret = __process_unregister_all_pkg_update_info(job);
1894 _free_backend_job(job);
1896 case REQUEST_TYPE_ENABLE_APP:
1897 ret = __process_enable_app(job);
1898 _free_backend_job(job);
1900 case REQUEST_TYPE_DISABLE_APP:
1901 ret = __process_disable_app(job);
1902 _free_backend_job(job);
1904 case REQUEST_TYPE_GETSIZE:
1905 __set_backend_busy(x);
1906 ret = __process_getsize(job);
1907 __post_process(ret, x, job);
1909 case REQUEST_TYPE_GETSIZE_SYNC:
1910 __set_backend_busy(x);
1911 ret = __process_getsize_sync(job);
1913 __free_extra_info(job);
1914 __post_process(ret, x, job);
1916 case REQUEST_TYPE_CLEARDATA:
1917 __set_backend_busy(x);
1919 ret = __process_cleardata(job);
1920 __post_process(ret, x, job);
1922 case REQUEST_TYPE_CLEARCACHE:
1923 __set_backend_busy(x);
1925 ret = __process_clearcache(job);
1926 __post_process(ret, x, job);
1928 case REQUEST_TYPE_ENABLE_GLOBAL_APP_FOR_UID:
1929 ret = __process_enable_global_app_for_uid(job);
1930 _free_backend_job(job);
1932 case REQUEST_TYPE_DISABLE_GLOBAL_APP_FOR_UID:
1933 ret = __process_disable_global_app_for_uid(job);
1934 _free_backend_job(job);
1936 case REQUEST_TYPE_KILL:
1937 ret = __process_kill(job);
1938 _free_backend_job(job);
1940 case REQUEST_TYPE_CHECK:
1941 ret = __process_check(job);
1942 _free_backend_job(job);
1944 case REQUEST_TYPE_GENERATE_LICENSE_REQUEST:
1945 ret = __process_generate_license_request(job);
1946 _free_backend_job(job);
1948 case REQUEST_TYPE_REGISTER_LICENSE:
1949 ret = __process_register_license(job);
1950 _free_backend_job(job);
1952 case REQUEST_TYPE_DECRYPT_PACKAGE:
1953 ret = __process_decrypt_package(job);
1954 _free_backend_job(job);
1956 case REQUEST_TYPE_ENABLE_APP_SPLASH_SCREEN:
1957 ret = __process_update_app_splash_screen(job, 1);
1958 _free_backend_job(job);
1960 case REQUEST_TYPE_DISABLE_APP_SPLASH_SCREEN:
1961 ret = __process_update_app_splash_screen(job, 0);
1962 _free_backend_job(job);
1964 case REQUEST_TYPE_SET_RESTRICTION_MODE:
1965 ret = __process_set_restriction_mode(job);
1966 _free_backend_job(job);
1968 case REQUEST_TYPE_UNSET_RESTRICTION_MODE:
1969 ret = __process_unset_restriction_mode(job);
1970 _free_backend_job(job);
1972 case REQUEST_TYPE_GET_RESTRICTION_MODE:
1973 ret = __process_get_restriction_mode(job);
1974 _free_backend_job(job);
1976 case REQUEST_TYPE_SET_APP_LABEL:
1977 ret = __process_set_app_label(job);
1978 _free_backend_job(job);
1980 case REQUEST_TYPE_MIGRATE_EXTERNAL_IMAGE:
1981 __set_backend_busy(x);
1983 ret = __process_migrate_external_image(job);
1984 __post_process(ret, x, job);
1994 int main(int argc, char *argv[])
1998 DBG("server start");
2000 if (__register_signal_handler()) {
2001 ERR("failed to register signal handler");
2005 r = _init_backend_queue();
2007 ERR("Queue Initialization Failed");
2011 r = __init_backend_info();
2013 ERR("backend info init failed");
2017 r = _init_request_handler();
2019 ERR("dbus init failed");
2023 #if !GLIB_CHECK_VERSION(2, 35, 0)
2026 mainloop = g_main_loop_new(NULL, FALSE);
2028 ERR("g_main_loop_new failed");
2032 DBG("Main loop is created.");
2034 g_main_loop_run(mainloop);
2036 DBG("Quit main loop.");
2037 _fini_request_handler();
2038 __fini_backend_info();
2039 _fini_backend_queue();
2041 g_source_remove(swid);
2042 g_io_channel_unref(sio);
2044 DBG("package manager server terminated.");