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_installer_error.h>
25 #include <pkgmgr-info.h>
26 #include <tzplatform_config.h>
28 #include "package_manager.h"
29 #include "package_manager_internal.h"
31 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
32 #define USER_HOME tzplatform_getenv(TZ_USER_HOME)
34 #define PRIV_SHARED_RES "priv_shared_res"
36 typedef struct _request_event_info {
38 package_manager_event_type_e event_type;
39 package_manager_event_state_e event_state;
40 struct _request_event_info *next;
43 struct package_manager_event_info {
45 package_manager_event_type_e event_type;
46 package_manager_event_state_e event_state;
49 struct package_manager_s {
51 pkgmgr_client_type ctype;
54 GHashTable *event_info_table;
55 package_manager_event_cb event_cb;
56 package_manager_res_event_cb res_event_cb;
61 struct package_manager_request_s {
63 pkgmgr_client_type ctype;
67 request_event_info *head;
68 package_manager_request_event_cb event_cb;
69 GHashTable *request_cb_table;
74 struct package_manager_request_cb_info {
76 package_manager_request_event_cb callback;
77 package_manager_request_res_event_cb res_callback;
81 typedef struct package_size_info {
86 long long external_data_size;
87 long long external_cache_size;
88 long long external_app_size;
89 } package_size_info_t;
91 struct package_manager_filter_s {
92 pkgmgrinfo_pkginfo_filter_h pkgmgrinfo_pkginfo_filter;
95 struct package_updateinfo_request_s {
97 pkg_update_info_t *updateinfo_handle;
100 struct package_manager_res_event_info_s {
101 pkgmgr_res_event_info *res_event_info_handle;
104 /* LCOV_EXCL_START */
105 static int package_manager_request_new_id()
107 static int request_handle_id = 0;
108 return request_handle_id++;
112 static int package_manager_new_id()
114 static int manager_handle_id = 0;
115 return manager_handle_id++;
118 /* LCOV_EXCL_START */
119 static void __clean_all_event_info(request_event_info *head)
121 request_event_info *current = head;
122 request_event_info *prev;
129 current = current->next;
135 static int __insert_event_info(package_manager_h manager, const char *pkg_name,
136 package_manager_event_type_e event_type,
137 package_manager_event_state_e event_state)
139 struct package_manager_event_info *info;
141 info = calloc(1, sizeof(struct package_manager_event_info));
144 info->pkg_name = strdup(pkg_name);
145 info->event_type = event_type;
146 info->event_state = event_state;
147 g_hash_table_insert(manager->event_info_table, info->pkg_name, info);
152 static void __free_event_info(gpointer data)
154 struct package_manager_event_info *info =
155 (struct package_manager_event_info *)data;
161 free(info->pkg_name);
164 _LOGD("event_info removed");
167 /* LCOV_EXCL_START */
168 static void __free_request_cb_info(gpointer data)
171 struct package_manager_request_cb_info *cb_info =
172 (struct package_manager_request_cb_info *)data;
174 req_id = cb_info->req_id;
178 _LOGD("request callback info removed, req_id(%d)", req_id);
182 /* LCOV_EXCL_START */
183 static void __initialize_request_cb_table(package_manager_request_h request)
185 request->request_cb_table =
186 g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, __free_request_cb_info);
190 static int __insert_request_cb_info(package_manager_request_h request, int req_id,
191 package_manager_request_event_cb callback, void *user_data)
193 struct package_manager_request_cb_info *cb_info;
195 if (request->request_cb_table == NULL)
198 cb_info = calloc(1, sizeof(struct package_manager_request_cb_info));
201 cb_info->req_id = req_id;
202 cb_info->callback = callback;
203 cb_info->user_data = user_data;
204 _LOGD("insert req_id(%d)", req_id);
205 g_hash_table_insert(request->request_cb_table, GINT_TO_POINTER(cb_info->req_id), cb_info);
210 static int __insert_res_request_cb_info(package_manager_request_h request,
211 int req_id, package_manager_request_res_event_cb callback,
214 struct package_manager_request_cb_info *cb_info;
216 if (request->request_cb_table == NULL)
219 cb_info = calloc(1, sizeof(struct package_manager_request_cb_info));
222 cb_info->req_id = req_id;
223 cb_info->res_callback = callback;
224 cb_info->user_data = user_data;
225 _LOGD("insert req_id(%d)", req_id);
226 g_hash_table_insert(request->request_cb_table, GINT_TO_POINTER(cb_info->req_id), cb_info);
231 /* LCOV_EXCL_START */
232 API int package_manager_request_create(package_manager_request_h *request)
234 struct package_manager_request_s *package_manager_request;
236 if (request == NULL) {
238 package_manager_error
239 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
243 package_manager_request =
244 calloc(1, sizeof(struct package_manager_request_s));
245 if (package_manager_request == NULL) {
247 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
249 "failed to create a package_manager handle");
252 package_manager_request->ctype = PC_REQUEST;
253 package_manager_request->pc = pkgmgr_client_new(PC_REQUEST);
254 if (package_manager_request->pc == NULL) {
255 free(package_manager_request);
257 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
259 "failed to create a package_manager client");
262 package_manager_request->handle_id = package_manager_request_new_id();
264 *request = package_manager_request;
266 return PACKAGE_MANAGER_ERROR_NONE;
270 /* LCOV_EXCL_START */
271 static int package_manager_client_validate_handle(package_manager_request_h
274 if (request == NULL || request->pc == NULL)
275 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
277 return PACKAGE_MANAGER_ERROR_NONE;
281 /* LCOV_EXCL_START */
282 API int package_manager_request_destroy(package_manager_request_h request)
284 if (package_manager_client_validate_handle(request)) {
286 package_manager_error
287 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
291 pkgmgr_client_free(request->pc);
293 free(request->pkg_type);
294 __clean_all_event_info(request->head);
295 if (request->request_cb_table) {
296 g_hash_table_destroy(request->request_cb_table);
297 request->request_cb_table = NULL;
301 return PACKAGE_MANAGER_ERROR_NONE;
305 /* LCOV_EXCL_START */
306 static int __reset_user_request_callback(package_manager_request_h request,
307 package_manager_request_event_cb callback, void *user_data)
309 if (package_manager_client_validate_handle(request))
310 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
312 request->event_cb = callback;
313 request->user_data = user_data;
315 return PACKAGE_MANAGER_ERROR_NONE;
319 /* LCOV_EXCL_START */
320 API int package_manager_request_set_event_cb(package_manager_request_h request,
321 package_manager_request_event_cb
322 callback, void *user_data)
326 if (package_manager_client_validate_handle(request))
327 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
330 ret = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
331 if (ret != PACKAGE_MANAGER_ERROR_NONE)
334 return __reset_user_request_callback(request, callback, user_data);
338 /* LCOV_EXCL_START */
339 API int package_manager_request_unset_event_cb(package_manager_request_h request)
341 if (package_manager_client_validate_handle(request))
342 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
344 request->event_cb = NULL;
345 request->user_data = NULL;
347 return PACKAGE_MANAGER_ERROR_NONE;
351 /* LCOV_EXCL_START */
352 API int package_manager_request_set_type(package_manager_request_h request,
353 const char *pkg_type)
355 if (package_manager_client_validate_handle(request)) {
357 package_manager_error
358 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
362 if (request->pkg_type)
363 free(request->pkg_type);
364 request->pkg_type = strdup(pkg_type);
366 return PACKAGE_MANAGER_ERROR_NONE;
370 /* LCOV_EXCL_START */
371 API int package_manager_request_set_mode(package_manager_request_h request,
372 package_manager_request_mode_e mode)
374 if (package_manager_client_validate_handle(request)) {
376 package_manager_error
377 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
381 /* request mode is not used anymore */
383 return PACKAGE_MANAGER_ERROR_NONE;
387 /* LCOV_EXCL_START */
388 API int package_manager_request_set_tep(package_manager_request_h request,
389 const char *tep_path)
393 if (package_manager_client_validate_handle(request) || tep_path == NULL) {
395 package_manager_error
396 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
400 if (pkgmgr_client_set_tep_path(request->pc, tep_path, true))
401 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
403 return PACKAGE_MANAGER_ERROR_NONE;
407 /* LCOV_EXCL_START */
408 static int package_manager_get_event_type(const char *key,
409 package_manager_event_type_e *
413 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
415 if (strcasecmp(key, PKGMGR_INSTALLER_INSTALL_EVENT_STR) == 0)
416 *event_type = PACKAGE_MANAGER_EVENT_TYPE_INSTALL;
417 else if (strcasecmp(key, PKGMGR_INSTALLER_UNINSTALL_EVENT_STR) == 0)
418 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UNINSTALL;
419 else if (strcasecmp(key, PKGMGR_INSTALLER_UPGRADE_EVENT_STR) == 0)
420 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UPDATE;
421 else if (strcasecmp(key, PKGMGR_INSTALLER_MOVE_EVENT_STR) == 0)
422 *event_type = PACKAGE_MANAGER_EVENT_TYPE_MOVE;
423 else if (strcasecmp(key, PKGMGR_INSTALLER_CLEAR_EVENT_STR) == 0)
424 *event_type = PACKAGE_MANAGER_EVENT_TYPE_CLEAR;
425 else if (strcasecmp(key, PKGMGR_INSTALLER_RES_COPY_EVENT_STR) == 0)
426 *event_type = PACKAGE_MANAGER_EVENT_TYPE_RES_COPY;
427 else if (strcasecmp(key, PKGMGR_INSTALLER_RES_CREATE_DIR_EVENT_STR) == 0)
428 *event_type = PACKAGE_MANAGER_EVENT_TYPE_RES_CREATE_DIR;
429 else if (strcasecmp(key, PKGMGR_INSTALLER_RES_REMOVE_EVENT_STR) == 0)
430 *event_type = PACKAGE_MANAGER_EVENT_TYPE_RES_REMOVE;
431 else if (strcasecmp(key, PKGMGR_INSTALLER_RES_UNINSTALL_EVENT_STR) == 0)
432 *event_type = PACKAGE_MANAGER_EVENT_TYPE_RES_UNINSTALL;
434 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
436 return PACKAGE_MANAGER_ERROR_NONE;
440 /* LCOV_EXCL_START */
441 static package_manager_error_e __convert_to_error(int errcode)
444 case PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR:
445 case PKGMGR_INSTALLER_ERRCODE_GLOBALSYMLINK_ERROR:
446 case PKGMGR_INSTALLER_ERRCODE_GRANT_PERMISSION_ERROR:
447 case PKGMGR_INSTALLER_ERRCODE_IMAGE_ERROR:
448 case PKGMGR_INSTALLER_ERRCODE_PARSE_ERROR:
449 case PKGMGR_INSTALLER_ERRCODE_RECOVERY_ERROR:
450 case PKGMGR_INSTALLER_ERRCODE_DELTA_ERROR:
451 case PKGMGR_INSTALLER_ERRCODE_APP_DIR_ERROR:
452 case PKGMGR_INSTALLER_ERRCODE_CONFIG_ERROR:
453 case PKGMGR_INSTALLER_ERRCODE_ICON_ERROR:
454 case PKGMGR_INSTALLER_ERRCODE_MANIFEST_ERROR:
455 case PKGMGR_INSTALLER_ERRCODE_OUT_OF_SPACE:
456 case PKGMGR_INSTALLER_ERRCODE_ERROR:
457 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
458 case PKGMGR_INSTALLER_ERRCODE_UNZIP_ERROR:
459 case PKGMGR_INSTALLER_ERRCODE_SECURITY_ERROR:
460 case PKGMGR_INSTALLER_ERRCODE_REGISTER_ERROR:
461 case PKGMGR_INSTALLER_ERRCODE_PRIVILEGE_ERROR:
462 case PKGMGR_INSTALLER_ERRCODE_SIGNATURE_ERROR:
463 case PKGMGR_INSTALLER_ERRCODE_SIGNATURE_INVALID:
464 case PKGMGR_INSTALLER_ERRCODE_CERT_ERROR:
465 case PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_MATCH:
466 case PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_FOUND:
467 case PKGMGR_INSTALLER_ERRCODE_ICON_NOT_FOUND:
468 case PKGMGR_INSTALLER_ERRCODE_MANIFEST_NOT_FOUND:
469 return PACKAGE_MANAGER_ERROR_IO_ERROR;
470 case PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND:
471 return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
472 case PKGMGR_INSTALLER_ERRCODE_OPERATION_NOT_ALLOWED:
473 return PACKAGE_MANAGER_ERROR_PERMISSION_DENIED;
474 case PKGMGR_INSTALLER_ERRCODE_INVALID_VALUE:
475 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
476 case PKGMGR_INSTALLER_ERRCODE_OK:
477 return PACKAGE_MANAGER_ERROR_NONE;
479 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
484 /* LCOV_EXCL_START */
485 static package_manager_error_e __convert_str_to_error(const char *val)
487 int errcode = atoi(val);
489 return __convert_to_error(errcode);
493 /* LCOV_EXCL_START */
494 static int __add_event_info(request_event_info **head, int req_id,
495 package_manager_event_type_e event_type,
496 package_manager_event_state_e event_state)
498 request_event_info *evt_info;
499 request_event_info *current;
500 request_event_info *prev;
502 evt_info = (request_event_info *) calloc(1, sizeof(request_event_info));
503 if (evt_info == NULL) {
504 _LOGD("calloc failed");
507 evt_info->req_id = req_id;
508 evt_info->event_type = event_type;
509 evt_info->event_state = event_state;
510 evt_info->next = NULL;
515 current = prev = *head;
518 current = current->next;
521 prev->next = evt_info;
528 static int __find_event_info(request_event_info **head, int req_id,
529 package_manager_event_type_e *event_type,
530 package_manager_event_state_e *event_state)
532 request_event_info *tmp;
537 _LOGE("tmp is NULL");
542 if (tmp->req_id == req_id) {
543 *event_type = tmp->event_type;
544 *event_state = tmp->event_state;
552 /* LCOV_EXCL_START */
553 static int __update_event_info(request_event_info **head, int req_id,
554 package_manager_event_type_e event_type,
555 package_manager_event_state_e event_state)
557 package_manager_event_type_e evt_type;
558 package_manager_event_state_e evt_state;
559 request_event_info *tmp;
561 if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
562 __add_event_info(head, req_id, event_type, event_state);
567 _LOGE("tmp is NULL");
572 if (tmp->req_id == req_id) {
573 tmp->event_type = event_type;
574 tmp->event_state = event_state;
585 /* LCOV_EXCL_START */
586 static int request_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
587 const char *pkg_name, const char *key,
588 const char *val, const void *pmsg, void *data)
591 package_manager_event_type_e event_type = -1;
592 package_manager_event_state_e event_state = -1;
594 package_manager_request_h request = data;
596 if (strcasecmp(key, "start") == 0) {
597 ret = package_manager_get_event_type(val, &event_type);
598 if (ret != PACKAGE_MANAGER_ERROR_NONE)
599 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
601 __add_event_info(&(request->head), req_id, event_type,
602 PACKAGE_MANAGER_EVENT_STATE_STARTED);
604 if (request->event_cb)
605 request->event_cb(req_id, pkg_type, pkg_name,
607 PACKAGE_MANAGER_EVENT_STATE_STARTED,
608 0, PACKAGE_MANAGER_ERROR_NONE, request->user_data);
610 } else if (strcasecmp(key, "install_percent") == 0
611 || strcasecmp(key, "progress_percent") == 0) {
612 if (__find_event_info
613 (&(request->head), req_id, &event_type,
614 &event_state) == 0) {
615 __update_event_info(&(request->head), req_id,
617 PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
618 if (request->event_cb)
619 request->event_cb(req_id, pkg_type, pkg_name,
621 PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
623 PACKAGE_MANAGER_ERROR_NONE,
627 } else if (strcasecmp(key, "error") == 0) {
628 if (__find_event_info
629 (&(request->head), req_id, &event_type,
630 &event_state) == 0) {
631 __update_event_info(&(request->head), req_id,
633 PACKAGE_MANAGER_EVENT_STATE_FAILED);
636 if (request->event_cb)
637 request->event_cb(req_id, pkg_type,
638 pkg_name, event_type,
639 PACKAGE_MANAGER_EVENT_STATE_FAILED,
641 __convert_str_to_error(val),
644 } else if (strcasecmp(key, "end") == 0) {
645 if (__find_event_info
646 (&(request->head), req_id, &event_type,
647 &event_state) == 0) {
648 if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
649 if (request->event_cb)
650 request->event_cb(req_id, pkg_type,
651 pkg_name, event_type,
652 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
654 PACKAGE_MANAGER_ERROR_NONE,
658 if (strcasecmp(key, "ok") != 0)
659 if (request->event_cb)
660 request->event_cb(req_id, pkg_type,
661 pkg_name, event_type,
662 PACKAGE_MANAGER_EVENT_STATE_FAILED,
664 PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
669 return PACKAGE_MANAGER_ERROR_NONE;
673 /* LCOV_EXCL_START */
674 static int internal_request_callback(uid_t target_uid, int req_id, const char *pkg_type,
675 const char *pkg_name, const char *key,
676 const char *val, const void *pmsg, void *data)
679 package_manager_event_type_e event_type = -1;
680 package_manager_event_state_e event_state = -1;
681 struct package_manager_request_cb_info *cb_info;
682 package_manager_request_event_cb event_cb;
683 void *user_data = NULL;
685 _LOGD("request callback called, req_id[%d]", req_id);
687 package_manager_request_h request = data;
689 if (request->request_cb_table)
690 cb_info = g_hash_table_lookup(request->request_cb_table,
691 GINT_TO_POINTER(req_id));
695 if (!cb_info || (cb_info && !cb_info->callback)) {
696 _LOGE("no callback info");
700 if (cb_info->req_id != req_id) {
701 _LOGE("not matched request id");
705 event_cb = cb_info->callback;
706 user_data = cb_info->user_data;
708 if (strcasecmp(key, "start") == 0) {
709 ret = package_manager_get_event_type(val, &event_type);
710 if (ret != PACKAGE_MANAGER_ERROR_NONE)
711 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
713 __add_event_info(&request->head, req_id, event_type,
714 PACKAGE_MANAGER_EVENT_STATE_STARTED);
716 event_cb(req_id, pkg_type, pkg_name,
718 PACKAGE_MANAGER_EVENT_STATE_STARTED,
719 0, PACKAGE_MANAGER_ERROR_NONE, user_data);
720 } else if (strcasecmp(key, "install_percent") == 0) {
721 if (__find_event_info(&request->head, req_id, &event_type,
722 &event_state) == 0) {
723 __update_event_info(&request->head, req_id,
725 PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
726 event_cb(req_id, pkg_type, pkg_name,
728 PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
730 PACKAGE_MANAGER_ERROR_NONE,
733 } else if (strcasecmp(key, "error") == 0) {
734 if (__find_event_info(&request->head, req_id, &event_type,
735 &event_state) == 0) {
736 __update_event_info(&request->head, req_id,
738 PACKAGE_MANAGER_EVENT_STATE_FAILED);
739 event_cb(req_id, pkg_type,
740 pkg_name, event_type,
741 PACKAGE_MANAGER_EVENT_STATE_FAILED,
743 __convert_str_to_error(val),
746 } else if (strcasecmp(key, "end") == 0) {
747 if (__find_event_info(&request->head, req_id, &event_type,
748 &event_state) == 0) {
749 if (request->request_cb_table) {
751 if (request->n_paths < 1) {
752 _LOGD("remove item, req_id(%d)", req_id);
754 request->request_cb_table,
755 GINT_TO_POINTER(req_id));
758 if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
759 if (strcasecmp(val, "ok") == 0) {
760 event_cb(req_id, pkg_type,
761 pkg_name, event_type,
762 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
764 PACKAGE_MANAGER_ERROR_NONE,
767 event_cb(req_id, pkg_type,
768 pkg_name, event_type,
769 PACKAGE_MANAGER_EVENT_STATE_FAILED,
771 PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
776 _LOGE("unexpected end event");
784 /* LCOV_EXCL_START */
785 static void internal_res_request_callback(uid_t target_uid, int req_id,
786 const char *pkgid, const char *request_type, const char *status,
787 pkgmgr_res_event_info *handle, void *data)
790 package_manager_event_type_e event_type = -1;
791 package_manager_event_state_e event_state = -1;
792 struct package_manager_request_cb_info *cb_info;
793 package_manager_request_res_event_cb event_cb;
794 struct package_manager_res_event_info_s event_info;
795 void *user_data = NULL;
797 _LOGD("request callback called, req_id[%d]", req_id);
799 package_manager_request_h request = data;
800 event_info.res_event_info_handle = handle;
802 if (request->request_cb_table)
803 cb_info = g_hash_table_lookup(request->request_cb_table,
804 GINT_TO_POINTER(req_id));
808 if (!cb_info || (cb_info && !cb_info->res_callback)) {
809 _LOGE("no callback info");
813 if (cb_info->req_id != req_id) {
814 _LOGE("not matched request id");
818 event_cb = cb_info->res_callback;
819 user_data = cb_info->user_data;
821 ret = package_manager_get_event_type(request_type, &event_type);
822 if (ret != PACKAGE_MANAGER_ERROR_NONE)
824 if (strcasecmp(status, "start") == 0) {
825 event_state = PACKAGE_MANAGER_EVENT_STATE_STARTED;
826 } else if (strcasecmp(status, "fail") == 0) {
827 event_state = PACKAGE_MANAGER_EVENT_STATE_FAILED;
828 _LOGD("remove item, req_id(%d)", req_id);
829 g_hash_table_remove(request->request_cb_table,
830 GINT_TO_POINTER(req_id));
831 } else if (strcasecmp(status, "ok") == 0) {
832 event_state = PACKAGE_MANAGER_EVENT_STATE_COMPLETED;
833 _LOGD("remove item, req_id(%d)", req_id);
834 g_hash_table_remove(request->request_cb_table,
835 GINT_TO_POINTER(req_id));
837 _LOGE("unexpected event");
841 event_cb(req_id, pkgid, event_type, event_state,
842 &event_info, user_data);
848 /* LCOV_EXCL_START */
849 static int __request_install(package_manager_request_h request,
850 const char *path, pkgmgr_handler event_cb, int *id)
854 if (package_manager_client_validate_handle(request))
855 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
858 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
861 request_id = pkgmgr_client_install(request->pc, request->pkg_type, NULL,
862 path, NULL, request->mode, event_cb ? event_cb : request_event_handler, request);
863 if (request_id < 0) {
864 retval = package_manager_convert_internal_error(request_id);
865 return package_manager_error(retval, __FUNCTION__, NULL);
871 return PACKAGE_MANAGER_ERROR_NONE;
875 /* LCOV_EXCL_START */
876 static int __request_install_packages(package_manager_request_h request,
877 const char **paths, int n_paths, pkgmgr_handler event_cb,
882 if (package_manager_client_validate_handle(request))
883 return package_manager_error(
884 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
887 if (paths == NULL || n_paths < 1)
888 return package_manager_error(
889 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
891 request->n_paths = n_paths;
893 request_id = pkgmgr_client_install_packages(request->pc, paths,
894 n_paths, event_cb ? event_cb : request_event_handler,
896 if (request_id < 0) {
897 retval = package_manager_convert_internal_error(request_id);
898 return package_manager_error(retval, __FUNCTION__, NULL);
904 return PACKAGE_MANAGER_ERROR_NONE;
908 /* LCOV_EXCL_START */
909 static int __request_uninstall(package_manager_request_h request,
910 const char *name, pkgmgr_handler event_cb, int *id)
914 if (package_manager_client_validate_handle(request))
915 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
918 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
921 request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
922 name, request->mode, event_cb ? event_cb : request_event_handler, request);
923 if (request_id < 0) {
924 retval = package_manager_convert_internal_error(request_id);
925 return package_manager_error(retval, __FUNCTION__, NULL);
931 return PACKAGE_MANAGER_ERROR_NONE;
935 /* LCOV_EXCL_START */
936 static int __request_move(package_manager_request_h request,
937 const char *name, package_manager_move_type_e move_type,
938 pkgmgr_handler event_cb, int *id)
942 if (package_manager_client_validate_handle(request))
943 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
946 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
949 request_id = pkgmgr_client_request_service(PM_REQUEST_MOVE, move_type,
950 request->pc, request->pkg_type, name,
951 NULL, event_cb ? event_cb : request_event_handler, request);
952 if (request_id < 0) {
953 retval = package_manager_convert_internal_error(request_id);
954 return package_manager_error(retval, __FUNCTION__, NULL);
959 return PACKAGE_MANAGER_ERROR_NONE;
963 /* LCOV_EXCL_START */
964 static int __request_mount_install(package_manager_request_h request,
965 const char *path, pkgmgr_handler event_cb, int *id)
969 if (package_manager_client_validate_handle(request))
970 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
973 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
976 request_id = pkgmgr_client_mount_install(request->pc, request->pkg_type, NULL,
977 path, NULL, request->mode, event_cb ? event_cb : request_event_handler, request);
978 if (request_id < 0) {
979 retval = package_manager_convert_internal_error(request_id);
980 return package_manager_error(retval, __FUNCTION__, NULL);
986 return PACKAGE_MANAGER_ERROR_NONE;
990 /* LCOV_EXCL_START */
991 static int __request_mount_install_packages(package_manager_request_h request,
992 const char **paths, int n_paths, pkgmgr_handler event_cb,
997 if (package_manager_client_validate_handle(request))
998 return package_manager_error(
999 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
1000 __FUNCTION__, NULL);
1002 if (paths == NULL || n_paths < 1)
1003 return package_manager_error(
1004 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
1005 __FUNCTION__, NULL);
1006 request->n_paths = n_paths;
1008 request_id = pkgmgr_client_mount_install_packages(request->pc, paths,
1009 n_paths, event_cb ? event_cb : request_event_handler,
1011 if (request_id < 0) {
1012 retval = package_manager_convert_internal_error(request_id);
1013 return package_manager_error(retval, __FUNCTION__, NULL);
1019 return PACKAGE_MANAGER_ERROR_NONE;
1021 /* LCOV_EXCL_STOP */
1023 /* LCOV_EXCL_START */
1024 static int __request_res_copy(package_manager_request_h request,
1025 pkgmgr_res_handler event_cb, int *id)
1029 if (package_manager_client_validate_handle(request))
1030 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1033 request_id = pkgmgr_client_res_copy(request->pc, event_cb, request);
1034 if (request_id < 0) {
1035 retval = package_manager_convert_internal_error(request_id);
1036 return package_manager_error(retval, __FUNCTION__, NULL);
1041 return PACKAGE_MANAGER_ERROR_NONE;
1043 /* LCOV_EXCL_STOP */
1045 /* LCOV_EXCL_START */
1046 static int __request_res_create_dir(package_manager_request_h request,
1047 pkgmgr_res_handler event_cb, int *id)
1051 if (package_manager_client_validate_handle(request))
1052 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1055 request_id = pkgmgr_client_res_create_dir(request->pc, event_cb, request);
1056 if (request_id < 0) {
1057 retval = package_manager_convert_internal_error(request_id);
1058 return package_manager_error(retval, __FUNCTION__, NULL);
1064 return PACKAGE_MANAGER_ERROR_NONE;
1066 /* LCOV_EXCL_STOP */
1068 /* LCOV_EXCL_START */
1069 static int __request_res_remove(package_manager_request_h request,
1070 pkgmgr_res_handler event_cb, int *id)
1074 if (package_manager_client_validate_handle(request))
1075 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1078 request_id = pkgmgr_client_res_remove(request->pc, event_cb, request);
1079 if (request_id < 0) {
1080 retval = package_manager_convert_internal_error(request_id);
1081 return package_manager_error(retval, __FUNCTION__, NULL);
1087 return PACKAGE_MANAGER_ERROR_NONE;
1089 /* LCOV_EXCL_STOP */
1091 /* LCOV_EXCL_START */
1092 API int package_manager_request_install(package_manager_request_h request,
1093 const char *path, int *id)
1095 return __request_install(request, path, NULL, id);
1097 /* LCOV_EXCL_STOP */
1099 /* LCOV_EXCL_START */
1100 API int package_manager_request_install_with_cb(package_manager_request_h request,
1101 const char *path, package_manager_request_event_cb callback,
1102 void *user_data, int *id)
1107 if (request->request_cb_table == NULL)
1108 __initialize_request_cb_table(request);
1110 ret = __request_install(request, path, internal_request_callback, &req_id);
1113 ret = __insert_request_cb_info(request, req_id, callback, user_data);
1115 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1116 __FUNCTION__, "failed to create request cb info");
1123 /* LCOV_EXCL_STOP */
1125 /* LCOV_EXCL_START */
1126 API int package_manager_request_install_packages(
1127 package_manager_request_h request, const char **paths,
1128 int paths_count, int *id)
1130 return __request_install_packages(request, paths, paths_count, NULL, id);
1132 /* LCOV_EXCL_STOP */
1134 /* LCOV_EXCL_START */
1135 API int package_manager_request_install_packages_with_cb(
1136 package_manager_request_h request, const char **paths,
1137 int paths_count, package_manager_request_event_cb callback,
1138 void *user_data, int *id)
1143 if (request->request_cb_table == NULL)
1144 __initialize_request_cb_table(request);
1146 ret = __request_install_packages(request, paths, paths_count,
1147 internal_request_callback, &req_id);
1150 ret = __insert_request_cb_info(request, req_id, callback,
1153 return package_manager_error(
1154 PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1156 "failed to create request cb info");
1163 /* LCOV_EXCL_STOP */
1165 /* LCOV_EXCL_START */
1166 API int package_manager_request_uninstall(package_manager_request_h request,
1167 const char *name, int *id)
1169 return __request_uninstall(request, name, NULL, id);
1171 /* LCOV_EXCL_STOP */
1173 /* LCOV_EXCL_START */
1174 API int package_manager_request_uninstall_with_cb(package_manager_request_h request,
1175 const char *name, package_manager_request_event_cb callback,
1176 void *user_data, int *id)
1181 if (request->request_cb_table == NULL)
1182 __initialize_request_cb_table(request);
1184 ret = __request_uninstall(request, name, internal_request_callback, &req_id);
1187 ret = __insert_request_cb_info(request, req_id, callback, user_data);
1189 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1190 __FUNCTION__, "failed to create request cb info");
1197 /* LCOV_EXCL_STOP */
1199 /* LCOV_EXCL_START */
1200 API int package_manager_request_move(package_manager_request_h request,
1201 const char *name, package_manager_move_type_e move_type)
1203 return __request_move(request, name, move_type, NULL, NULL);
1205 /* LCOV_EXCL_STOP */
1207 /* LCOV_EXCL_START */
1208 API int package_manager_request_move_with_cb(package_manager_request_h request,
1209 const char *name, package_manager_move_type_e move_type,
1210 package_manager_request_event_cb callback, void *user_data, int *id)
1215 if (request->request_cb_table == NULL)
1216 __initialize_request_cb_table(request);
1218 ret = __request_move(request, name, move_type, internal_request_callback, &req_id);
1221 ret = __insert_request_cb_info(request, req_id, callback, user_data);
1223 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1224 __FUNCTION__, "failed to create request cb info");
1231 /* LCOV_EXCL_STOP */
1233 /* LCOV_EXCL_START */
1234 API int package_manager_request_mount_install(package_manager_request_h request,
1235 const char *path, int *id)
1237 return __request_mount_install(request, path, NULL, id);
1239 /* LCOV_EXCL_STOP */
1241 /* LCOV_EXCL_START */
1242 API int package_manager_request_mount_install_with_cb(package_manager_request_h request,
1243 const char *path, package_manager_request_event_cb callback,
1244 void *user_data, int *id)
1249 if (request->request_cb_table == NULL)
1250 __initialize_request_cb_table(request);
1252 ret = __request_mount_install(request, path, internal_request_callback, &req_id);
1255 ret = __insert_request_cb_info(request, req_id, callback, user_data);
1257 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1258 __FUNCTION__, "failed to create request cb info");
1265 /* LCOV_EXCL_STOP */
1267 /* LCOV_EXCL_START */
1268 API int package_manager_request_mount_install_packages(
1269 package_manager_request_h request, const char **paths,
1270 int paths_count, int *id)
1272 return __request_mount_install_packages(request, paths, paths_count, NULL,
1275 /* LCOV_EXCL_STOP */
1277 /* LCOV_EXCL_START */
1278 API int package_manager_request_mount_install_packages_with_cb(
1279 package_manager_request_h request, const char **paths,
1280 int paths_count, package_manager_request_event_cb callback,
1281 void *user_data, int *id)
1286 if (request->request_cb_table == NULL)
1287 __initialize_request_cb_table(request);
1289 ret = __request_mount_install_packages(request, paths, paths_count,
1290 internal_request_callback, &req_id);
1293 ret = __insert_request_cb_info(request, req_id, callback,
1296 return package_manager_error(
1297 PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1299 "failed to create request cb info");
1306 /* LCOV_EXCL_STOP */
1308 API int package_manager_create(package_manager_h *manager)
1311 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1312 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1315 struct package_manager_s *package_manager = NULL;
1317 if (manager == NULL) {
1319 package_manager_error
1320 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1324 package_manager = calloc(1, sizeof(struct package_manager_s));
1325 if (package_manager == NULL) {
1326 /* LCOV_EXCL_START */
1328 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1330 "failed to create a package_manager handle");
1331 /* LCOV_EXCL_STOP */
1334 package_manager->ctype = PC_LISTENING;
1335 package_manager->pc = pkgmgr_client_new(PC_LISTENING);
1336 if (package_manager->pc == NULL) {
1337 /* LCOV_EXCL_START */
1338 free(package_manager);
1340 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1342 "failed to create a package_manager client");
1343 /* LCOV_EXCL_STOP */
1346 package_manager->handle_id = package_manager_new_id();
1347 g_mutex_init(&package_manager->mutex);
1349 *manager = package_manager;
1351 return PACKAGE_MANAGER_ERROR_NONE;
1354 static int package_manager_validate_handle(package_manager_h manager)
1356 if (manager == NULL || manager->pc == NULL)
1357 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1359 return PACKAGE_MANAGER_ERROR_NONE;
1362 API int package_manager_destroy(package_manager_h manager)
1364 if (package_manager_validate_handle(manager)) {
1366 package_manager_error
1367 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1371 g_mutex_clear(&manager->mutex);
1372 pkgmgr_client_free(manager->pc);
1373 if (manager->event_info_table)
1374 g_hash_table_destroy(manager->event_info_table);
1377 return PACKAGE_MANAGER_ERROR_NONE;
1380 /* App Event Listening Policy:
1381 * +----------------+------------+---------------+------------------+
1382 * |Listener \ Type |Global Event|My User's Event|Other user's Event|
1383 * +----------------+------------+---------------+------------------+
1384 * |User Process App| Grant | Grant | Deny |
1385 * +----------------+------------+---------------+------------------+
1386 * |Platform module | Grant | Grant | Grant |
1387 * +----------------+------------+---------------+------------------+
1388 * UID assignment policy:
1389 * https://wiki.tizen.org/wiki/Security/User_and_group_ID_assignment_policy
1391 #define REGULAR_USER 5000
1392 /* LCOV_EXCL_START */
1393 static int __validate_event_signal(uid_t target_uid)
1395 uid_t self = getuid();
1397 if (self == target_uid)
1400 if (self < REGULAR_USER)
1405 /* LCOV_EXCL_STOP */
1407 static int internal_callback(uid_t target_uid, int req_id, const char *pkg_type,
1408 const char *pkg_name, const char *key,
1409 const char *val, const void *pmsg, void *data)
1411 struct package_manager_event_info *info = NULL;
1413 package_manager_h manager = data;
1414 uid_t uid = target_uid;
1415 bool invoke_callback = false;
1416 package_manager_event_type_e event_type = -1;
1417 package_manager_event_state_e event_state;
1419 package_manager_error_e error = PACKAGE_MANAGER_ERROR_NONE;
1421 _LOGD("req_id(%d), pkg_name(%s), type(%s), key(%s), val(%s)",
1422 req_id, pkg_name, pkg_type, key, val);
1424 if (target_uid == GLOBAL_USER)
1427 if (__validate_event_signal(uid))
1428 return PACKAGE_MANAGER_ERROR_NONE;
1430 if (manager && manager->event_info_table) {
1431 g_mutex_lock(&manager->mutex);
1432 info = g_hash_table_lookup(manager->event_info_table, pkg_name);
1434 /* LCOV_EXCL_START */
1435 _LOGE("invalid handle");
1436 return PACKAGE_MANAGER_ERROR_NONE;
1437 /* LCOV_EXCL_STOP */
1441 if (strcasecmp(key, "start") != 0) {
1442 /* LCOV_EXCL_START */
1443 _LOGD("unexpected signal or no info(removed)");
1444 g_mutex_unlock(&manager->mutex);
1445 return PACKAGE_MANAGER_ERROR_NONE;
1446 /* LCOV_EXCL_STOP */
1450 if (strcasecmp(key, "start") == 0) {
1451 ret = package_manager_get_event_type(val, &event_type);
1452 if (ret != PACKAGE_MANAGER_ERROR_NONE) {
1453 g_mutex_unlock(&manager->mutex);
1454 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1458 __insert_event_info(manager, pkg_name, event_type,
1459 PACKAGE_MANAGER_EVENT_STATE_STARTED);
1461 event_state = PACKAGE_MANAGER_EVENT_STATE_STARTED;
1463 error = PACKAGE_MANAGER_ERROR_NONE;
1464 invoke_callback = true;
1466 /* LCOV_EXCL_START */
1467 _LOGE("unexpected start event");
1468 /* LCOV_EXCL_STOP */
1470 } else if (strcasecmp(key, "install_percent") == 0
1471 || strcasecmp(key, "progress_percent") == 0) {
1472 info->event_state = PACKAGE_MANAGER_EVENT_STATE_PROCESSING;
1473 event_type = info->event_type;
1474 event_state = info->event_state;
1475 progress = atoi(val);
1476 error = PACKAGE_MANAGER_ERROR_NONE;
1477 invoke_callback = true;
1478 } else if (strcasecmp(key, "error") == 0) {
1479 /* LCOV_EXCL_START */
1480 info->event_state = PACKAGE_MANAGER_EVENT_STATE_FAILED;
1481 event_type = info->event_type;
1482 event_state = info->event_state;
1484 error = __convert_str_to_error(val);
1485 invoke_callback = true;
1486 /* LCOV_EXCL_STOP */
1487 } else if (strcasecmp(key, "end") == 0) {
1488 if (info->event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
1489 if (strcasecmp(val, "ok") == 0) {
1490 event_type = info->event_type;
1492 PACKAGE_MANAGER_EVENT_STATE_COMPLETED;
1494 error = PACKAGE_MANAGER_ERROR_NONE;
1495 invoke_callback = true;
1497 /* LCOV_EXCL_START */
1498 event_type = info->event_type;
1500 PACKAGE_MANAGER_EVENT_STATE_FAILED;
1502 error = PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1503 invoke_callback = true;
1504 /* LCOV_EXCL_STOP */
1507 g_hash_table_remove(manager->event_info_table, info->pkg_name);
1509 g_mutex_unlock(&manager->mutex);
1511 if (invoke_callback && manager->event_cb && getuid() == uid) {
1512 manager->event_cb(pkg_type, pkg_name, event_type, event_state,
1513 progress, error, manager->user_data);
1516 return PACKAGE_MANAGER_ERROR_NONE;
1519 /* LCOV_EXCL_START */
1520 static void internal_res_callback(uid_t target_uid, int req_id,
1521 const char *pkgid, const char *request_type, const char *status,
1522 pkgmgr_res_event_info *handle, void *data)
1525 package_manager_h manager = data;
1526 uid_t uid = target_uid;
1527 package_manager_event_type_e event_type = -1;
1528 package_manager_event_state_e event_state;
1529 struct package_manager_res_event_info_s event_info;
1531 event_info.res_event_info_handle = handle;
1533 _LOGD("req_id(%d), pkg_name(%s), request_type(%s), status(%s)",
1534 req_id, pkgid, request_type, status);
1536 if (target_uid == GLOBAL_USER)
1539 if (__validate_event_signal(uid))
1543 g_mutex_lock(&manager->mutex);
1545 _LOGE("invalid handle");
1548 ret = package_manager_get_event_type(request_type, &event_type);
1549 if (ret != PACKAGE_MANAGER_ERROR_NONE) {
1550 g_mutex_unlock(&manager->mutex);
1554 if (strcasecmp(status, "start") == 0) {
1555 event_state = PACKAGE_MANAGER_EVENT_STATE_STARTED;
1556 } else if (strcasecmp(status, "fail") == 0) {
1557 event_state = PACKAGE_MANAGER_EVENT_STATE_FAILED;
1558 } else if (strcasecmp(status, "ok") == 0) {
1559 event_state = PACKAGE_MANAGER_EVENT_STATE_COMPLETED;
1561 _LOGE("unexpected event");
1562 g_mutex_unlock(&manager->mutex);
1565 g_mutex_unlock(&manager->mutex);
1567 if (manager->res_event_cb && getuid() == uid) {
1568 _LOGE("call callback");
1569 manager->res_event_cb(pkgid, event_type, event_state,
1570 &event_info, manager->user_data);
1572 if (!manager->res_event_cb)
1573 _LOGE("res_event_cb is null");
1574 if (getuid() != uid)
1575 _LOGE("getuid : %d, uid : %d", getuid(), uid);
1580 /* LCOV_EXCL_STOP */
1582 static int __convert_status_type(package_manager_status_type_e status_type)
1586 if (status_type == PACKAGE_MANAGER_STATUS_TYPE_ALL)
1587 return PKGMGR_CLIENT_STATUS_ALL;
1589 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_INSTALL)
1590 type |= PKGMGR_CLIENT_STATUS_INSTALL;
1591 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL)
1592 type |= PKGMGR_CLIENT_STATUS_UNINSTALL;
1593 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_UPGRADE)
1594 type |= PKGMGR_CLIENT_STATUS_UPGRADE;
1595 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_MOVE)
1596 type |= PKGMGR_CLIENT_STATUS_MOVE;
1597 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_CLEAR_DATA)
1598 type |= PKGMGR_CLIENT_STATUS_CLEAR_DATA;
1599 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_INSTALL_PROGRESS)
1600 type |= PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS;
1601 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_GET_SIZE)
1602 type |= PKGMGR_CLIENT_STATUS_GET_SIZE;
1603 /* LCOV_EXCL_START */
1604 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_RES_COPY)
1605 type |= PKGMGR_CLIENT_STATUS_RES_COPY;
1606 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_RES_CREATE_DIR)
1607 type |= PKGMGR_CLIENT_STATUS_RES_CREATE_DIR;
1608 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_RES_REMOVE)
1609 type |= PKGMGR_CLIENT_STATUS_RES_REMOVE;
1610 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_RES_UNINSTALL)
1611 type |= PKGMGR_CLIENT_STATUS_RES_UNINSTALL;
1612 /* LCOV_EXCL_STOP */
1617 API int package_manager_set_event_status(package_manager_h manager, int status_type)
1621 int type_all = PACKAGE_MANAGER_STATUS_TYPE_INSTALL |
1622 PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL |
1623 PACKAGE_MANAGER_STATUS_TYPE_UPGRADE |
1624 PACKAGE_MANAGER_STATUS_TYPE_MOVE |
1625 PACKAGE_MANAGER_STATUS_TYPE_CLEAR_DATA |
1626 PACKAGE_MANAGER_STATUS_TYPE_INSTALL_PROGRESS |
1627 PACKAGE_MANAGER_STATUS_TYPE_GET_SIZE |
1628 PACKAGE_MANAGER_STATUS_TYPE_RES_COPY |
1629 PACKAGE_MANAGER_STATUS_TYPE_RES_CREATE_DIR |
1630 PACKAGE_MANAGER_STATUS_TYPE_RES_REMOVE |
1631 PACKAGE_MANAGER_STATUS_TYPE_RES_UNINSTALL;
1633 if (manager == NULL)
1634 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1636 if (status_type < 0 || status_type > type_all)
1637 /* LCOV_EXCL_START */
1638 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1639 /* LCOV_EXCL_STOP */
1641 type = __convert_status_type(status_type);
1642 retval = pkgmgr_client_set_status_type(manager->pc, type);
1645 /* LCOV_EXCL_START */
1646 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1647 /* LCOV_EXCL_STOP */
1649 return PACKAGE_MANAGER_ERROR_NONE;
1652 API int package_manager_set_event_cb(package_manager_h manager,
1653 package_manager_event_cb callback,
1657 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1658 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1661 if (package_manager_validate_handle(manager)) {
1663 package_manager_error
1664 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1668 manager->event_cb = callback;
1669 manager->user_data = user_data;
1671 retval = pkgmgr_client_remove_listen_status(manager->pc);
1673 /* LCOV_EXCL_START */
1674 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR,
1675 __FUNCTION__, NULL);
1676 /* LCOV_EXCL_STOP */
1679 retval = pkgmgr_client_listen_status(manager->pc,
1680 internal_callback, manager);
1682 /* LCOV_EXCL_START */
1683 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR,
1684 __FUNCTION__, NULL);
1685 /* LCOV_EXCL_STOP */
1688 if (!manager->event_info_table) {
1689 manager->event_info_table =
1690 g_hash_table_new_full(g_str_hash, g_str_equal,
1691 NULL, __free_event_info);
1694 return PACKAGE_MANAGER_ERROR_NONE;
1697 /* LCOV_EXCL_START */
1698 API int package_manager_set_res_event_cb(package_manager_h manager,
1699 package_manager_res_event_cb callback, void *user_data)
1703 if (package_manager_validate_handle(manager)) {
1705 package_manager_error
1706 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1710 manager->res_event_cb = callback;
1711 manager->user_data = user_data;
1713 retval = pkgmgr_client_remove_listen_status(manager->pc);
1715 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR,
1716 __FUNCTION__, NULL);
1719 retval = pkgmgr_client_listen_res_status(manager->pc,
1720 internal_res_callback, manager);
1722 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR,
1723 __FUNCTION__, NULL);
1726 return PACKAGE_MANAGER_ERROR_NONE;
1728 /* LCOV_EXCL_STOP */
1730 API int package_manager_unset_event_cb(package_manager_h manager)
1732 if (manager == NULL) {
1734 package_manager_error
1735 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1740 manager->event_cb = NULL;
1741 manager->res_event_cb = NULL;
1742 manager->user_data = NULL;
1744 g_mutex_lock(&manager->mutex);
1745 g_hash_table_remove_all(manager->event_info_table);
1746 g_mutex_unlock(&manager->mutex);
1748 retval = pkgmgr_client_remove_listen_status(manager->pc);
1749 if (retval == PKGMGR_R_EINVAL)
1750 /* LCOV_EXCL_START */
1752 package_manager_error
1753 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1755 /* LCOV_EXCL_STOP */
1756 else if (retval == PKGMGR_R_ERROR)
1757 /* LCOV_EXCL_START */
1759 package_manager_error
1760 (PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__,
1762 /* LCOV_EXCL_STOP */
1764 return PACKAGE_MANAGER_ERROR_NONE;
1767 API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
1769 pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
1771 char *pkg_id = NULL;
1772 char *pkg_id_dup = NULL;
1774 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1775 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1778 if (app_id == NULL || package_id == NULL)
1779 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1781 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1782 /* LCOV_EXCL_START */
1783 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1784 /* LCOV_EXCL_STOP */
1785 retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1786 if (retval != PMINFO_R_OK) {
1787 /* LCOV_EXCL_START */
1788 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1789 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1790 /* LCOV_EXCL_STOP */
1793 pkg_id_dup = strdup(pkg_id);
1794 if (pkg_id_dup == NULL) {
1795 /* LCOV_EXCL_START */
1796 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1797 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1798 /* LCOV_EXCL_STOP */
1801 *package_id = pkg_id_dup;
1803 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1805 return PACKAGE_MANAGER_ERROR_NONE;
1808 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
1811 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1812 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1815 retval = package_info_get_package_info(package_id, package_info);
1817 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1818 return package_manager_error(retval, __FUNCTION__, NULL);
1820 return PACKAGE_MANAGER_ERROR_NONE;
1823 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
1827 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1828 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1831 retval = package_info_foreach_package_info(callback, user_data);
1833 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1834 return package_manager_error(retval, __FUNCTION__, NULL);
1836 return PACKAGE_MANAGER_ERROR_NONE;
1839 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)
1841 pkgmgrinfo_cert_compare_result_type_e result;
1843 if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
1844 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1845 if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
1846 /* LCOV_EXCL_START */
1847 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1848 /* LCOV_EXCL_STOP */
1849 *compare_result = (package_manager_compare_result_type_e)result;
1851 return PACKAGE_MANAGER_ERROR_NONE;
1854 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)
1856 pkgmgrinfo_cert_compare_result_type_e result;
1858 if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
1859 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1860 if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
1861 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1863 *compare_result = (package_manager_compare_result_type_e)result;
1865 return PACKAGE_MANAGER_ERROR_NONE;
1868 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
1871 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1872 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1875 pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1876 pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
1878 char *pkg_id = NULL;
1879 bool is_preload = 0;
1880 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1881 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1883 retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1884 if (retval != PMINFO_R_OK) {
1885 /* LCOV_EXCL_START */
1886 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1887 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1888 /* LCOV_EXCL_STOP */
1890 if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
1891 /* LCOV_EXCL_START */
1892 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1893 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1894 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1895 /* LCOV_EXCL_STOP */
1897 if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK) {
1898 /* LCOV_EXCL_START */
1899 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1900 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1901 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1902 /* LCOV_EXCL_STOP */
1906 /* LCOV_EXCL_START */
1908 /* LCOV_EXCL_STOP */
1912 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1913 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1915 return PACKAGE_MANAGER_ERROR_NONE;
1918 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1921 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1922 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1925 pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1926 pkgmgrinfo_permission_type permission = 0;
1927 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1928 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1929 retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1930 if (retval != PMINFO_R_OK) {
1931 /* LCOV_EXCL_START */
1932 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1933 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1934 /* LCOV_EXCL_STOP */
1937 if (permission == PMINFO_PERMISSION_NORMAL)
1938 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1939 /* LCOV_EXCL_START */
1940 else if (permission == PMINFO_PERMISSION_SIGNATURE)
1941 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1942 else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1943 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1945 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1946 /* LCOV_EXCL_STOP */
1948 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1949 return PACKAGE_MANAGER_ERROR_NONE;
1952 API int package_manager_clear_cache_dir(const char *package_id)
1956 int res = pkgmgr_client_clear_cache_dir(package_id);
1958 retval = package_manager_convert_internal_error(res);
1959 return package_manager_error(retval, __FUNCTION__, NULL);
1962 return PACKAGE_MANAGER_ERROR_NONE;
1965 /* LCOV_EXCL_START */
1966 API int package_manager_clear_data_dir(const char *package_id)
1969 pkgmgr_client *pc = NULL;
1970 char *pkg_type = NULL;
1971 pkgmgrinfo_pkginfo_h pkginfo = NULL;
1973 if (package_id == NULL)
1974 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1976 retval = pkgmgrinfo_pkginfo_get_pkginfo(package_id, &pkginfo);
1977 if (retval == PMINFO_R_ENOENT)
1978 return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
1979 else if (retval != PMINFO_R_OK || pkginfo == NULL)
1980 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1982 retval = pkgmgrinfo_pkginfo_get_type(pkginfo, &pkg_type);
1983 if (retval != PMINFO_R_OK || pkg_type == NULL) {
1984 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1985 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1988 pc = pkgmgr_client_new(PC_REQUEST);
1990 _LOGE("Out of memory");
1991 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1992 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
1995 retval = pkgmgr_client_clear_user_data(pc, pkg_type, package_id, PM_QUIET);
1996 pkgmgr_client_free(pc);
1997 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2000 retval = package_manager_convert_internal_error(retval);
2001 return package_manager_error(retval, __FUNCTION__, NULL);
2004 return PACKAGE_MANAGER_ERROR_NONE;
2006 /* LCOV_EXCL_STOP */
2008 /* LCOV_EXCL_START */
2009 API int package_manager_clear_user_data_with_path(const char *package_id,
2010 const char *file_path)
2013 pkgmgr_client *pc = NULL;
2014 char *pkg_type = NULL;
2015 pkgmgrinfo_pkginfo_h pkginfo = NULL;
2017 if (package_id == NULL || file_path == NULL)
2018 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
2020 retval = pkgmgrinfo_pkginfo_get_pkginfo(package_id, &pkginfo);
2021 if (retval == PMINFO_R_ENOENT)
2022 return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
2023 if (retval != PMINFO_R_OK || pkginfo == NULL)
2024 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
2026 retval = pkgmgrinfo_pkginfo_get_type(pkginfo, &pkg_type);
2027 if (retval != PMINFO_R_OK || pkg_type == NULL) {
2028 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2029 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
2032 pc = pkgmgr_client_new(PC_REQUEST);
2034 _LOGE("Out of memory");
2035 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2036 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
2039 retval = pkgmgr_client_clear_user_data_with_path(pc, pkg_type,
2040 package_id, file_path, PM_QUIET);
2041 pkgmgr_client_free(pc);
2042 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2045 retval = package_manager_convert_internal_error(retval);
2046 return package_manager_error(retval, __FUNCTION__, NULL);
2049 return PACKAGE_MANAGER_ERROR_NONE;
2051 /* LCOV_EXCL_STOP */
2053 /* LCOV_EXCL_START */
2054 API int package_manager_clear_all_cache_dir(void)
2056 return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
2058 /* LCOV_EXCL_STOP */
2060 struct getsize_cbdata {
2066 static void __free_getsize_cbdata(struct getsize_cbdata *cbdata)
2068 pkgmgr_client_free(cbdata->pc);
2072 static void __copy_size_info(const pkg_size_info_t *src, package_size_info_t *dst)
2074 if (src == NULL || dst == NULL) {
2075 /* LCOV_EXCL_START */
2076 _LOGE("src or dst size info is NULL");
2078 /* LCOV_EXCL_STOP */
2081 dst->data_size = src->data_size;
2082 dst->cache_size = src->cache_size;
2083 dst->app_size = src->app_size;
2084 dst->external_data_size = src->ext_data_size;
2085 dst->external_cache_size = src->ext_cache_size;
2086 dst->external_app_size = src->ext_app_size;
2089 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
2091 struct getsize_cbdata *cbdata = (struct getsize_cbdata *)user_data;
2092 package_manager_size_info_receive_cb callback = cbdata->cb;
2093 if (callback == NULL) {
2094 /* LCOV_EXCL_START */
2095 _LOGE("callback is null.");
2096 __free_getsize_cbdata(cbdata);
2098 /* LCOV_EXCL_STOP */
2101 package_size_info_t size_info;
2102 __copy_size_info(result, &size_info);
2104 callback(pkgid, (package_size_info_h)&size_info, cbdata->user_data);
2106 __free_getsize_cbdata(cbdata);
2109 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
2111 struct getsize_cbdata *cbdata = (struct getsize_cbdata *)user_data;
2112 package_manager_total_size_info_receive_cb callback = cbdata->cb;
2113 if (callback == NULL) {
2114 /* LCOV_EXCL_START */
2115 _LOGE("callback is null.");
2116 __free_getsize_cbdata(cbdata);
2118 /* LCOV_EXCL_STOP */
2121 package_size_info_t size_info;
2122 __copy_size_info(result, &size_info);
2124 callback((package_size_info_h)&size_info, cbdata->user_data);
2126 __free_getsize_cbdata(cbdata);
2129 static int _get_pkg_size_info(const char *package_id, void *callback, void *user_data)
2131 struct getsize_cbdata *cbdata;
2133 if (package_id == NULL || callback == NULL)
2134 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2136 cbdata = malloc(sizeof(struct getsize_cbdata));
2138 /* LCOV_EXCL_START */
2139 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
2140 /* LCOV_EXCL_STOP */
2142 pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
2144 /* LCOV_EXCL_START */
2146 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
2147 /* LCOV_EXCL_STOP */
2151 cbdata->cb = callback;
2152 cbdata->user_data = user_data;
2155 if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
2156 res = pkgmgr_client_get_package_size_info(pc, package_id, __result_cb, cbdata);
2158 res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, cbdata);
2160 if (res != PKGMGR_R_OK) {
2161 /* LCOV_EXCL_START */
2162 __free_getsize_cbdata(cbdata);
2163 res = package_manager_convert_internal_error(res);
2164 return package_manager_error(res, __FUNCTION__, NULL);
2165 /* LCOV_EXCL_STOP */
2168 return PACKAGE_MANAGER_ERROR_NONE;
2171 API int package_manager_get_package_size_info(const char *package_id, package_manager_size_info_receive_cb callback, void *user_data)
2173 return _get_pkg_size_info(package_id, (void *)callback, user_data);
2176 API int package_manager_get_total_package_size_info(package_manager_total_size_info_receive_cb callback, void *user_data)
2178 return _get_pkg_size_info(PKG_SIZE_INFO_TOTAL, (void *)callback, user_data);
2181 API int package_manager_filter_create(package_manager_filter_h *handle)
2184 pkgmgrinfo_pkginfo_filter_h pkgmgr_filter = NULL;
2186 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
2187 if (retval != PACKAGE_MANAGER_ERROR_NONE)
2190 if (handle == NULL) {
2192 package_manager_error
2193 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
2197 retval = pkgmgrinfo_pkginfo_filter_create(&pkgmgr_filter);
2198 if (retval != PACKAGE_MANAGER_ERROR_NONE)
2199 /* LCOV_EXCL_START */
2200 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2201 /* LCOV_EXCL_STOP */
2203 *handle = pkgmgr_filter;
2205 return PACKAGE_MANAGER_ERROR_NONE;
2208 API int package_manager_filter_destroy(package_manager_filter_h handle)
2212 if (handle == NULL) {
2214 package_manager_error
2215 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
2219 retval = pkgmgrinfo_pkginfo_filter_destroy(handle);
2220 if (retval != PACKAGE_MANAGER_ERROR_NONE)
2221 /* LCOV_EXCL_START */
2222 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2223 /* LCOV_EXCL_STOP */
2225 return PACKAGE_MANAGER_ERROR_NONE;
2228 API int package_manager_filter_add_bool(package_manager_filter_h handle,
2229 const char *property, const bool value)
2233 if ((handle == NULL) || (property == NULL)) {
2235 package_manager_error
2236 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
2240 retval = pkgmgrinfo_pkginfo_filter_add_bool(handle, property, value);
2241 if (retval != PACKAGE_MANAGER_ERROR_NONE)
2242 /* LCOV_EXCL_START */
2243 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2244 /* LCOV_EXCL_STOP */
2246 return PACKAGE_MANAGER_ERROR_NONE;
2250 API int package_manager_filter_add_string(package_manager_filter_h handle, const char *property, const char *value)
2254 if ((handle == NULL) || (property == NULL) || (value == NULL)) {
2256 package_manager_error
2257 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
2261 retval = pkgmgrinfo_pkginfo_filter_add_string(handle, property, value);
2262 if (retval != PACKAGE_MANAGER_ERROR_NONE)
2263 /* LCOV_EXCL_START */
2264 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2265 /* LCOV_EXCL_STOP */
2267 return PACKAGE_MANAGER_ERROR_NONE;
2270 API int package_manager_filter_count(package_manager_filter_h handle, int *count)
2273 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
2274 if (retval != PACKAGE_MANAGER_ERROR_NONE)
2277 if ((handle == NULL) || (count == NULL))
2278 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2280 retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
2282 /* LCOV_EXCL_START */
2283 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2284 /* LCOV_EXCL_STOP */
2286 return PACKAGE_MANAGER_ERROR_NONE;
2289 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
2290 package_manager_package_info_cb callback, void *user_data)
2293 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
2294 if (retval != PACKAGE_MANAGER_ERROR_NONE)
2297 retval = package_info_filter_foreach_package_info(handle, callback, user_data);
2299 if (retval != PACKAGE_MANAGER_ERROR_NONE)
2300 return package_manager_error(retval, __FUNCTION__, NULL);
2302 return PACKAGE_MANAGER_ERROR_NONE;
2305 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
2308 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2310 package_size_info_t *size_info = (package_size_info_t *)handle;
2312 *data_size = (long long)size_info->data_size;
2313 return PACKAGE_MANAGER_ERROR_NONE;
2316 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
2319 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2321 package_size_info_t *size_info = (package_size_info_t *)handle;
2323 *cache_size = size_info->cache_size;
2324 return PACKAGE_MANAGER_ERROR_NONE;
2327 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
2330 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2332 package_size_info_t *size_info = (package_size_info_t *)handle;
2333 *app_size = size_info->app_size;
2334 return PACKAGE_MANAGER_ERROR_NONE;
2337 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
2340 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
2342 package_size_info_t *size_info = (package_size_info_t *)handle;
2343 *ext_data_size = size_info->external_data_size;
2344 return PACKAGE_MANAGER_ERROR_NONE;
2347 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_size)
2350 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2352 package_size_info_t *size_info = (package_size_info_t *)handle;
2353 *ext_cache_size = size_info->external_cache_size;
2354 return PACKAGE_MANAGER_ERROR_NONE;
2357 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
2360 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2362 package_size_info_t *size_info = (package_size_info_t *)handle;
2363 *ext_app_size = size_info->external_app_size;
2364 return PACKAGE_MANAGER_ERROR_NONE;
2367 API int package_manager_updateinfo_set_pkgid(package_updateinfo_request_h pkg_updateinfo_req, const char *pkgid)
2369 struct package_updateinfo_request_s *request;
2371 if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL || pkgid == NULL)
2372 /* LCOV_EXCL_START */
2373 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2374 /* LCOV_EXCL_STOP */
2376 request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
2377 if (request->updateinfo_handle->pkgid)
2378 /* LCOV_EXCL_START */
2379 free(request->updateinfo_handle->pkgid);
2380 /* LCOV_EXCL_STOP */
2381 request->updateinfo_handle->pkgid = strdup(pkgid);
2382 if (request->updateinfo_handle->pkgid == NULL)
2383 /* LCOV_EXCL_START */
2384 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
2385 /* LCOV_EXCL_STOP */
2387 return PACKAGE_MANAGER_ERROR_NONE;
2390 API int package_manager_updateinfo_set_version(package_updateinfo_request_h pkg_updateinfo_req, const char *version)
2392 struct package_updateinfo_request_s *request;
2394 if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL || version == NULL)
2395 /* LCOV_EXCL_START */
2396 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2397 /* LCOV_EXCL_STOP */
2399 request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
2400 if (request->updateinfo_handle->version)
2401 /* LCOV_EXCL_START */
2402 free(request->updateinfo_handle->version);
2403 /* LCOV_EXCL_STOP */
2404 request->updateinfo_handle->version = strdup(version);
2405 if (request->updateinfo_handle->version == NULL)
2406 /* LCOV_EXCL_START */
2407 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
2408 /* LCOV_EXCL_STOP */
2410 return PACKAGE_MANAGER_ERROR_NONE;
2413 static int package_manager_updateinfo_convert_property(package_updateinfo_type_e property, pkgmgr_updateinfo_type *converted_property)
2415 if (converted_property == NULL)
2418 if (property == PACKAGE_UPDATEINFO_TYPE_FORCE)
2419 *converted_property = PM_UPDATEINFO_TYPE_FORCE;
2420 else if (property == PACKAGE_UPDATEINFO_TYPE_OPTIONAL)
2421 *converted_property = PM_UPDATEINFO_TYPE_OPTIONAL;
2422 else if (property == PACKAGE_UPDATEINFO_TYPE_NONE)
2423 *converted_property = PM_UPDATEINFO_TYPE_NONE;
2430 API int package_manager_updateinfo_set_type(package_updateinfo_request_h pkg_updateinfo_req, package_updateinfo_type_e type)
2433 pkgmgr_updateinfo_type converted_type;
2434 struct package_updateinfo_request_s *request;
2436 if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL)
2437 /* LCOV_EXCL_START */
2438 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2439 /* LCOV_EXCL_STOP */
2441 request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
2442 retval = package_manager_updateinfo_convert_property(type, &converted_type);
2443 /* LCOV_EXCL_START */
2445 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2446 /* LCOV_EXCL_STOP */
2448 request->updateinfo_handle->type = converted_type;
2449 return PACKAGE_MANAGER_ERROR_NONE;
2452 API int package_manager_updateinfo_request_destroy(package_updateinfo_request_h pkg_updateinfo_req)
2454 struct package_updateinfo_request_s *request;
2456 if (pkg_updateinfo_req == NULL)
2457 /* LCOV_EXCL_START */
2458 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2459 /* LCOV_EXCL_STOP */
2461 request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
2463 pkgmgr_client_free(request->pc);
2465 if (request->updateinfo_handle) {
2466 if (request->updateinfo_handle->pkgid)
2467 free(request->updateinfo_handle->pkgid);
2468 if (request->updateinfo_handle->version)
2469 free(request->updateinfo_handle->version);
2470 free(request->updateinfo_handle);
2474 return PACKAGE_MANAGER_ERROR_NONE;
2477 API int package_manager_updateinfo_request_create(package_updateinfo_request_h *pkg_updateinfo_req)
2479 struct package_updateinfo_request_s *request;
2480 pkg_update_info_t *update_info;
2482 if (pkg_updateinfo_req == NULL)
2483 /* LCOV_EXCL_START */
2484 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2485 /* LCOV_EXCL_STOP */
2487 request = calloc(1, sizeof(struct package_updateinfo_request_s));
2488 if (request == NULL)
2489 /* LCOV_EXCL_START */
2490 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
2491 /* LCOV_EXCL_STOP */
2493 request->pc = pkgmgr_client_new(PC_REQUEST);
2494 if (request->pc == NULL) {
2495 /* LCOV_EXCL_START */
2497 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
2498 /* LCOV_EXCL_STOP */
2501 update_info = calloc(1, sizeof(pkg_update_info_t));
2502 if (update_info == NULL) {
2503 /* LCOV_EXCL_START */
2504 pkgmgr_client_free(request->pc);
2506 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
2507 /* LCOV_EXCL_STOP */
2509 request->updateinfo_handle = update_info;
2511 *pkg_updateinfo_req = request;
2512 return PACKAGE_MANAGER_ERROR_NONE;
2515 /* LCOV_EXCL_START */
2516 API int package_manager_updateinfo_request_register(package_updateinfo_request_h pkg_updateinfo_req)
2518 struct package_updateinfo_request_s *update_info;
2521 if (pkg_updateinfo_req == NULL)
2522 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2523 update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
2525 retval = pkgmgr_client_register_pkg_update_info(update_info->pc, update_info->updateinfo_handle);
2526 if (retval == PKGMGR_R_EINVAL)
2527 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2529 return PACKAGE_MANAGER_ERROR_NONE;
2531 /* LCOV_EXCL_STOP */
2533 /* LCOV_EXCL_START */
2534 API int package_manager_updateinfo_request_unregister(package_updateinfo_request_h pkg_updateinfo_req, const char *pkgid)
2537 struct package_updateinfo_request_s *update_info;
2539 if (pkg_updateinfo_req == NULL || pkgid == NULL)
2540 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2542 update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
2543 retval = pkgmgr_client_unregister_pkg_update_info(update_info->pc, pkgid);
2544 if (retval != PMINFO_R_OK)
2545 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2547 return PACKAGE_MANAGER_ERROR_NONE;
2549 /* LCOV_EXCL_STOP */
2551 /* LCOV_EXCL_START */
2552 API int package_manager_updateinfo_request_unregister_all(package_updateinfo_request_h pkg_updateinfo_req)
2555 struct package_updateinfo_request_s *update_info;
2557 if (pkg_updateinfo_req == NULL)
2558 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2560 update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
2561 retval = pkgmgr_client_unregister_all_pkg_update_info(update_info->pc);
2563 if (retval != PMINFO_R_OK)
2564 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2566 return PACKAGE_MANAGER_ERROR_NONE;
2568 /* LCOV_EXCL_STOP */
2570 /* LCOV_EXCL_START */
2571 API int package_manager_request_add_res_copy_path(
2572 package_manager_request_h request,
2573 const char *src_path, const char *dest_path)
2577 if (package_manager_client_validate_handle(request)
2578 || src_path == NULL || dest_path == NULL) {
2580 package_manager_error
2581 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
2585 if (pkgmgr_client_add_res_copy_path(request->pc, src_path, dest_path))
2586 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
2588 return PACKAGE_MANAGER_ERROR_NONE;
2590 /* LCOV_EXCL_STOP */
2592 /* LCOV_EXCL_START */
2593 API int package_manager_request_res_copy_with_cb(package_manager_request_h request,
2594 package_manager_request_res_event_cb callback,
2595 void *user_data, int *id)
2600 if (package_manager_client_validate_handle(request)
2601 || callback == NULL || id == NULL) {
2602 return package_manager_error(
2603 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2606 if (request->request_cb_table == NULL)
2607 __initialize_request_cb_table(request);
2609 ret = __request_res_copy(request, internal_res_request_callback, &req_id);
2612 ret = __insert_res_request_cb_info(request, req_id,
2613 callback, user_data);
2615 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
2616 __FUNCTION__, "failed to create request cb info");
2623 /* LCOV_EXCL_STOP */
2625 /* LCOV_EXCL_START */
2626 API int package_manager_request_add_res_create_dir_path(
2627 package_manager_request_h request, const char *dir_path)
2631 if (package_manager_client_validate_handle(request)
2632 || dir_path == NULL) {
2634 package_manager_error
2635 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
2639 if (pkgmgr_client_add_res_create_dir_path(request->pc, dir_path))
2640 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
2642 return PACKAGE_MANAGER_ERROR_NONE;
2644 /* LCOV_EXCL_STOP */
2646 /* LCOV_EXCL_START */
2647 API int package_manager_request_res_create_dir_with_cb(
2648 package_manager_request_h request,
2649 package_manager_request_res_event_cb callback,
2650 void *user_data, int *id)
2655 if (package_manager_client_validate_handle(request)
2656 || callback == NULL || id == NULL) {
2657 return package_manager_error(
2658 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2661 if (request->request_cb_table == NULL)
2662 __initialize_request_cb_table(request);
2664 ret = __request_res_create_dir(request, internal_res_request_callback, &req_id);
2667 ret = __insert_res_request_cb_info(request, req_id,
2668 callback, user_data);
2670 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
2671 __FUNCTION__, "failed to create request cb info");
2678 /* LCOV_EXCL_STOP */
2680 /* LCOV_EXCL_START */
2681 API int package_manager_request_add_res_remove_path(
2682 package_manager_request_h request, const char *res_path)
2686 if (package_manager_client_validate_handle(request)
2687 || res_path == NULL) {
2689 package_manager_error
2690 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
2694 if (pkgmgr_client_add_res_remove_path(request->pc, res_path))
2695 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
2697 return PACKAGE_MANAGER_ERROR_NONE;
2699 /* LCOV_EXCL_STOP */
2701 /* LCOV_EXCL_START */
2702 API int package_manager_request_res_remove_with_cb(
2703 package_manager_request_h request,
2704 package_manager_request_res_event_cb callback,
2705 void *user_data, int *id)
2710 if (package_manager_client_validate_handle(request)
2711 || callback == NULL || id == NULL) {
2712 return package_manager_error(
2713 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2716 if (request->request_cb_table == NULL)
2717 __initialize_request_cb_table(request);
2719 ret = __request_res_remove(request, internal_res_request_callback, &req_id);
2722 ret = __insert_res_request_cb_info(request, req_id,
2723 callback, user_data);
2725 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
2726 __FUNCTION__, "failed to create request cb info");
2733 /* LCOV_EXCL_STOP */
2735 /* LCOV_EXCL_START */
2736 API int package_manager_res_event_info_get_error_code(
2737 package_manager_res_event_info_h handle,
2738 package_manager_error_e *error)
2743 ret = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
2744 if (ret != PACKAGE_MANAGER_ERROR_NONE)
2747 if (handle == NULL || error == NULL)
2748 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2750 struct package_manager_res_event_info_s *event_info =
2751 (struct package_manager_res_event_info_s *)handle;
2753 if (event_info->res_event_info_handle == NULL)
2754 return package_manager_error(
2755 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
2756 __FUNCTION__, NULL);
2758 if (pkgmgr_res_event_info_get_error_code(
2759 event_info->res_event_info_handle, &error_code))
2760 return package_manager_error(
2761 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
2762 __FUNCTION__, NULL);
2764 *error = __convert_to_error(error_code);
2766 return PACKAGE_MANAGER_ERROR_NONE;
2768 /* LCOV_EXCL_STOP */
2770 typedef struct _foreach_res_event_path_context_ {
2771 package_manager_res_event_path_cb callback;
2773 } foreach_res_event_path_context_s;
2775 /* LCOV_EXCL_START */
2776 static int package_res_event_info_foreach_path_cb(const char *path,
2777 pkgmgr_res_event_path_state state, void *user_data)
2779 foreach_res_event_path_context_s *foreach_context = user_data;
2780 package_manager_res_event_path_state_e path_state =
2781 PACKAGE_MANAGER_RES_EVENT_PATH_STATE_NONE;
2784 if (foreach_context == NULL) {
2785 package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
2786 __FUNCTION__, NULL);
2790 if (state == PM_RES_EVENT_PATH_STATE_NONE) {
2791 path_state = PACKAGE_MANAGER_RES_EVENT_PATH_STATE_NONE;
2792 } else if (state == PM_RES_EVENT_PATH_STATE_OK) {
2793 path_state = PACKAGE_MANAGER_RES_EVENT_PATH_STATE_OK;
2794 } else if (state == PM_RES_EVENT_PATH_STATE_FAILED) {
2795 path_state = PACKAGE_MANAGER_RES_EVENT_PATH_STATE_FAILED;
2797 package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
2798 __FUNCTION__, NULL);
2802 r = foreach_context->callback(path, path_state,
2803 foreach_context->user_data);
2809 /* LCOV_EXCL_STOP */
2811 /* LCOV_EXCL_START */
2812 API int package_manager_res_event_info_foreach_path(
2813 package_manager_res_event_info_h handle,
2814 package_manager_res_event_path_cb callback, void *user_data)
2817 foreach_res_event_path_context_s foreach_res_event_path_context = {
2818 .callback = callback,
2819 .user_data = user_data,
2822 ret = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
2823 if (ret != PACKAGE_MANAGER_ERROR_NONE)
2826 if (handle == NULL || callback == NULL)
2827 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2829 struct package_manager_res_event_info_s *event_info =
2830 (struct package_manager_res_event_info_s *)handle;
2832 if (event_info->res_event_info_handle == NULL)
2833 return package_manager_error(
2834 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
2835 __FUNCTION__, NULL);
2837 ret = pkgmgr_res_event_info_foreach_path(
2838 event_info->res_event_info_handle,
2839 package_res_event_info_foreach_path_cb,
2840 &foreach_res_event_path_context);
2841 if (ret != PKGMGR_R_OK) {
2842 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
2843 __FUNCTION__, NULL);
2846 return PACKAGE_MANAGER_ERROR_NONE;
2848 /* LCOV_EXCL_STOP */
2850 /* LCOV_EXCL_START */
2851 API int package_manager_get_priv_shared_res_path(const char *package_id, char **path)
2857 ret = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
2858 if (ret != PACKAGE_MANAGER_ERROR_NONE)
2861 if (package_id == NULL || path == NULL)
2862 return package_manager_error(
2863 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
2864 __FUNCTION__, NULL);
2866 snprintf(buf, sizeof(buf), "%s/%s/%s", USER_HOME,
2867 PRIV_SHARED_RES, package_id);
2869 path_dup = strdup(buf);
2870 if (path_dup == NULL)
2871 return package_manager_error(
2872 PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
2873 __FUNCTION__, NULL);
2876 return PACKAGE_MANAGER_ERROR_NONE;
2878 /* LCOV_EXCL_STOP */