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;
45 struct package_manager_s {
47 pkgmgr_client_type ctype;
50 GHashTable *event_info_table;
51 package_manager_event_cb event_cb;
55 struct package_manager_request_s {
57 pkgmgr_client_type ctype;
61 request_event_info *head;
62 package_manager_request_event_cb event_cb;
63 GHashTable *request_cb_table;
67 struct package_manager_request_cb_info {
69 package_manager_request_event_cb callback;
73 typedef struct package_size_info {
78 long long external_data_size;
79 long long external_cache_size;
80 long long external_app_size;
81 } package_size_info_t;
83 struct package_manager_filter_s {
84 pkgmgrinfo_pkginfo_filter_h pkgmgrinfo_pkginfo_filter;
87 struct package_updateinfo_request_s {
89 pkg_update_info_t *updateinfo_handle;
92 static int package_manager_request_new_id()
94 static int request_handle_id = 0;
95 return request_handle_id++;
98 static int package_manager_new_id()
100 static int manager_handle_id = 0;
101 return manager_handle_id++;
104 static void __clean_all_event_info(request_event_info *head)
106 request_event_info *current = head;
107 request_event_info *prev;
114 current = current->next;
119 static int __insert_event_info(package_manager_h manager, const char *pkg_name,
120 package_manager_event_type_e event_type)
122 struct package_manager_event_info *info;
124 info = calloc(1, sizeof(struct package_manager_event_info));
127 info->pkg_name = strdup(pkg_name);
128 info->event_type = event_type;
129 g_hash_table_insert(manager->event_info_table, info->pkg_name, info);
134 static void __free_event_info(gpointer data)
136 struct package_manager_event_info *info =
137 (struct package_manager_event_info *)data;
143 free(info->pkg_name);
146 _LOGD("event_info removed");
149 static void __free_request_cb_info(gpointer data)
152 struct package_manager_request_cb_info *cb_info =
153 (struct package_manager_request_cb_info *)data;
155 req_id = cb_info->req_id;
159 _LOGD("request callback info removed, req_id(%d)", req_id);
162 static void __initialize_request_cb_table(package_manager_request_h request)
164 request->request_cb_table =
165 g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, __free_request_cb_info);
168 static int __insert_request_cb_info(package_manager_request_h request, int req_id,
169 package_manager_request_event_cb callback, void *user_data)
171 struct package_manager_request_cb_info *cb_info;
173 if (request->request_cb_table == NULL)
176 cb_info = calloc(1, sizeof(struct package_manager_request_cb_info));
179 cb_info->req_id = req_id;
180 cb_info->callback = callback;
181 cb_info->user_data = user_data;
182 _LOGD("insert req_id(%d)", req_id);
183 g_hash_table_insert(request->request_cb_table, GINT_TO_POINTER(cb_info->req_id), cb_info);
188 API int package_manager_request_create(package_manager_request_h *request)
190 struct package_manager_request_s *package_manager_request;
192 if (request == NULL) {
194 package_manager_error
195 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
199 package_manager_request =
200 calloc(1, sizeof(struct package_manager_request_s));
201 if (package_manager_request == NULL) {
203 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
205 "failed to create a package_manager handle");
208 package_manager_request->ctype = PC_REQUEST;
209 package_manager_request->pc = pkgmgr_client_new(PC_REQUEST);
210 if (package_manager_request->pc == NULL) {
211 free(package_manager_request);
213 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
215 "failed to create a package_manager client");
218 package_manager_request->handle_id = package_manager_request_new_id();
220 *request = package_manager_request;
222 return PACKAGE_MANAGER_ERROR_NONE;
225 static int package_manager_client_validate_handle(package_manager_request_h
228 if (request == NULL || request->pc == NULL)
229 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
231 return PACKAGE_MANAGER_ERROR_NONE;
234 API int package_manager_request_destroy(package_manager_request_h request)
236 if (package_manager_client_validate_handle(request)) {
238 package_manager_error
239 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
243 pkgmgr_client_free(request->pc);
245 free(request->pkg_type);
246 __clean_all_event_info(request->head);
247 if (request->request_cb_table) {
248 g_hash_table_destroy(request->request_cb_table);
249 request->request_cb_table = NULL;
253 return PACKAGE_MANAGER_ERROR_NONE;
256 static int __reset_user_request_callback(package_manager_request_h request,
257 package_manager_request_event_cb callback, void *user_data)
259 if (package_manager_client_validate_handle(request))
260 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
262 request->event_cb = callback;
263 request->user_data = user_data;
265 return PACKAGE_MANAGER_ERROR_NONE;
268 API int package_manager_request_set_event_cb(package_manager_request_h request,
269 package_manager_request_event_cb
270 callback, void *user_data)
274 ret = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
275 if (ret != PACKAGE_MANAGER_ERROR_NONE)
278 return __reset_user_request_callback(request, callback, user_data);
281 API int package_manager_request_unset_event_cb(package_manager_request_h request)
283 if (package_manager_client_validate_handle(request))
284 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
286 request->event_cb = NULL;
287 request->user_data = NULL;
289 return PACKAGE_MANAGER_ERROR_NONE;
292 API int package_manager_request_set_type(package_manager_request_h request,
293 const char *pkg_type)
295 if (package_manager_client_validate_handle(request)) {
297 package_manager_error
298 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
302 request->pkg_type = strdup(pkg_type);
304 return PACKAGE_MANAGER_ERROR_NONE;
307 API int package_manager_request_set_mode(package_manager_request_h request,
308 package_manager_request_mode_e mode)
310 if (package_manager_client_validate_handle(request)) {
312 package_manager_error
313 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
317 /* request mode is not used anymore */
319 return PACKAGE_MANAGER_ERROR_NONE;
322 API int package_manager_request_set_tep(package_manager_request_h request,
323 const char *tep_path)
327 if (package_manager_client_validate_handle(request) || tep_path == NULL) {
329 package_manager_error
330 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
334 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
335 if (retval != PACKAGE_MANAGER_ERROR_NONE)
338 if (pkgmgr_client_set_tep_path(request->pc, tep_path, true))
339 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
341 return PACKAGE_MANAGER_ERROR_NONE;
344 static int package_manager_get_event_type(const char *key,
345 package_manager_event_type_e *
349 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
351 if (strcasecmp(key, PKGMGR_INSTALLER_INSTALL_EVENT_STR) == 0)
352 *event_type = PACKAGE_MANAGER_EVENT_TYPE_INSTALL;
353 else if (strcasecmp(key, PKGMGR_INSTALLER_UNINSTALL_EVENT_STR) == 0)
354 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UNINSTALL;
355 else if (strcasecmp(key, PKGMGR_INSTALLER_UPGRADE_EVENT_STR) == 0)
356 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UPDATE;
357 else if (strcasecmp(key, PKGMGR_INSTALLER_MOVE_EVENT_STR) == 0)
358 *event_type = PACKAGE_MANAGER_EVENT_TYPE_MOVE;
359 else if (strcasecmp(key, PKGMGR_INSTALLER_CLEAR_EVENT_STR) == 0)
360 *event_type = PACKAGE_MANAGER_EVENT_TYPE_CLEAR;
362 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
364 return PACKAGE_MANAGER_ERROR_NONE;
367 static int __add_event_info(request_event_info **head, int req_id,
368 package_manager_event_type_e event_type,
369 package_manager_event_state_e event_state)
371 request_event_info *evt_info;
372 request_event_info *current;
373 request_event_info *prev;
375 evt_info = (request_event_info *) calloc(1, sizeof(request_event_info));
376 if (evt_info == NULL) {
377 _LOGD("calloc failed");
380 evt_info->req_id = req_id;
381 evt_info->event_type = event_type;
382 evt_info->next = NULL;
387 current = prev = *head;
390 current = current->next;
393 prev->next = evt_info;
399 static int __find_event_info(request_event_info **head, int req_id,
400 package_manager_event_type_e *event_type,
401 package_manager_event_state_e *event_state)
403 request_event_info *tmp;
408 _LOGE("tmp is NULL");
413 if (tmp->req_id == req_id) {
414 *event_type = tmp->event_type;
422 static int __update_event_info(request_event_info **head, int req_id,
423 package_manager_event_type_e event_type,
424 package_manager_event_state_e event_state)
426 package_manager_event_type_e evt_type;
427 package_manager_event_state_e evt_state;
428 request_event_info *tmp;
430 if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
431 __add_event_info(head, req_id, event_type, event_state);
436 _LOGE("tmp is NULL");
441 if (tmp->req_id == req_id) {
442 tmp->event_type = event_type;
452 static int request_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
453 const char *pkg_name, const char *key,
454 const char *val, const void *pmsg, void *data)
457 package_manager_event_type_e event_type = -1;
458 package_manager_event_state_e event_state = -1;
460 package_manager_request_h request = data;
462 if (strcasecmp(key, "start") == 0) {
463 ret = package_manager_get_event_type(val, &event_type);
464 if (ret != PACKAGE_MANAGER_ERROR_NONE)
465 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
467 __add_event_info(&(request->head), req_id, event_type,
468 PACKAGE_MANAGER_EVENT_STATE_STARTED);
470 if (request->event_cb)
471 request->event_cb(req_id, pkg_type, pkg_name,
473 PACKAGE_MANAGER_EVENT_STATE_STARTED,
474 0, PACKAGE_MANAGER_ERROR_NONE, request->user_data);
476 } else if (strcasecmp(key, "install_percent") == 0
477 || strcasecmp(key, "progress_percent") == 0) {
478 if (__find_event_info
479 (&(request->head), req_id, &event_type,
480 &event_state) == 0) {
481 __update_event_info(&(request->head), req_id,
483 PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
484 if (request->event_cb)
485 request->event_cb(req_id, pkg_type, pkg_name,
487 PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
489 PACKAGE_MANAGER_ERROR_NONE,
493 } else if (strcasecmp(key, "error") == 0) {
494 if (strcasecmp(key, "0") != 0) {
495 if (__find_event_info
496 (&(request->head), req_id, &event_type,
497 &event_state) == 0) {
498 __update_event_info(&(request->head), req_id,
500 PACKAGE_MANAGER_EVENT_STATE_FAILED);
503 if (request->event_cb)
504 request->event_cb(req_id, pkg_type,
505 pkg_name, event_type,
506 PACKAGE_MANAGER_EVENT_STATE_FAILED,
508 PACKAGE_MANAGER_ERROR_NONE,
512 } else if (strcasecmp(key, "end") == 0) {
513 if (__find_event_info
514 (&(request->head), req_id, &event_type,
515 &event_state) == 0) {
516 if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
517 if (request->event_cb)
518 request->event_cb(req_id, pkg_type,
519 pkg_name, event_type,
520 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
522 PACKAGE_MANAGER_ERROR_NONE,
526 if (strcasecmp(key, "ok") != 0)
527 if (request->event_cb)
528 request->event_cb(req_id, pkg_type,
529 pkg_name, event_type,
530 PACKAGE_MANAGER_EVENT_STATE_FAILED,
532 PACKAGE_MANAGER_ERROR_NONE,
537 return PACKAGE_MANAGER_ERROR_NONE;
540 static int internal_request_callback(uid_t target_uid, int req_id, const char *pkg_type,
541 const char *pkg_name, const char *key,
542 const char *val, const void *pmsg, void *data)
545 package_manager_event_type_e event_type = -1;
546 package_manager_event_state_e event_state = -1;
547 struct package_manager_request_cb_info *cb_info;
548 package_manager_request_event_cb event_cb;
549 void *user_data = NULL;
551 _LOGD("request callback called, req_id[%d]", req_id);
553 package_manager_request_h request = data;
555 if (request->request_cb_table)
556 cb_info = g_hash_table_lookup(request->request_cb_table,
557 GINT_TO_POINTER(req_id));
561 if (!cb_info || (cb_info && !cb_info->callback)) {
562 _LOGE("no callback info");
566 if (cb_info->req_id != req_id) {
567 _LOGE("not matched request id");
571 event_cb = cb_info->callback;
572 user_data = cb_info->user_data;
574 if (strcasecmp(key, "start") == 0) {
575 ret = package_manager_get_event_type(val, &event_type);
576 if (ret != PACKAGE_MANAGER_ERROR_NONE)
577 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
579 __add_event_info(&request->head, req_id, event_type,
580 PACKAGE_MANAGER_EVENT_STATE_STARTED);
582 event_cb(req_id, pkg_type, pkg_name,
584 PACKAGE_MANAGER_EVENT_STATE_STARTED,
585 0, PACKAGE_MANAGER_ERROR_NONE, user_data);
586 } else if (strcasecmp(key, "install_percent") == 0) {
587 if (__find_event_info(&request->head, req_id, &event_type,
588 &event_state) == 0) {
589 __update_event_info(&request->head, req_id,
591 PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
592 event_cb(req_id, pkg_type, pkg_name,
594 PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
596 PACKAGE_MANAGER_ERROR_NONE,
599 } else if (strcasecmp(key, "error") == 0) {
600 if (__find_event_info(&request->head, req_id, &event_type,
601 &event_state) == 0) {
602 __update_event_info(&request->head, req_id,
604 PACKAGE_MANAGER_EVENT_STATE_FAILED);
605 event_cb(req_id, pkg_type,
606 pkg_name, event_type,
607 PACKAGE_MANAGER_EVENT_STATE_FAILED,
609 PACKAGE_MANAGER_ERROR_NONE,
612 } else if (strcasecmp(key, "end") == 0) {
613 if (__find_event_info(&request->head, req_id, &event_type,
614 &event_state) == 0) {
615 if (request->request_cb_table) {
616 _LOGD("remove item, req_id(%d)", req_id);
617 g_hash_table_remove(request->request_cb_table,
618 GINT_TO_POINTER(req_id));
620 if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
621 if (strcasecmp(val, "ok") == 0) {
622 event_cb(req_id, pkg_type,
623 pkg_name, event_type,
624 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
626 PACKAGE_MANAGER_ERROR_NONE,
629 event_cb(req_id, pkg_type,
630 pkg_name, event_type,
631 PACKAGE_MANAGER_EVENT_STATE_FAILED,
633 PACKAGE_MANAGER_ERROR_NONE,
638 _LOGE("unexpected end event");
645 static int __request_install(package_manager_request_h request,
646 const char *path, pkgmgr_handler event_cb, int *id)
649 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
650 if (retval != PACKAGE_MANAGER_ERROR_NONE)
653 if (package_manager_client_validate_handle(request))
654 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
657 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
660 request_id = pkgmgr_client_install(request->pc, request->pkg_type, NULL,
661 path, NULL, request->mode, event_cb ? event_cb : request_event_handler, request);
663 if (request_id == PKGMGR_R_EINVAL)
664 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
665 else if (request_id == PKGMGR_R_ENOPKG)
666 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
667 else if (request_id == PKGMGR_R_ENOMEM)
668 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
669 else if (request_id == PKGMGR_R_EIO)
670 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
671 else if (request_id == PKGMGR_R_EPRIV)
672 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
673 else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
674 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
679 return PACKAGE_MANAGER_ERROR_NONE;
682 static int __request_uninstall(package_manager_request_h request,
683 const char *name, pkgmgr_handler event_cb, int *id)
686 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
687 if (retval != PACKAGE_MANAGER_ERROR_NONE)
690 if (package_manager_client_validate_handle(request))
691 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
694 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
697 request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
698 name, request->mode, event_cb ? event_cb : request_event_handler, request);
700 if (request_id == PKGMGR_R_EINVAL)
701 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
702 else if (request_id == PKGMGR_R_ENOPKG)
703 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
704 else if (request_id == PKGMGR_R_ENOMEM)
705 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
706 else if (request_id == PKGMGR_R_EIO)
707 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
708 else if (request_id == PKGMGR_R_EPRIV)
709 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
710 else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
711 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
716 return PACKAGE_MANAGER_ERROR_NONE;
719 static int __request_move(package_manager_request_h request,
720 const char *name, package_manager_move_type_e move_type,
721 pkgmgr_handler event_cb, int *id)
724 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
725 if (retval != PACKAGE_MANAGER_ERROR_NONE)
728 if (package_manager_client_validate_handle(request))
729 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
732 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
735 request_id = pkgmgr_client_request_service(PM_REQUEST_MOVE, move_type,
736 request->pc, request->pkg_type, name,
737 NULL, event_cb ? event_cb : request_event_handler, request);
739 if (request_id == PKGMGR_R_EINVAL)
740 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
741 else if (request_id == PKGMGR_R_ENOPKG)
742 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
743 else if (request_id == PKGMGR_R_ENOMEM)
744 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
745 else if (request_id == PKGMGR_R_EIO)
746 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
747 else if (request_id == PKGMGR_R_EPRIV)
748 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
749 else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
750 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
755 return PACKAGE_MANAGER_ERROR_NONE;
758 static int __request_mount_install(package_manager_request_h request,
759 const char *path, pkgmgr_handler event_cb, int *id)
762 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
763 if (retval != PACKAGE_MANAGER_ERROR_NONE)
766 if (package_manager_client_validate_handle(request))
767 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
770 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
773 request_id = pkgmgr_client_mount_install(request->pc, request->pkg_type, NULL,
774 path, NULL, request->mode, event_cb ? event_cb : request_event_handler, request);
776 if (request_id == PKGMGR_R_EINVAL)
777 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
778 else if (request_id == PKGMGR_R_ENOPKG)
779 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
780 else if (request_id == PKGMGR_R_ENOMEM)
781 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
782 else if (request_id == PKGMGR_R_EIO)
783 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
784 else if (request_id == PKGMGR_R_EPRIV)
785 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
786 else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
787 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
792 return PACKAGE_MANAGER_ERROR_NONE;
796 API int package_manager_request_install(package_manager_request_h request,
797 const char *path, int *id)
799 return __request_install(request, path, NULL, id);
802 API int package_manager_request_install_with_cb(package_manager_request_h request,
803 const char *path, package_manager_request_event_cb callback,
804 void *user_data, int *id)
809 if (request->request_cb_table == NULL)
810 __initialize_request_cb_table(request);
812 ret = __request_install(request, path, internal_request_callback, &req_id);
815 ret = __insert_request_cb_info(request, req_id, callback, user_data);
817 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
818 __FUNCTION__, "failed to create request cb info");
826 API int package_manager_request_uninstall(package_manager_request_h request,
827 const char *name, int *id)
829 return __request_uninstall(request, name, NULL, id);
832 API int package_manager_request_uninstall_with_cb(package_manager_request_h request,
833 const char *name, package_manager_request_event_cb callback,
834 void *user_data, int *id)
839 if (request->request_cb_table == NULL)
840 __initialize_request_cb_table(request);
842 ret = __request_uninstall(request, name, internal_request_callback, &req_id);
845 ret = __insert_request_cb_info(request, req_id, callback, user_data);
847 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
848 __FUNCTION__, "failed to create request cb info");
856 API int package_manager_request_move(package_manager_request_h request,
857 const char *name, package_manager_move_type_e move_type)
859 return __request_move(request, name, move_type, NULL, NULL);
862 API int package_manager_request_move_with_cb(package_manager_request_h request,
863 const char *name, package_manager_move_type_e move_type,
864 package_manager_request_event_cb callback, void *user_data, int *id)
869 if (request->request_cb_table == NULL)
870 __initialize_request_cb_table(request);
872 ret = __request_move(request, name, move_type, internal_request_callback, &req_id);
875 ret = __insert_request_cb_info(request, req_id, callback, user_data);
877 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
878 __FUNCTION__, "failed to create request cb info");
886 API int package_manager_request_mount_install(package_manager_request_h request,
887 const char *path, int *id)
889 return __request_mount_install(request, path, NULL, id);
892 API int package_manager_request_mount_install_with_cb(package_manager_request_h request,
893 const char *path, package_manager_request_event_cb callback,
894 void *user_data, int *id)
899 if (request->request_cb_table == NULL)
900 __initialize_request_cb_table(request);
902 ret = __request_mount_install(request, path, internal_request_callback, &req_id);
905 ret = __insert_request_cb_info(request, req_id, callback, user_data);
907 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
908 __FUNCTION__, "failed to create request cb info");
916 API int package_manager_create(package_manager_h *manager)
919 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
920 if (retval != PACKAGE_MANAGER_ERROR_NONE)
923 struct package_manager_s *package_manager = NULL;
925 if (manager == NULL) {
927 package_manager_error
928 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
932 package_manager = calloc(1, sizeof(struct package_manager_s));
933 if (package_manager == NULL) {
935 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
937 "failed to create a package_manager handle");
940 package_manager->ctype = PC_LISTENING;
941 package_manager->pc = pkgmgr_client_new(PC_LISTENING);
942 if (package_manager->pc == NULL) {
943 free(package_manager);
945 package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
947 "failed to create a package_manager client");
950 package_manager->handle_id = package_manager_new_id();
952 *manager = package_manager;
954 return PACKAGE_MANAGER_ERROR_NONE;
957 static int package_manager_validate_handle(package_manager_h manager)
959 if (manager == NULL || manager->pc == NULL)
960 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
962 return PACKAGE_MANAGER_ERROR_NONE;
965 API int package_manager_destroy(package_manager_h manager)
967 if (package_manager_validate_handle(manager)) {
969 package_manager_error
970 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
974 pkgmgr_client_free(manager->pc);
975 g_hash_table_destroy(manager->event_info_table);
978 return PACKAGE_MANAGER_ERROR_NONE;
981 /* App Event Listening Policy:
982 * +----------------+------------+---------------+------------------+
983 * |Listener \ Type |Global Event|My User's Event|Other user's Event|
984 * +----------------+------------+---------------+------------------+
985 * |User Process App| Grant | Grant | Deny |
986 * +----------------+------------+---------------+------------------+
987 * |Platform module | Grant | Grant | Grant |
988 * +----------------+------------+---------------+------------------+
989 * UID assignment policy:
990 * https://wiki.tizen.org/wiki/Security/User_and_group_ID_assignment_policy
992 #define REGULAR_USER 5000
993 static int __validate_event_signal(uid_t target_uid)
995 uid_t self = getuid();
997 if (self == target_uid)
1000 if (self < REGULAR_USER)
1006 static int internal_callback(uid_t target_uid, int req_id, const char *pkg_type,
1007 const char *pkg_name, const char *key,
1008 const char *val, const void *pmsg, void *data)
1011 package_manager_event_type_e event_type = -1;
1012 package_manager_event_state_e event_state = -1;
1013 struct package_manager_event_info *info = NULL;
1014 package_manager_h manager = data;
1015 uid_t uid = target_uid;
1017 _LOGD("req_id(%d), pkg_name(%s), type(%s), key(%s), val(%s)",
1018 req_id, pkg_name, pkg_type, key, val);
1020 if (target_uid == GLOBAL_USER)
1023 if (__validate_event_signal(uid))
1024 return PACKAGE_MANAGER_ERROR_NONE;
1026 if (manager && manager->event_info_table) {
1027 info = g_hash_table_lookup(manager->event_info_table, pkg_name);
1029 _LOGE("invalid handle");
1030 return PACKAGE_MANAGER_ERROR_NONE;
1034 if (strcasecmp(key, "start") != 0) {
1035 _LOGD("unexpected signal or no info(removed)");
1036 return PACKAGE_MANAGER_ERROR_NONE;
1040 if (strcasecmp(key, "start") == 0) {
1041 ret = package_manager_get_event_type(val, &event_type);
1042 if (ret != PACKAGE_MANAGER_ERROR_NONE)
1043 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1046 __insert_event_info(manager, pkg_name, event_type);
1048 if (manager->event_cb && getuid() == uid)
1049 manager->event_cb(pkg_type, pkg_name,
1051 PACKAGE_MANAGER_EVENT_STATE_STARTED,
1053 PACKAGE_MANAGER_ERROR_NONE,
1054 manager->user_data);
1056 _LOGE("unexpected start event");
1058 } else if (strcasecmp(key, "install_percent") == 0
1059 || strcasecmp(key, "progress_percent") == 0) {
1060 if (manager->event_cb && getuid() == uid)
1061 manager->event_cb(pkg_type, pkg_name,
1063 PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
1065 PACKAGE_MANAGER_ERROR_NONE,
1066 manager->user_data);
1067 } else if (strcasecmp(key, "error") == 0) {
1068 if (manager->event_cb && getuid() == uid)
1069 manager->event_cb(pkg_type, pkg_name,
1071 PACKAGE_MANAGER_EVENT_STATE_FAILED,
1073 PACKAGE_MANAGER_ERROR_NONE,
1074 manager->user_data);
1075 } else if (strcasecmp(key, "end") == 0) {
1076 if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
1077 if (manager->event_cb && getuid() == uid) {
1078 if (strcasecmp(val, "ok") == 0) {
1079 manager->event_cb(pkg_type, pkg_name,
1081 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
1083 PACKAGE_MANAGER_ERROR_NONE,
1084 manager->user_data);
1086 manager->event_cb(pkg_type, pkg_name,
1088 PACKAGE_MANAGER_EVENT_STATE_FAILED,
1090 PACKAGE_MANAGER_ERROR_NONE,
1091 manager->user_data);
1095 g_hash_table_remove(manager->event_info_table, info->pkg_name);
1098 return PACKAGE_MANAGER_ERROR_NONE;
1101 static int __convert_status_type(package_manager_status_type_e status_type)
1105 if (status_type == PACKAGE_MANAGER_STATUS_TYPE_ALL)
1106 return PKGMGR_CLIENT_STATUS_ALL;
1108 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_INSTALL)
1109 type |= PKGMGR_CLIENT_STATUS_INSTALL;
1110 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL)
1111 type |= PKGMGR_CLIENT_STATUS_UNINSTALL;
1112 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_UPGRADE)
1113 type |= PKGMGR_CLIENT_STATUS_UPGRADE;
1114 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_MOVE)
1115 type |= PKGMGR_CLIENT_STATUS_MOVE;
1116 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_CLEAR_DATA)
1117 type |= PKGMGR_CLIENT_STATUS_CLEAR_DATA;
1118 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_INSTALL_PROGRESS)
1119 type |= PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS;
1120 if (status_type & PACKAGE_MANAGER_STATUS_TYPE_GET_SIZE)
1121 type |= PKGMGR_CLIENT_STATUS_GET_SIZE;
1126 API int package_manager_set_event_status(package_manager_h manager, int status_type)
1130 int type_all = PACKAGE_MANAGER_STATUS_TYPE_INSTALL |
1131 PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL |
1132 PACKAGE_MANAGER_STATUS_TYPE_UPGRADE |
1133 PACKAGE_MANAGER_STATUS_TYPE_MOVE |
1134 PACKAGE_MANAGER_STATUS_TYPE_CLEAR_DATA |
1135 PACKAGE_MANAGER_STATUS_TYPE_INSTALL_PROGRESS |
1136 PACKAGE_MANAGER_STATUS_TYPE_GET_SIZE;
1138 if (manager == NULL)
1139 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1141 if (status_type < 0 || status_type > type_all)
1142 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1144 type = __convert_status_type(status_type);
1145 retval = pkgmgr_client_set_status_type(manager->pc, type);
1148 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1150 return PACKAGE_MANAGER_ERROR_NONE;
1153 API int package_manager_set_event_cb(package_manager_h manager,
1154 package_manager_event_cb callback,
1159 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1160 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1163 if (package_manager_validate_handle(manager)) {
1165 package_manager_error
1166 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1170 manager->event_cb = callback;
1171 manager->user_data = user_data;
1173 retval = pkgmgr_client_listen_status(manager->pc,
1174 internal_callback, manager);
1176 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR,
1177 __FUNCTION__, NULL);
1180 if (!manager->event_info_table) {
1181 manager->event_info_table =
1182 g_hash_table_new_full(g_str_hash, g_str_equal,
1183 NULL, __free_event_info);
1186 return PACKAGE_MANAGER_ERROR_NONE;
1189 API int package_manager_unset_event_cb(package_manager_h manager)
1191 if (manager == NULL) {
1193 package_manager_error
1194 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1199 manager->event_cb = NULL;
1200 manager->user_data = NULL;
1202 g_hash_table_remove_all(manager->event_info_table);
1204 retval = pkgmgr_client_remove_listen_status(manager->pc);
1205 if (retval == PKGMGR_R_EINVAL)
1207 package_manager_error
1208 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1210 else if (retval == PKGMGR_R_ERROR)
1212 package_manager_error
1213 (PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__,
1216 return PACKAGE_MANAGER_ERROR_NONE;
1219 API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
1221 pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
1223 char *pkg_id = NULL;
1224 char *pkg_id_dup = NULL;
1226 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1227 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1230 if (app_id == NULL || package_id == NULL)
1231 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1233 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1234 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1235 retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1236 if (retval != PMINFO_R_OK)
1237 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1239 pkg_id_dup = strdup(pkg_id);
1240 if (pkg_id_dup == NULL) {
1241 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1242 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1245 *package_id = pkg_id_dup;
1247 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1249 return PACKAGE_MANAGER_ERROR_NONE;
1252 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
1255 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1256 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1259 retval = package_info_get_package_info(package_id, package_info);
1261 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1262 return package_manager_error(retval, __FUNCTION__, NULL);
1264 return PACKAGE_MANAGER_ERROR_NONE;
1267 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
1272 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1273 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1276 retval = package_info_foreach_package_info(callback, user_data);
1278 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1279 return package_manager_error(retval, __FUNCTION__, NULL);
1281 return PACKAGE_MANAGER_ERROR_NONE;
1284 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)
1286 pkgmgrinfo_cert_compare_result_type_e result;
1288 if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
1289 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1290 if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
1291 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1292 *compare_result = (package_manager_compare_result_type_e)result;
1294 return PACKAGE_MANAGER_ERROR_NONE;
1297 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)
1299 pkgmgrinfo_cert_compare_result_type_e result;
1301 if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
1302 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1303 if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
1304 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1306 *compare_result = (package_manager_compare_result_type_e)result;
1308 return PACKAGE_MANAGER_ERROR_NONE;
1311 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
1315 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1316 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1319 pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1320 pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
1322 char *pkg_id = NULL;
1323 bool is_preload = 0;
1324 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1325 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1327 retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1328 if (retval != PMINFO_R_OK) {
1329 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1330 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1332 if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
1333 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1334 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1335 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1337 if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK) {
1338 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1339 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1340 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1348 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1349 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1351 return PACKAGE_MANAGER_ERROR_NONE;
1354 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1358 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1359 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1362 pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1363 pkgmgrinfo_permission_type permission = 0;
1364 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1365 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1366 retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1367 if (retval != PMINFO_R_OK)
1368 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1370 if (permission == PMINFO_PERMISSION_NORMAL)
1371 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1372 else if (permission == PMINFO_PERMISSION_SIGNATURE)
1373 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1374 else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1375 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1377 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1379 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1380 return PACKAGE_MANAGER_ERROR_NONE;
1383 API int package_manager_clear_cache_dir(const char *package_id)
1387 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_CACHE);
1388 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1391 int res = pkgmgr_client_clear_cache_dir(package_id);
1392 if (res == PKGMGR_R_EINVAL) {
1393 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1394 } else if (res == PKGMGR_R_ENOPKG) {
1395 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1396 } else if (res == PKGMGR_R_ENOMEM) {
1397 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1398 } else if (res == PKGMGR_R_EIO) {
1399 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1400 } else if (res == PKGMGR_R_EPRIV) {
1401 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1402 } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1403 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1404 } else if (res != PKGMGR_R_OK) {
1405 _LOGE("Unexpected error");
1406 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1409 return PACKAGE_MANAGER_ERROR_NONE;
1412 API int package_manager_clear_data_dir(const char *package_id)
1415 pkgmgr_client *pc = NULL;
1416 char *pkg_type = NULL;
1417 pkgmgrinfo_pkginfo_h pkginfo = NULL;
1419 if (package_id == NULL)
1420 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1422 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1423 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1426 retval = pkgmgrinfo_pkginfo_get_pkginfo(package_id, &pkginfo);
1427 if (retval == PMINFO_R_ENOENT)
1428 return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
1429 else if (retval != PMINFO_R_OK || pkginfo == NULL)
1430 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1432 retval = pkgmgrinfo_pkginfo_get_type(pkginfo, &pkg_type);
1433 if (retval != PMINFO_R_OK || pkg_type == NULL) {
1434 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1435 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1438 pc = pkgmgr_client_new(PC_REQUEST);
1440 _LOGE("Out of memory");
1441 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1442 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
1445 retval = pkgmgr_client_clear_user_data(pc, pkg_type, package_id, PM_QUIET);
1446 pkgmgr_client_free(pc);
1447 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1449 if (retval == PKGMGR_R_EINVAL) {
1450 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1451 } else if (retval == PKGMGR_R_ENOPKG) {
1452 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1453 } else if (retval == PKGMGR_R_ENOMEM) {
1454 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1455 } else if (retval == PKGMGR_R_EIO) {
1456 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1457 } else if (retval == PKGMGR_R_EPRIV) {
1458 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1459 } else if (retval == PKGMGR_R_ESYSTEM || retval == PKGMGR_R_ECOMM || retval == PKGMGR_R_ERROR) {
1460 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1461 } else if (retval != PKGMGR_R_OK) {
1462 _LOGE("Unexpected error");
1463 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1466 return PACKAGE_MANAGER_ERROR_NONE;
1469 API int package_manager_clear_all_cache_dir(void)
1473 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1474 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1477 return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
1480 static void __free_client(gpointer data)
1482 pkgmgr_client *pc = (pkgmgr_client *)data;
1483 pkgmgr_client_free(pc);
1486 static void __initialize_cb_table(void)
1488 __cb_table = g_hash_table_new_full(g_direct_hash, g_direct_equal, __free_client, NULL);
1491 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
1493 package_manager_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1494 if (callback == NULL) {
1495 _LOGE("callback is null.");
1496 g_hash_table_remove(__cb_table, pc);
1500 package_size_info_t size_info;
1501 size_info.data_size = result->data_size;
1502 size_info.cache_size = result->cache_size;
1503 size_info.app_size = result->app_size;
1504 size_info.external_data_size = result->ext_data_size;
1505 size_info.external_cache_size = result->ext_cache_size;
1506 size_info.external_app_size = result->ext_app_size;
1508 callback(pkgid, (package_size_info_h)&size_info, user_data);
1510 g_hash_table_remove(__cb_table, pc);
1513 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
1515 package_manager_total_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1516 if (callback == NULL) {
1517 _LOGE("callback is null.");
1518 g_hash_table_remove(__cb_table, pc);
1522 package_size_info_t size_info;
1523 size_info.data_size = result->data_size;
1524 size_info.cache_size = result->cache_size;
1525 size_info.app_size = result->app_size;
1526 size_info.external_data_size = result->ext_data_size;
1527 size_info.external_cache_size = result->ext_cache_size;
1528 size_info.external_app_size = result->ext_app_size;
1530 callback((package_size_info_h)&size_info, user_data);
1532 g_hash_table_remove(__cb_table, pc);
1535 static int _get_pkg_size_info(const char *package_id, void *callback, void *user_data)
1537 if (package_id == NULL || callback == NULL)
1538 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1540 if (__cb_table == NULL)
1541 __initialize_cb_table();
1543 pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
1545 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1548 if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
1549 res = pkgmgr_client_get_package_size_info(pc, package_id, __result_cb, user_data);
1551 res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, user_data);
1553 if (res == PKGMGR_R_EINVAL) {
1554 pkgmgr_client_free(pc);
1555 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1556 } else if (res == PKGMGR_R_ENOPKG) {
1557 pkgmgr_client_free(pc);
1558 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1559 } else if (res == PKGMGR_R_ENOMEM) {
1560 pkgmgr_client_free(pc);
1561 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1562 } else if (res == PKGMGR_R_EIO) {
1563 pkgmgr_client_free(pc);
1564 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1565 } else if (res == PKGMGR_R_EPRIV) {
1566 pkgmgr_client_free(pc);
1567 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1568 } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1569 pkgmgr_client_free(pc);
1570 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1571 } else if (res != PKGMGR_R_OK) {
1572 _LOGE("Unexpected error");
1573 pkgmgr_client_free(pc);
1574 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1577 g_hash_table_insert(__cb_table, pc, callback);
1579 return PACKAGE_MANAGER_ERROR_NONE;
1582 API int package_manager_get_package_size_info(const char *package_id, package_manager_size_info_receive_cb callback, void *user_data)
1584 return _get_pkg_size_info(package_id, (void *)callback, user_data);
1587 API int package_manager_get_total_package_size_info(package_manager_total_size_info_receive_cb callback, void *user_data)
1589 return _get_pkg_size_info(PKG_SIZE_INFO_TOTAL, (void *)callback, user_data);
1592 API int package_manager_filter_create(package_manager_filter_h *handle)
1595 pkgmgrinfo_pkginfo_filter_h pkgmgr_filter = NULL;
1597 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1598 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1601 if (handle == NULL) {
1603 package_manager_error
1604 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1608 retval = pkgmgrinfo_pkginfo_filter_create(&pkgmgr_filter);
1609 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1610 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1612 *handle = pkgmgr_filter;
1614 return PACKAGE_MANAGER_ERROR_NONE;
1617 API int package_manager_filter_destroy(package_manager_filter_h handle)
1621 if (handle == NULL) {
1623 package_manager_error
1624 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1628 retval = pkgmgrinfo_pkginfo_filter_destroy(handle);
1629 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1630 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1632 return PACKAGE_MANAGER_ERROR_NONE;
1635 API int package_manager_filter_add_bool(package_manager_filter_h handle,
1636 const char *property, const bool value)
1640 if ((handle == NULL) || (property == NULL)) {
1642 package_manager_error
1643 (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1647 retval = pkgmgrinfo_pkginfo_filter_add_bool(handle, property, value);
1648 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1649 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1651 return PACKAGE_MANAGER_ERROR_NONE;
1654 API int package_manager_filter_count(package_manager_filter_h handle, int *count)
1658 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1659 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1662 if ((handle == NULL) || (count == NULL))
1663 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1665 retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
1667 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1669 return PACKAGE_MANAGER_ERROR_NONE;
1672 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
1673 package_manager_package_info_cb callback, void *user_data)
1677 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1678 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1681 retval = package_info_filter_foreach_package_info(handle, callback, user_data);
1683 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1684 return package_manager_error(retval, __FUNCTION__, NULL);
1686 return PACKAGE_MANAGER_ERROR_NONE;
1689 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
1692 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1694 package_size_info_t *size_info = (package_size_info_t *)handle;
1696 *data_size = (long long)size_info->data_size;
1697 return PACKAGE_MANAGER_ERROR_NONE;
1700 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
1703 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1705 package_size_info_t *size_info = (package_size_info_t *)handle;
1707 *cache_size = size_info->cache_size;
1708 return PACKAGE_MANAGER_ERROR_NONE;
1711 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
1714 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1716 package_size_info_t *size_info = (package_size_info_t *)handle;
1717 *app_size = size_info->app_size;
1718 return PACKAGE_MANAGER_ERROR_NONE;
1721 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
1724 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1726 package_size_info_t *size_info = (package_size_info_t *)handle;
1727 *ext_data_size = size_info->external_data_size;
1728 return PACKAGE_MANAGER_ERROR_NONE;
1731 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_size)
1734 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1736 package_size_info_t *size_info = (package_size_info_t *)handle;
1737 *ext_cache_size = size_info->external_cache_size;
1738 return PACKAGE_MANAGER_ERROR_NONE;
1741 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
1744 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1746 package_size_info_t *size_info = (package_size_info_t *)handle;
1747 *ext_app_size = size_info->external_app_size;
1748 return PACKAGE_MANAGER_ERROR_NONE;
1751 API int package_manager_updateinfo_set_pkgid(package_updateinfo_request_h pkg_updateinfo_req, const char *pkgid)
1753 struct package_updateinfo_request_s *request;
1755 if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL)
1756 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1758 request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1759 if (request->updateinfo_handle->pkgid)
1760 free(request->updateinfo_handle->pkgid);
1761 request->updateinfo_handle->pkgid = strdup(pkgid);
1762 if (request->updateinfo_handle->pkgid == NULL)
1763 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1765 return PACKAGE_MANAGER_ERROR_NONE;
1768 API int package_manager_updateinfo_set_version(package_updateinfo_request_h pkg_updateinfo_req, const char *version)
1770 struct package_updateinfo_request_s *request;
1772 if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL)
1773 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1775 request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1776 if (request->updateinfo_handle->version)
1777 free(request->updateinfo_handle->version);
1778 request->updateinfo_handle->version = strdup(version);
1779 if (request->updateinfo_handle->version == NULL)
1780 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1782 return PACKAGE_MANAGER_ERROR_NONE;
1785 static int package_manager_updateinfo_convert_property(package_updateinfo_type_e property, pkgmgr_updateinfo_type *converted_property)
1787 if (converted_property == NULL)
1790 if (property == PACKAGE_UPDATEINFO_TYPE_FORCE)
1791 *converted_property = PM_UPDATEINFO_TYPE_FORCE;
1792 else if (property == PACKAGE_UPDATEINFO_TYPE_OPTIONAL)
1793 *converted_property = PM_UPDATEINFO_TYPE_OPTIONAL;
1794 else if (property == PACKAGE_UPDATEINFO_TYPE_NONE)
1795 *converted_property = PM_UPDATEINFO_TYPE_NONE;
1802 API int package_manager_updateinfo_set_type(package_updateinfo_request_h pkg_updateinfo_req, package_updateinfo_type_e type)
1805 pkgmgr_updateinfo_type converted_type;
1806 struct package_updateinfo_request_s *request;
1808 if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL)
1809 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1811 request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1812 retval = package_manager_updateinfo_convert_property(type, &converted_type);
1814 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1816 request->updateinfo_handle->type = converted_type;
1817 return PACKAGE_MANAGER_ERROR_NONE;
1820 API int package_manager_updateinfo_request_destroy(package_updateinfo_request_h pkg_updateinfo_req)
1822 struct package_updateinfo_request_s *request;
1824 if (pkg_updateinfo_req == NULL)
1825 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1827 request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1829 pkgmgr_client_free(request->pc);
1831 if (request->updateinfo_handle) {
1832 if (request->updateinfo_handle->pkgid)
1833 free(request->updateinfo_handle->pkgid);
1834 if (request->updateinfo_handle->version)
1835 free(request->updateinfo_handle->version);
1836 free(request->updateinfo_handle);
1840 return PACKAGE_MANAGER_ERROR_NONE;
1843 API int package_manager_updateinfo_request_create(package_updateinfo_request_h *pkg_updateinfo_req)
1845 struct package_updateinfo_request_s *request;
1846 pkg_update_info_t *update_info;
1848 if (pkg_updateinfo_req == NULL)
1849 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1851 request = calloc(1, sizeof(struct package_updateinfo_request_s));
1852 if (request == NULL)
1853 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1855 request->pc = pkgmgr_client_new(PC_REQUEST);
1856 if (request->pc == NULL) {
1858 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1861 update_info = calloc(1, sizeof(pkg_update_info_t));
1862 if (update_info == NULL) {
1863 pkgmgr_client_free(request->pc);
1865 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1867 request->updateinfo_handle = update_info;
1869 *pkg_updateinfo_req = request;
1870 return PACKAGE_MANAGER_ERROR_NONE;
1873 API int package_manager_updateinfo_request_register(package_updateinfo_request_h pkg_updateinfo_req)
1875 struct package_updateinfo_request_s *update_info;
1878 if (pkg_updateinfo_req == NULL)
1879 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1880 update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1882 retval = pkgmgr_client_register_pkg_update_info(update_info->pc, update_info->updateinfo_handle);
1883 if (retval == PKGMGR_R_EINVAL)
1884 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1886 return PACKAGE_MANAGER_ERROR_NONE;
1889 API int package_manager_updateinfo_request_unregister(package_updateinfo_request_h pkg_updateinfo_req, const char *pkgid)
1892 struct package_updateinfo_request_s *update_info;
1894 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1895 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1898 if (pkg_updateinfo_req == NULL || pkgid == NULL)
1899 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1901 update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1902 retval = pkgmgr_client_unregister_pkg_update_info(update_info->pc, pkgid);
1903 if (retval != PMINFO_R_OK)
1904 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1906 return PACKAGE_MANAGER_ERROR_NONE;
1909 API int package_manager_updateinfo_request_unregister_all(package_updateinfo_request_h pkg_updateinfo_req)
1912 struct package_updateinfo_request_s *update_info;
1914 retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1915 if (retval != PACKAGE_MANAGER_ERROR_NONE)
1918 if (pkg_updateinfo_req == NULL)
1919 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1921 update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1922 retval = pkgmgr_client_unregister_all_pkg_update_info(update_info->pc);
1924 if (retval != PMINFO_R_OK)
1925 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1927 return PACKAGE_MANAGER_ERROR_NONE;