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>
30 #include <sys/socket.h>
35 #include <tzplatform_config.h>
37 #include "package-manager.h"
38 #include "pkgmgr_installer.h"
39 #include "pkgmgr_installer_config.h"
40 #include "pkgmgr_installer_debug.h"
41 #include "pkgmgr_installer_info.h"
42 #include "pkgmgr_installer_error.h"
43 #include "package-manager-types.h"
45 #include <pkgmgr-info.h>
47 /* API export macro */
49 #define API __attribute__ ((visibility("default")))
52 #define MAX_STRLEN 1024
53 #define MAX_QUERY_LEN 4096
55 #define CHK_PI_RET(r) \
56 do { if (NULL == pi) return (r); } while (0)
58 #define OPTVAL_PRELOAD 1000
59 #define OPTVAL_FORCE_REMOVAL 1001
60 #define OPTVAL_PRELOAD_RW 1002
61 #define OPTVAL_NO_REMOVAL 1003
62 #define OPTVAL_KEEP_RWDATA 1004
63 #define OPTVAL_PARTIAL_RW 1005
64 #define OPTVAL_MIGRATE_EXTIMG 1006
65 #define OPTVAL_SKIP_CHECK_REFERENCE 1007
66 #define OPTVAL_RECOVER_DB 1008
67 #define OPTVAL_RECOVERY_CLEANUP 1009
69 /* Supported options */
70 const char *short_opts = "k:l:i:d:c:m:t:o:r:p:s:b:e:M:y:u:w:D:A:qGS";
71 const struct option long_opts[] = {
72 { "session-id", 1, NULL, 'k' },
73 { "license-path", 1, NULL, 'l' },
74 { "install", 1, NULL, 'i' },
75 { "uninstall", 1, NULL, 'd' },
76 { "clear", 1, NULL, 'c' },
77 { "move", 1, NULL, 'm' },
78 { "move-type", 1, NULL, 't' },
79 { "optional-data", 0, NULL, 'o' },
80 { "reinstall", 0, NULL, 'r' },
81 { "caller-pkgid", 1, NULL, 'p' },
82 { "tep-path", 1, NULL, 'e' },
83 { "tep-move", 1, NULL, 'M' },
84 { "smack", 1, NULL, 's' },
85 { "manifest-direct-install", 1, NULL, 'y' },
86 { "mount-install", 1, NULL, 'w' },
87 { "recovery", 1, NULL, 'b' },
88 { "debug-mode", 0, NULL, 'G' },
89 { "skip-optimization", 0, NULL, 'S' },
90 { "preload", 0, NULL, OPTVAL_PRELOAD }, /* for preload RO */
91 { "force-remove", 0, NULL, OPTVAL_FORCE_REMOVAL }, /* for preload RO/RW */
92 { "preload-rw", 0, NULL, OPTVAL_PRELOAD_RW }, /* for preload RW */
93 { "no-remove", 0, NULL, OPTVAL_NO_REMOVAL }, /* for preload RW */
94 { "keep-rwdata", 0, NULL, OPTVAL_KEEP_RWDATA }, /* for preload RW */
95 { "partial-rw", 0, NULL, OPTVAL_PARTIAL_RW }, /* for preload RO */
96 { "migrate-extimg", 1, NULL, OPTVAL_MIGRATE_EXTIMG },
97 { "skip-check-reference", 0, NULL, OPTVAL_SKIP_CHECK_REFERENCE },
98 { "recover-db", 1, NULL, OPTVAL_RECOVER_DB },
99 { "recovery-cleanup", 0, NULL, OPTVAL_RECOVERY_CLEANUP },
100 { 0, 0, 0, 0 } /* sentinel */
103 struct pkgmgr_installer {
123 int skip_check_reference;
124 int skip_optimization;
125 int recovery_cleanup;
126 GDBusConnection *conn;
127 GHashTable *pkg_list;
131 typedef struct pkg_signal_info {
136 static uid_t g_target_uid;
137 static int g_debug_mode;
138 static int g_skip_optimization;
139 static pkgmgr_privilege_level g_privilege_level = PM_PRIVILEGE_UNKNOWN;
141 static const char *__get_signal_name(pkgmgr_installer *pi, const char *key,
142 const char *pkg_type)
144 if (strcmp(key, PKGMGR_INSTALLER_INSTALL_PERCENT_KEY_STR) == 0)
146 else if (strcmp(key, PKGMGR_INSTALLER_GET_SIZE_KEY_STR) == 0)
148 else if (strcmp(key, PKGMGR_INSTALLER_APPID_KEY_STR) == 0)
149 return PKGMGR_INSTALLER_UNINSTALL_EVENT_STR;
150 else if (strcmp(pkg_type, PKGMGR_INSTALLER_CLEAR_CACHE_KEY_STR) == 0)
152 else if (pi->is_upgrade)
153 return PKGMGR_INSTALLER_UPGRADE_EVENT_STR;
156 switch (pi->request_type) {
157 case PKGMGR_REQ_INSTALL:
158 case PKGMGR_REQ_MANIFEST_DIRECT_INSTALL:
159 case PKGMGR_REQ_MOUNT_INSTALL:
160 case PKGMGR_REQ_REINSTALL:
161 case PKGMGR_REQ_ENABLE_PKG:
162 case PKGMGR_REQ_RECOVER:
163 return PKGMGR_INSTALLER_INSTALL_EVENT_STR;
164 case PKGMGR_REQ_UNINSTALL:
165 case PKGMGR_REQ_DISABLE_PKG:
166 return PKGMGR_INSTALLER_UNINSTALL_EVENT_STR;
167 case PKGMGR_REQ_UPGRADE:
168 return PKGMGR_INSTALLER_UPGRADE_EVENT_STR;
169 case PKGMGR_REQ_MOVE:
170 return PKGMGR_INSTALLER_MOVE_EVENT_STR;
171 case PKGMGR_REQ_ENABLE_APP:
172 return PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR;
173 case PKGMGR_REQ_DISABLE_APP:
174 return PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR;
175 case PKGMGR_REQ_ENABLE_APP_SPLASH_SCREEN:
176 return PKGMGR_INSTALLER_APP_ENABLE_SPLASH_SCREEN_EVENT_STR;
177 case PKGMGR_REQ_DISABLE_APP_SPLASH_SCREEN:
178 return PKGMGR_INSTALLER_APP_DISABLE_SPLASH_SCREEN_EVENT_STR;
179 case PKGMGR_REQ_CLEAR:
180 return PKGMGR_INSTALLER_CLEAR_EVENT_STR;
181 case PKGMGR_REQ_GETSIZE:
182 return PKGMGR_INSTALLER_GET_SIZE_KEY_STR;
183 case PKGMGR_REQ_RES_COPY:
184 return PKGMGR_INSTALLER_RES_COPY_EVENT_STR;
185 case PKGMGR_REQ_RES_CREATE_DIR:
186 return PKGMGR_INSTALLER_RES_CREATE_DIR_EVENT_STR;
187 case PKGMGR_REQ_RES_REMOVE:
188 return PKGMGR_INSTALLER_RES_REMOVE_EVENT_STR;
189 case PKGMGR_REQ_RES_UNINSTALL:
190 return PKGMGR_INSTALLER_RES_UNINSTALL_EVENT_STR;
193 ERR("cannot find type");
198 static int __send_signal_for_event(pkgmgr_installer *pi, const char *pkg_type,
199 const char *pkgid, const char *appid, const char *key,
203 const char *tmp_appid = appid;
204 const char *signal_name;
206 GVariantBuilder *builder;
209 if (!pi || pi->conn == NULL)
212 sid = pi->session_id;
216 signal_name = __get_signal_name(pi, key, pkg_type);
218 ERR("unknown signal type");
222 builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)"));
223 g_variant_builder_add(builder, "(sss)", pkgid,
224 (tmp_appid ? tmp_appid : ""), pkg_type);
225 v = g_variant_new("(usa(sss)ss)",
226 pi->target_uid, sid, builder, key, val);
227 g_variant_builder_unref(builder);
228 if (g_dbus_connection_emit_signal(pi->conn, NULL,
229 PKGMGR_INSTALLER_DBUS_OBJECT_PATH,
230 PKGMGR_INSTALLER_DBUS_INTERFACE, signal_name,
232 ERR("failed to send dbus signal");
234 ERR("err: %s", err->message);
243 static int __send_signal_to_agent(uid_t uid, void *data, size_t len)
246 struct sockaddr_un sa;
249 fd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0);
251 ERR("failed to create socket: %d", errno);
255 sa.sun_family = AF_UNIX;
256 snprintf(sa.sun_path, sizeof(sa.sun_path), "/run/pkgmgr/agent/%d", uid);
258 r = connect(fd, (struct sockaddr *)&sa, sizeof(sa));
260 ERR("failed to connect socket(%s): %d", sa.sun_path, errno);
265 r = send(fd, data, len, MSG_NOSIGNAL);
267 ERR("failed to send data: %d", errno);
277 static int __send_signal_for_event_for_uid(pkgmgr_installer *pi, uid_t uid,
278 const char *pkg_type, const char *pkgid, const char *appid,
279 const char *key, const char *val)
282 const char *signal_name;
283 const char *tmp_appid = appid;
285 GVariantBuilder *builder;
293 if (!pi || pi->conn == NULL)
296 sid = pi->session_id;
300 data_len = sizeof(size_t) + sizeof(gsize);
302 signal_name = __get_signal_name(pi, key, pkg_type);
304 ERR("unknown signal name");
308 /* including null byte */
309 name_size = strlen(signal_name) + 1;
310 data_len += name_size;
312 builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)"));
313 g_variant_builder_add(builder, "(sss)", pkgid,
314 (tmp_appid ? tmp_appid : ""), pkg_type);
315 gv = g_variant_new("(usa(sss)ss)", pi->target_uid, sid,
317 g_variant_builder_unref(builder);
319 ERR("failed to create GVariant instance");
322 gv_len = g_variant_get_size(gv);
323 gv_data = g_malloc(gv_len);
324 g_variant_store(gv, gv_data);
328 data = malloc(data_len);
330 ERR("out of memory");
335 memcpy(ptr, &name_size, sizeof(size_t));
336 ptr += sizeof(size_t);
337 memcpy(ptr, &gv_len, sizeof(gsize));
338 ptr += sizeof(gsize);
339 memcpy(ptr, signal_name, name_size);
341 memcpy(ptr, gv_data, gv_len);
344 if (__send_signal_to_agent(uid, data, data_len)) {
345 ERR("failed to send signal to agent");
355 static void __free_pkg_list(gpointer data)
357 pkg_signal_info *info = (pkg_signal_info *)data;
359 free(info->pkg_type);
363 API pkgmgr_installer *pkgmgr_installer_new(void)
365 pkgmgr_installer *pi;
368 pi = calloc(1, sizeof(struct pkgmgr_installer));
372 pi->conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
373 if (pi->conn == NULL) {
374 ERR("failed to get bus: %s", err->message);
382 pi->request_type = PKGMGR_REQ_INVALID;
383 pi->pkg_list = g_hash_table_new_full(
384 g_str_hash, g_str_equal, NULL, __free_pkg_list);
388 API pkgmgr_installer *pkgmgr_installer_offline_new(void)
390 pkgmgr_installer *pi;
392 pi = calloc(1, sizeof(struct pkgmgr_installer));
398 pi->request_type = PKGMGR_REQ_INVALID;
403 API int pkgmgr_installer_free(pkgmgr_installer *pi)
409 free(pi->pkgmgr_info);
411 free(pi->session_id);
412 if (pi->optional_data)
413 free(pi->optional_data);
414 if (pi->caller_pkgid)
415 free(pi->caller_pkgid);
420 g_dbus_connection_flush_sync(pi->conn, NULL, NULL);
421 g_object_unref(pi->conn);
425 g_list_free_full(pi->pkgs, free);
428 g_hash_table_destroy(pi->pkg_list);
435 static void __parse_multiple_pkgs(pkgmgr_installer *pi, int argc, char **argv)
437 while ((optind <= argc) && (*argv[optind - 1] != '-')) {
438 pi->pkgs = g_list_append(pi->pkgs, strdup(argv[optind - 1]));
445 pkgmgr_installer_receive_request(pkgmgr_installer *pi,
446 const int argc, char **argv)
453 optind = 1; /* Initialize optind to clear prev. index */
458 pi->target_uid = getuid();
459 g_target_uid = pi->target_uid;
461 g_skip_optimization = 0;
464 g_list_free_full(pi->pkgs, free);
469 c = getopt_long(argc, argv, short_opts, long_opts, &opt_idx);
470 /* printf("c=%d %c\n", c, c); //debug */
472 break; /* Parse is end */
474 case OPTVAL_PRELOAD: /* request for preload app */
476 DBG("preload request [%d]", pi->is_preload);
478 case OPTVAL_FORCE_REMOVAL: /* request for force-remove */
479 pi->force_removal = 1;
480 DBG("force-remove request [%d]", pi->force_removal);
482 case OPTVAL_PRELOAD_RW: /* request for preload-rw app */
483 pi->is_preload_rw = 1;
484 DBG("preload-rw request [%d]", pi->is_preload_rw);
486 case OPTVAL_NO_REMOVAL: /* request for no-remove */
488 DBG("no-remove request [%d]", pi->no_removal);
490 case OPTVAL_KEEP_RWDATA: /* request for keep-rwdata */
492 DBG("keep-rwdata request [%d]", pi->keep_rwdata);
494 case OPTVAL_PARTIAL_RW: /* request for partial-rw */
496 DBG("partial-rw request [%d]", pi->partial_rw);
498 case OPTVAL_MIGRATE_EXTIMG:
499 /* request for legacy extimg migration */
504 mode = OPTVAL_MIGRATE_EXTIMG;
505 pi->request_type = PKGMGR_REQ_MIGRATE_EXTIMG;
507 free(pi->pkgmgr_info);
508 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
509 __parse_multiple_pkgs(pi, argc, argv);
510 DBG("legacy extimg migration requested");
512 case OPTVAL_SKIP_CHECK_REFERENCE:
513 pi->skip_check_reference = 1;
515 case OPTVAL_RECOVER_DB:
516 pi->request_type = PKGMGR_REQ_RECOVER_DB;
517 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
518 __parse_multiple_pkgs(pi, argc, argv);
520 case OPTVAL_RECOVERY_CLEANUP:
521 pi->recovery_cleanup = 1;
523 case 'k': /* session id */
525 free(pi->session_id);
526 pi->session_id = strndup(optarg, MAX_STRLEN);
529 case 'l': /* license path */
530 if (pi->license_path)
531 free(pi->license_path);
532 pi->license_path = strndup(optarg, MAX_STRLEN);
535 case 'i': /* install */
541 pi->request_type = PKGMGR_REQ_INSTALL;
543 free(pi->pkgmgr_info);
544 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
545 __parse_multiple_pkgs(pi, argc, argv);
546 DBG("option is [i] pkgid[%s]", pi->pkgmgr_info);
547 if (pi->pkgmgr_info && strlen(pi->pkgmgr_info) == 0) {
548 free(pi->pkgmgr_info);
549 pi->pkgmgr_info = NULL;
555 case 'e': /* install */
558 pi->tep_path = strndup(optarg, MAX_STRLEN);
559 pi->is_tep_included = 1;
560 DBG("option is [e] tep_path[%s]", pi->tep_path);
563 case 'M': /* install */
564 if (strcmp(optarg, "tep_move") == 0)
568 DBG("option is [M] tep_move[%d]", pi->tep_move);
571 case 'd': /* uninstall */
577 pi->request_type = PKGMGR_REQ_UNINSTALL;
579 free(pi->pkgmgr_info);
580 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
581 __parse_multiple_pkgs(pi, argc, argv);
585 case 'c': /* clear */
591 pi->request_type = PKGMGR_REQ_CLEAR;
593 free(pi->pkgmgr_info);
594 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
595 __parse_multiple_pkgs(pi, argc, argv);
604 pi->request_type = PKGMGR_REQ_MOVE;
606 free(pi->pkgmgr_info);
607 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
608 __parse_multiple_pkgs(pi, argc, argv);
611 case 'r': /* reinstall */
617 pi->request_type = PKGMGR_REQ_REINSTALL;
619 free(pi->pkgmgr_info);
620 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
621 __parse_multiple_pkgs(pi, argc, argv);
624 case 't': /* move type*/
625 pi->move_type = atoi(optarg);
628 case 'p': /* caller pkgid*/
629 if (pi->caller_pkgid)
630 free(pi->caller_pkgid);
631 pi->caller_pkgid = strndup(optarg, MAX_STRLEN);
635 case 's': /* smack */
641 pi->request_type = PKGMGR_REQ_SMACK;
643 free(pi->pkgmgr_info);
644 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
645 __parse_multiple_pkgs(pi, argc, argv);
648 case 'o': /* optional data*/
649 pi->optional_data = strndup(optarg, MAX_STRLEN);
652 case 'y': /* pkgid for direct manifest installation */
654 pi->request_type = PKGMGR_REQ_MANIFEST_DIRECT_INSTALL;
655 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
656 __parse_multiple_pkgs(pi, argc, argv);
659 case 'w': /* pkgid for mount installation */
661 pi->request_type = PKGMGR_REQ_MOUNT_INSTALL;
662 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
663 __parse_multiple_pkgs(pi, argc, argv);
666 case 'b': /* recovery */
672 pi->request_type = PKGMGR_REQ_RECOVER;
674 free(pi->pkgmgr_info);
675 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
676 __parse_multiple_pkgs(pi, argc, argv);
679 case 'D': /* disable pkg */
680 pi->request_type = PKGMGR_REQ_DISABLE_PKG;
682 free(pi->pkgmgr_info);
683 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
684 __parse_multiple_pkgs(pi, argc, argv);
687 case 'A': /* enable pkg */
688 pi->request_type = PKGMGR_REQ_ENABLE_PKG;
690 free(pi->pkgmgr_info);
691 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
692 __parse_multiple_pkgs(pi, argc, argv);
696 g_target_uid = (uid_t)atoi(optarg);
697 pi->target_uid = (uid_t)atoi(optarg);
700 case 'G': /* debug mode */
705 case 'S': /* skip optimization */
706 pi->skip_optimization = 1;
707 g_skip_optimization = 1;
711 case '?': /* Not an option */
720 /* if target user is not set, set as tizenglobalapp user */
721 if (pi->target_uid == 0) {
722 pi->target_uid = tzplatform_getuid(TZ_SYS_GLOBALAPP_USER);
723 g_target_uid = pi->target_uid;
729 API int pkgmgr_installer_get_request_type(pkgmgr_installer *pi)
731 CHK_PI_RET(PKGMGR_REQ_INVALID);
732 return pi->request_type;
735 API uid_t pkgmgr_installer_get_uid(pkgmgr_installer *pi)
737 CHK_PI_RET(PKGMGR_REQ_INVALID);
738 return pi->target_uid;
741 API const char *pkgmgr_installer_get_request_info(pkgmgr_installer *pi)
743 CHK_PI_RET(PKGMGR_REQ_INVALID);
744 return pi->pkgmgr_info;
747 API const char *pkgmgr_installer_get_request_info_at(pkgmgr_installer *pi,
750 CHK_PI_RET(PKGMGR_REQ_INVALID);
751 return (const char *)g_list_nth_data(pi->pkgs, at);
754 API int pkgmgr_installer_get_request_info_count(pkgmgr_installer *pi)
756 CHK_PI_RET(PKGMGR_REQ_INVALID);
757 return g_list_length(pi->pkgs);
760 API const char *pkgmgr_installer_get_tep_path(pkgmgr_installer *pi)
762 CHK_PI_RET(PKGMGR_REQ_INVALID);
766 API int pkgmgr_installer_get_tep_move_type(pkgmgr_installer *pi)
768 CHK_PI_RET(PKGMGR_REQ_INVALID);
772 API const char *pkgmgr_installer_get_session_id(pkgmgr_installer *pi)
774 CHK_PI_RET(PKGMGR_REQ_INVALID);
775 return pi->session_id;
778 API const char *pkgmgr_installer_get_license_path(pkgmgr_installer *pi)
780 CHK_PI_RET(PKGMGR_REQ_INVALID);
781 return pi->license_path;
784 API const char *pkgmgr_installer_get_optional_data(pkgmgr_installer *pi)
786 CHK_PI_RET(PKGMGR_REQ_INVALID);
787 return pi->optional_data;
790 API int pkgmgr_installer_is_quiet(pkgmgr_installer *pi)
795 API int pkgmgr_installer_get_move_type(pkgmgr_installer *pi)
797 CHK_PI_RET(PKGMGR_REQ_INVALID);
798 return pi->move_type;
801 API const char *pkgmgr_installer_get_caller_pkgid(pkgmgr_installer *pi)
803 CHK_PI_RET(PKGMGR_REQ_INVALID);
804 return pi->caller_pkgid;
807 API int pkgmgr_installer_get_is_preload(pkgmgr_installer *pi)
809 CHK_PI_RET(PKGMGR_REQ_INVALID);
810 return pi->is_preload;
813 API int pkgmgr_installer_get_force_removal(pkgmgr_installer *pi)
815 CHK_PI_RET(PKGMGR_REQ_INVALID);
816 return pi->force_removal;
819 API int pkgmgr_installer_get_is_preload_rw(pkgmgr_installer *pi)
821 CHK_PI_RET(PKGMGR_REQ_INVALID);
822 return pi->is_preload_rw;
825 API int pkgmgr_installer_get_no_removal(pkgmgr_installer *pi)
827 CHK_PI_RET(PKGMGR_REQ_INVALID);
828 return pi->no_removal;
831 API int pkgmgr_installer_get_keep_rwdata(pkgmgr_installer *pi)
833 CHK_PI_RET(PKGMGR_REQ_INVALID);
834 return pi->keep_rwdata;
837 API int pkgmgr_installer_get_partial_rw(pkgmgr_installer *pi)
839 CHK_PI_RET(PKGMGR_REQ_INVALID);
840 return pi->partial_rw;
843 API int pkgmgr_installer_get_debug_mode(pkgmgr_installer *pi)
845 CHK_PI_RET(PKGMGR_REQ_INVALID);
846 return pi->debug_mode;
849 API int pkgmgr_installer_get_skip_check_reference(pkgmgr_installer *pi)
851 CHK_PI_RET(PKGMGR_REQ_INVALID);
852 return pi->skip_check_reference;
855 API int pkgmgr_installer_get_skip_optimization(pkgmgr_installer *pi)
857 CHK_PI_RET(PKGMGR_REQ_INVALID);
858 return pi->skip_optimization;
861 API int pkgmgr_installer_get_recovery_cleanup(pkgmgr_installer *pi)
863 CHK_PI_RET(PKGMGR_REQ_INVALID);
864 return pi->recovery_cleanup;
867 API int pkgmgr_installer_send_app_uninstall_signal(pkgmgr_installer *pi,
868 const char *pkg_type,
873 ret = __send_signal_for_event(pi, pkg_type, pkgid, NULL,
874 PKGMGR_INSTALLER_APPID_KEY_STR, val);
878 API int pkgmgr_installer_send_app_uninstall_signal_for_uid(
879 pkgmgr_installer *pi, uid_t uid, const char *pkg_type,
880 const char *pkgid, const char *val)
883 ret = __send_signal_for_event_for_uid(pi, uid, pkg_type, pkgid, NULL,
884 PKGMGR_INSTALLER_APPID_KEY_STR, val);
888 API int pkgmgr_installer_set_uid(pkgmgr_installer *pi, uid_t uid)
893 pi->target_uid = uid;
894 g_target_uid = pi->target_uid;
900 pkgmgr_installer_send_app_signal(pkgmgr_installer *pi,
901 const char *pkg_type,
904 const char *key, const char *val)
909 ERR("connection is NULL");
913 r = __send_signal_for_event(pi, pkg_type, pkgid, appid, key, val);
919 pkgmgr_installer_send_signal(pkgmgr_installer *pi,
920 const char *pkg_type,
922 const char *key, const char *val)
927 ERR("connection is NULL");
931 r = __send_signal_for_event(pi, pkg_type, pkgid, NULL, key, val);
936 API int pkgmgr_installer_send_app_signal_for_uid(pkgmgr_installer *pi,
937 uid_t uid, const char *pkg_type, const char *pkgid,
938 const char *appid, const char *key, const char *val)
943 ERR("connection is NULL");
947 r = __send_signal_for_event_for_uid(pi, uid, pkg_type, pkgid, appid,
953 API int pkgmgr_installer_send_signal_for_uid(pkgmgr_installer *pi,
954 uid_t uid, const char *pkg_type, const char *pkgid,
955 const char *key, const char *val)
960 ERR("connection is NULL");
964 r = __send_signal_for_event_for_uid(pi, uid, pkg_type, pkgid, NULL,
970 API int pkgmgr_installer_set_request_type(pkgmgr_installer *pi, int request_type)
975 pi->request_type = request_type;
979 API int pkgmgr_installer_set_session_id(pkgmgr_installer *pi, const char *session_id)
981 if (pi == NULL || session_id == NULL)
984 pi->session_id = strndup(session_id, MAX_STRLEN);
988 API int pkgmgr_installer_create_certinfo_set_handle(pkgmgr_instcertinfo_h *handle)
991 ret = pkgmgrinfo_create_certinfo_set_handle(handle);
995 API int pkgmgr_installer_set_cert_value(pkgmgr_instcertinfo_h handle, pkgmgr_instcert_type cert_type, char *cert_value)
998 ret = pkgmgrinfo_set_cert_value(handle, cert_type, cert_value);
1002 API int pkgmgr_installer_save_certinfo(const char *pkgid, pkgmgr_instcertinfo_h handle, uid_t uid)
1005 ret = pkgmgrinfo_save_certinfo(pkgid, handle, uid);
1009 API int pkgmgr_installer_destroy_certinfo_set_handle(pkgmgr_instcertinfo_h handle)
1012 ret = pkgmgrinfo_destroy_certinfo_set_handle(handle);
1016 API int pkgmgr_installer_delete_certinfo(const char *pkgid)
1019 ret = pkgmgrinfo_delete_certinfo(pkgid);
1023 API int pkgmgr_installer_set_privilege_level(pkgmgr_privilege_level level)
1025 g_privilege_level = level;
1030 API int pkgmgr_installer_info_get_target_uid(uid_t *uid)
1032 *uid = g_target_uid;
1037 API int pkgmgr_installer_info_get_privilege_level(pkgmgr_privilege_level *level)
1039 *level = g_privilege_level;
1044 API int pkgmgr_installer_info_get_debug_mode(int *debug_mode)
1046 *debug_mode = g_debug_mode;
1050 API int pkgmgr_installer_info_get_skip_optimization(int *skip_optimization)
1052 *skip_optimization = g_skip_optimization;
1056 #define CASE_TO_STR(ERRCODE) case ERRCODE: return ERRCODE##_STR
1057 API const char *pkgmgr_installer_error_to_string(int error_code)
1059 switch (error_code) {
1060 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR);
1061 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_GLOBALSYMLINK_ERROR);
1062 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_GRANT_PERMISSION_ERROR);
1063 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_IMAGE_ERROR);
1064 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_UNZIP_ERROR);
1065 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_SECURITY_ERROR);
1066 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_REGISTER_ERROR);
1067 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_PRIVILEGE_ERROR);
1068 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_PARSE_ERROR);
1069 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_RECOVERY_ERROR);
1070 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_DELTA_ERROR);
1071 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_APP_DIR_ERROR);
1072 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_CONFIG_ERROR);
1073 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_SIGNATURE_ERROR);
1074 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_SIGNATURE_INVALID);
1075 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_CERT_ERROR);
1076 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_MATCH);
1077 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_FOUND);
1078 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_ICON_ERROR);
1079 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_ICON_NOT_FOUND);
1080 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_MANIFEST_ERROR);
1081 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_MANIFEST_NOT_FOUND);
1082 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND);
1083 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_OPERATION_NOT_ALLOWED);
1084 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_OUT_OF_SPACE);
1085 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_INVALID_VALUE);
1086 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_ERROR);
1087 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_OK);
1089 return PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR_STR;
1093 API int pkgmgr_installer_add_pkg(pkgmgr_installer *pi,
1094 const char *pkgid, const char *pkg_type)
1096 pkg_signal_info *info;
1097 if (!pi || !pkgid || !pkg_type) {
1098 ERR("invalid argument");
1102 info = calloc(1, sizeof(pkg_signal_info));
1104 ERR("out of memory");
1108 info->pkgid = strdup(pkgid);
1109 info->pkg_type = strdup(pkg_type);
1110 if (!info->pkgid || !info->pkg_type) {
1111 ERR("out of memory");
1113 free(info->pkg_type);
1117 g_hash_table_insert(pi->pkg_list, (gpointer)info->pkgid, (gpointer)info);
1122 static void __build_multi_signal(gpointer key, gpointer value,
1125 GVariantBuilder *builder = (GVariantBuilder *)user_data;
1126 pkg_signal_info *info = (pkg_signal_info *)value;
1128 g_variant_builder_add(builder, "(sss)", info->pkgid, "", info->pkg_type);
1131 API int pkgmgr_installer_send_signals(pkgmgr_installer *pi,
1132 const char *key, const char *val)
1135 const char *signal_name;
1137 GVariantBuilder *builder;
1139 if (!pi || !key || !val) {
1140 ERR("invalid argument");
1144 sid = pi->session_id;
1148 signal_name = __get_signal_name(pi, key, "");
1150 ERR("unknown signal type");
1154 builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)"));
1155 g_hash_table_foreach(pi->pkg_list, __build_multi_signal, builder);
1156 if (g_dbus_connection_emit_signal(pi->conn, NULL,
1157 PKGMGR_INSTALLER_DBUS_OBJECT_PATH,
1158 PKGMGR_INSTALLER_DBUS_INTERFACE, signal_name,
1159 g_variant_new("(usa(sss)ss)",
1160 pi->target_uid, sid, builder, key,
1161 val), &err) != TRUE) {
1162 ERR("failed to send dbus signal");
1164 ERR("err: %s", err->message);
1167 g_variant_builder_unref(builder);
1170 g_variant_builder_unref(builder);
1175 API int pkgmgr_installer_send_signals_for_uid(pkgmgr_installer *pi, uid_t uid,
1176 const char *key, const char *val)
1182 GVariantBuilder *builder;
1187 const char *signal_name;
1189 if (!pi || !pi->conn) {
1190 ERR("connection is NULL");
1194 sid = pi->session_id;
1198 data_len = sizeof(size_t) + sizeof(gsize);
1200 /* including null byte */
1201 signal_name = __get_signal_name(pi, key, "");
1203 ERR("unknown signal type");
1206 name_size = strlen(signal_name) + 1;
1207 data_len += name_size;
1209 builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)"));
1210 g_hash_table_foreach(pi->pkg_list, __build_multi_signal, builder);
1212 gv = g_variant_new("(usa(sss)ss)", uid, sid, builder, key, val);
1213 g_variant_builder_unref(builder);
1215 ERR("failed to create GVariant instance");
1219 gv_len = g_variant_get_size(gv);
1220 gv_data = g_malloc(gv_len);
1221 g_variant_store(gv, gv_data);
1222 g_variant_unref(gv);
1225 data = malloc(data_len);
1227 ERR("out of memory");
1232 memcpy(ptr, &name_size, sizeof(size_t));
1233 ptr += sizeof(size_t);
1234 memcpy(ptr, &gv_len, sizeof(gsize));
1235 ptr += sizeof(gsize);
1236 memcpy(ptr, signal_name, name_size);
1238 memcpy(ptr, gv_data, gv_len);
1241 if (__send_signal_to_agent(uid, data, data_len)) {
1242 ERR("failed to send signal to agent");
1252 API int pkgmgr_installer_set_is_upgrade(pkgmgr_installer *pi, int is_upgrade) {
1256 pi->is_upgrade = is_upgrade;
1260 static GVariant *__get_gvariant_from_event_info(pkgmgr_res_event_info *event_info)
1262 pkgmgr_res_event_info_t *info = event_info;
1264 return g_variant_new("(i)", info->error_code);
1267 API int pkgmgr_installer_send_res_copy_signal(pkgmgr_installer *pi,
1268 const char *pkgid, const char *status,
1269 pkgmgr_res_event_info *event_info)
1272 const char *signal_name;
1275 if (!pi || !pkgid || !status) {
1276 ERR("invalid argument");
1280 sid = pi->session_id;
1284 signal_name = __get_signal_name(pi, "", "");
1286 ERR("unknown signal type");
1290 if (g_dbus_connection_emit_signal(pi->conn, NULL,
1291 PKGMGR_INSTALLER_DBUS_OBJECT_PATH,
1292 PKGMGR_INSTALLER_DBUS_INTERFACE, signal_name,
1293 g_variant_new("(usssv)", pi->target_uid, sid,
1295 __get_gvariant_from_event_info(
1298 ERR("failed to send dbus signal");
1300 ERR("err: %s", err->message);
1309 API int pkgmgr_installer_send_res_copy_signal_for_uid(pkgmgr_installer *pi,
1310 uid_t uid, const char *pkgid, const char *status,
1311 pkgmgr_res_event_info *event_info)
1321 const char *signal_name;
1323 if (!pi || !pi->conn) {
1324 ERR("connection is NULL");
1328 sid = pi->session_id;
1332 data_len = sizeof(size_t) + sizeof(gsize);
1334 /* including null byte */
1335 signal_name = __get_signal_name(pi, "", "");
1337 ERR("unknown signal type");
1340 name_size = strlen(signal_name) + 1;
1341 data_len += name_size;
1343 gv = g_variant_new("(usssv)", pi->target_uid, sid,
1345 __get_gvariant_from_event_info(event_info));
1347 ERR("failed to create GVariant instance");
1351 gv_len = g_variant_get_size(gv);
1352 gv_data = g_malloc(gv_len);
1353 g_variant_store(gv, gv_data);
1354 g_variant_unref(gv);
1357 data = malloc(data_len);
1359 ERR("out of memory");
1364 memcpy(ptr, &name_size, sizeof(size_t));
1365 ptr += sizeof(size_t);
1366 memcpy(ptr, &gv_len, sizeof(gsize));
1367 ptr += sizeof(gsize);
1368 memcpy(ptr, signal_name, name_size);
1370 memcpy(ptr, gv_data, gv_len);
1373 if (__send_signal_to_agent(uid, data, data_len)) {
1374 ERR("failed to send signal to agent");