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 "pkgmgr_installer.h"
38 #include "pkgmgr_installer_config.h"
39 #include "pkgmgr_installer_debug.h"
40 #include "pkgmgr_installer_info.h"
41 #include "pkgmgr_installer_error.h"
43 #include <pkgmgr-info.h>
45 /* API export macro */
47 #define API __attribute__ ((visibility("default")))
50 #define MAX_STRLEN 1024
51 #define MAX_QUERY_LEN 4096
53 #define CHK_PI_RET(r) \
54 do { if (NULL == pi) return (r); } while (0)
56 #define OPTVAL_PRELOAD 1000
57 #define OPTVAL_FORCE_REMOVAL 1001
58 #define OPTVAL_PRELOAD_RW 1002
59 #define OPTVAL_NO_REMOVAL 1003
60 #define OPTVAL_KEEP_RWDATA 1004
61 #define OPTVAL_PARTIAL_RW 1005
62 #define OPTVAL_MIGRATE_EXTIMG 1006
63 #define OPTVAL_SKIP_CHECK_REFERENCE 1007
64 #define OPTVAL_RECOVER_DB 1008
66 /* Supported options */
67 const char *short_opts = "k:l:i:d:c:m:t:o:r:p:s:b:e:M:y:u:w:D:A:qGS";
68 const struct option long_opts[] = {
69 { "session-id", 1, NULL, 'k' },
70 { "license-path", 1, NULL, 'l' },
71 { "install", 1, NULL, 'i' },
72 { "uninstall", 1, NULL, 'd' },
73 { "clear", 1, NULL, 'c' },
74 { "move", 1, NULL, 'm' },
75 { "move-type", 1, NULL, 't' },
76 { "optional-data", 0, NULL, 'o' },
77 { "reinstall", 0, NULL, 'r' },
78 { "caller-pkgid", 1, NULL, 'p' },
79 { "tep-path", 1, NULL, 'e' },
80 { "tep-move", 1, NULL, 'M' },
81 { "smack", 1, NULL, 's' },
82 { "manifest-direct-install", 1, NULL, 'y' },
83 { "mount-install", 1, NULL, 'w' },
84 { "recovery", 1, NULL, 'b' },
85 { "debug-mode", 0, NULL, 'G' },
86 { "skip-optimization", 0, NULL, 'S' },
87 { "preload", 0, NULL, OPTVAL_PRELOAD }, /* for preload RO */
88 { "force-remove", 0, NULL, OPTVAL_FORCE_REMOVAL }, /* for preload RO/RW */
89 { "preload-rw", 0, NULL, OPTVAL_PRELOAD_RW }, /* for preload RW */
90 { "no-remove", 0, NULL, OPTVAL_NO_REMOVAL }, /* for preload RW */
91 { "keep-rwdata", 0, NULL, OPTVAL_KEEP_RWDATA }, /* for preload RW */
92 { "partial-rw", 0, NULL, OPTVAL_PARTIAL_RW }, /* for preload RO */
93 { "migrate-extimg", 1, NULL, OPTVAL_MIGRATE_EXTIMG },
94 { "skip-check-reference", 0, NULL, OPTVAL_SKIP_CHECK_REFERENCE },
95 { "recover-db", 1, NULL, OPTVAL_RECOVER_DB },
96 { 0, 0, 0, 0 } /* sentinel */
99 struct pkgmgr_installer {
118 int skip_check_reference;
119 int skip_optimization;
120 GDBusConnection *conn;
121 GHashTable *pkg_list;
125 typedef struct pkg_signal_info {
130 static uid_t g_target_uid;
131 static int g_debug_mode;
132 static int g_skip_optimization;
133 static pkgmgr_privilege_level g_privilege_level = PM_PRIVILEGE_UNKNOWN;
135 static const char *__get_signal_name(pkgmgr_installer *pi, const char *key,
136 const char *pkg_type)
138 if (strcmp(key, PKGMGR_INSTALLER_INSTALL_PERCENT_KEY_STR) == 0)
140 else if (strcmp(key, PKGMGR_INSTALLER_GET_SIZE_KEY_STR) == 0)
142 else if (strcmp(key, PKGMGR_INSTALLER_APPID_KEY_STR) == 0)
143 return PKGMGR_INSTALLER_UNINSTALL_EVENT_STR;
144 else if (strcmp(pkg_type, PKGMGR_INSTALLER_CLEAR_CACHE_KEY_STR) == 0)
147 switch (pi->request_type) {
148 case PKGMGR_REQ_INSTALL:
149 case PKGMGR_REQ_MANIFEST_DIRECT_INSTALL:
150 case PKGMGR_REQ_MOUNT_INSTALL:
151 case PKGMGR_REQ_REINSTALL:
152 case PKGMGR_REQ_ENABLE_PKG:
153 case PKGMGR_REQ_RECOVER:
154 return PKGMGR_INSTALLER_INSTALL_EVENT_STR;
155 case PKGMGR_REQ_UNINSTALL:
156 case PKGMGR_REQ_DISABLE_PKG:
157 return PKGMGR_INSTALLER_UNINSTALL_EVENT_STR;
158 case PKGMGR_REQ_UPGRADE:
159 return PKGMGR_INSTALLER_UPGRADE_EVENT_STR;
160 case PKGMGR_REQ_MOVE:
161 return PKGMGR_INSTALLER_MOVE_EVENT_STR;
162 case PKGMGR_REQ_ENABLE_APP:
163 return PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR;
164 case PKGMGR_REQ_DISABLE_APP:
165 return PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR;
166 case PKGMGR_REQ_ENABLE_APP_SPLASH_SCREEN:
167 return PKGMGR_INSTALLER_APP_ENABLE_SPLASH_SCREEN_EVENT_STR;
168 case PKGMGR_REQ_DISABLE_APP_SPLASH_SCREEN:
169 return PKGMGR_INSTALLER_APP_DISABLE_SPLASH_SCREEN_EVENT_STR;
170 case PKGMGR_REQ_CLEAR:
171 return PKGMGR_INSTALLER_CLEAR_EVENT_STR;
172 case PKGMGR_REQ_GETSIZE:
173 return PKGMGR_INSTALLER_GET_SIZE_KEY_STR;
176 ERR("cannot find type");
181 static int __send_signal_for_event(pkgmgr_installer *pi, const char *pkg_type,
182 const char *pkgid, const char *appid, const char *key,
186 const char *tmp_appid = appid;
187 const char *signal_name;
189 GVariantBuilder *builder;
192 if (!pi || pi->conn == NULL)
195 sid = pi->session_id;
199 signal_name = __get_signal_name(pi, key, pkg_type);
201 ERR("unknown signal type");
205 builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)"));
206 g_variant_builder_add(builder, "(sss)", pkgid,
207 (tmp_appid ? tmp_appid : ""), pkg_type);
208 v = g_variant_new("(usa(sss)ss)",
209 pi->target_uid, sid, builder, key, val);
210 g_variant_builder_unref(builder);
211 if (g_dbus_connection_emit_signal(pi->conn, NULL,
212 PKGMGR_INSTALLER_DBUS_OBJECT_PATH,
213 PKGMGR_INSTALLER_DBUS_INTERFACE, signal_name,
215 ERR("failed to send dbus signal");
217 ERR("err: %s", err->message);
226 static int __send_signal_to_agent(uid_t uid, void *data, size_t len)
229 struct sockaddr_un sa;
232 fd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0);
234 ERR("failed to create socket: %d", errno);
238 sa.sun_family = AF_UNIX;
239 snprintf(sa.sun_path, sizeof(sa.sun_path), "/run/pkgmgr/agent/%d", uid);
241 r = connect(fd, (struct sockaddr *)&sa, sizeof(sa));
243 ERR("failed to connect socket(%s): %d", sa.sun_path, errno);
248 r = send(fd, data, len, MSG_NOSIGNAL);
250 ERR("failed to send data: %d", errno);
260 static int __send_signal_for_event_for_uid(pkgmgr_installer *pi, uid_t uid,
261 const char *pkg_type, const char *pkgid, const char *appid,
262 const char *key, const char *val)
265 const char *signal_name;
266 const char *tmp_appid = appid;
268 GVariantBuilder *builder;
276 if (!pi || pi->conn == NULL)
279 sid = pi->session_id;
283 data_len = sizeof(size_t) + sizeof(gsize);
285 signal_name = __get_signal_name(pi, key, pkg_type);
287 ERR("unknown signal name");
291 /* including null byte */
292 name_size = strlen(signal_name) + 1;
293 data_len += name_size;
295 builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)"));
296 g_variant_builder_add(builder, "(sss)", pkgid,
297 (tmp_appid ? tmp_appid : ""), pkg_type);
298 gv = g_variant_new("(usa(sss)ss)", pi->target_uid, sid,
300 g_variant_builder_unref(builder);
302 ERR("failed to create GVariant instance");
305 gv_len = g_variant_get_size(gv);
306 gv_data = g_malloc(gv_len);
307 g_variant_store(gv, gv_data);
311 data = malloc(data_len);
313 ERR("out of memory");
318 memcpy(ptr, &name_size, sizeof(size_t));
319 ptr += sizeof(size_t);
320 memcpy(ptr, &gv_len, sizeof(gsize));
321 ptr += sizeof(gsize);
322 memcpy(ptr, signal_name, name_size);
324 memcpy(ptr, gv_data, gv_len);
327 if (__send_signal_to_agent(uid, data, data_len)) {
328 ERR("failed to send signal to agent");
338 static void __free_pkg_list(gpointer data)
340 pkg_signal_info *info = (pkg_signal_info *)data;
342 free(info->pkg_type);
346 API pkgmgr_installer *pkgmgr_installer_new(void)
348 pkgmgr_installer *pi;
351 pi = calloc(1, sizeof(struct pkgmgr_installer));
355 pi->conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
356 if (pi->conn == NULL) {
357 ERR("failed to get bus: %s", err->message);
365 pi->request_type = PKGMGR_REQ_INVALID;
366 pi->pkg_list = g_hash_table_new_full(
367 g_str_hash, g_str_equal, NULL, __free_pkg_list);
371 API pkgmgr_installer *pkgmgr_installer_offline_new(void)
373 pkgmgr_installer *pi;
375 pi = calloc(1, sizeof(struct pkgmgr_installer));
381 pi->request_type = PKGMGR_REQ_INVALID;
386 API int pkgmgr_installer_free(pkgmgr_installer *pi)
392 free(pi->pkgmgr_info);
394 free(pi->session_id);
395 if (pi->optional_data)
396 free(pi->optional_data);
397 if (pi->caller_pkgid)
398 free(pi->caller_pkgid);
403 g_dbus_connection_flush_sync(pi->conn, NULL, NULL);
404 g_object_unref(pi->conn);
408 g_hash_table_destroy(pi->pkg_list);
415 static void __parse_multiple_pkgs(pkgmgr_installer *pi, int argc, char **argv)
417 while ((optind <= argc) && (*argv[optind - 1] != '-')) {
418 pi->pkgs = g_list_append(pi->pkgs, strdup(argv[optind - 1]));
425 pkgmgr_installer_receive_request(pkgmgr_installer *pi,
426 const int argc, char **argv)
433 optind = 1; /* Initialize optind to clear prev. index */
438 pi->target_uid = getuid();
439 g_target_uid = pi->target_uid;
441 g_skip_optimization = 0;
444 g_list_free_full(pi->pkgs, free);
449 c = getopt_long(argc, argv, short_opts, long_opts, &opt_idx);
450 /* printf("c=%d %c\n", c, c); //debug */
452 break; /* Parse is end */
454 case OPTVAL_PRELOAD: /* request for preload app */
456 DBG("preload request [%d]", pi->is_preload);
458 case OPTVAL_FORCE_REMOVAL: /* request for force-remove */
459 pi->force_removal = 1;
460 DBG("force-remove request [%d]", pi->force_removal);
462 case OPTVAL_PRELOAD_RW: /* request for preload-rw app */
463 pi->is_preload_rw = 1;
464 DBG("preload-rw request [%d]", pi->is_preload_rw);
466 case OPTVAL_NO_REMOVAL: /* request for no-remove */
468 DBG("no-remove request [%d]", pi->no_removal);
470 case OPTVAL_KEEP_RWDATA: /* request for keep-rwdata */
472 DBG("keep-rwdata request [%d]", pi->keep_rwdata);
474 case OPTVAL_PARTIAL_RW: /* request for partial-rw */
476 DBG("partial-rw request [%d]", pi->partial_rw);
478 case OPTVAL_MIGRATE_EXTIMG:
479 /* request for legacy extimg migration */
484 mode = OPTVAL_MIGRATE_EXTIMG;
485 pi->request_type = PKGMGR_REQ_MIGRATE_EXTIMG;
487 free(pi->pkgmgr_info);
488 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
489 __parse_multiple_pkgs(pi, argc, argv);
490 DBG("legacy extimg migration requested");
492 case OPTVAL_SKIP_CHECK_REFERENCE:
493 pi->skip_check_reference = 1;
495 case OPTVAL_RECOVER_DB:
496 pi->request_type = PKGMGR_REQ_RECOVER_DB;
497 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
498 __parse_multiple_pkgs(pi, argc, argv);
500 case 'k': /* session id */
502 free(pi->session_id);
503 pi->session_id = strndup(optarg, MAX_STRLEN);
506 case 'l': /* license path */
507 if (pi->license_path)
508 free(pi->license_path);
509 pi->license_path = strndup(optarg, MAX_STRLEN);
512 case 'i': /* install */
518 pi->request_type = PKGMGR_REQ_INSTALL;
520 free(pi->pkgmgr_info);
521 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
522 __parse_multiple_pkgs(pi, argc, argv);
523 DBG("option is [i] pkgid[%s]", pi->pkgmgr_info);
524 if (pi->pkgmgr_info && strlen(pi->pkgmgr_info) == 0) {
525 free(pi->pkgmgr_info);
526 pi->pkgmgr_info = NULL;
532 case 'e': /* install */
535 pi->tep_path = strndup(optarg, MAX_STRLEN);
536 pi->is_tep_included = 1;
537 DBG("option is [e] tep_path[%s]", pi->tep_path);
540 case 'M': /* install */
541 if (strcmp(optarg, "tep_move") == 0)
545 DBG("option is [M] tep_move[%d]", pi->tep_move);
548 case 'd': /* uninstall */
554 pi->request_type = PKGMGR_REQ_UNINSTALL;
556 free(pi->pkgmgr_info);
557 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
558 __parse_multiple_pkgs(pi, argc, argv);
562 case 'c': /* clear */
568 pi->request_type = PKGMGR_REQ_CLEAR;
570 free(pi->pkgmgr_info);
571 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
572 __parse_multiple_pkgs(pi, argc, argv);
581 pi->request_type = PKGMGR_REQ_MOVE;
583 free(pi->pkgmgr_info);
584 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
585 __parse_multiple_pkgs(pi, argc, argv);
588 case 'r': /* reinstall */
594 pi->request_type = PKGMGR_REQ_REINSTALL;
596 free(pi->pkgmgr_info);
597 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
598 __parse_multiple_pkgs(pi, argc, argv);
601 case 't': /* move type*/
602 pi->move_type = atoi(optarg);
605 case 'p': /* caller pkgid*/
606 if (pi->caller_pkgid)
607 free(pi->caller_pkgid);
608 pi->caller_pkgid = strndup(optarg, MAX_STRLEN);
612 case 's': /* smack */
618 pi->request_type = PKGMGR_REQ_SMACK;
620 free(pi->pkgmgr_info);
621 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
622 __parse_multiple_pkgs(pi, argc, argv);
625 case 'o': /* optional data*/
626 pi->optional_data = strndup(optarg, MAX_STRLEN);
629 case 'y': /* pkgid for direct manifest installation */
631 pi->request_type = PKGMGR_REQ_MANIFEST_DIRECT_INSTALL;
632 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
633 __parse_multiple_pkgs(pi, argc, argv);
636 case 'w': /* pkgid for mount installation */
638 pi->request_type = PKGMGR_REQ_MOUNT_INSTALL;
639 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
640 __parse_multiple_pkgs(pi, argc, argv);
643 case 'b': /* recovery */
649 pi->request_type = PKGMGR_REQ_RECOVER;
651 free(pi->pkgmgr_info);
652 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
653 __parse_multiple_pkgs(pi, argc, argv);
656 case 'D': /* disable pkg */
657 pi->request_type = PKGMGR_REQ_DISABLE_PKG;
659 free(pi->pkgmgr_info);
660 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
661 __parse_multiple_pkgs(pi, argc, argv);
664 case 'A': /* enable pkg */
665 pi->request_type = PKGMGR_REQ_ENABLE_PKG;
667 free(pi->pkgmgr_info);
668 pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
669 __parse_multiple_pkgs(pi, argc, argv);
673 g_target_uid = (uid_t)atoi(optarg);
674 pi->target_uid = (uid_t)atoi(optarg);
677 case 'G': /* debug mode */
682 case 'S': /* skip optimization */
683 pi->skip_optimization = 1;
684 g_skip_optimization = 1;
688 case '?': /* Not an option */
697 /* if target user is not set, set as tizenglobalapp user */
698 if (pi->target_uid == 0) {
699 pi->target_uid = tzplatform_getuid(TZ_SYS_GLOBALAPP_USER);
700 g_target_uid = pi->target_uid;
706 API int pkgmgr_installer_get_request_type(pkgmgr_installer *pi)
708 CHK_PI_RET(PKGMGR_REQ_INVALID);
709 return pi->request_type;
712 API uid_t pkgmgr_installer_get_uid(pkgmgr_installer *pi)
714 CHK_PI_RET(PKGMGR_REQ_INVALID);
715 return pi->target_uid;
718 API const char *pkgmgr_installer_get_request_info(pkgmgr_installer *pi)
720 CHK_PI_RET(PKGMGR_REQ_INVALID);
721 return pi->pkgmgr_info;
724 API const char *pkgmgr_installer_get_request_info_at(pkgmgr_installer *pi,
727 CHK_PI_RET(PKGMGR_REQ_INVALID);
728 return (const char *)g_list_nth_data(pi->pkgs, at);
731 API int pkgmgr_installer_get_request_info_count(pkgmgr_installer *pi)
733 CHK_PI_RET(PKGMGR_REQ_INVALID);
734 return g_list_length(pi->pkgs);
737 API const char *pkgmgr_installer_get_tep_path(pkgmgr_installer *pi)
739 CHK_PI_RET(PKGMGR_REQ_INVALID);
743 API int pkgmgr_installer_get_tep_move_type(pkgmgr_installer *pi)
745 CHK_PI_RET(PKGMGR_REQ_INVALID);
749 API const char *pkgmgr_installer_get_session_id(pkgmgr_installer *pi)
751 CHK_PI_RET(PKGMGR_REQ_INVALID);
752 return pi->session_id;
755 API const char *pkgmgr_installer_get_license_path(pkgmgr_installer *pi)
757 CHK_PI_RET(PKGMGR_REQ_INVALID);
758 return pi->license_path;
761 API const char *pkgmgr_installer_get_optional_data(pkgmgr_installer *pi)
763 CHK_PI_RET(PKGMGR_REQ_INVALID);
764 return pi->optional_data;
767 API int pkgmgr_installer_is_quiet(pkgmgr_installer *pi)
772 API int pkgmgr_installer_get_move_type(pkgmgr_installer *pi)
774 CHK_PI_RET(PKGMGR_REQ_INVALID);
775 return pi->move_type;
778 API const char *pkgmgr_installer_get_caller_pkgid(pkgmgr_installer *pi)
780 CHK_PI_RET(PKGMGR_REQ_INVALID);
781 return pi->caller_pkgid;
784 API int pkgmgr_installer_get_is_preload(pkgmgr_installer *pi)
786 CHK_PI_RET(PKGMGR_REQ_INVALID);
787 return pi->is_preload;
790 API int pkgmgr_installer_get_force_removal(pkgmgr_installer *pi)
792 CHK_PI_RET(PKGMGR_REQ_INVALID);
793 return pi->force_removal;
796 API int pkgmgr_installer_get_is_preload_rw(pkgmgr_installer *pi)
798 CHK_PI_RET(PKGMGR_REQ_INVALID);
799 return pi->is_preload_rw;
802 API int pkgmgr_installer_get_no_removal(pkgmgr_installer *pi)
804 CHK_PI_RET(PKGMGR_REQ_INVALID);
805 return pi->no_removal;
808 API int pkgmgr_installer_get_keep_rwdata(pkgmgr_installer *pi)
810 CHK_PI_RET(PKGMGR_REQ_INVALID);
811 return pi->keep_rwdata;
814 API int pkgmgr_installer_get_partial_rw(pkgmgr_installer *pi)
816 CHK_PI_RET(PKGMGR_REQ_INVALID);
817 return pi->partial_rw;
820 API int pkgmgr_installer_get_debug_mode(pkgmgr_installer *pi)
822 CHK_PI_RET(PKGMGR_REQ_INVALID);
823 return pi->debug_mode;
826 API int pkgmgr_installer_get_skip_check_reference(pkgmgr_installer *pi)
828 CHK_PI_RET(PKGMGR_REQ_INVALID);
829 return pi->skip_check_reference;
832 API int pkgmgr_installer_get_skip_optimization(pkgmgr_installer *pi)
834 CHK_PI_RET(PKGMGR_REQ_INVALID);
835 return pi->skip_optimization;
838 API int pkgmgr_installer_send_app_uninstall_signal(pkgmgr_installer *pi,
839 const char *pkg_type,
844 ret = __send_signal_for_event(pi, pkg_type, pkgid, NULL,
845 PKGMGR_INSTALLER_APPID_KEY_STR, val);
849 API int pkgmgr_installer_send_app_uninstall_signal_for_uid(
850 pkgmgr_installer *pi, uid_t uid, const char *pkg_type,
851 const char *pkgid, const char *val)
854 ret = __send_signal_for_event_for_uid(pi, uid, pkg_type, pkgid, NULL,
855 PKGMGR_INSTALLER_APPID_KEY_STR, val);
859 API int pkgmgr_installer_set_uid(pkgmgr_installer *pi, uid_t uid)
864 pi->target_uid = uid;
865 g_target_uid = pi->target_uid;
871 pkgmgr_installer_send_app_signal(pkgmgr_installer *pi,
872 const char *pkg_type,
875 const char *key, const char *val)
880 ERR("connection is NULL");
884 r = __send_signal_for_event(pi, pkg_type, pkgid, appid, key, val);
890 pkgmgr_installer_send_signal(pkgmgr_installer *pi,
891 const char *pkg_type,
893 const char *key, const char *val)
898 ERR("connection is NULL");
902 if (strcmp(key, PKGMGR_INSTALLER_START_KEY_STR) == 0 &&
903 strcmp(val, PKGMGR_INSTALLER_UPGRADE_EVENT_STR) == 0)
904 pi->request_type = PKGMGR_REQ_UPGRADE;
906 r = __send_signal_for_event(pi, pkg_type, pkgid, NULL, key, val);
911 API int pkgmgr_installer_send_app_signal_for_uid(pkgmgr_installer *pi,
912 uid_t uid, const char *pkg_type, const char *pkgid,
913 const char *appid, const char *key, const char *val)
918 ERR("connection is NULL");
922 r = __send_signal_for_event_for_uid(pi, uid, pkg_type, pkgid, appid,
928 API int pkgmgr_installer_send_signal_for_uid(pkgmgr_installer *pi,
929 uid_t uid, const char *pkg_type, const char *pkgid,
930 const char *key, const char *val)
935 ERR("connection is NULL");
939 if (strcmp(key, PKGMGR_INSTALLER_START_KEY_STR) == 0 &&
940 strcmp(val, PKGMGR_INSTALLER_UPGRADE_EVENT_STR) == 0)
941 pi->request_type = PKGMGR_REQ_UPGRADE;
943 r = __send_signal_for_event_for_uid(pi, uid, pkg_type, pkgid, NULL,
949 API int pkgmgr_installer_set_request_type(pkgmgr_installer *pi, int request_type)
954 pi->request_type = request_type;
958 API int pkgmgr_installer_set_session_id(pkgmgr_installer *pi, const char *session_id)
960 if (pi == NULL || session_id == NULL)
963 pi->session_id = strndup(session_id, MAX_STRLEN);
967 API int pkgmgr_installer_create_certinfo_set_handle(pkgmgr_instcertinfo_h *handle)
970 ret = pkgmgrinfo_create_certinfo_set_handle(handle);
974 API int pkgmgr_installer_set_cert_value(pkgmgr_instcertinfo_h handle, pkgmgr_instcert_type cert_type, char *cert_value)
977 ret = pkgmgrinfo_set_cert_value(handle, cert_type, cert_value);
981 API int pkgmgr_installer_save_certinfo(const char *pkgid, pkgmgr_instcertinfo_h handle, uid_t uid)
984 ret = pkgmgrinfo_save_certinfo(pkgid, handle, uid);
988 API int pkgmgr_installer_destroy_certinfo_set_handle(pkgmgr_instcertinfo_h handle)
991 ret = pkgmgrinfo_destroy_certinfo_set_handle(handle);
995 API int pkgmgr_installer_delete_certinfo(const char *pkgid)
998 ret = pkgmgrinfo_delete_certinfo(pkgid);
1002 API int pkgmgr_installer_set_privilege_level(pkgmgr_privilege_level level)
1004 g_privilege_level = level;
1009 API int pkgmgr_installer_info_get_target_uid(uid_t *uid)
1011 *uid = g_target_uid;
1016 API int pkgmgr_installer_info_get_privilege_level(pkgmgr_privilege_level *level)
1018 *level = g_privilege_level;
1023 API int pkgmgr_installer_info_get_debug_mode(int *debug_mode)
1025 *debug_mode = g_debug_mode;
1029 API int pkgmgr_installer_info_get_skip_optimization(int *skip_optimization)
1031 *skip_optimization = g_skip_optimization;
1035 #define CASE_TO_STR(ERRCODE) case ERRCODE: return ERRCODE##_STR
1036 API const char *pkgmgr_installer_error_to_string(int error_code)
1038 switch (error_code) {
1039 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR);
1040 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_GLOBALSYMLINK_ERROR);
1041 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_GRANT_PERMISSION_ERROR);
1042 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_IMAGE_ERROR);
1043 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_UNZIP_ERROR);
1044 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_SECURITY_ERROR);
1045 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_REGISTER_ERROR);
1046 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_PRIVILEGE_ERROR);
1047 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_PARSE_ERROR);
1048 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_RECOVERY_ERROR);
1049 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_DELTA_ERROR);
1050 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_APP_DIR_ERROR);
1051 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_CONFIG_ERROR);
1052 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_SIGNATURE_ERROR);
1053 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_SIGNATURE_INVALID);
1054 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_CERT_ERROR);
1055 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_MATCH);
1056 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_FOUND);
1057 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_ICON_ERROR);
1058 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_ICON_NOT_FOUND);
1059 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_MANIFEST_ERROR);
1060 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_MANIFEST_NOT_FOUND);
1061 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND);
1062 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_OPERATION_NOT_ALLOWED);
1063 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_OUT_OF_SPACE);
1064 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_INVALID_VALUE);
1065 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_ERROR);
1066 CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_OK);
1068 return PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR_STR;
1072 API int pkgmgr_installer_add_pkg(pkgmgr_installer *pi,
1073 const char *pkgid, const char *pkg_type)
1075 pkg_signal_info *info;
1076 if (!pi || !pkgid || !pkg_type) {
1077 ERR("invalid argument");
1081 info = calloc(1, sizeof(pkg_signal_info));
1083 ERR("out of memory");
1087 info->pkgid = strdup(pkgid);
1088 info->pkg_type = strdup(pkg_type);
1089 if (!info->pkgid || !info->pkg_type) {
1090 ERR("out of memory");
1092 free(info->pkg_type);
1096 g_hash_table_insert(pi->pkg_list, (gpointer)info->pkgid, (gpointer)info);
1101 static void __build_multi_signal(gpointer key, gpointer value,
1104 GVariantBuilder *builder = (GVariantBuilder *)user_data;
1105 pkg_signal_info *info = (pkg_signal_info *)value;
1107 g_variant_builder_add(builder, "(sss)", info->pkgid, "", info->pkg_type);
1110 API int pkgmgr_installer_send_signals(pkgmgr_installer *pi,
1111 const char *key, const char *val)
1114 const char *signal_name;
1116 GVariantBuilder *builder;
1118 if (!pi || !key || !val) {
1119 ERR("invalid argument");
1123 sid = pi->session_id;
1127 signal_name = __get_signal_name(pi, key, "");
1129 ERR("unknown signal type");
1133 builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)"));
1134 g_hash_table_foreach(pi->pkg_list, __build_multi_signal, builder);
1135 if (g_dbus_connection_emit_signal(pi->conn, NULL,
1136 PKGMGR_INSTALLER_DBUS_OBJECT_PATH,
1137 PKGMGR_INSTALLER_DBUS_INTERFACE, signal_name,
1138 g_variant_new("(usa(sss)ss)",
1139 pi->target_uid, sid, builder, key,
1140 val), &err) != TRUE) {
1141 ERR("failed to send dbus signal");
1143 ERR("err: %s", err->message);
1146 g_variant_builder_unref(builder);
1149 g_variant_builder_unref(builder);
1154 API int pkgmgr_installer_send_signals_for_uid(pkgmgr_installer *pi, uid_t uid,
1155 const char *key, const char *val)
1161 GVariantBuilder *builder;
1166 const char *signal_name;
1168 if (!pi || !pi->conn) {
1169 ERR("connection is NULL");
1173 sid = pi->session_id;
1177 data_len = sizeof(size_t) + sizeof(gsize);
1179 /* including null byte */
1180 signal_name = __get_signal_name(pi, key, "");
1182 ERR("unknown signal type");
1185 name_size = strlen(signal_name) + 1;
1186 data_len += name_size;
1188 builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)"));
1189 g_hash_table_foreach(pi->pkg_list, __build_multi_signal, builder);
1191 gv = g_variant_new("(usa(sss)ss)", uid, sid, builder, key, val);
1192 g_variant_builder_unref(builder);
1194 ERR("failed to create GVariant instance");
1198 gv_len = g_variant_get_size(gv);
1199 gv_data = g_malloc(gv_len);
1200 g_variant_store(gv, gv_data);
1201 g_variant_unref(gv);
1204 data = malloc(data_len);
1206 ERR("out of memory");
1211 memcpy(ptr, &name_size, sizeof(size_t));
1212 ptr += sizeof(size_t);
1213 memcpy(ptr, &gv_len, sizeof(gsize));
1214 ptr += sizeof(gsize);
1215 memcpy(ptr, signal_name, name_size);
1217 memcpy(ptr, gv_data, gv_len);
1220 if (__send_signal_to_agent(uid, data, data_len)) {
1221 ERR("failed to send signal to agent");