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 detected malware from [%s]", 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(%s)", 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 job->extra_data = extra_getsize_info;
1376 if (mkfifo(extra_getsize_info->getsize_fifo, 0600) < 0) {
1377 ERR("failed to mkfifo");
1381 snprintf(args, sizeof(args), "%s %s %s %d -k %s -u %d --sync",
1382 backend_cmd, job->pkgid, job->args, job->caller_uid,
1383 job->req_id, job->target_uid);
1384 argv = __generate_argv(args);
1385 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1390 ERR("failed to execute backend");
1393 if (__setup_size_info_io(job) < 0) {
1394 ERR("failed to setup io handler");
1401 _return_value_to_caller(job->req_id,
1402 g_variant_new("(ix)", PKGMGR_R_ERROR, -1));
1406 static int __process_cleardata(struct backend_job *job)
1408 static const char *backend_cmd = "/usr/bin/pkg_cleardata";
1410 char args[MAX_PKG_ARGS_LEN];
1413 if ((int)job->target_uid < REGULAR_USER)
1416 snprintf(args, sizeof(args), "%s -d -n %s -u %d",
1417 backend_cmd, job->pkgid, job->target_uid);
1418 argv = __generate_argv(args);
1419 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1425 static int __process_clearcache(struct backend_job *job)
1427 static const char *backend_cmd = "/usr/bin/pkg_cleardata";
1429 char args[MAX_PKG_ARGS_LEN];
1432 if ((int)job->target_uid < REGULAR_USER)
1435 snprintf(args, sizeof(args), "%s -c -n %s -u %d",
1436 backend_cmd, job->pkgid, job->target_uid);
1437 argv = __generate_argv(args);
1438 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1444 static int __process_kill(struct backend_job *job)
1447 pkgmgrinfo_pkginfo_h handle;
1450 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(job->pkgid, job->target_uid,
1453 ERR("Failed to get handle");
1454 _return_value_to_caller(job->req_id,
1455 g_variant_new("(ii)", PKGMGR_R_ERROR, 0));
1459 pdata = calloc(1, sizeof(pkgcmd_data));
1460 if (pdata == NULL) {
1461 ERR("memory alloc failed");
1462 _return_value_to_caller(job->req_id,
1463 g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
1466 pdata->cmd = strdup("kill");
1467 if (pdata->cmd == NULL) {
1468 ERR("out of memory");
1469 _return_value_to_caller(job->req_id,
1470 g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
1474 pdata->uid = job->target_uid;
1475 ret = pkgmgrinfo_appinfo_get_usr_list(handle, PMINFO_ALL_APP,
1476 __pkgcmd_app_cb, pdata, job->target_uid);
1478 _return_value_to_caller(job->req_id,
1479 g_variant_new("(ii)", PKGMGR_R_OK, pdata->pid));
1483 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1485 ERR("pkgmgrinfo_appinfo_get_list() failed");
1492 static int __process_check(struct backend_job *job)
1495 pkgmgrinfo_pkginfo_h handle;
1498 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(job->pkgid, job->target_uid,
1501 ERR("Failed to get handle");
1502 _return_value_to_caller(job->req_id,
1503 g_variant_new("(ii)", PKGMGR_R_ERROR, 0));
1507 pdata = calloc(1, sizeof(pkgcmd_data));
1508 if (pdata == NULL) {
1509 ERR("memory alloc failed");
1510 _return_value_to_caller(job->req_id,
1511 g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
1514 pdata->cmd = strdup("check");
1515 if (pdata->cmd == NULL) {
1516 ERR("out of memory");
1517 _return_value_to_caller(job->req_id,
1518 g_variant_new("(ii)", PKGMGR_R_ENOMEM, 0));
1522 pdata->uid = job->target_uid;
1523 ret = pkgmgrinfo_appinfo_get_usr_list(handle, PMINFO_ALL_APP,
1524 __pkgcmd_app_cb, pdata, job->target_uid);
1526 _return_value_to_caller(job->req_id,
1527 g_variant_new("(ii)", PKGMGR_R_OK, pdata->pid));
1531 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1533 ERR("pkgmgrinfo_appinfo_get_list() failed");
1540 static int __load_drm_library(void)
1545 drm_lib_handle = dlopen(PATH_LIBDRM_SVC_CORE, RTLD_LAZY);
1546 if (!drm_lib_handle) {
1547 DBG("Unable to open %s", PATH_LIBDRM_SVC_CORE);
1551 _drm_tizen_generate_license_request =
1552 dlsym(drm_lib_handle, "drm_tizen_generate_license_request");
1553 if (_drm_tizen_generate_license_request == NULL) {
1554 ERR("_drm_tizen_generate_license_request() failed");
1558 _drm_tizen_register_license =
1559 dlsym(drm_lib_handle, "drm_tizen_register_license");
1560 if (_drm_tizen_register_license == NULL) {
1561 ERR("_register_license() failed");
1565 _drm_tizen_decrypt_package =
1566 dlsym(drm_lib_handle, "drm_tizen_decrypt_package");
1567 if (_drm_tizen_decrypt_package == NULL) {
1568 ERR("_drm_tizen_decrypt_package() failed");
1574 if (drm_lib_handle) {
1575 dlclose(drm_lib_handle);
1576 drm_lib_handle = NULL;
1581 static void __unload_drm_library(void)
1583 if (drm_lib_handle) {
1584 dlclose(drm_lib_handle);
1585 drm_lib_handle = NULL;
1589 static int __process_generate_license_request(struct backend_job *job)
1592 char req_data[MAX_PKG_ARGS_LEN];
1593 unsigned int req_data_len;
1594 char license_url[MAX_PKG_ARGS_LEN];
1595 unsigned int license_url_len;
1598 resp_data = job->args;
1599 req_data_len = sizeof(req_data);
1600 license_url_len = sizeof(license_url);
1602 if (__load_drm_library() != 0) {
1603 ERR("Failed to load library");
1607 ret = _drm_tizen_generate_license_request(resp_data, strlen(resp_data),
1608 req_data, &req_data_len,
1609 license_url, &license_url_len);
1611 ERR("drm_tizen_generate_license_request failed");
1614 _return_value_to_caller(job->req_id,
1615 g_variant_new("(iss)", PKGMGR_R_OK, req_data,
1621 _return_value_to_caller(job->req_id, g_variant_new("(iss)",
1622 PKGMGR_R_ESYSTEM, "", ""));
1623 is_drm_busy = false;
1624 __unload_drm_library();
1628 static int __process_register_license(struct backend_job *job)
1633 resp_data = job->args;
1634 if (!_drm_tizen_register_license) {
1635 ERR("_drm_tizen_register_license is not loaded");
1638 ret = _drm_tizen_register_license(resp_data, strlen(resp_data));
1640 ERR("drm_tizen_register_license failed: %d", ret);
1643 _return_value_to_caller(job->req_id,
1644 g_variant_new("(i)", PKGMGR_R_OK));
1648 _return_value_to_caller(job->req_id,
1649 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1650 is_drm_busy = false;
1651 __unload_drm_library();
1656 static int __process_decrypt_package(struct backend_job *job)
1659 char *drm_file_path;
1660 char *decrypted_file_path;
1662 drm_file_path = job->pkgid;
1663 decrypted_file_path = job->args;
1665 /* TODO: check ownership of decrypted file */
1666 if (!_drm_tizen_decrypt_package) {
1667 ERR("drm_tizen_decrypt_package is not loaded");
1671 ret = _drm_tizen_decrypt_package(drm_file_path, strlen(drm_file_path),
1672 decrypted_file_path, strlen(decrypted_file_path));
1674 ERR("drm_tizen_decrypt_package failed: %d", ret);
1677 _return_value_to_caller(job->req_id,
1678 g_variant_new("(i)", PKGMGR_R_OK));
1682 _return_value_to_caller(job->req_id,
1683 g_variant_new("(i)", PKGMGR_R_ESYSTEM));
1684 is_drm_busy = false;
1685 __unload_drm_library();
1690 static int __process_update_app_splash_screen(struct backend_job *job, int flag)
1693 bool is_global = false;
1696 ret = __change_job_info(job, job->target_uid, &is_global);
1697 if (ret != PMINFO_R_OK || strlen(job->appid) == 0)
1700 val = flag ? PKGMGR_INSTALLER_APP_ENABLE_SPLASH_SCREEN_EVENT_STR :
1701 PKGMGR_INSTALLER_APP_DISABLE_SPLASH_SCREEN_EVENT_STR;
1702 _send_app_signal(job->target_uid, job->req_id, job->pkgid, job->appid,
1703 PKGMGR_INSTALLER_START_KEY_STR, val, job->req_type);
1706 ret = pkgmgr_parser_update_global_app_splash_screen_display_info_in_usr_db(job->appid, job->target_uid, flag);
1708 ret = pkgmgr_parser_update_app_splash_screen_display_info_in_usr_db(
1709 job->appid, job->target_uid, flag);
1710 if (ret != PMINFO_R_OK)
1711 _send_app_signal(job->target_uid, job->req_id, job->pkgid,
1712 job->appid, PKGMGR_INSTALLER_END_KEY_STR,
1713 PKGMGR_INSTALLER_FAIL_EVENT_STR,
1716 _send_app_signal(job->target_uid, job->req_id, job->pkgid,
1717 job->appid, PKGMGR_INSTALLER_END_KEY_STR,
1718 PKGMGR_INSTALLER_OK_EVENT_STR,
1724 static int __process_set_restriction_mode(struct backend_job *job)
1729 mode = atoi(job->args);
1730 ret = _set_restriction_mode(job->target_uid, job->pkgid, mode);
1732 _return_value_to_caller(job->req_id,
1733 g_variant_new("(i)", ret));
1738 static int __process_unset_restriction_mode(struct backend_job *job)
1743 mode = atoi(job->args);
1744 ret = _unset_restriction_mode(job->target_uid, job->pkgid, mode);
1746 _return_value_to_caller(job->req_id,
1747 g_variant_new("(i)", ret));
1752 static int __process_get_restriction_mode(struct backend_job *job)
1757 ret = _get_restriction_mode(job->target_uid, job->pkgid, &mode);
1759 _return_value_to_caller(job->req_id,
1760 g_variant_new("(ii)", mode, ret));
1765 static int __process_set_app_label(struct backend_job *job)
1769 ret = pkgmgr_parser_update_app_label_info_in_usr_db(job->pkgid,
1770 job->target_uid, job->args);
1771 _return_value_to_caller(job->req_id, g_variant_new("(i)", ret));
1776 static int __process_set_app_icon(struct backend_job *job)
1780 ret = pkgmgr_parser_update_app_icon_info_in_usr_db(job->pkgid,
1781 job->target_uid, job->args);
1782 _return_value_to_caller(job->req_id, g_variant_new("(i)", ret));
1787 static int __process_migrate_external_image(struct backend_job *job)
1791 char args[MAX_PKG_ARGS_LEN];
1794 backend_cmd = job->backend_path;
1795 if (backend_cmd == NULL)
1798 snprintf(args, sizeof(args), "%s -k %s --migrate-extimg %s -u %d %s",
1799 backend_cmd, job->req_id, job->pkgid,
1800 (int)job->target_uid, job->args);
1802 argv = __generate_argv(args);
1804 pid = __fork_and_exec_with_args(argv, APPFW_UID);
1810 static int __post_process(int ret, int x, struct backend_job *job)
1813 __set_backend_free(x);
1814 _free_backend_job(job);
1816 g_hash_table_insert(backend_info_table, (gpointer)ret,
1822 gboolean queue_job(void *data)
1824 struct backend_job *job = NULL;
1828 /* Pop a job from queue */
1829 for (x = 0; x < num_of_backends; x++) {
1830 if (__is_backend_busy(x))
1833 job = _pop_queue(x);
1838 /* all backend messages queue are empty or busy */
1839 if (x == num_of_backends || job == NULL) {
1840 DBG("no job available");
1844 /* set current backend job */
1845 DBG("handle request type [%d]", job->req_type);
1847 if (job->req_type == REQUEST_TYPE_INSTALL ||
1848 job->req_type == REQUEST_TYPE_MOUNT_INSTALL ||
1849 job->req_type == REQUEST_TYPE_REINSTALL) {
1850 ret = __check_csr(job->pkgid);
1853 _send_fail_signal(job);
1854 _free_backend_job(job);
1859 switch (job->req_type) {
1860 case REQUEST_TYPE_INSTALL:
1861 __set_backend_busy(x);
1863 ret = __process_install(job);
1864 __post_process(ret, x, job);
1866 case REQUEST_TYPE_MOUNT_INSTALL:
1867 __set_backend_busy(x);
1869 ret = __process_mount_install(job);
1870 __post_process(ret, x, job);
1872 case REQUEST_TYPE_REINSTALL:
1873 __set_backend_busy(x);
1875 ret = __process_reinstall(job);
1876 __post_process(ret, x, job);
1878 case REQUEST_TYPE_UNINSTALL:
1879 __set_backend_busy(x);
1881 ret = __process_uninstall(job);
1882 __post_process(ret, x, job);
1884 case REQUEST_TYPE_MOVE:
1885 __set_backend_busy(x);
1887 ret = __process_move(job);
1888 __post_process(ret, x, job);
1890 case REQUEST_TYPE_ENABLE_PKG:
1891 __set_backend_busy(x);
1893 ret = __process_enable_pkg(job);
1895 _send_fail_signal(job);
1896 __post_process(ret, x, job);
1898 case REQUEST_TYPE_DISABLE_PKG:
1899 __set_backend_busy(x);
1901 ret = __process_disable_pkg(job);
1903 _send_fail_signal(job);
1904 __post_process(ret, x, job);
1906 case REQUEST_TYPE_REGISTER_PKG_UPDATE_INFO:
1907 ret = __process_register_pkg_update_info(job);
1908 __free_extra_info(job);
1909 _free_backend_job(job);
1911 case REQUEST_TYPE_UNREGISTER_PKG_UPDATE_INFO:
1912 ret = __process_unregister_pkg_update_info(job);
1913 _free_backend_job(job);
1915 case REQUEST_TYPE_UNREGISTER_ALL_PKG_UPDATE_INFO:
1916 ret = __process_unregister_all_pkg_update_info(job);
1917 _free_backend_job(job);
1919 case REQUEST_TYPE_ENABLE_APP:
1920 ret = __process_enable_app(job);
1921 _free_backend_job(job);
1923 case REQUEST_TYPE_DISABLE_APP:
1924 ret = __process_disable_app(job);
1925 _free_backend_job(job);
1927 case REQUEST_TYPE_GETSIZE:
1928 __set_backend_busy(x);
1929 ret = __process_getsize(job);
1930 __post_process(ret, x, job);
1932 case REQUEST_TYPE_GETSIZE_SYNC:
1933 __set_backend_busy(x);
1934 ret = __process_getsize_sync(job);
1936 __free_extra_info(job);
1937 __post_process(ret, x, job);
1939 case REQUEST_TYPE_CLEARDATA:
1940 __set_backend_busy(x);
1942 ret = __process_cleardata(job);
1943 __post_process(ret, x, job);
1945 case REQUEST_TYPE_CLEARCACHE:
1946 __set_backend_busy(x);
1948 ret = __process_clearcache(job);
1949 __post_process(ret, x, job);
1951 case REQUEST_TYPE_ENABLE_GLOBAL_APP_FOR_UID:
1952 ret = __process_enable_global_app_for_uid(job);
1953 _free_backend_job(job);
1955 case REQUEST_TYPE_DISABLE_GLOBAL_APP_FOR_UID:
1956 ret = __process_disable_global_app_for_uid(job);
1957 _free_backend_job(job);
1959 case REQUEST_TYPE_KILL:
1960 ret = __process_kill(job);
1961 _free_backend_job(job);
1963 case REQUEST_TYPE_CHECK:
1964 ret = __process_check(job);
1965 _free_backend_job(job);
1967 case REQUEST_TYPE_GENERATE_LICENSE_REQUEST:
1968 ret = __process_generate_license_request(job);
1969 _free_backend_job(job);
1971 case REQUEST_TYPE_REGISTER_LICENSE:
1972 ret = __process_register_license(job);
1973 _free_backend_job(job);
1975 case REQUEST_TYPE_DECRYPT_PACKAGE:
1976 ret = __process_decrypt_package(job);
1977 _free_backend_job(job);
1979 case REQUEST_TYPE_ENABLE_APP_SPLASH_SCREEN:
1980 ret = __process_update_app_splash_screen(job, 1);
1981 _free_backend_job(job);
1983 case REQUEST_TYPE_DISABLE_APP_SPLASH_SCREEN:
1984 ret = __process_update_app_splash_screen(job, 0);
1985 _free_backend_job(job);
1987 case REQUEST_TYPE_SET_RESTRICTION_MODE:
1988 ret = __process_set_restriction_mode(job);
1989 _free_backend_job(job);
1991 case REQUEST_TYPE_UNSET_RESTRICTION_MODE:
1992 ret = __process_unset_restriction_mode(job);
1993 _free_backend_job(job);
1995 case REQUEST_TYPE_GET_RESTRICTION_MODE:
1996 ret = __process_get_restriction_mode(job);
1997 _free_backend_job(job);
1999 case REQUEST_TYPE_SET_APP_LABEL:
2000 ret = __process_set_app_label(job);
2001 _free_backend_job(job);
2003 case REQUEST_TYPE_SET_APP_ICON:
2004 ret = __process_set_app_icon(job);
2005 _free_backend_job(job);
2007 case REQUEST_TYPE_MIGRATE_EXTERNAL_IMAGE:
2008 __set_backend_busy(x);
2010 ret = __process_migrate_external_image(job);
2011 __post_process(ret, x, job);
2021 int main(int argc, char *argv[])
2025 DBG("server start");
2027 if (__register_signal_handler()) {
2028 ERR("failed to register signal handler");
2032 r = _init_backend_queue();
2034 ERR("Queue Initialization Failed");
2038 r = __init_backend_info();
2040 ERR("backend info init failed");
2044 r = _init_request_handler();
2046 ERR("dbus init failed");
2050 #if !GLIB_CHECK_VERSION(2, 35, 0)
2053 mainloop = g_main_loop_new(NULL, FALSE);
2055 ERR("g_main_loop_new failed");
2059 DBG("Main loop is created.");
2061 g_main_loop_run(mainloop);
2063 DBG("Quit main loop.");
2064 _fini_request_handler();
2065 __fini_backend_info();
2066 _fini_backend_queue();
2068 g_source_remove(swid);
2069 g_io_channel_unref(sio);
2071 DBG("package manager server terminated.");