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 _request_event_info {
35 package_manager_event_type_e event_type;
36 package_manager_event_state_e event_state;
37 struct _request_event_info *next;
40 struct package_manager_event_info {
42 package_manager_event_type_e event_type;
43 package_manager_event_state_e event_state;
46 struct package_manager_s {
48 pkgmgr_client_type ctype;
51 GHashTable *event_info_table;
52 package_manager_event_cb event_cb;
56 struct package_manager_request_s {
58 pkgmgr_client_type ctype;
62 request_event_info *head;
63 package_manager_request_event_cb event_cb;
64 GHashTable *request_cb_table;
68 struct package_manager_request_cb_info {
70 package_manager_request_event_cb callback;
74 typedef struct package_size_info {
79 long long external_data_size;
80 long long external_cache_size;
81 long long external_app_size;
82 } package_size_info_t;
84 struct package_manager_filter_s {
85 pkgmgrinfo_pkginfo_filter_h pkgmgrinfo_pkginfo_filter;
88 struct package_updateinfo_request_s {
90 pkg_update_info_t *updateinfo_handle;
93 static int package_manager_request_new_id()
95 static int request_handle_id = 0;
96 return request_handle_id++;
99 static int package_manager_new_id()
101 static int manager_handle_id = 0;
102 return manager_handle_id++;
105 static void __clean_all_event_info(request_event_info *head)
107 request_event_info *current = head;
108 request_event_info *prev;
115 current = current->next;
120 static int __insert_event_info(package_manager_h manager, const char *pkg_name,
121 package_manager_event_type_e event_type,
122 package_manager_event_state_e event_state)
124 struct package_manager_event_info *info;
126 info = calloc(1, sizeof(struct package_manager_event_info));
129 info->pkg_name = strdup(pkg_name);
130 info->event_type = event_type;
131 info->event_state = event_state;
132 g_hash_table_insert(manager->event_info_table, info->pkg_name, info);
137 static void __free_event_info(gpointer data)
139 struct package_manager_event_info *info =
140 (struct package_manager_event_info *)data;
146 free(info->pkg_name);
149 _LOGD("event_info removed");
152 static void __free_request_cb_info(gpointer data)
155 struct package_manager_request_cb_info *cb_info =
156 (struct package_manager_request_cb_info *)data;
158 req_id = cb_info->req_id;
162 _LOGD("request callback info removed, req_id(%d)", req_id);
165 static void __initialize_request_cb_table(package_manager_request_h request)
167 request->request_cb_table =
168 g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, __free_request_cb_info);
171 static int __insert_request_cb_info(package_manager_request_h request, int req_id,
172 package_manager_request_event_cb callback, void *user_data)
174 struct package_manager_request_cb_info *cb_info;
176 if (request->request_cb_table == NULL)
179 cb_info = calloc(1, sizeof(struct package_manager_request_cb_info));
182 cb_info->req_id = req_id;
183 cb_info->callback = callback;
184 cb_info->user_data = user_data;
185 _LOGD("insert req_id(%d)", req_id);
186 g_hash_table_insert(request->request_cb_table, GINT_TO_POINTER(cb_info->req_id), cb_info);
191 API int package_manager_request_create(package_manager_request_h *request)
193 struct package_manager_request_s *package_manager_request;
195 if (request == NULL) {
197 package_manager_error
198 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
202 package_manager_request =
203 calloc(1, sizeof(struct package_manager_request_s));
204 if (package_manager_request == NULL) {
206 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
208 "failed to create a package_manager handle");
211 package_manager_request->ctype = PC_REQUEST;
212 package_manager_request->pc = pkgmgr_client_new(PC_REQUEST);
213 if (package_manager_request->pc == NULL) {
214 free(package_manager_request);
216 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
218 "failed to create a package_manager client");
221 package_manager_request->handle_id = package_manager_request_new_id();
223 *request = package_manager_request;
225 return PACKAGE_MANAGER_ERROR_NONE;
228 static int package_manager_client_validate_handle(package_manager_request_h
231 if (request == NULL || request->pc == NULL)
232 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
234 return PACKAGE_MANAGER_ERROR_NONE;
237 API int package_manager_request_destroy(package_manager_request_h request)
239 if (package_manager_client_validate_handle(request)) {
241 package_manager_error
242 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
246 pkgmgr_client_free(request->pc);
248 free(request->pkg_type);
249 __clean_all_event_info(request->head);
250 if (request->request_cb_table) {
251 g_hash_table_destroy(request->request_cb_table);
252 request->request_cb_table = NULL;
256 return PACKAGE_MANAGER_ERROR_NONE;
259 static int __reset_user_request_callback(package_manager_request_h request,
260 package_manager_request_event_cb callback, void *user_data)
262 if (package_manager_client_validate_handle(request))
263 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
265 request->event_cb = callback;
266 request->user_data = user_data;
268 return PACKAGE_MANAGER_ERROR_NONE;
271 API int package_manager_request_set_event_cb(package_manager_request_h request,
272 package_manager_request_event_cb
273 callback, void *user_data)
277 ret = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
278 if (ret != PACKAGE_MANAGER_ERROR_NONE)
281 return __reset_user_request_callback(request, callback, user_data);
284 API int package_manager_request_unset_event_cb(package_manager_request_h request)
286 if (package_manager_client_validate_handle(request))
287 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
289 request->event_cb = NULL;
290 request->user_data = NULL;
292 return PACKAGE_MANAGER_ERROR_NONE;
295 API int package_manager_request_set_type(package_manager_request_h request,
296 const char *pkg_type)
298 if (package_manager_client_validate_handle(request)) {
300 package_manager_error
301 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
305 request->pkg_type = strdup(pkg_type);
307 return PACKAGE_MANAGER_ERROR_NONE;
310 API int package_manager_request_set_mode(package_manager_request_h request,
311 package_manager_request_mode_e mode)
313 if (package_manager_client_validate_handle(request)) {
315 package_manager_error
316 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
320 /* request mode is not used anymore */
322 return PACKAGE_MANAGER_ERROR_NONE;
325 API int package_manager_request_set_tep(package_manager_request_h request,
326 const char *tep_path)
330 if (package_manager_client_validate_handle(request) || tep_path == NULL) {
332 package_manager_error
333 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
337 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
338 if (retval != PACKAGE_MANAGER_ERROR_NONE)
341 if (pkgmgr_client_set_tep_path(request->pc, tep_path, true))
342 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
344 return PACKAGE_MANAGER_ERROR_NONE;
347 static int package_manager_get_event_type(const char *key,
348 package_manager_event_type_e *
352 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
354 if (strcasecmp(key, PKGMGR_INSTALLER_INSTALL_EVENT_STR) == 0)
355 *event_type = PACKAGE_MANAGER_EVENT_TYPE_INSTALL;
356 else if (strcasecmp(key, PKGMGR_INSTALLER_UNINSTALL_EVENT_STR) == 0)
357 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UNINSTALL;
358 else if (strcasecmp(key, PKGMGR_INSTALLER_UPGRADE_EVENT_STR) == 0)
359 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UPDATE;
360 else if (strcasecmp(key, PKGMGR_INSTALLER_MOVE_EVENT_STR) == 0)
361 *event_type = PACKAGE_MANAGER_EVENT_TYPE_MOVE;
362 else if (strcasecmp(key, PKGMGR_INSTALLER_CLEAR_EVENT_STR) == 0)
363 *event_type = PACKAGE_MANAGER_EVENT_TYPE_CLEAR;
365 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
367 return PACKAGE_MANAGER_ERROR_NONE;
370 static int __add_event_info(request_event_info **head, int req_id,
371 package_manager_event_type_e event_type,
372 package_manager_event_state_e event_state)
374 request_event_info *evt_info;
375 request_event_info *current;
376 request_event_info *prev;
378 evt_info = (request_event_info *) calloc(1, sizeof(request_event_info));
379 if (evt_info == NULL) {
380 _LOGD("calloc failed");
383 evt_info->req_id = req_id;
384 evt_info->event_type = event_type;
385 evt_info->event_state = event_state;
386 evt_info->next = NULL;
391 current = prev = *head;
394 current = current->next;
397 prev->next = evt_info;
403 static int __find_event_info(request_event_info **head, int req_id,
404 package_manager_event_type_e *event_type,
405 package_manager_event_state_e *event_state)
407 request_event_info *tmp;
412 _LOGE("tmp is NULL");
417 if (tmp->req_id == req_id) {
418 *event_type = tmp->event_type;
419 *event_state = tmp->event_state;
427 static int __update_event_info(request_event_info **head, int req_id,
428 package_manager_event_type_e event_type,
429 package_manager_event_state_e event_state)
431 package_manager_event_type_e evt_type;
432 package_manager_event_state_e evt_state;
433 request_event_info *tmp;
435 if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
436 __add_event_info(head, req_id, event_type, event_state);
441 _LOGE("tmp is NULL");
446 if (tmp->req_id == req_id) {
447 tmp->event_type = event_type;
448 tmp->event_state = event_state;
458 static int request_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
459 const char *pkg_name, const char *key,
460 const char *val, const void *pmsg, void *data)
463 package_manager_event_type_e event_type = -1;
464 package_manager_event_state_e event_state = -1;
466 package_manager_request_h request = data;
468 if (strcasecmp(key, "start") == 0) {
469 ret = package_manager_get_event_type(val, &event_type);
470 if (ret != PACKAGE_MANAGER_ERROR_NONE)
471 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
473 __add_event_info(&(request->head), req_id, event_type,
474 PACKAGE_MANAGER_EVENT_STATE_STARTED);
476 if (request->event_cb)
477 request->event_cb(req_id, pkg_type, pkg_name,
479 PACKAGE_MANAGER_EVENT_STATE_STARTED,
480 0, PACKAGE_MANAGER_ERROR_NONE, request->user_data);
482 } else if (strcasecmp(key, "install_percent") == 0
483 || strcasecmp(key, "progress_percent") == 0) {
484 if (__find_event_info
485 (&(request->head), req_id, &event_type,
486 &event_state) == 0) {
487 __update_event_info(&(request->head), req_id,
489 PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
490 if (request->event_cb)
491 request->event_cb(req_id, pkg_type, pkg_name,
493 PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
495 PACKAGE_MANAGER_ERROR_NONE,
499 } else if (strcasecmp(key, "error") == 0) {
500 if (__find_event_info
501 (&(request->head), req_id, &event_type,
502 &event_state) == 0) {
503 __update_event_info(&(request->head), req_id,
505 PACKAGE_MANAGER_EVENT_STATE_FAILED);
508 if (request->event_cb)
509 request->event_cb(req_id, pkg_type,
510 pkg_name, event_type,
511 PACKAGE_MANAGER_EVENT_STATE_FAILED,
513 PACKAGE_MANAGER_ERROR_NONE,
516 } else if (strcasecmp(key, "end") == 0) {
517 if (__find_event_info
518 (&(request->head), req_id, &event_type,
519 &event_state) == 0) {
520 if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
521 if (request->event_cb)
522 request->event_cb(req_id, pkg_type,
523 pkg_name, event_type,
524 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
526 PACKAGE_MANAGER_ERROR_NONE,
530 if (strcasecmp(key, "ok") != 0)
531 if (request->event_cb)
532 request->event_cb(req_id, pkg_type,
533 pkg_name, event_type,
534 PACKAGE_MANAGER_EVENT_STATE_FAILED,
536 PACKAGE_MANAGER_ERROR_NONE,
541 return PACKAGE_MANAGER_ERROR_NONE;
544 static int internal_request_callback(uid_t target_uid, int req_id, const char *pkg_type,
545 const char *pkg_name, const char *key,
546 const char *val, const void *pmsg, void *data)
549 package_manager_event_type_e event_type = -1;
550 package_manager_event_state_e event_state = -1;
551 struct package_manager_request_cb_info *cb_info;
552 package_manager_request_event_cb event_cb;
553 void *user_data = NULL;
555 _LOGD("request callback called, req_id[%d]", req_id);
557 package_manager_request_h request = data;
559 if (request->request_cb_table)
560 cb_info = g_hash_table_lookup(request->request_cb_table,
561 GINT_TO_POINTER(req_id));
565 if (!cb_info || (cb_info && !cb_info->callback)) {
566 _LOGE("no callback info");
570 if (cb_info->req_id != req_id) {
571 _LOGE("not matched request id");
575 event_cb = cb_info->callback;
576 user_data = cb_info->user_data;
578 if (strcasecmp(key, "start") == 0) {
579 ret = package_manager_get_event_type(val, &event_type);
580 if (ret != PACKAGE_MANAGER_ERROR_NONE)
581 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
583 __add_event_info(&request->head, req_id, event_type,
584 PACKAGE_MANAGER_EVENT_STATE_STARTED);
586 event_cb(req_id, pkg_type, pkg_name,
588 PACKAGE_MANAGER_EVENT_STATE_STARTED,
589 0, PACKAGE_MANAGER_ERROR_NONE, user_data);
590 } else if (strcasecmp(key, "install_percent") == 0) {
591 if (__find_event_info(&request->head, req_id, &event_type,
592 &event_state) == 0) {
593 __update_event_info(&request->head, req_id,
595 PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
596 event_cb(req_id, pkg_type, pkg_name,
598 PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
600 PACKAGE_MANAGER_ERROR_NONE,
603 } else if (strcasecmp(key, "error") == 0) {
604 if (__find_event_info(&request->head, req_id, &event_type,
605 &event_state) == 0) {
606 __update_event_info(&request->head, req_id,
608 PACKAGE_MANAGER_EVENT_STATE_FAILED);
609 event_cb(req_id, pkg_type,
610 pkg_name, event_type,
611 PACKAGE_MANAGER_EVENT_STATE_FAILED,
613 PACKAGE_MANAGER_ERROR_NONE,
616 } else if (strcasecmp(key, "end") == 0) {
617 if (__find_event_info(&request->head, req_id, &event_type,
618 &event_state) == 0) {
619 if (request->request_cb_table) {
620 _LOGD("remove item, req_id(%d)", req_id);
621 g_hash_table_remove(request->request_cb_table,
622 GINT_TO_POINTER(req_id));
624 if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
625 if (strcasecmp(val, "ok") == 0) {
626 event_cb(req_id, pkg_type,
627 pkg_name, event_type,
628 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
630 PACKAGE_MANAGER_ERROR_NONE,
633 event_cb(req_id, pkg_type,
634 pkg_name, event_type,
635 PACKAGE_MANAGER_EVENT_STATE_FAILED,
637 PACKAGE_MANAGER_ERROR_NONE,
642 _LOGE("unexpected end event");
649 static int __request_install(package_manager_request_h request,
650 const char *path, pkgmgr_handler event_cb, int *id)
653 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
654 if (retval != PACKAGE_MANAGER_ERROR_NONE)
657 if (package_manager_client_validate_handle(request))
658 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
661 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
664 request_id = pkgmgr_client_install(request->pc, request->pkg_type, NULL,
665 path, NULL, request->mode, event_cb ? event_cb : request_event_handler, request);
667 if (request_id == PKGMGR_R_EINVAL)
668 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
669 else if (request_id == PKGMGR_R_ENOPKG)
670 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
671 else if (request_id == PKGMGR_R_ENOMEM)
672 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
673 else if (request_id == PKGMGR_R_EIO)
674 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
675 else if (request_id == PKGMGR_R_EPRIV)
676 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
677 else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
678 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
683 return PACKAGE_MANAGER_ERROR_NONE;
686 static int __request_uninstall(package_manager_request_h request,
687 const char *name, pkgmgr_handler event_cb, int *id)
690 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
691 if (retval != PACKAGE_MANAGER_ERROR_NONE)
694 if (package_manager_client_validate_handle(request))
695 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
698 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
701 request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
702 name, request->mode, event_cb ? event_cb : request_event_handler, request);
704 if (request_id == PKGMGR_R_EINVAL)
705 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
706 else if (request_id == PKGMGR_R_ENOPKG)
707 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
708 else if (request_id == PKGMGR_R_ENOMEM)
709 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
710 else if (request_id == PKGMGR_R_EIO)
711 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
712 else if (request_id == PKGMGR_R_EPRIV)
713 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
714 else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
715 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
720 return PACKAGE_MANAGER_ERROR_NONE;
723 static int __request_move(package_manager_request_h request,
724 const char *name, package_manager_move_type_e move_type,
725 pkgmgr_handler event_cb, int *id)
728 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
729 if (retval != PACKAGE_MANAGER_ERROR_NONE)
732 if (package_manager_client_validate_handle(request))
733 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
736 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
739 request_id = pkgmgr_client_request_service(PM_REQUEST_MOVE, move_type,
740 request->pc, request->pkg_type, name,
741 NULL, event_cb ? event_cb : request_event_handler, request);
743 if (request_id == PKGMGR_R_EINVAL)
744 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
745 else if (request_id == PKGMGR_R_ENOPKG)
746 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
747 else if (request_id == PKGMGR_R_ENOMEM)
748 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
749 else if (request_id == PKGMGR_R_EIO)
750 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
751 else if (request_id == PKGMGR_R_EPRIV)
752 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
753 else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
754 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
759 return PACKAGE_MANAGER_ERROR_NONE;
762 static int __request_mount_install(package_manager_request_h request,
763 const char *path, pkgmgr_handler event_cb, int *id)
766 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
767 if (retval != PACKAGE_MANAGER_ERROR_NONE)
770 if (package_manager_client_validate_handle(request))
771 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
774 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
777 request_id = pkgmgr_client_mount_install(request->pc, request->pkg_type, NULL,
778 path, NULL, request->mode, event_cb ? event_cb : request_event_handler, request);
780 if (request_id == PKGMGR_R_EINVAL)
781 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
782 else if (request_id == PKGMGR_R_ENOPKG)
783 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
784 else if (request_id == PKGMGR_R_ENOMEM)
785 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
786 else if (request_id == PKGMGR_R_EIO)
787 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
788 else if (request_id == PKGMGR_R_EPRIV)
789 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
790 else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
791 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
796 return PACKAGE_MANAGER_ERROR_NONE;
800 API int package_manager_request_install(package_manager_request_h request,
801 const char *path, int *id)
803 return __request_install(request, path, NULL, id);
806 API int package_manager_request_install_with_cb(package_manager_request_h request,
807 const char *path, package_manager_request_event_cb callback,
808 void *user_data, int *id)
813 if (request->request_cb_table == NULL)
814 __initialize_request_cb_table(request);
816 ret = __request_install(request, path, internal_request_callback, &req_id);
819 ret = __insert_request_cb_info(request, req_id, callback, user_data);
821 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
822 __FUNCTION__, "failed to create request cb info");
830 API int package_manager_request_uninstall(package_manager_request_h request,
831 const char *name, int *id)
833 return __request_uninstall(request, name, NULL, id);
836 API int package_manager_request_uninstall_with_cb(package_manager_request_h request,
837 const char *name, package_manager_request_event_cb callback,
838 void *user_data, int *id)
843 if (request->request_cb_table == NULL)
844 __initialize_request_cb_table(request);
846 ret = __request_uninstall(request, name, internal_request_callback, &req_id);
849 ret = __insert_request_cb_info(request, req_id, callback, user_data);
851 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
852 __FUNCTION__, "failed to create request cb info");
860 API int package_manager_request_move(package_manager_request_h request,
861 const char *name, package_manager_move_type_e move_type)
863 return __request_move(request, name, move_type, NULL, NULL);
866 API int package_manager_request_move_with_cb(package_manager_request_h request,
867 const char *name, package_manager_move_type_e move_type,
868 package_manager_request_event_cb callback, void *user_data, int *id)
873 if (request->request_cb_table == NULL)
874 __initialize_request_cb_table(request);
876 ret = __request_move(request, name, move_type, internal_request_callback, &req_id);
879 ret = __insert_request_cb_info(request, req_id, callback, user_data);
881 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
882 __FUNCTION__, "failed to create request cb info");
890 API int package_manager_request_mount_install(package_manager_request_h request,
891 const char *path, int *id)
893 return __request_mount_install(request, path, NULL, id);
896 API int package_manager_request_mount_install_with_cb(package_manager_request_h request,
897 const char *path, package_manager_request_event_cb callback,
898 void *user_data, int *id)
903 if (request->request_cb_table == NULL)
904 __initialize_request_cb_table(request);
906 ret = __request_mount_install(request, path, internal_request_callback, &req_id);
909 ret = __insert_request_cb_info(request, req_id, callback, user_data);
911 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
912 __FUNCTION__, "failed to create request cb info");
920 API int package_manager_create(package_manager_h *manager)
923 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
924 if (retval != PACKAGE_MANAGER_ERROR_NONE)
927 struct package_manager_s *package_manager = NULL;
929 if (manager == NULL) {
931 package_manager_error
932 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
936 package_manager = calloc(1, sizeof(struct package_manager_s));
937 if (package_manager == NULL) {
939 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
941 "failed to create a package_manager handle");
944 package_manager->ctype = PC_LISTENING;
945 package_manager->pc = pkgmgr_client_new(PC_LISTENING);
946 if (package_manager->pc == NULL) {
947 free(package_manager);
949 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
951 "failed to create a package_manager client");
954 package_manager->handle_id = package_manager_new_id();
956 *manager = package_manager;
958 return PACKAGE_MANAGER_ERROR_NONE;
961 static int package_manager_validate_handle(package_manager_h manager)
963 if (manager == NULL || manager->pc == NULL)
964 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
966 return PACKAGE_MANAGER_ERROR_NONE;
969 API int package_manager_destroy(package_manager_h manager)
971 if (package_manager_validate_handle(manager)) {
973 package_manager_error
974 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
978 pkgmgr_client_free(manager->pc);
979 g_hash_table_destroy(manager->event_info_table);
982 return PACKAGE_MANAGER_ERROR_NONE;
985 /* App Event Listening Policy:
986 * +----------------+------------+---------------+------------------+
987 * |Listener \ Type |Global Event|My User's Event|Other user's Event|
988 * +----------------+------------+---------------+------------------+
989 * |User Process App| Grant | Grant | Deny |
990 * +----------------+------------+---------------+------------------+
991 * |Platform module | Grant | Grant | Grant |
992 * +----------------+------------+---------------+------------------+
993 * UID assignment policy:
994 * https://wiki.tizen.org/wiki/Security/User_and_group_ID_assignment_policy
996 #define REGULAR_USER 5000
997 static int __validate_event_signal(uid_t target_uid)
999 uid_t self = getuid();
1001 if (self == target_uid)
1004 if (self < REGULAR_USER)
1010 static int internal_callback(uid_t target_uid, int req_id, const char *pkg_type,
1011 const char *pkg_name, const char *key,
1012 const char *val, const void *pmsg, void *data)
1015 package_manager_event_type_e event_type = -1;
1016 struct package_manager_event_info *info = NULL;
1017 package_manager_h manager = data;
1018 uid_t uid = target_uid;
1020 _LOGD("req_id(%d), pkg_name(%s), type(%s), key(%s), val(%s)",
1021 req_id, pkg_name, pkg_type, key, val);
1023 if (target_uid == GLOBAL_USER)
1026 if (__validate_event_signal(uid))
1027 return PACKAGE_MANAGER_ERROR_NONE;
1029 if (manager && manager->event_info_table) {
1030 info = g_hash_table_lookup(manager->event_info_table, pkg_name);
1032 _LOGE("invalid handle");
1033 return PACKAGE_MANAGER_ERROR_NONE;
1037 if (strcasecmp(key, "start") != 0) {
1038 _LOGD("unexpected signal or no info(removed)");
1039 return PACKAGE_MANAGER_ERROR_NONE;
1043 if (strcasecmp(key, "start") == 0) {
1044 ret = package_manager_get_event_type(val, &event_type);
1045 if (ret != PACKAGE_MANAGER_ERROR_NONE)
1046 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1049 __insert_event_info(manager, pkg_name, event_type,
1050 PACKAGE_MANAGER_EVENT_STATE_STARTED);
1052 if (manager->event_cb && getuid() == uid)
1053 manager->event_cb(pkg_type, pkg_name,
1055 PACKAGE_MANAGER_EVENT_STATE_STARTED,
1057 PACKAGE_MANAGER_ERROR_NONE,
1058 manager->user_data);
1060 _LOGE("unexpected start event");
1062 } else if (strcasecmp(key, "install_percent") == 0
1063 || strcasecmp(key, "progress_percent") == 0) {
1064 info->event_state = PACKAGE_MANAGER_EVENT_STATE_PROCESSING;
1065 if (manager->event_cb && getuid() == uid)
1066 manager->event_cb(pkg_type, pkg_name,
1070 PACKAGE_MANAGER_ERROR_NONE,
1071 manager->user_data);
1072 } else if (strcasecmp(key, "error") == 0) {
1073 info->event_state = PACKAGE_MANAGER_EVENT_STATE_FAILED;
1074 if (manager->event_cb && getuid() == uid)
1075 manager->event_cb(pkg_type, pkg_name,
1079 PACKAGE_MANAGER_ERROR_NONE,
1080 manager->user_data);
1081 } else if (strcasecmp(key, "end") == 0) {
1082 if (info->event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
1083 if (manager->event_cb && getuid() == uid) {
1084 if (strcasecmp(val, "ok") == 0) {
1085 manager->event_cb(pkg_type, pkg_name,
1087 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
1089 PACKAGE_MANAGER_ERROR_NONE,
1090 manager->user_data);
1092 manager->event_cb(pkg_type, pkg_name,
1094 PACKAGE_MANAGER_EVENT_STATE_FAILED,
1096 PACKAGE_MANAGER_ERROR_NONE,
1097 manager->user_data);
1101 g_hash_table_remove(manager->event_info_table, info->pkg_name);
1104 return PACKAGE_MANAGER_ERROR_NONE;
1107 static int __convert_status_type(package_manager_status_type_e status_type)
1111 if (status_type == PACKAGE_MANAGER_STATUS_TYPE_ALL)
1112 return PKGMGR_CLIENT_STATUS_ALL;
1114 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_INSTALL)
1115 type |= PKGMGR_CLIENT_STATUS_INSTALL;
1116 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL)
1117 type |= PKGMGR_CLIENT_STATUS_UNINSTALL;
1118 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_UPGRADE)
1119 type |= PKGMGR_CLIENT_STATUS_UPGRADE;
1120 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_MOVE)
1121 type |= PKGMGR_CLIENT_STATUS_MOVE;
1122 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_CLEAR_DATA)
1123 type |= PKGMGR_CLIENT_STATUS_CLEAR_DATA;
1124 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_INSTALL_PROGRESS)
1125 type |= PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS;
1126 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_GET_SIZE)
1127 type |= PKGMGR_CLIENT_STATUS_GET_SIZE;
1132 API int package_manager_set_event_status(package_manager_h manager, int status_type)
1136 int type_all = PACKAGE_MANAGER_STATUS_TYPE_INSTALL |
1137 PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL |
1138 PACKAGE_MANAGER_STATUS_TYPE_UPGRADE |
1139 PACKAGE_MANAGER_STATUS_TYPE_MOVE |
1140 PACKAGE_MANAGER_STATUS_TYPE_CLEAR_DATA |
1141 PACKAGE_MANAGER_STATUS_TYPE_INSTALL_PROGRESS |
1142 PACKAGE_MANAGER_STATUS_TYPE_GET_SIZE;
1144 if (manager == NULL)
1145 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1147 if (status_type < 0 || status_type > type_all)
1148 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1150 type = __convert_status_type(status_type);
1151 retval = pkgmgr_client_set_status_type(manager->pc, type);
1154 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1156 return PACKAGE_MANAGER_ERROR_NONE;
1159 API int package_manager_set_event_cb(package_manager_h manager,
1160 package_manager_event_cb callback,
1165 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1166 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1169 if (package_manager_validate_handle(manager)) {
1171 package_manager_error
1172 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1176 manager->event_cb = callback;
1177 manager->user_data = user_data;
1179 retval = pkgmgr_client_listen_status(manager->pc,
1180 internal_callback, manager);
1182 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR,
1183 __FUNCTION__, NULL);
1186 if (!manager->event_info_table) {
1187 manager->event_info_table =
1188 g_hash_table_new_full(g_str_hash, g_str_equal,
1189 NULL, __free_event_info);
1192 return PACKAGE_MANAGER_ERROR_NONE;
1195 API int package_manager_unset_event_cb(package_manager_h manager)
1197 if (manager == NULL) {
1199 package_manager_error
1200 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1205 manager->event_cb = NULL;
1206 manager->user_data = NULL;
1208 g_hash_table_remove_all(manager->event_info_table);
1210 retval = pkgmgr_client_remove_listen_status(manager->pc);
1211 if (retval == PKGMGR_R_EINVAL)
1213 package_manager_error
1214 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1216 else if (retval == PKGMGR_R_ERROR)
1218 package_manager_error
1219 (PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__,
1222 return PACKAGE_MANAGER_ERROR_NONE;
1225 API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
1227 pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
1229 char *pkg_id = NULL;
1230 char *pkg_id_dup = NULL;
1232 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1233 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1236 if (app_id == NULL || package_id == NULL)
1237 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1239 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1240 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1241 retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1242 if (retval != PMINFO_R_OK)
1243 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1245 pkg_id_dup = strdup(pkg_id);
1246 if (pkg_id_dup == NULL) {
1247 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1248 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1251 *package_id = pkg_id_dup;
1253 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1255 return PACKAGE_MANAGER_ERROR_NONE;
1258 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
1261 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1262 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1265 retval = package_info_get_package_info(package_id, package_info);
1267 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1268 return package_manager_error(retval, __FUNCTION__, NULL);
1270 return PACKAGE_MANAGER_ERROR_NONE;
1273 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
1278 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1279 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1282 retval = package_info_foreach_package_info(callback, user_data);
1284 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1285 return package_manager_error(retval, __FUNCTION__, NULL);
1287 return PACKAGE_MANAGER_ERROR_NONE;
1290 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)
1292 pkgmgrinfo_cert_compare_result_type_e result;
1294 if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
1295 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1296 if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
1297 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1298 *compare_result = (package_manager_compare_result_type_e)result;
1300 return PACKAGE_MANAGER_ERROR_NONE;
1303 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)
1305 pkgmgrinfo_cert_compare_result_type_e result;
1307 if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
1308 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1309 if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
1310 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1312 *compare_result = (package_manager_compare_result_type_e)result;
1314 return PACKAGE_MANAGER_ERROR_NONE;
1317 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
1321 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1322 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1325 pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1326 pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
1328 char *pkg_id = NULL;
1329 bool is_preload = 0;
1330 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1331 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1333 retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1334 if (retval != PMINFO_R_OK) {
1335 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1336 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1338 if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
1339 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1340 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1341 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1343 if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK) {
1344 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1345 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1346 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1354 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1355 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1357 return PACKAGE_MANAGER_ERROR_NONE;
1360 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1364 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1365 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1368 pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1369 pkgmgrinfo_permission_type permission = 0;
1370 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1371 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1372 retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1373 if (retval != PMINFO_R_OK)
1374 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1376 if (permission == PMINFO_PERMISSION_NORMAL)
1377 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1378 else if (permission == PMINFO_PERMISSION_SIGNATURE)
1379 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1380 else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1381 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1383 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1385 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1386 return PACKAGE_MANAGER_ERROR_NONE;
1389 API int package_manager_clear_cache_dir(const char *package_id)
1393 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_CACHE);
1394 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1397 int res = pkgmgr_client_clear_cache_dir(package_id);
1398 if (res == PKGMGR_R_EINVAL) {
1399 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1400 } else if (res == PKGMGR_R_ENOPKG) {
1401 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1402 } else if (res == PKGMGR_R_ENOMEM) {
1403 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1404 } else if (res == PKGMGR_R_EIO) {
1405 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1406 } else if (res == PKGMGR_R_EPRIV) {
1407 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1408 } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1409 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1410 } else if (res != PKGMGR_R_OK) {
1411 _LOGE("Unexpected error");
1412 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1415 return PACKAGE_MANAGER_ERROR_NONE;
1418 API int package_manager_clear_data_dir(const char *package_id)
1421 pkgmgr_client *pc = NULL;
1422 char *pkg_type = NULL;
1423 pkgmgrinfo_pkginfo_h pkginfo = NULL;
1425 if (package_id == NULL)
1426 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1428 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1429 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1432 retval = pkgmgrinfo_pkginfo_get_pkginfo(package_id, &pkginfo);
1433 if (retval == PMINFO_R_ENOENT)
1434 return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
1435 else if (retval != PMINFO_R_OK || pkginfo == NULL)
1436 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1438 retval = pkgmgrinfo_pkginfo_get_type(pkginfo, &pkg_type);
1439 if (retval != PMINFO_R_OK || pkg_type == NULL) {
1440 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1441 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1444 pc = pkgmgr_client_new(PC_REQUEST);
1446 _LOGE("Out of memory");
1447 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1448 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
1451 retval = pkgmgr_client_clear_user_data(pc, pkg_type, package_id, PM_QUIET);
1452 pkgmgr_client_free(pc);
1453 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1455 if (retval == PKGMGR_R_EINVAL) {
1456 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1457 } else if (retval == PKGMGR_R_ENOPKG) {
1458 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1459 } else if (retval == PKGMGR_R_ENOMEM) {
1460 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1461 } else if (retval == PKGMGR_R_EIO) {
1462 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1463 } else if (retval == PKGMGR_R_EPRIV) {
1464 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1465 } else if (retval == PKGMGR_R_ESYSTEM || retval == PKGMGR_R_ECOMM || retval == PKGMGR_R_ERROR) {
1466 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1467 } else if (retval != PKGMGR_R_OK) {
1468 _LOGE("Unexpected error");
1469 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1472 return PACKAGE_MANAGER_ERROR_NONE;
1475 API int package_manager_clear_all_cache_dir(void)
1479 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1480 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1483 return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
1486 static void __free_client(gpointer data)
1488 pkgmgr_client *pc = (pkgmgr_client *)data;
1489 pkgmgr_client_free(pc);
1492 static void __initialize_cb_table(void)
1494 __cb_table = g_hash_table_new_full(g_direct_hash, g_direct_equal, __free_client, NULL);
1497 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
1499 package_manager_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1500 if (callback == NULL) {
1501 _LOGE("callback is null.");
1502 g_hash_table_remove(__cb_table, pc);
1506 package_size_info_t size_info;
1507 size_info.data_size = result->data_size;
1508 size_info.cache_size = result->cache_size;
1509 size_info.app_size = result->app_size;
1510 size_info.external_data_size = result->ext_data_size;
1511 size_info.external_cache_size = result->ext_cache_size;
1512 size_info.external_app_size = result->ext_app_size;
1514 callback(pkgid, (package_size_info_h)&size_info, user_data);
1516 g_hash_table_remove(__cb_table, pc);
1519 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
1521 package_manager_total_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1522 if (callback == NULL) {
1523 _LOGE("callback is null.");
1524 g_hash_table_remove(__cb_table, pc);
1528 package_size_info_t size_info;
1529 size_info.data_size = result->data_size;
1530 size_info.cache_size = result->cache_size;
1531 size_info.app_size = result->app_size;
1532 size_info.external_data_size = result->ext_data_size;
1533 size_info.external_cache_size = result->ext_cache_size;
1534 size_info.external_app_size = result->ext_app_size;
1536 callback((package_size_info_h)&size_info, user_data);
1538 g_hash_table_remove(__cb_table, pc);
1541 static int _get_pkg_size_info(const char *package_id, void *callback, void *user_data)
1543 if (package_id == NULL || callback == NULL)
1544 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1546 if (__cb_table == NULL)
1547 __initialize_cb_table();
1549 pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
1551 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1554 if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
1555 res = pkgmgr_client_get_package_size_info(pc, package_id, __result_cb, user_data);
1557 res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, user_data);
1559 if (res == PKGMGR_R_EINVAL) {
1560 pkgmgr_client_free(pc);
1561 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1562 } else if (res == PKGMGR_R_ENOPKG) {
1563 pkgmgr_client_free(pc);
1564 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1565 } else if (res == PKGMGR_R_ENOMEM) {
1566 pkgmgr_client_free(pc);
1567 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1568 } else if (res == PKGMGR_R_EIO) {
1569 pkgmgr_client_free(pc);
1570 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1571 } else if (res == PKGMGR_R_EPRIV) {
1572 pkgmgr_client_free(pc);
1573 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1574 } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1575 pkgmgr_client_free(pc);
1576 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1577 } else if (res != PKGMGR_R_OK) {
1578 _LOGE("Unexpected error");
1579 pkgmgr_client_free(pc);
1580 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1583 g_hash_table_insert(__cb_table, pc, callback);
1585 return PACKAGE_MANAGER_ERROR_NONE;
1588 API int package_manager_get_package_size_info(const char *package_id, package_manager_size_info_receive_cb callback, void *user_data)
1590 return _get_pkg_size_info(package_id, (void *)callback, user_data);
1593 API int package_manager_get_total_package_size_info(package_manager_total_size_info_receive_cb callback, void *user_data)
1595 return _get_pkg_size_info(PKG_SIZE_INFO_TOTAL, (void *)callback, user_data);
1598 API int package_manager_filter_create(package_manager_filter_h *handle)
1601 pkgmgrinfo_pkginfo_filter_h pkgmgr_filter = NULL;
1603 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1604 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1607 if (handle == NULL) {
1609 package_manager_error
1610 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1614 retval = pkgmgrinfo_pkginfo_filter_create(&pkgmgr_filter);
1615 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1616 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1618 *handle = pkgmgr_filter;
1620 return PACKAGE_MANAGER_ERROR_NONE;
1623 API int package_manager_filter_destroy(package_manager_filter_h handle)
1627 if (handle == NULL) {
1629 package_manager_error
1630 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1634 retval = pkgmgrinfo_pkginfo_filter_destroy(handle);
1635 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1636 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1638 return PACKAGE_MANAGER_ERROR_NONE;
1641 API int package_manager_filter_add_bool(package_manager_filter_h handle,
1642 const char *property, const bool value)
1646 if ((handle == NULL) || (property == NULL)) {
1648 package_manager_error
1649 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1653 retval = pkgmgrinfo_pkginfo_filter_add_bool(handle, property, value);
1654 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1655 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1657 return PACKAGE_MANAGER_ERROR_NONE;
1660 API int package_manager_filter_count(package_manager_filter_h handle, int *count)
1664 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1665 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1668 if ((handle == NULL) || (count == NULL))
1669 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1671 retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
1673 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1675 return PACKAGE_MANAGER_ERROR_NONE;
1678 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
1679 package_manager_package_info_cb callback, void *user_data)
1683 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1684 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1687 retval = package_info_filter_foreach_package_info(handle, callback, user_data);
1689 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1690 return package_manager_error(retval, __FUNCTION__, NULL);
1692 return PACKAGE_MANAGER_ERROR_NONE;
1695 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
1698 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1700 package_size_info_t *size_info = (package_size_info_t *)handle;
1702 *data_size = (long long)size_info->data_size;
1703 return PACKAGE_MANAGER_ERROR_NONE;
1706 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
1709 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1711 package_size_info_t *size_info = (package_size_info_t *)handle;
1713 *cache_size = size_info->cache_size;
1714 return PACKAGE_MANAGER_ERROR_NONE;
1717 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
1720 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1722 package_size_info_t *size_info = (package_size_info_t *)handle;
1723 *app_size = size_info->app_size;
1724 return PACKAGE_MANAGER_ERROR_NONE;
1727 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
1730 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1732 package_size_info_t *size_info = (package_size_info_t *)handle;
1733 *ext_data_size = size_info->external_data_size;
1734 return PACKAGE_MANAGER_ERROR_NONE;
1737 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_size)
1740 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1742 package_size_info_t *size_info = (package_size_info_t *)handle;
1743 *ext_cache_size = size_info->external_cache_size;
1744 return PACKAGE_MANAGER_ERROR_NONE;
1747 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
1750 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1752 package_size_info_t *size_info = (package_size_info_t *)handle;
1753 *ext_app_size = size_info->external_app_size;
1754 return PACKAGE_MANAGER_ERROR_NONE;
1757 API int package_manager_updateinfo_set_pkgid(package_updateinfo_request_h pkg_updateinfo_req, const char *pkgid)
1759 struct package_updateinfo_request_s *request;
1761 if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL || pkgid == NULL)
1762 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1764 request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1765 if (request->updateinfo_handle->pkgid)
1766 free(request->updateinfo_handle->pkgid);
1767 request->updateinfo_handle->pkgid = strdup(pkgid);
1768 if (request->updateinfo_handle->pkgid == NULL)
1769 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1771 return PACKAGE_MANAGER_ERROR_NONE;
1774 API int package_manager_updateinfo_set_version(package_updateinfo_request_h pkg_updateinfo_req, const char *version)
1776 struct package_updateinfo_request_s *request;
1778 if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL || version == NULL)
1779 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1781 request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1782 if (request->updateinfo_handle->version)
1783 free(request->updateinfo_handle->version);
1784 request->updateinfo_handle->version = strdup(version);
1785 if (request->updateinfo_handle->version == NULL)
1786 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1788 return PACKAGE_MANAGER_ERROR_NONE;
1791 static int package_manager_updateinfo_convert_property(package_updateinfo_type_e property, pkgmgr_updateinfo_type *converted_property)
1793 if (converted_property == NULL)
1796 if (property == PACKAGE_UPDATEINFO_TYPE_FORCE)
1797 *converted_property = PM_UPDATEINFO_TYPE_FORCE;
1798 else if (property == PACKAGE_UPDATEINFO_TYPE_OPTIONAL)
1799 *converted_property = PM_UPDATEINFO_TYPE_OPTIONAL;
1800 else if (property == PACKAGE_UPDATEINFO_TYPE_NONE)
1801 *converted_property = PM_UPDATEINFO_TYPE_NONE;
1808 API int package_manager_updateinfo_set_type(package_updateinfo_request_h pkg_updateinfo_req, package_updateinfo_type_e type)
1811 pkgmgr_updateinfo_type converted_type;
1812 struct package_updateinfo_request_s *request;
1814 if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL)
1815 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1817 request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1818 retval = package_manager_updateinfo_convert_property(type, &converted_type);
1820 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1822 request->updateinfo_handle->type = converted_type;
1823 return PACKAGE_MANAGER_ERROR_NONE;
1826 API int package_manager_updateinfo_request_destroy(package_updateinfo_request_h pkg_updateinfo_req)
1828 struct package_updateinfo_request_s *request;
1830 if (pkg_updateinfo_req == NULL)
1831 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1833 request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1835 pkgmgr_client_free(request->pc);
1837 if (request->updateinfo_handle) {
1838 if (request->updateinfo_handle->pkgid)
1839 free(request->updateinfo_handle->pkgid);
1840 if (request->updateinfo_handle->version)
1841 free(request->updateinfo_handle->version);
1842 free(request->updateinfo_handle);
1846 return PACKAGE_MANAGER_ERROR_NONE;
1849 API int package_manager_updateinfo_request_create(package_updateinfo_request_h *pkg_updateinfo_req)
1851 struct package_updateinfo_request_s *request;
1852 pkg_update_info_t *update_info;
1854 if (pkg_updateinfo_req == NULL)
1855 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1857 request = calloc(1, sizeof(struct package_updateinfo_request_s));
1858 if (request == NULL)
1859 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1861 request->pc = pkgmgr_client_new(PC_REQUEST);
1862 if (request->pc == NULL) {
1864 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1867 update_info = calloc(1, sizeof(pkg_update_info_t));
1868 if (update_info == NULL) {
1869 pkgmgr_client_free(request->pc);
1871 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1873 request->updateinfo_handle = update_info;
1875 *pkg_updateinfo_req = request;
1876 return PACKAGE_MANAGER_ERROR_NONE;
1879 API int package_manager_updateinfo_request_register(package_updateinfo_request_h pkg_updateinfo_req)
1881 struct package_updateinfo_request_s *update_info;
1884 if (pkg_updateinfo_req == NULL)
1885 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1886 update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1888 retval = pkgmgr_client_register_pkg_update_info(update_info->pc, update_info->updateinfo_handle);
1889 if (retval == PKGMGR_R_EINVAL)
1890 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1892 return PACKAGE_MANAGER_ERROR_NONE;
1895 API int package_manager_updateinfo_request_unregister(package_updateinfo_request_h pkg_updateinfo_req, const char *pkgid)
1898 struct package_updateinfo_request_s *update_info;
1900 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1901 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1904 if (pkg_updateinfo_req == NULL || pkgid == NULL)
1905 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1907 update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1908 retval = pkgmgr_client_unregister_pkg_update_info(update_info->pc, pkgid);
1909 if (retval != PMINFO_R_OK)
1910 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1912 return PACKAGE_MANAGER_ERROR_NONE;
1915 API int package_manager_updateinfo_request_unregister_all(package_updateinfo_request_h pkg_updateinfo_req)
1918 struct package_updateinfo_request_s *update_info;
1920 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1921 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1924 if (pkg_updateinfo_req == NULL)
1925 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1927 update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1928 retval = pkgmgr_client_unregister_all_pkg_update_info(update_info->pc);
1930 if (retval != PMINFO_R_OK)
1931 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1933 return PACKAGE_MANAGER_ERROR_NONE;