2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the License);
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an AS IS BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
22 #include <package-manager.h>
23 #include <pkgmgr_installer.h>
24 #include <pkgmgr-info.h>
25 #include <tzplatform_config.h>
27 #include "package_manager.h"
28 #include "package_manager_internal.h"
30 static GHashTable *__cb_table = NULL;
32 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
33 typedef struct _event_info {
35 package_manager_event_type_e event_type;
36 package_manager_event_state_e event_state;
37 struct _event_info *next;
40 struct package_manager_s {
46 package_manager_event_cb event_cb;
50 struct package_manager_request_s {
57 package_manager_request_event_cb event_cb;
61 typedef struct package_size_info {
66 long long external_data_size;
67 long long external_cache_size;
68 long long external_app_size;
69 } package_size_info_t;
71 struct package_manager_filter_s {
72 pkgmgrinfo_pkginfo_filter_h pkgmgrinfo_pkginfo_filter;
75 static int package_manager_request_new_id()
77 static int request_handle_id = 0;
78 return request_handle_id++;
81 static int package_manager_new_id()
83 static int manager_handle_id = 0;
84 return manager_handle_id++;
87 API int package_manager_request_create(package_manager_request_h *request)
89 struct package_manager_request_s *package_manager_request;
91 if (request == NULL) {
94 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
98 package_manager_request =
99 calloc(1, sizeof(struct package_manager_request_s));
100 if (package_manager_request == NULL) {
102 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
104 "failed to create a package_manager handle");
107 package_manager_request->ctype = PC_REQUEST;
108 package_manager_request->pc = pkgmgr_client_new(PC_REQUEST);
109 if (package_manager_request->pc == NULL) {
110 free(package_manager_request);
112 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
114 "failed to create a package_manager client");
117 package_manager_request->handle_id = package_manager_request_new_id();
119 *request = package_manager_request;
121 return PACKAGE_MANAGER_ERROR_NONE;
124 static int package_manager_client_validate_handle(package_manager_request_h
127 if (request == NULL || request->pc == NULL)
128 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
130 return PACKAGE_MANAGER_ERROR_NONE;
133 API int package_manager_request_destroy(package_manager_request_h request)
135 if (package_manager_client_validate_handle(request)) {
137 package_manager_error
138 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
142 pkgmgr_client_free(request->pc);
144 free(request->pkg_type);
147 return PACKAGE_MANAGER_ERROR_NONE;
150 API int package_manager_request_set_event_cb(package_manager_request_h request,
151 package_manager_request_event_cb
152 callback, void *user_data)
156 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
157 if (retval != PACKAGE_MANAGER_ERROR_NONE)
160 if (package_manager_client_validate_handle(request)) {
162 package_manager_error
163 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
167 request->event_cb = callback;
168 request->user_data = user_data;
170 return PACKAGE_MANAGER_ERROR_NONE;
173 API int package_manager_request_unset_event_cb(package_manager_request_h request)
175 if (package_manager_client_validate_handle(request))
176 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
178 request->event_cb = NULL;
179 request->user_data = NULL;
181 return PACKAGE_MANAGER_ERROR_NONE;
184 API int package_manager_request_set_type(package_manager_request_h request,
185 const char *pkg_type)
187 if (package_manager_client_validate_handle(request)) {
189 package_manager_error
190 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
194 request->pkg_type = strdup(pkg_type);
196 return PACKAGE_MANAGER_ERROR_NONE;
199 API int package_manager_request_set_mode(package_manager_request_h request,
200 package_manager_request_mode_e mode)
202 if (package_manager_client_validate_handle(request)) {
204 package_manager_error
205 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
209 /* request mode is not used anymore */
211 return PACKAGE_MANAGER_ERROR_NONE;
214 API int package_manager_request_set_tep(package_manager_request_h request,
215 const char *tep_path)
219 if (package_manager_client_validate_handle(request) || tep_path == NULL) {
221 package_manager_error
222 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
226 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
227 if (retval != PACKAGE_MANAGER_ERROR_NONE)
230 if (pkgmgr_client_set_tep_path(request->pc, tep_path, true))
231 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
233 return PACKAGE_MANAGER_ERROR_NONE;
236 static int package_manager_get_event_type(const char *key,
237 package_manager_event_type_e *
241 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
243 if (strcasecmp(key, PKGMGR_INSTALLER_INSTALL_EVENT_STR) == 0)
244 *event_type = PACKAGE_MANAGER_EVENT_TYPE_INSTALL;
245 else if (strcasecmp(key, PKGMGR_INSTALLER_UNINSTALL_EVENT_STR) == 0)
246 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UNINSTALL;
247 else if (strcasecmp(key, PKGMGR_INSTALLER_UPGRADE_EVENT_STR) == 0)
248 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UPDATE;
250 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
252 return PACKAGE_MANAGER_ERROR_NONE;
255 static int __add_event_info(event_info **head, int req_id,
256 package_manager_event_type_e event_type,
257 package_manager_event_state_e event_state)
259 event_info *evt_info;
263 evt_info = (event_info *) calloc(1, sizeof(event_info));
264 if (evt_info == NULL) {
265 _LOGD("calloc failed");
268 evt_info->req_id = req_id;
269 evt_info->event_type = event_type;
270 evt_info->next = NULL;
275 current = prev = *head;
278 current = current->next;
281 prev->next = evt_info;
287 static int __find_event_info(event_info **head, int req_id,
288 package_manager_event_type_e *event_type,
289 package_manager_event_state_e *event_state)
296 _LOGE("tmp is NULL");
300 _LOGD("tmp->req_id %d, event_type %d", tmp->req_id, event_type);
303 if (tmp->req_id == req_id) {
304 *event_type = tmp->event_type;
312 static int __update_event_info(event_info **head, int req_id,
313 package_manager_event_type_e event_type,
314 package_manager_event_state_e event_state)
316 package_manager_event_type_e evt_type;
317 package_manager_event_state_e evt_state;
320 if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
321 __add_event_info(head, req_id, event_type, event_state);
326 _LOGE("tmp is NULL");
331 if (tmp->req_id == req_id) {
332 tmp->event_type = event_type;
343 static int __remove_event_info(event_info **head request, int req_id)
354 if (current->next->req_id == req_id) {
356 current->next = current->next->next;
368 static int request_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
369 const char *pkg_name, const char *key,
370 const char *val, const void *pmsg, void *data)
373 package_manager_event_type_e event_type = -1;
374 package_manager_event_state_e event_state = -1;
376 _LOGD("request_event_handler is called");
378 package_manager_request_h request = data;
380 if (strcasecmp(key, "start") == 0) {
381 ret = package_manager_get_event_type(val, &event_type);
382 if (ret != PACKAGE_MANAGER_ERROR_NONE)
383 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
385 __add_event_info(&(request->head), req_id, event_type,
386 PACKAGE_MANAGER_EVENT_STATE_STARTED);
388 if (request->event_cb)
389 request->event_cb(req_id, pkg_type, pkg_name,
391 PACKAGE_MANAGER_EVENT_STATE_STARTED,
392 0, PACKAGE_MANAGER_ERROR_NONE, request->user_data);
394 } else if (strcasecmp(key, "install_percent") == 0
395 || strcasecmp(key, "progress_percent") == 0) {
396 if (__find_event_info
397 (&(request->head), req_id, &event_type,
398 &event_state) == 0) {
399 __update_event_info(&(request->head), req_id,
401 PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
402 if (request->event_cb)
403 request->event_cb(req_id, pkg_type, pkg_name,
405 PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
407 PACKAGE_MANAGER_ERROR_NONE,
411 } else if (strcasecmp(key, "error") == 0) {
412 if (strcasecmp(key, "0") != 0) {
413 if (__find_event_info
414 (&(request->head), req_id, &event_type,
415 &event_state) == 0) {
416 __update_event_info(&(request->head), req_id,
418 PACKAGE_MANAGER_EVENT_STATE_FAILED);
421 if (request->event_cb)
422 request->event_cb(req_id, pkg_type,
423 pkg_name, event_type,
424 PACKAGE_MANAGER_EVENT_STATE_FAILED,
426 PACKAGE_MANAGER_ERROR_NONE,
430 } else if (strcasecmp(key, "end") == 0) {
431 if (__find_event_info
432 (&(request->head), req_id, &event_type,
433 &event_state) == 0) {
434 if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
435 if (request->event_cb)
436 request->event_cb(req_id, pkg_type,
437 pkg_name, event_type,
438 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
440 PACKAGE_MANAGER_ERROR_NONE,
444 if (strcasecmp(key, "ok") != 0)
445 if (request->event_cb)
446 request->event_cb(req_id, pkg_type,
447 pkg_name, event_type,
448 PACKAGE_MANAGER_EVENT_STATE_FAILED,
450 PACKAGE_MANAGER_ERROR_NONE,
455 return PACKAGE_MANAGER_ERROR_NONE;
458 API int package_manager_request_install(package_manager_request_h request,
459 const char *path, int *id)
463 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
464 if (retval != PACKAGE_MANAGER_ERROR_NONE)
467 if (package_manager_client_validate_handle(request))
468 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
471 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
474 request_id = pkgmgr_client_install(request->pc, request->pkg_type, NULL,
475 path, NULL, request->mode, request_event_handler, request);
477 if (request_id == PKGMGR_R_EINVAL)
478 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
479 else if (request_id == PKGMGR_R_ENOPKG)
480 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
481 else if (request_id == PKGMGR_R_ENOMEM)
482 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
483 else if (request_id == PKGMGR_R_EIO)
484 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
485 else if (request_id == PKGMGR_R_EPRIV)
486 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
487 else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
488 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
492 return PACKAGE_MANAGER_ERROR_NONE;
495 API int package_manager_request_uninstall(package_manager_request_h request,
496 const char *name, int *id)
500 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
501 if (retval != PACKAGE_MANAGER_ERROR_NONE)
504 if (package_manager_client_validate_handle(request))
505 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
508 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
511 request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
512 name, request->mode, request_event_handler, request);
514 if (request_id == PKGMGR_R_EINVAL)
515 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
516 else if (request_id == PKGMGR_R_ENOPKG)
517 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
518 else if (request_id == PKGMGR_R_ENOMEM)
519 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
520 else if (request_id == PKGMGR_R_EIO)
521 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
522 else if (request_id == PKGMGR_R_EPRIV)
523 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
524 else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
525 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
529 return PACKAGE_MANAGER_ERROR_NONE;
532 API int package_manager_request_move(package_manager_request_h request,
533 const char *name, package_manager_move_type_e move_type)
537 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
538 if (retval != PACKAGE_MANAGER_ERROR_NONE)
541 if (package_manager_client_validate_handle(request))
542 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
545 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
548 ret = pkgmgr_client_request_service(PM_REQUEST_MOVE, move_type,
549 request->pc, request->pkg_type, name,
550 NULL, request_event_handler, NULL);
552 if (ret == PKGMGR_R_EINVAL)
553 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
554 else if (ret == PKGMGR_R_ENOPKG)
555 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
556 else if (ret == PKGMGR_R_ENOMEM)
557 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
558 else if (ret == PKGMGR_R_EIO)
559 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
560 else if (ret == PKGMGR_R_EPRIV)
561 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
562 else if (ret == PKGMGR_R_ESYSTEM || ret == PKGMGR_R_ECOMM || ret == PKGMGR_R_ERROR)
563 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
565 return PACKAGE_MANAGER_ERROR_NONE;
568 API int package_manager_create(package_manager_h *manager)
572 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
573 if (retval != PACKAGE_MANAGER_ERROR_NONE)
576 struct package_manager_s *package_manager = NULL;
578 if (manager == NULL) {
580 package_manager_error
581 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
585 package_manager = calloc(1, sizeof(struct package_manager_s));
586 if (package_manager == NULL) {
588 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
590 "failed to create a package_manager handle");
593 package_manager->ctype = PC_LISTENING;
594 package_manager->pc = pkgmgr_client_new(PC_LISTENING);
595 if (package_manager->pc == NULL) {
596 free(package_manager);
598 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
600 "failed to create a package_manager client");
603 package_manager->handle_id = package_manager_new_id();
605 *manager = package_manager;
607 return PACKAGE_MANAGER_ERROR_NONE;
610 static int package_manager_validate_handle(package_manager_h manager)
612 if (manager == NULL || manager->pc == NULL)
613 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
615 return PACKAGE_MANAGER_ERROR_NONE;
618 API int package_manager_destroy(package_manager_h manager)
620 if (package_manager_validate_handle(manager)) {
622 package_manager_error
623 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
627 pkgmgr_client_free(manager->pc);
631 return PACKAGE_MANAGER_ERROR_NONE;
634 static int __add_event(event_info **head, int req_id,
635 package_manager_event_type_e event_type,
636 package_manager_event_state_e event_state)
638 event_info *evt_info;
640 evt_info = (event_info *) calloc(1, sizeof(event_info));
641 if (evt_info == NULL) {
642 _LOGD("calloc failed");
645 evt_info->req_id = req_id;
646 evt_info->event_type = event_type;
647 evt_info->next = NULL;
654 static int __find_event(event_info **head, int req_id,
655 package_manager_event_type_e *event_type,
656 package_manager_event_state_e *event_state)
663 _LOGE("tmp is NULL");
667 *event_type = tmp->event_type;
671 static int __update_event(event_info **head, int req_id,
672 package_manager_event_type_e event_type,
673 package_manager_event_state_e event_state)
675 package_manager_event_type_e evt_type;
676 package_manager_event_state_e evt_state;
679 if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
680 __add_event_info(head, req_id, event_type, event_state);
685 _LOGE("tmp is NULL");
689 tmp->event_type = event_type;
696 /* App Event Listening Policy:
697 * +----------------+------------+---------------+------------------+
698 * |Listener \ Type |Global Event|My User's Event|Other user's Event|
699 * +----------------+------------+---------------+------------------+
700 * |User Process App| Grant | Grant | Deny |
701 * +----------------+------------+---------------+------------------+
702 * |Platform module | Grant | Grant | Grant |
703 * +----------------+------------+---------------+------------------+
704 * UID assignment policy:
705 * https://wiki.tizen.org/wiki/Security/User_and_group_ID_assignment_policy
707 #define REGULAR_USER 5000
708 static int __validate_event_signal(uid_t target_uid)
710 uid_t self = getuid();
712 if (self == target_uid)
715 if (self < REGULAR_USER)
721 static int global_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
722 const char *pkg_name, const char *key,
723 const char *val, const void *pmsg, void *data)
726 package_manager_event_type_e event_type = -1;
727 package_manager_event_state_e event_state = -1;
728 uid_t uid = target_uid;
730 _LOGD("global_event_handler is called");
732 package_manager_h manager = data;
734 if (target_uid == GLOBAL_USER)
737 if (__validate_event_signal(uid))
738 return PACKAGE_MANAGER_ERROR_NONE;
740 if (strcasecmp(key, "start") == 0) {
741 ret = package_manager_get_event_type(val, &event_type);
742 if (ret != PACKAGE_MANAGER_ERROR_NONE)
743 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
745 __add_event(&(manager->head), req_id, event_type,
746 PACKAGE_MANAGER_EVENT_STATE_STARTED);
748 if (manager->event_cb && getuid() == uid)
749 manager->event_cb(pkg_type, pkg_name,
751 PACKAGE_MANAGER_EVENT_STATE_STARTED,
752 0, PACKAGE_MANAGER_ERROR_NONE, manager->user_data);
753 } else if (strcasecmp(key, "install_percent") == 0
754 || strcasecmp(key, "progress_percent") == 0) {
756 (&(manager->head), req_id, &event_type,
757 &event_state) == 0) {
758 __update_event(&(manager->head), req_id,
760 PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
761 if (manager->event_cb && getuid() == uid)
762 manager->event_cb(pkg_type, pkg_name,
764 PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
766 PACKAGE_MANAGER_ERROR_NONE,
770 } else if (strcasecmp(key, "error") == 0) {
771 if (strcasecmp(key, "0") != 0) {
773 (&(manager->head), req_id, &event_type,
774 &event_state) == 0) {
775 __update_event(&(manager->head), req_id,
777 PACKAGE_MANAGER_EVENT_STATE_FAILED);
780 if (manager->event_cb && getuid() == uid)
781 manager->event_cb(pkg_type,
782 pkg_name, event_type,
783 PACKAGE_MANAGER_EVENT_STATE_FAILED,
785 PACKAGE_MANAGER_ERROR_NONE,
788 } else if (strcasecmp(key, "end") == 0) {
790 (&(manager->head), req_id, &event_type,
791 &event_state) == 0) {
792 if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
793 if (manager->event_cb && getuid() == uid)
794 manager->event_cb(pkg_type,
795 pkg_name, event_type,
796 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
798 PACKAGE_MANAGER_ERROR_NONE,
802 if (strcasecmp(key, "ok") != 0) {
803 if (manager->event_cb && getuid() == uid)
804 manager->event_cb(pkg_type,
805 pkg_name, event_type,
806 PACKAGE_MANAGER_EVENT_STATE_FAILED,
808 PACKAGE_MANAGER_ERROR_NONE,
814 return PACKAGE_MANAGER_ERROR_NONE;
817 API int package_manager_set_event_status(package_manager_h manager, int status_type)
822 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
824 retval = pkgmgrinfo_client_set_status_type(manager->pc, status_type);
827 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
829 return PACKAGE_MANAGER_ERROR_NONE;
832 API int package_manager_set_event_cb(package_manager_h manager,
833 package_manager_event_cb callback,
838 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
839 if (retval != PACKAGE_MANAGER_ERROR_NONE)
842 if (package_manager_validate_handle(manager)) {
844 package_manager_error
845 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
849 manager->event_cb = callback;
850 manager->user_data = user_data;
852 pkgmgr_client_listen_status(manager->pc, global_event_handler, manager);
854 return PACKAGE_MANAGER_ERROR_NONE;
857 API int package_manager_unset_event_cb(package_manager_h manager)
859 if (manager == NULL) {
861 package_manager_error
862 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
867 manager->event_cb = NULL;
868 manager->user_data = NULL;
870 retval = pkgmgr_client_remove_listen_status(manager->pc);
871 if (retval == PKGMGR_R_EINVAL)
873 package_manager_error
874 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
876 else if (retval == PKGMGR_R_ERROR)
878 package_manager_error
879 (PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__,
882 return PACKAGE_MANAGER_ERROR_NONE;
885 API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
887 pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
890 char *pkg_id_dup = NULL;
892 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
893 if (retval != PACKAGE_MANAGER_ERROR_NONE)
896 if (app_id == NULL || package_id == NULL)
897 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
899 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
900 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
901 retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
902 if (retval != PMINFO_R_OK)
903 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
905 pkg_id_dup = strdup(pkg_id);
906 if (pkg_id_dup == NULL) {
907 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
908 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
911 *package_id = pkg_id_dup;
913 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
915 return PACKAGE_MANAGER_ERROR_NONE;
918 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
921 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
922 if (retval != PACKAGE_MANAGER_ERROR_NONE)
925 retval = package_info_get_package_info(package_id, package_info);
927 if (retval != PACKAGE_MANAGER_ERROR_NONE)
928 return package_manager_error(retval, __FUNCTION__, NULL);
930 return PACKAGE_MANAGER_ERROR_NONE;
933 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
938 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
939 if (retval != PACKAGE_MANAGER_ERROR_NONE)
942 retval = package_info_foreach_package_info(callback, user_data);
944 if (retval != PACKAGE_MANAGER_ERROR_NONE)
945 return package_manager_error(retval, __FUNCTION__, NULL);
947 return PACKAGE_MANAGER_ERROR_NONE;
950 API int package_manager_compare_package_cert_info(const char *lhs_package_id, const char *rhs_package_id, package_manager_compare_result_type_e *compare_result)
952 pkgmgrinfo_cert_compare_result_type_e result;
954 if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
955 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
956 if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
957 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
958 *compare_result = (package_manager_compare_result_type_e)result;
960 return PACKAGE_MANAGER_ERROR_NONE;
963 API int package_manager_compare_app_cert_info(const char *lhs_app_id, const char *rhs_app_id, package_manager_compare_result_type_e *compare_result)
965 pkgmgrinfo_cert_compare_result_type_e result;
967 if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
968 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
969 if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
970 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
972 *compare_result = (package_manager_compare_result_type_e)result;
974 return PACKAGE_MANAGER_ERROR_NONE;
977 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
981 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
982 if (retval != PACKAGE_MANAGER_ERROR_NONE)
985 pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
986 pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
990 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
991 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
993 retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
994 if (retval != PMINFO_R_OK) {
995 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
996 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
998 if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
999 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1000 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1001 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1003 if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK) {
1004 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1005 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1006 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1014 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1015 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1017 return PACKAGE_MANAGER_ERROR_NONE;
1020 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1024 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1025 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1028 pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1029 pkgmgrinfo_permission_type permission = 0;
1030 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1031 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1032 retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1033 if (retval != PMINFO_R_OK)
1034 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1036 if (permission == PMINFO_PERMISSION_NORMAL)
1037 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1038 else if (permission == PMINFO_PERMISSION_SIGNATURE)
1039 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1040 else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1041 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1043 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1045 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1046 return PACKAGE_MANAGER_ERROR_NONE;
1049 API int package_manager_clear_cache_dir(const char *package_id)
1053 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_CACHE);
1054 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1057 int res = pkgmgr_client_clear_cache_dir(package_id);
1058 if (res == PKGMGR_R_EINVAL) {
1059 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1060 } else if (res == PKGMGR_R_ENOPKG) {
1061 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1062 } else if (res == PKGMGR_R_ENOMEM) {
1063 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1064 } else if (res == PKGMGR_R_EIO) {
1065 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1066 } else if (res == PKGMGR_R_EPRIV) {
1067 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1068 } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1069 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1070 } else if (res != PKGMGR_R_OK) {
1071 _LOGE("Unexpected error");
1072 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1075 return PACKAGE_MANAGER_ERROR_NONE;
1078 API int package_manager_clear_all_cache_dir(void)
1082 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1083 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1086 return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
1089 static void __free_client(gpointer data)
1091 pkgmgr_client *pc = (pkgmgr_client *)data;
1092 pkgmgr_client_free(pc);
1095 static void __initialize_cb_table(void)
1097 __cb_table = g_hash_table_new_full(g_int_hash, g_int_equal, __free_client, NULL);
1100 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
1102 package_manager_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1103 if (callback == NULL) {
1104 _LOGE("callback is null.");
1105 g_hash_table_remove(__cb_table, pc);
1109 package_size_info_t size_info;
1110 size_info.data_size = result->data_size;
1111 size_info.cache_size = result->cache_size;
1112 size_info.app_size = result->app_size;
1113 size_info.external_data_size = result->ext_data_size;
1114 size_info.external_cache_size = result->ext_cache_size;
1115 size_info.external_app_size = result->ext_app_size;
1117 callback(pkgid, (package_size_info_h)&size_info, user_data);
1119 g_hash_table_remove(__cb_table, pc);
1122 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
1124 package_manager_total_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1125 if (callback == NULL) {
1126 _LOGE("callback is null.");
1127 g_hash_table_remove(__cb_table, pc);
1131 package_size_info_t size_info;
1132 size_info.data_size = result->data_size;
1133 size_info.cache_size = result->cache_size;
1134 size_info.app_size = result->app_size;
1135 size_info.external_data_size = result->ext_data_size;
1136 size_info.external_cache_size = result->ext_cache_size;
1137 size_info.external_app_size = result->ext_app_size;
1139 callback((package_size_info_h)&size_info, user_data);
1141 g_hash_table_remove(__cb_table, pc);
1144 static int _get_pkg_size_info(const char *package_id, void *callback, void *user_data)
1146 if (package_id == NULL || callback == NULL)
1147 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1149 if (__cb_table == NULL)
1150 __initialize_cb_table();
1152 pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
1154 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1157 if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
1158 res = pkgmgr_client_get_package_size_info(pc, package_id, __result_cb, user_data);
1160 res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, user_data);
1162 if (res == PKGMGR_R_EINVAL) {
1163 pkgmgr_client_free(pc);
1164 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1165 } else if (res == PKGMGR_R_ENOPKG) {
1166 pkgmgr_client_free(pc);
1167 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1168 } else if (res == PKGMGR_R_ENOMEM) {
1169 pkgmgr_client_free(pc);
1170 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1171 } else if (res == PKGMGR_R_EIO) {
1172 pkgmgr_client_free(pc);
1173 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1174 } else if (res == PKGMGR_R_EPRIV) {
1175 pkgmgr_client_free(pc);
1176 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1177 } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1178 pkgmgr_client_free(pc);
1179 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1180 } else if (res != PKGMGR_R_OK) {
1181 _LOGE("Unexpected error");
1182 pkgmgr_client_free(pc);
1183 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1186 g_hash_table_insert(__cb_table, pc, callback);
1188 _LOGD("Successful");
1189 return PACKAGE_MANAGER_ERROR_NONE;
1192 API int package_manager_get_package_size_info(const char *package_id, package_manager_size_info_receive_cb callback, void *user_data)
1194 return _get_pkg_size_info(package_id, (void *)callback, user_data);
1197 API int package_manager_get_total_package_size_info(package_manager_total_size_info_receive_cb callback, void *user_data)
1199 return _get_pkg_size_info(PKG_SIZE_INFO_TOTAL, (void *)callback, user_data);
1202 API int package_manager_filter_create(package_manager_filter_h *handle)
1205 pkgmgrinfo_pkginfo_filter_h pkgmgr_filter = NULL;
1207 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1208 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1211 if (handle == NULL) {
1213 package_manager_error
1214 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1218 retval = pkgmgrinfo_pkginfo_filter_create(&pkgmgr_filter);
1219 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1220 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1222 *handle = pkgmgr_filter;
1224 return PACKAGE_MANAGER_ERROR_NONE;
1227 API int package_manager_filter_destroy(package_manager_filter_h handle)
1231 if (handle == NULL) {
1233 package_manager_error
1234 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1238 retval = pkgmgrinfo_pkginfo_filter_destroy(handle);
1239 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1240 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1242 return PACKAGE_MANAGER_ERROR_NONE;
1245 API int package_manager_filter_add_bool(package_manager_filter_h handle,
1246 const char *property, const bool value)
1250 if ((handle == NULL) || (property == NULL)) {
1252 package_manager_error
1253 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1257 retval = pkgmgrinfo_pkginfo_filter_add_bool(handle, property, value);
1258 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1259 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1261 return PACKAGE_MANAGER_ERROR_NONE;
1264 API int package_manager_filter_count(package_manager_filter_h handle, int *count)
1268 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1269 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1272 if ((handle == NULL) || (count == NULL))
1273 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1275 retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
1277 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1279 return PACKAGE_MANAGER_ERROR_NONE;
1282 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
1283 package_manager_package_info_cb callback, void *user_data)
1287 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1288 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1291 retval = package_info_filter_foreach_package_info(handle, callback, user_data);
1293 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1294 return package_manager_error(retval, __FUNCTION__, NULL);
1296 return PACKAGE_MANAGER_ERROR_NONE;
1299 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
1302 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1304 package_size_info_t *size_info = (package_size_info_t *)handle;
1306 *data_size = (long long)size_info->data_size;
1307 return PACKAGE_MANAGER_ERROR_NONE;
1310 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
1313 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1315 package_size_info_t *size_info = (package_size_info_t *)handle;
1317 *cache_size = size_info->cache_size;
1318 return PACKAGE_MANAGER_ERROR_NONE;
1321 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
1324 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1326 package_size_info_t *size_info = (package_size_info_t *)handle;
1327 *app_size = size_info->app_size;
1328 return PACKAGE_MANAGER_ERROR_NONE;
1331 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
1334 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1336 package_size_info_t *size_info = (package_size_info_t *)handle;
1337 *ext_data_size = size_info->external_data_size;
1338 return PACKAGE_MANAGER_ERROR_NONE;
1341 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_size)
1344 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1346 package_size_info_t *size_info = (package_size_info_t *)handle;
1347 *ext_cache_size = size_info->external_cache_size;
1348 return PACKAGE_MANAGER_ERROR_NONE;
1351 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
1354 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1356 package_size_info_t *size_info = (package_size_info_t *)handle;
1357 *ext_app_size = size_info->external_app_size;
1358 return PACKAGE_MANAGER_ERROR_NONE;