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);
846 pkgid = g_shell_quote(job->pkgid);
852 snprintf(args, sizeof(args), "%s -k %s -i %s -u %d %s", backend_cmd,
853 req_id, pkgid, (int)job->target_uid, job->args);
855 argv = __generate_argv(args);
857 pid = __fork_and_exec_with_args(argv, APPFW_UID);
865 static int __process_mount_install(struct backend_job *job)
869 char args[MAX_PKG_ARGS_LEN];
874 backend_cmd = job->backend_path;
875 if (backend_cmd == NULL)
878 req_id = g_shell_quote(job->req_id);
881 pkgid = g_shell_quote(job->pkgid);
886 snprintf(args, sizeof(args), "%s -k %s -w %s -u %d %s", backend_cmd,
887 req_id, pkgid, (int)job->target_uid, job->args);
889 argv = __generate_argv(args);
891 pid = __fork_and_exec_with_args(argv, APPFW_UID);
899 static int __process_reinstall(struct backend_job *job)
903 char args[MAX_PKG_ARGS_LEN];
908 backend_cmd = job->backend_path;
909 if (backend_cmd == NULL)
912 req_id = g_shell_quote(job->req_id);
915 pkgid = g_shell_quote(job->pkgid);
921 snprintf(args, sizeof(args), "%s -k %s -r %s -u %d", backend_cmd,
922 req_id, pkgid, (int)job->target_uid);
923 argv = __generate_argv(args);
925 pid = __fork_and_exec_with_args(argv, APPFW_UID);
934 static int __process_uninstall(struct backend_job *job)
938 char args[MAX_PKG_ARGS_LEN];
941 backend_cmd = job->backend_path;
942 if (backend_cmd == NULL)
945 snprintf(args, sizeof(args), "%s -k %s -d %s -u %d", backend_cmd,
946 job->req_id, job->pkgid, (int)job->target_uid);
947 argv = __generate_argv(args);
949 pid = __fork_and_exec_with_args(argv, APPFW_UID);
956 static int __process_move(struct backend_job *job)
960 char args[MAX_PKG_ARGS_LEN];
963 backend_cmd = job->backend_path;
964 if (backend_cmd == NULL)
967 snprintf(args, sizeof(args), "%s -k %s -m %s -u %d -t %s", backend_cmd,
968 job->req_id, job->pkgid, (int)job->target_uid, job->args);
969 argv = __generate_argv(args);
971 pid = __fork_and_exec_with_args(argv, APPFW_UID);
978 static int __process_enable_pkg(struct backend_job *job)
982 char args[MAX_PKG_ARGS_LEN];
983 pkgmgrinfo_pkginfo_h pkginfo_h;
989 backend_cmd = job->backend_path;
990 if (backend_cmd == NULL)
993 ret = pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(
994 job->pkgid, job->target_uid, &pkginfo_h);
995 if (ret != PMINFO_R_OK) {
996 ERR("Failed to get appinfo");
1000 ret = pkgmgrinfo_pkginfo_is_global(pkginfo_h, &is_global);
1001 if (ret != PMINFO_R_OK) {
1002 ERR("Failed to get global value");
1003 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
1007 if ((is_global && job->target_uid != GLOBAL_USER) ||
1008 (!is_global && job->target_uid == GLOBAL_USER)) {
1009 ERR("Invalid attempt to enable pkg");
1010 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
1014 ret = pkgmgrinfo_pkginfo_is_readonly(pkginfo_h, &is_readonly);
1015 if (ret != PMINFO_R_OK) {
1016 ERR("Failed to get readonly value");
1017 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
1021 snprintf(args, sizeof(args), "%s -k %s -u %d -A %s %s",
1022 backend_cmd, job->req_id, (int)job->target_uid,
1023 job->pkgid, (is_readonly) ? "--preload" : "");
1024 argv = __generate_argv(args);
1025 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1028 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
1033 static int __process_disable_pkg(struct backend_job *job)
1037 char args[MAX_PKG_ARGS_LEN];
1038 pkgmgrinfo_pkginfo_h pkginfo_h;
1044 backend_cmd = job->backend_path;
1045 if (backend_cmd == NULL)
1048 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(
1049 job->pkgid, job->target_uid, &pkginfo_h);
1050 if (ret != PMINFO_R_OK) {
1051 ERR("Failed to get appinfo");
1055 ret = pkgmgrinfo_pkginfo_is_global(pkginfo_h, &is_global);
1056 if (ret != PMINFO_R_OK) {
1057 ERR("Failed to get global value");
1058 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
1062 if ((is_global && job->target_uid != GLOBAL_USER) ||
1063 (!is_global && job->target_uid == GLOBAL_USER)) {
1064 ERR("Invalid attempt to disable pkg");
1065 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
1069 ret = pkgmgrinfo_pkginfo_is_readonly(pkginfo_h, &is_readonly);
1070 if (ret != PMINFO_R_OK) {
1071 ERR("Failed to get readonly value");
1072 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
1076 snprintf(args, sizeof(args), "%s -k %s -u %d -D %s %s",
1077 backend_cmd, job->req_id, (int)job->target_uid,
1078 job->pkgid, (is_readonly) ? "--preload" : "");
1079 argv = __generate_argv(args);
1081 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1085 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo_h);
1089 static int __process_register_pkg_update_info(struct backend_job *job)
1093 if (!job->extra_data) {
1094 _return_value_to_caller(job->req_id,
1095 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1099 ret = pkgmgr_parser_register_pkg_update_info_in_usr_db(
1100 (pkgmgrinfo_updateinfo_h)job->extra_data, job->target_uid);
1101 if (ret == PMINFO_R_OK)
1102 _return_value_to_caller(job->req_id,
1103 g_variant_new("(i)", PKGMGR_R_OK));
1105 _return_value_to_caller(job->req_id,
1106 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1108 pkgmgrinfo_updateinfo_destroy(job->extra_data);
1109 job->extra_data = NULL;
1114 static int __process_unregister_pkg_update_info(struct backend_job *job)
1116 int ret = pkgmgr_parser_unregister_pkg_update_info_in_usr_db
1117 (job->pkgid, job->target_uid);
1119 if (ret == PMINFO_R_OK)
1120 _return_value_to_caller(job->req_id,
1121 g_variant_new("(i)", PKGMGR_R_OK));
1123 _return_value_to_caller(job->req_id,
1124 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1128 static int __process_unregister_all_pkg_update_info(struct backend_job *job)
1130 int ret = pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(
1133 if (ret != PMINFO_R_OK) {
1134 _return_value_to_caller(job->req_id,
1135 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1139 if (__is_admin_user(job->caller_uid)) {
1140 ret = pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(
1142 if (ret != PMINFO_R_OK) {
1143 _return_value_to_caller(job->req_id,
1144 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1148 _return_value_to_caller(job->req_id,
1149 g_variant_new("(i)", PKGMGR_R_OK));
1154 static int __process_enable_app(struct backend_job *job)
1157 bool is_global = false;
1159 /* get actual pkgid and replace it to appid which is currently stored
1162 ret = __change_job_info(job, job->target_uid, &is_global);
1163 if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
1164 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
1165 PKGMGR_INSTALLER_START_KEY_STR,
1166 PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR,
1168 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
1169 PKGMGR_INSTALLER_END_KEY_STR,
1170 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1175 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1176 PKGMGR_INSTALLER_START_KEY_STR,
1177 PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR, job->req_type);
1179 ret = pkgmgr_parser_update_app_disable_info_in_usr_db(job->appid,
1180 job->target_uid, 0);
1181 if (ret != PMINFO_R_OK)
1182 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1183 PKGMGR_INSTALLER_END_KEY_STR,
1184 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1187 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1188 PKGMGR_INSTALLER_END_KEY_STR,
1189 PKGMGR_INSTALLER_OK_EVENT_STR,
1195 static int __process_disable_app(struct backend_job *job)
1198 bool is_global = false;
1200 /* get actual pkgid and replace it to appid which is currently stored
1203 ret = __change_job_info(job, job->target_uid, &is_global);
1204 if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
1205 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
1206 PKGMGR_INSTALLER_START_KEY_STR,
1207 PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR,
1209 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
1210 PKGMGR_INSTALLER_END_KEY_STR,
1211 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1216 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1217 PKGMGR_INSTALLER_START_KEY_STR,
1218 PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR, job->req_type);
1220 ret = __kill_app(job->appid, job->target_uid);
1222 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1223 PKGMGR_INSTALLER_END_KEY_STR,
1224 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1228 ret = pkgmgr_parser_update_app_disable_info_in_usr_db(job->appid,
1229 job->target_uid, 1);
1230 if (ret != PMINFO_R_OK)
1231 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1232 PKGMGR_INSTALLER_END_KEY_STR,
1233 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1236 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1237 PKGMGR_INSTALLER_END_KEY_STR,
1238 PKGMGR_INSTALLER_OK_EVENT_STR,
1244 static int __process_enable_global_app_for_uid(struct backend_job *job)
1247 bool is_global = true;
1249 /* get actual pkgid and replace it to appid which is currently stored
1252 ret = __change_job_info(job, job->target_uid, &is_global);
1253 if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
1254 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
1255 PKGMGR_INSTALLER_START_KEY_STR,
1256 PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR,
1258 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
1259 PKGMGR_INSTALLER_END_KEY_STR,
1260 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1265 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1266 PKGMGR_INSTALLER_START_KEY_STR,
1267 PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR,
1270 ret = pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(
1271 job->appid, job->target_uid, 0);
1272 if (ret != PMINFO_R_OK)
1273 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1274 PKGMGR_INSTALLER_END_KEY_STR,
1275 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1278 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1279 PKGMGR_INSTALLER_END_KEY_STR,
1280 PKGMGR_INSTALLER_OK_EVENT_STR,
1286 static int __process_disable_global_app_for_uid(struct backend_job *job)
1289 bool is_global = true;
1291 /* get actual pkgid and replace it to appid which is currently stored
1294 ret = __change_job_info(job, GLOBAL_USER, &is_global);
1295 if (ret != PMINFO_R_OK || strlen(job->appid) == 0) {
1296 _send_app_signal(job->target_uid, job->req_id,
1297 job->pkgid, job->pkgid,
1298 PKGMGR_INSTALLER_START_KEY_STR,
1299 PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR,
1301 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->pkgid,
1302 PKGMGR_INSTALLER_END_KEY_STR,
1303 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1308 _send_app_signal(job->target_uid, job->req_id,
1309 job->pkgid, job->appid,
1310 PKGMGR_INSTALLER_START_KEY_STR,
1311 PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR,
1314 ret = __kill_app(job->appid, job->target_uid);
1315 ret = pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(
1316 job->appid, job->target_uid, 1);
1318 if (ret != PMINFO_R_OK)
1319 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1320 PKGMGR_INSTALLER_END_KEY_STR,
1321 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1324 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1325 PKGMGR_INSTALLER_END_KEY_STR,
1326 PKGMGR_INSTALLER_OK_EVENT_STR,
1332 static int __process_getsize(struct backend_job *job)
1334 static const char backend_cmd[] = "/usr/bin/pkg_getsize";
1336 char args[MAX_PKG_ARGS_LEN];
1339 snprintf(args, sizeof(args), "%s %s %s %d -k %s -u %d",
1340 backend_cmd, job->pkgid, job->args, job->caller_uid,
1341 job->req_id, job->target_uid);
1342 argv = __generate_argv(args);
1343 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1350 static int __process_getsize_sync(struct backend_job *job)
1352 static const char backend_cmd[] = "/usr/bin/pkg_getsize";
1354 char args[MAX_PKG_ARGS_LEN];
1355 char fifo_path[PATH_MAX];
1356 struct getsize_sync_extra_info *extra_getsize_info;
1359 snprintf(fifo_path, sizeof(fifo_path), "/tmp/pkgmgr/%s",
1362 extra_getsize_info = calloc(1, sizeof(struct getsize_sync_extra_info));
1363 if (!extra_getsize_info) {
1364 ERR("memory alloc failed");
1368 extra_getsize_info->getsize_fifo = strdup(fifo_path);
1369 if (!extra_getsize_info->getsize_fifo) {
1370 ERR("out of memory");
1374 if (mkfifo(extra_getsize_info->getsize_fifo, 0600) < 0) {
1375 ERR("failed to mkfifo");
1378 job->extra_data = extra_getsize_info;
1380 snprintf(args, sizeof(args), "%s %s %s %d -k %s -u %d --sync",
1381 backend_cmd, job->pkgid, job->args, job->caller_uid,
1382 job->req_id, job->target_uid);
1383 argv = __generate_argv(args);
1384 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1389 ERR("failed to execute backend");
1392 if (__setup_size_info_io(job) < 0) {
1393 ERR("failed to setup io handler");
1400 _return_value_to_caller(job->req_id,
1401 g_variant_new("(ix)", PKGMGR_R_ERROR, -1));
1405 static int __process_cleardata(struct backend_job *job)
1407 static const char *backend_cmd = "/usr/bin/pkg_cleardata";
1409 char args[MAX_PKG_ARGS_LEN];
1412 if ((int)job->target_uid < REGULAR_USER)
1415 snprintf(args, sizeof(args), "%s -d -n %s -u %d",
1416 backend_cmd, job->pkgid, job->target_uid);
1417 argv = __generate_argv(args);
1418 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1424 static int __process_clearcache(struct backend_job *job)
1426 static const char *backend_cmd = "/usr/bin/pkg_cleardata";
1428 char args[MAX_PKG_ARGS_LEN];
1431 if ((int)job->target_uid < REGULAR_USER)
1434 snprintf(args, sizeof(args), "%s -c -n %s -u %d",
1435 backend_cmd, job->pkgid, job->target_uid);
1436 argv = __generate_argv(args);
1437 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1443 static int __process_kill(struct backend_job *job)
1446 pkgmgrinfo_pkginfo_h handle;
1449 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(job->pkgid, job->target_uid,
1452 ERR("Failed to get handle");
1453 _return_value_to_caller(job->req_id,
1454 g_variant_new("(ii)", PKGMGR_R_ERROR, 0));
1458 pdata = calloc(1, sizeof(pkgcmd_data));
1459 if (pdata == NULL) {
1460 ERR("memory alloc failed");
1461 _return_value_to_caller(job->req_id,
1462 g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
1465 pdata->cmd = strdup("kill");
1466 if (pdata->cmd == NULL) {
1467 ERR("out of memory");
1468 _return_value_to_caller(job->req_id,
1469 g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
1473 pdata->uid = job->target_uid;
1474 ret = pkgmgrinfo_appinfo_get_usr_list(handle, PMINFO_ALL_APP,
1475 __pkgcmd_app_cb, pdata, job->target_uid);
1477 _return_value_to_caller(job->req_id,
1478 g_variant_new("(ii)", PKGMGR_R_OK, pdata->pid));
1482 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1484 ERR("pkgmgrinfo_appinfo_get_list() failed");
1491 static int __process_check(struct backend_job *job)
1494 pkgmgrinfo_pkginfo_h handle;
1497 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(job->pkgid, job->target_uid,
1500 ERR("Failed to get handle");
1501 _return_value_to_caller(job->req_id,
1502 g_variant_new("(ii)", PKGMGR_R_ERROR, 0));
1506 pdata = calloc(1, sizeof(pkgcmd_data));
1507 if (pdata == NULL) {
1508 ERR("memory alloc failed");
1509 _return_value_to_caller(job->req_id,
1510 g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
1513 pdata->cmd = strdup("check");
1514 if (pdata->cmd == NULL) {
1515 ERR("out of memory");
1516 _return_value_to_caller(job->req_id,
1517 g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
1521 pdata->uid = job->target_uid;
1522 ret = pkgmgrinfo_appinfo_get_usr_list(handle, PMINFO_ALL_APP,
1523 __pkgcmd_app_cb, pdata, job->target_uid);
1525 _return_value_to_caller(job->req_id,
1526 g_variant_new("(ii)", PKGMGR_R_OK, pdata->pid));
1530 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1532 ERR("pkgmgrinfo_appinfo_get_list() failed");
1539 static int __load_drm_library(void)
1544 drm_lib_handle = dlopen(PATH_LIBDRM_SVC_CORE, RTLD_LAZY);
1545 if (!drm_lib_handle) {
1546 DBG("Unable to open %s", PATH_LIBDRM_SVC_CORE);
1550 _drm_tizen_generate_license_request =
1551 dlsym(drm_lib_handle, "drm_tizen_generate_license_request");
1552 if (_drm_tizen_generate_license_request == NULL) {
1553 ERR("_drm_tizen_generate_license_request() failed");
1557 _drm_tizen_register_license =
1558 dlsym(drm_lib_handle, "drm_tizen_register_license");
1559 if (_drm_tizen_register_license == NULL) {
1560 ERR("_register_license() failed");
1564 _drm_tizen_decrypt_package =
1565 dlsym(drm_lib_handle, "drm_tizen_decrypt_package");
1566 if (_drm_tizen_decrypt_package == NULL) {
1567 ERR("_drm_tizen_decrypt_package() failed");
1573 if (drm_lib_handle) {
1574 dlclose(drm_lib_handle);
1575 drm_lib_handle = NULL;
1580 static void __unload_drm_library(void)
1582 if (drm_lib_handle) {
1583 dlclose(drm_lib_handle);
1584 drm_lib_handle = NULL;
1588 static int __process_generate_license_request(struct backend_job *job)
1591 char req_data[MAX_PKG_ARGS_LEN];
1592 unsigned int req_data_len;
1593 char license_url[MAX_PKG_ARGS_LEN];
1594 unsigned int license_url_len;
1597 resp_data = job->args;
1598 req_data_len = sizeof(req_data);
1599 license_url_len = sizeof(license_url);
1601 if (__load_drm_library() != 0) {
1602 ERR("Failed to load library");
1606 ret = _drm_tizen_generate_license_request(resp_data, strlen(resp_data),
1607 req_data, &req_data_len,
1608 license_url, &license_url_len);
1610 ERR("drm_tizen_generate_license_request failed");
1613 _return_value_to_caller(job->req_id,
1614 g_variant_new("(iss)", PKGMGR_R_OK, req_data,
1620 _return_value_to_caller(job->req_id, g_variant_new("(iss)",
1621 PKGMGR_R_ESYSTEM, "", ""));
1622 is_drm_busy = false;
1623 __unload_drm_library();
1627 static int __process_register_license(struct backend_job *job)
1632 resp_data = job->args;
1633 if (!_drm_tizen_register_license) {
1634 ERR("_drm_tizen_register_license is not loaded");
1637 ret = _drm_tizen_register_license(resp_data, strlen(resp_data));
1639 ERR("drm_tizen_register_license failed: %d", ret);
1642 _return_value_to_caller(job->req_id,
1643 g_variant_new("(i)", PKGMGR_R_OK));
1647 _return_value_to_caller(job->req_id,
1648 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1649 is_drm_busy = false;
1650 __unload_drm_library();
1655 static int __process_decrypt_package(struct backend_job *job)
1658 char *drm_file_path;
1659 char *decrypted_file_path;
1661 drm_file_path = job->pkgid;
1662 decrypted_file_path = job->args;
1664 /* TODO: check ownership of decrypted file */
1665 if (!_drm_tizen_decrypt_package) {
1666 ERR("drm_tizen_decrypt_package is not loaded");
1670 ret = _drm_tizen_decrypt_package(drm_file_path, strlen(drm_file_path),
1671 decrypted_file_path, strlen(decrypted_file_path));
1673 ERR("drm_tizen_decrypt_package failed: %d", ret);
1676 _return_value_to_caller(job->req_id,
1677 g_variant_new("(i)", PKGMGR_R_OK));
1681 _return_value_to_caller(job->req_id,
1682 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1683 is_drm_busy = false;
1684 __unload_drm_library();
1689 static int __process_update_app_splash_screen(struct backend_job *job, int flag)
1692 bool is_global = false;
1695 ret = __change_job_info(job, job->target_uid, &is_global);
1696 if (ret != PMINFO_R_OK || strlen(job->appid) == 0)
1699 val = flag ? PKGMGR_INSTALLER_APP_ENABLE_SPLASH_SCREEN_EVENT_STR :
1700 PKGMGR_INSTALLER_APP_DISABLE_SPLASH_SCREEN_EVENT_STR;
1701 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1702 PKGMGR_INSTALLER_START_KEY_STR, val, job->req_type);
1705 ret = pkgmgr_parser_update_global_app_splash_screen_display_info_in_usr_db(job->appid, job->target_uid, flag);
1707 ret = pkgmgr_parser_update_app_splash_screen_display_info_in_usr_db(
1708 job->appid, job->target_uid, flag);
1709 if (ret != PMINFO_R_OK)
1710 _send_app_signal(job->target_uid, job->req_id, job->pkgid,
1711 job->appid, PKGMGR_INSTALLER_END_KEY_STR,
1712 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1715 _send_app_signal(job->target_uid, job->req_id, job->pkgid,
1716 job->appid, PKGMGR_INSTALLER_END_KEY_STR,
1717 PKGMGR_INSTALLER_OK_EVENT_STR,
1723 static int __process_set_restriction_mode(struct backend_job *job)
1728 mode = atoi(job->args);
1729 ret = _set_restriction_mode(job->target_uid, job->pkgid, mode);
1731 _return_value_to_caller(job->req_id,
1732 g_variant_new("(i)", ret));
1737 static int __process_unset_restriction_mode(struct backend_job *job)
1742 mode = atoi(job->args);
1743 ret = _unset_restriction_mode(job->target_uid, job->pkgid, mode);
1745 _return_value_to_caller(job->req_id,
1746 g_variant_new("(i)", ret));
1751 static int __process_get_restriction_mode(struct backend_job *job)
1756 ret = _get_restriction_mode(job->target_uid, job->pkgid, &mode);
1758 _return_value_to_caller(job->req_id,
1759 g_variant_new("(ii)", mode, ret));
1764 static int __process_set_app_label(struct backend_job *job)
1768 ret = pkgmgr_parser_update_app_label_info_in_usr_db(job->pkgid,
1769 job->target_uid, job->args);
1770 _return_value_to_caller(job->req_id, g_variant_new("(i)", ret));
1775 static int __process_migrate_external_image(struct backend_job *job)
1779 char args[MAX_PKG_ARGS_LEN];
1782 backend_cmd = job->backend_path;
1783 if (backend_cmd == NULL)
1786 snprintf(args, sizeof(args), "%s -k %s --migrate-extimg %s -u %d %s",
1787 backend_cmd, job->req_id, job->pkgid,
1788 (int)job->target_uid, job->args);
1790 argv = __generate_argv(args);
1792 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1798 static int __post_process(int ret, int x, struct backend_job *job)
1801 __set_backend_free(x);
1802 _free_backend_job(job);
1804 g_hash_table_insert(backend_info_table, (gpointer)ret,
1810 gboolean queue_job(void *data)
1812 struct backend_job *job = NULL;
1816 /* Pop a job from queue */
1817 for (x = 0; x < num_of_backends; x++) {
1818 if (__is_backend_busy(x))
1821 job = _pop_queue(x);
1826 /* all backend messages queue are empty or busy */
1827 if (x == num_of_backends || job == NULL) {
1828 DBG("no job available");
1832 /* set current backend job */
1833 DBG("handle request type [%d]", job->req_type);
1835 if (job->req_type == REQUEST_TYPE_INSTALL ||
1836 job->req_type == REQUEST_TYPE_MOUNT_INSTALL ||
1837 job->req_type == REQUEST_TYPE_REINSTALL) {
1838 ret = __check_csr(job->pkgid);
1841 _send_fail_signal(job);
1842 _free_backend_job(job);
1847 switch (job->req_type) {
1848 case REQUEST_TYPE_INSTALL:
1849 __set_backend_busy(x);
1851 ret = __process_install(job);
1852 __post_process(ret, x, job);
1854 case REQUEST_TYPE_MOUNT_INSTALL:
1855 __set_backend_busy(x);
1857 ret = __process_mount_install(job);
1858 __post_process(ret, x, job);
1860 case REQUEST_TYPE_REINSTALL:
1861 __set_backend_busy(x);
1863 ret = __process_reinstall(job);
1864 __post_process(ret, x, job);
1866 case REQUEST_TYPE_UNINSTALL:
1867 __set_backend_busy(x);
1869 ret = __process_uninstall(job);
1870 __post_process(ret, x, job);
1872 case REQUEST_TYPE_MOVE:
1873 __set_backend_busy(x);
1875 ret = __process_move(job);
1876 __post_process(ret, x, job);
1878 case REQUEST_TYPE_ENABLE_PKG:
1879 __set_backend_busy(x);
1881 ret = __process_enable_pkg(job);
1883 _send_fail_signal(job);
1884 __post_process(ret, x, job);
1886 case REQUEST_TYPE_DISABLE_PKG:
1887 __set_backend_busy(x);
1889 ret = __process_disable_pkg(job);
1891 _send_fail_signal(job);
1892 __post_process(ret, x, job);
1894 case REQUEST_TYPE_REGISTER_PKG_UPDATE_INFO:
1895 ret = __process_register_pkg_update_info(job);
1896 __free_extra_info(job);
1897 _free_backend_job(job);
1899 case REQUEST_TYPE_UNREGISTER_PKG_UPDATE_INFO:
1900 ret = __process_unregister_pkg_update_info(job);
1901 _free_backend_job(job);
1903 case REQUEST_TYPE_UNREGISTER_ALL_PKG_UPDATE_INFO:
1904 ret = __process_unregister_all_pkg_update_info(job);
1905 _free_backend_job(job);
1907 case REQUEST_TYPE_ENABLE_APP:
1908 ret = __process_enable_app(job);
1909 _free_backend_job(job);
1911 case REQUEST_TYPE_DISABLE_APP:
1912 ret = __process_disable_app(job);
1913 _free_backend_job(job);
1915 case REQUEST_TYPE_GETSIZE:
1916 __set_backend_busy(x);
1917 ret = __process_getsize(job);
1918 __post_process(ret, x, job);
1920 case REQUEST_TYPE_GETSIZE_SYNC:
1921 __set_backend_busy(x);
1922 ret = __process_getsize_sync(job);
1924 __free_extra_info(job);
1925 __post_process(ret, x, job);
1927 case REQUEST_TYPE_CLEARDATA:
1928 __set_backend_busy(x);
1930 ret = __process_cleardata(job);
1931 __post_process(ret, x, job);
1933 case REQUEST_TYPE_CLEARCACHE:
1934 __set_backend_busy(x);
1936 ret = __process_clearcache(job);
1937 __post_process(ret, x, job);
1939 case REQUEST_TYPE_ENABLE_GLOBAL_APP_FOR_UID:
1940 ret = __process_enable_global_app_for_uid(job);
1941 _free_backend_job(job);
1943 case REQUEST_TYPE_DISABLE_GLOBAL_APP_FOR_UID:
1944 ret = __process_disable_global_app_for_uid(job);
1945 _free_backend_job(job);
1947 case REQUEST_TYPE_KILL:
1948 ret = __process_kill(job);
1949 _free_backend_job(job);
1951 case REQUEST_TYPE_CHECK:
1952 ret = __process_check(job);
1953 _free_backend_job(job);
1955 case REQUEST_TYPE_GENERATE_LICENSE_REQUEST:
1956 ret = __process_generate_license_request(job);
1957 _free_backend_job(job);
1959 case REQUEST_TYPE_REGISTER_LICENSE:
1960 ret = __process_register_license(job);
1961 _free_backend_job(job);
1963 case REQUEST_TYPE_DECRYPT_PACKAGE:
1964 ret = __process_decrypt_package(job);
1965 _free_backend_job(job);
1967 case REQUEST_TYPE_ENABLE_APP_SPLASH_SCREEN:
1968 ret = __process_update_app_splash_screen(job, 1);
1969 _free_backend_job(job);
1971 case REQUEST_TYPE_DISABLE_APP_SPLASH_SCREEN:
1972 ret = __process_update_app_splash_screen(job, 0);
1973 _free_backend_job(job);
1975 case REQUEST_TYPE_SET_RESTRICTION_MODE:
1976 ret = __process_set_restriction_mode(job);
1977 _free_backend_job(job);
1979 case REQUEST_TYPE_UNSET_RESTRICTION_MODE:
1980 ret = __process_unset_restriction_mode(job);
1981 _free_backend_job(job);
1983 case REQUEST_TYPE_GET_RESTRICTION_MODE:
1984 ret = __process_get_restriction_mode(job);
1985 _free_backend_job(job);
1987 case REQUEST_TYPE_SET_APP_LABEL:
1988 ret = __process_set_app_label(job);
1989 _free_backend_job(job);
1991 case REQUEST_TYPE_MIGRATE_EXTERNAL_IMAGE:
1992 __set_backend_busy(x);
1994 ret = __process_migrate_external_image(job);
1995 __post_process(ret, x, job);
2005 int main(int argc, char *argv[])
2009 DBG("server start");
2011 if (__register_signal_handler()) {
2012 ERR("failed to register signal handler");
2016 r = _init_backend_queue();
2018 ERR("Queue Initialization Failed");
2022 r = __init_backend_info();
2024 ERR("backend info init failed");
2028 r = _init_request_handler();
2030 ERR("dbus init failed");
2034 #if !GLIB_CHECK_VERSION(2, 35, 0)
2037 mainloop = g_main_loop_new(NULL, FALSE);
2039 ERR("g_main_loop_new failed");
2043 DBG("Main loop is created.");
2045 g_main_loop_run(mainloop);
2047 DBG("Quit main loop.");
2048 _fini_request_handler();
2049 __fini_backend_info();
2050 _fini_backend_queue();
2052 g_source_remove(swid);
2053 g_io_channel_unref(sio);
2055 DBG("package manager server terminated.");