4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
7 * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
30 #include <sys/smack.h>
31 #include <linux/limits.h>
35 #include <libxml/parser.h>
36 #include <libxml/xmlreader.h>
37 #include <libxml/xmlschemas.h>
41 #include "pkgmgr_parser.h"
42 #include "pkgmgrinfo_basic.h"
43 #include "pkgmgrinfo_private.h"
44 #include "pkgmgrinfo_debug.h"
45 #include "pkgmgr-info.h"
46 #include "pkgmgr_parser_db.h"
47 #include "pkgmgr_parser_internal.h"
49 static int _pkginfo_get_pkginfo(const char *pkgid, uid_t uid,
50 pkgmgr_pkginfo_x **pkginfo);
51 static char *_get_filtered_query(const char *query_raw,
52 pkgmgrinfo_filter_x *filter);
54 static bool _get_bool_value(const char *str)
58 else if (!strcasecmp(str, "true"))
64 static gint __compare_func(gconstpointer data1, gconstpointer data2)
66 pkgmgrinfo_node_x *node1 = (pkgmgrinfo_node_x*)data1;
67 pkgmgrinfo_node_x *node2 = (pkgmgrinfo_node_x*)data2;
68 if (node1->prop == node2->prop)
70 else if (node1->prop > node2->prop)
76 static void __destroy_each_node(gpointer data, gpointer user_data)
79 pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x*)data;
92 static void __cleanup_pkginfo(pkgmgr_pkginfo_x *data)
96 free((void *)data->locale);
100 pkgmgrinfo_basic_free_package(data->pkg_info);
106 static int __child_element(xmlTextReaderPtr reader, int depth)
108 int ret = xmlTextReaderRead(reader);
109 int cur = xmlTextReaderDepth(reader);
112 switch (xmlTextReaderNodeType(reader)) {
113 case XML_READER_TYPE_ELEMENT:
114 if (cur == depth + 1)
117 case XML_READER_TYPE_TEXT:
118 /*text is handled by each function separately*/
119 if (cur == depth + 1)
122 case XML_READER_TYPE_END_ELEMENT:
131 ret = xmlTextReaderRead(reader);
132 cur = xmlTextReaderDepth(reader);
137 long long _pkgmgr_calculate_dir_size(char *dirname)
141 int q = 0; /*quotient*/
142 int r = 0; /*remainder*/
144 struct dirent *ep = NULL;
145 struct stat fileinfo;
146 char abs_filename[FILENAME_MAX] = { 0, };
147 retvm_if(dirname == NULL, PMINFO_R_ERROR, "dirname is NULL");
149 dp = opendir(dirname);
151 while ((ep = readdir(dp)) != NULL) {
152 if (!strcmp(ep->d_name, ".") ||
153 !strcmp(ep->d_name, "..")) {
156 snprintf(abs_filename, FILENAME_MAX, "%s/%s", dirname,
158 if (lstat(abs_filename, &fileinfo) < 0)
159 perror(abs_filename);
161 if (S_ISDIR(fileinfo.st_mode)) {
162 total += fileinfo.st_size;
163 if (strcmp(ep->d_name, ".")
164 && strcmp(ep->d_name, "..")) {
165 ret = _pkgmgr_calculate_dir_size
169 } else if (S_ISLNK(fileinfo.st_mode)) {
172 /*It is a file. Calculate the actual
173 size occupied (in terms of 4096 blocks)*/
174 q = (fileinfo.st_size / BLOCK_SIZE);
175 r = (fileinfo.st_size % BLOCK_SIZE);
179 total += q * BLOCK_SIZE;
185 _LOGE("Couldn't open the directory\n");
192 static gint __list_strcmp(gconstpointer a, gconstpointer b)
194 return strcmp((char *)a, (char *)b);
197 static int _pkginfo_get_list(sqlite3 *db, const char *locale,
198 pkgmgrinfo_filter_x *filter, GList **list)
200 static const char query_raw[] =
201 "SELECT DISTINCT package_info.package FROM package_info"
202 " LEFT OUTER JOIN package_localized_info"
203 " ON package_info.package=package_localized_info.package"
204 " AND package_localized_info.package_locale=%Q "
205 " LEFT OUTER JOIN package_privilege_info"
206 " ON package_info.package=package_privilege_info.package";
209 char *query_localized;
213 query = _get_filtered_query(query_raw, filter);
216 query_localized = sqlite3_mprintf(query, locale);
218 if (query_localized == NULL)
221 ret = sqlite3_prepare_v2(db, query_localized,
222 strlen(query_localized), &stmt, NULL);
223 sqlite3_free(query_localized);
224 if (ret != SQLITE_OK) {
225 LOGE("prepare failed: %s", sqlite3_errmsg(db));
229 while (sqlite3_step(stmt) == SQLITE_ROW) {
230 _save_column_str(stmt, 0, (const char **)&pkgid);
232 *list = g_list_insert_sorted(*list, pkgid,
236 sqlite3_finalize(stmt);
241 static int _pkginfo_get_filtered_list(pkgmgrinfo_filter_x *filter, uid_t uid,
251 locale = _get_system_locale();
253 return PMINFO_R_ERROR;
255 dbpath = getUserPkgParserDBPathUID(uid);
256 if (dbpath == NULL) {
258 return PMINFO_R_ERROR;
261 ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
262 if (ret != SQLITE_OK) {
263 _LOGE("failed to open db: %d", ret);
265 return PMINFO_R_ERROR;
268 if (_pkginfo_get_list(db, locale, filter, list)) {
270 sqlite3_close_v2(db);
271 return PMINFO_R_ERROR;
273 sqlite3_close_v2(db);
275 if (uid == GLOBAL_USER) {
280 /* search again from global */
281 dbpath = getUserPkgParserDBPathUID(GLOBAL_USER);
282 if (dbpath == NULL) {
284 return PMINFO_R_ERROR;
287 ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
288 if (ret != SQLITE_OK) {
289 _LOGE("failed to open db: %d", ret);
291 return PMINFO_R_ERROR;
294 if (_pkginfo_get_list(db, locale, filter, list)) {
296 sqlite3_close_v2(db);
297 return PMINFO_R_ERROR;
299 sqlite3_close_v2(db);
301 /* remove duplicate element:
302 * since the list is sorted, we can remove duplicates in linear time
304 for (tmp = *list, tmp2 = g_list_next(tmp); tmp;
305 tmp = tmp2, tmp2 = g_list_next(tmp)) {
306 if (tmp->prev == NULL || tmp->data == NULL)
308 if (strcmp((const char *)tmp->prev->data,
309 (const char *)tmp->data) == 0)
310 *list = g_list_delete_link(*list, tmp);
319 static int _pkginfo_get_filtered_foreach_pkginfo(pkgmgrinfo_filter_x *filter,
320 pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data, uid_t uid)
323 pkgmgr_pkginfo_x *info;
329 ret = _pkginfo_get_filtered_list(filter, uid, &list);
330 if (ret != PMINFO_R_OK)
331 return PMINFO_R_ERROR;
333 for (tmp = list; tmp; tmp = tmp->next) {
334 pkgid = (char *)tmp->data;
336 ret = _pkginfo_get_pkginfo(pkgid, uid, &info);
337 if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
338 ret = _pkginfo_get_pkginfo(pkgid, GLOBAL_USER,
340 if (ret != PMINFO_R_OK) {
344 if (pkg_list_cb(info, user_data) < 0)
346 pkgmgrinfo_pkginfo_destroy_pkginfo(info);
356 API int pkgmgrinfo_pkginfo_get_usr_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
357 void *user_data, uid_t uid)
359 if (pkg_list_cb == NULL) {
360 LOGE("invalid parameter");
361 return PMINFO_R_EINVAL;
364 return _pkginfo_get_filtered_foreach_pkginfo(NULL, pkg_list_cb,
368 API int pkgmgrinfo_pkginfo_get_list(pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data)
370 return pkgmgrinfo_pkginfo_get_usr_list(pkg_list_cb, user_data, GLOBAL_USER);
373 static int _pkginfo_get_author(sqlite3 *db, const char *pkgid,
376 static const char query_raw[] =
377 "SELECT author_name, author_email, author_href "
378 "FROM package_info WHERE package=%Q";
385 query = sqlite3_mprintf(query_raw, pkgid);
387 LOGE("out of memory");
388 return PMINFO_R_ERROR;
391 ret = sqlite3_prepare_v2(db, query, strlen(query),
394 if (ret != SQLITE_OK) {
395 LOGE("prepare failed: %s", sqlite3_errmsg(db));
396 return PMINFO_R_ERROR;
399 if (sqlite3_step(stmt) == SQLITE_ERROR) {
400 LOGE("step error: %s", sqlite3_errmsg(db));
401 sqlite3_finalize(stmt);
402 return PMINFO_R_ERROR;
405 /* one author per one package */
406 info = calloc(1, sizeof(author_x));
408 LOGE("out of memory");
409 sqlite3_finalize(stmt);
410 return PMINFO_R_ERROR;
413 _save_column_str(stmt, idx++, &info->text);
414 _save_column_str(stmt, idx++, &info->email);
415 _save_column_str(stmt, idx++, &info->href);
418 *author = g_list_append(*author, info);
420 sqlite3_finalize(stmt);
425 static int _pkginfo_get_label(sqlite3 *db, const char *pkgid,
426 const char *locale, GList **label)
428 static const char query_raw[] =
429 "SELECT package_label, package_locale "
430 "FROM package_localized_info "
431 "WHERE package=%Q AND package_locale IN (%Q, %Q)";
438 query = sqlite3_mprintf(query_raw, pkgid, locale, DEFAULT_LOCALE);
440 LOGE("out of memory");
441 return PMINFO_R_ERROR;
444 ret = sqlite3_prepare_v2(db, query, strlen(query),
447 if (ret != SQLITE_OK) {
448 LOGE("prepare failed: %s", sqlite3_errmsg(db));
449 return PMINFO_R_ERROR;
452 while (sqlite3_step(stmt) == SQLITE_ROW) {
453 info = calloc(1, sizeof(label_x));
455 LOGE("out of memory");
456 sqlite3_finalize(stmt);
457 return PMINFO_R_ERROR;
460 _save_column_str(stmt, idx++, &info->text);
461 _save_column_str(stmt, idx++, &info->lang);
462 *label = g_list_append(*label, info);
465 sqlite3_finalize(stmt);
470 static int _pkginfo_get_icon(sqlite3 *db, const char *pkgid, const char *locale,
473 static const char query_raw[] =
474 "SELECT package_icon, package_locale "
475 "FROM package_localized_info "
476 "WHERE package=%Q AND package_locale IN (%Q, %Q)";
483 query = sqlite3_mprintf(query_raw, pkgid, locale, DEFAULT_LOCALE);
485 LOGE("out of memory");
486 return PMINFO_R_ERROR;
489 ret = sqlite3_prepare_v2(db, query, strlen(query),
492 if (ret != SQLITE_OK) {
493 LOGE("prepare failed: %s", sqlite3_errmsg(db));
494 return PMINFO_R_ERROR;
497 while (sqlite3_step(stmt) == SQLITE_ROW) {
498 info = calloc(1, sizeof(icon_x));
500 LOGE("out of memory");
501 sqlite3_finalize(stmt);
502 return PMINFO_R_ERROR;
505 _save_column_str(stmt, idx++, &info->text);
506 _save_column_str(stmt, idx++, &info->lang);
507 *icon = g_list_append(*icon, info);
510 sqlite3_finalize(stmt);
515 static int _pkginfo_get_description(sqlite3 *db, const char *pkgid,
516 const char *locale, GList **description)
518 static const char query_raw[] =
519 "SELECT package_description, package_locale "
520 "FROM package_localized_info "
521 "WHERE package=%Q AND package_locale IN (%Q, %Q)";
528 query = sqlite3_mprintf(query_raw, pkgid, locale, DEFAULT_LOCALE);
530 LOGE("out of memory");
531 return PMINFO_R_ERROR;
534 ret = sqlite3_prepare_v2(db, query, strlen(query),
537 if (ret != SQLITE_OK) {
538 LOGE("prepare failed: %s", sqlite3_errmsg(db));
539 return PMINFO_R_ERROR;
542 while (sqlite3_step(stmt) == SQLITE_ROW) {
543 info = calloc(1, sizeof(description_x));
545 LOGE("out of memory");
546 sqlite3_finalize(stmt);
547 return PMINFO_R_ERROR;
550 _save_column_str(stmt, idx++, &info->text);
551 _save_column_str(stmt, idx++, &info->lang);
552 *description = g_list_append(*description, info);
555 sqlite3_finalize(stmt);
560 static int _pkginfo_get_privilege(sqlite3 *db, const char *pkgid,
563 static const char query_raw[] =
564 "SELECT privilege FROM package_privilege_info WHERE package=%Q";
568 const char *privilege;
570 query = sqlite3_mprintf(query_raw, pkgid);
572 LOGE("out of memory");
573 return PMINFO_R_ERROR;
576 ret = sqlite3_prepare_v2(db, query, strlen(query),
579 if (ret != SQLITE_OK) {
580 LOGE("prepare failed: %s", sqlite3_errmsg(db));
581 return PMINFO_R_ERROR;
584 while (sqlite3_step(stmt) == SQLITE_ROW) {
586 _save_column_str(stmt, 0, &privilege);
588 *privileges = g_list_append(*privileges,
589 (gpointer)privilege);
592 sqlite3_finalize(stmt);
597 static char *_get_filtered_query(const char *query_raw,
598 pkgmgrinfo_filter_x *filter)
600 char buf[MAX_QUERY_LEN] = { 0, };
609 strncat(buf, query_raw, MAX_QUERY_LEN - 1);
611 for (list = head; list; list = list->next) {
612 /* TODO: revise condition getter function */
613 __get_filter_condition(list->data, &condition);
614 if (condition == NULL)
616 if (buf[strlen(query_raw)] == '\0') {
617 len += strlen(" WHERE ");
618 strncat(buf, " WHERE ", MAX_QUERY_LEN - len - 1);
620 len += strlen(" AND ");
621 strncat(buf, " AND ", MAX_QUERY_LEN -len - 1);
623 len += strlen(condition);
624 strncat(buf, condition, sizeof(buf) - len - 1);
632 static int _pkginfo_get_package(sqlite3 *db, const char *pkgid,
633 const char *locale, package_x **package)
635 static const char query_raw[] =
636 "SELECT package, package_version, "
637 "install_location, package_removable, package_preload, "
638 "package_readonly, package_update, package_appsetting, "
639 "package_system, package_type, package_size, installed_time, "
640 "installed_storage, storeclient_id, mainapp_id, package_url, "
641 "root_path, csc_path, package_nodisplay, package_api_version, "
642 "package_support_disable, package_tep_name "
643 "FROM package_info WHERE package=%Q AND package_disable='false'";
650 query = sqlite3_mprintf(query_raw, pkgid);
652 LOGE("out of memory");
653 return PMINFO_R_ERROR;
656 ret = sqlite3_prepare_v2(db, query, strlen(query),
659 if (ret != SQLITE_OK) {
660 LOGE("prepare failed: %s", sqlite3_errmsg(db));
661 return PMINFO_R_ERROR;
664 ret = sqlite3_step(stmt);
665 if (ret == SQLITE_DONE) {
666 sqlite3_finalize(stmt);
667 return PMINFO_R_ENOENT;
668 } else if (ret != SQLITE_ROW) {
669 LOGE("step failed: %s", sqlite3_errmsg(db));
670 sqlite3_finalize(stmt);
671 return PMINFO_R_ERROR;
674 info = calloc(1, sizeof(package_x));
676 LOGE("out of memory");
677 sqlite3_finalize(stmt);
678 return PMINFO_R_ERROR;
681 _save_column_str(stmt, idx++, &info->package);
682 _save_column_str(stmt, idx++, &info->version);
683 _save_column_str(stmt, idx++, &info->installlocation);
684 _save_column_str(stmt, idx++, &info->removable);
685 _save_column_str(stmt, idx++, &info->preload);
686 _save_column_str(stmt, idx++, &info->readonly);
687 _save_column_str(stmt, idx++, &info->update);
688 _save_column_str(stmt, idx++, &info->appsetting);
689 _save_column_str(stmt, idx++, &info->system);
690 _save_column_str(stmt, idx++, &info->type);
691 _save_column_str(stmt, idx++, &info->package_size);
692 _save_column_str(stmt, idx++, &info->installed_time);
693 _save_column_str(stmt, idx++, &info->installed_storage);
694 _save_column_str(stmt, idx++, &info->storeclient_id);
695 _save_column_str(stmt, idx++, &info->mainapp_id);
696 _save_column_str(stmt, idx++, &info->package_url);
697 _save_column_str(stmt, idx++, &info->root_path);
698 _save_column_str(stmt, idx++, &info->csc_path);
699 _save_column_str(stmt, idx++, &info->nodisplay_setting);
700 _save_column_str(stmt, idx++, &info->api_version);
701 _save_column_str(stmt, idx++, &info->support_disable);
702 _save_column_str(stmt, idx++, &info->tep_name);
704 if (_pkginfo_get_author(db, info->package, &info->author)) {
705 pkgmgrinfo_basic_free_package(info);
706 sqlite3_finalize(stmt);
707 return PMINFO_R_ERROR;
710 if (_pkginfo_get_label(db, info->package, locale, &info->label)) {
711 pkgmgrinfo_basic_free_package(info);
712 sqlite3_finalize(stmt);
713 return PMINFO_R_ERROR;
716 if (_pkginfo_get_icon(db, info->package, locale, &info->icon)) {
717 pkgmgrinfo_basic_free_package(info);
718 sqlite3_finalize(stmt);
719 return PMINFO_R_ERROR;
722 if (_pkginfo_get_description(db, info->package, locale,
723 &info->description)) {
724 pkgmgrinfo_basic_free_package(info);
725 sqlite3_finalize(stmt);
726 return PMINFO_R_ERROR;
729 if (_pkginfo_get_privilege(db, info->package, &info->privileges)) {
730 pkgmgrinfo_basic_free_package(info);
731 sqlite3_finalize(stmt);
732 return PMINFO_R_ERROR;
736 sqlite3_finalize(stmt);
741 static int _pkginfo_get_pkginfo(const char *pkgid, uid_t uid,
742 pkgmgr_pkginfo_x **pkginfo)
748 pkgmgr_pkginfo_x *info;
750 dbpath = getUserPkgParserDBPathUID(uid);
752 return PMINFO_R_ERROR;
754 locale = _get_system_locale();
756 return PMINFO_R_ERROR;
758 ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
759 if (ret != SQLITE_OK) {
760 _LOGE("failed to open db: %d", ret);
762 return PMINFO_R_ERROR;
765 info = calloc(1, sizeof(pkgmgr_pkginfo_x));
767 _LOGE("out of memory");
769 sqlite3_close_v2(db);
770 return PMINFO_R_ERROR;
773 ret = _pkginfo_get_package(db, pkgid, locale, &info->pkg_info);
774 if (ret != PMINFO_R_OK) {
777 sqlite3_close_v2(db);
781 info->locale = locale;
783 info->pkg_info->for_all_users = strdup(
784 uid != GLOBAL_USER ? "false" : "true");
788 sqlite3_close_v2(db);
793 API int pkgmgrinfo_pkginfo_get_usr_pkginfo(const char *pkgid, uid_t uid,
794 pkgmgrinfo_pkginfo_h *handle)
798 if (pkgid == NULL || handle == NULL) {
799 LOGE("invalid parameter");
800 return PMINFO_R_EINVAL;
803 ret = _pkginfo_get_pkginfo(pkgid, uid, (pkgmgr_pkginfo_x **)handle);
804 if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
805 ret = _pkginfo_get_pkginfo(pkgid, GLOBAL_USER,
806 (pkgmgr_pkginfo_x **)handle);
808 if (ret != PMINFO_R_OK)
809 _LOGE("failed to get pkginfo of %s for user %d", pkgid, uid);
814 API int pkgmgrinfo_pkginfo_get_pkginfo(const char *pkgid, pkgmgrinfo_pkginfo_h *handle)
816 return pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, GLOBAL_USER, handle);
819 API int pkgmgrinfo_pkginfo_get_pkgname(pkgmgrinfo_pkginfo_h handle, char **pkg_name)
821 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
823 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
824 retvm_if(pkg_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
826 if (info->pkg_info == NULL || info->pkg_info->package == NULL)
827 return PMINFO_R_ERROR;
829 *pkg_name = (char *)info->pkg_info->package;
834 API int pkgmgrinfo_pkginfo_get_pkgid(pkgmgrinfo_pkginfo_h handle, char **pkgid)
836 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
838 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
839 retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
841 if (info->pkg_info == NULL || info->pkg_info->package == NULL)
842 return PMINFO_R_ERROR;
844 *pkgid = (char *)info->pkg_info->package;
849 API int pkgmgrinfo_pkginfo_get_type(pkgmgrinfo_pkginfo_h handle, char **type)
851 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
853 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
854 retvm_if(type == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
856 if (info->pkg_info == NULL || info->pkg_info->type == NULL)
857 return PMINFO_R_ERROR;
859 *type = (char *)info->pkg_info->type;
864 API int pkgmgrinfo_pkginfo_get_version(pkgmgrinfo_pkginfo_h handle, char **version)
866 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
868 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
869 retvm_if(version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
871 if (info->pkg_info == NULL || info->pkg_info->version == NULL)
872 return PMINFO_R_ERROR;
874 *version = (char *)info->pkg_info->version;
879 API int pkgmgrinfo_pkginfo_get_api_version(pkgmgrinfo_pkginfo_h handle, char **api_version)
881 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
883 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
884 retvm_if(api_version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
886 if (info->pkg_info == NULL || info->pkg_info->api_version == NULL)
887 return PMINFO_R_ERROR;
889 *api_version = (char *)info->pkg_info->api_version;
894 API int pkgmgrinfo_pkginfo_get_tep_name(pkgmgrinfo_pkginfo_h handle, char **tep_name)
896 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
898 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
899 retvm_if(tep_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
901 if (info->pkg_info == NULL || info->pkg_info->tep_name == NULL)
902 return PMINFO_R_ERROR;
904 if (strlen(info->pkg_info->tep_name) == 0)
905 return PMINFO_R_ERROR;
907 *tep_name = (char *)info->pkg_info->tep_name;
912 API int pkgmgrinfo_pkginfo_get_install_location(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_install_location *location)
915 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
917 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
918 retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
920 if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
921 return PMINFO_R_ERROR;
923 val = (char *)info->pkg_info->installlocation;
924 if (strcmp(val, "internal-only") == 0)
925 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
926 else if (strcmp(val, "prefer-external") == 0)
927 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
929 *location = PMINFO_INSTALL_LOCATION_AUTO;
934 API int pkgmgrinfo_pkginfo_get_package_size(pkgmgrinfo_pkginfo_h handle, int *size)
936 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
938 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
939 retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
941 if (info->pkg_info == NULL || info->pkg_info->package_size == NULL)
942 return PMINFO_R_ERROR;
944 *size = atoi((char *)info->pkg_info->package_size);
949 API int pkgmgrinfo_pkginfo_get_total_size(pkgmgrinfo_pkginfo_h handle, int *size)
952 char device_path[PKG_STRING_LEN_MAX] = { '\0', };
953 long long rw_size = 0;
954 long long ro_size = 0;
955 long long tmp_size = 0;
956 long long total_size = 0;
957 struct stat fileinfo;
960 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
961 retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
963 ret = pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
965 return PMINFO_R_ERROR;
968 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/bin", PKG_RW_PATH, pkgid);
969 if (lstat(device_path, &fileinfo) == 0) {
970 if (!S_ISLNK(fileinfo.st_mode)) {
971 tmp_size = _pkgmgr_calculate_dir_size(device_path);
977 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/info", PKG_RW_PATH, pkgid);
978 if (lstat(device_path, &fileinfo) == 0) {
979 if (!S_ISLNK(fileinfo.st_mode)) {
980 tmp_size = _pkgmgr_calculate_dir_size(device_path);
986 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/res", PKG_RW_PATH, pkgid);
987 if (lstat(device_path, &fileinfo) == 0) {
988 if (!S_ISLNK(fileinfo.st_mode)) {
989 tmp_size = _pkgmgr_calculate_dir_size(device_path);
995 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/data", PKG_RW_PATH, pkgid);
996 if (lstat(device_path, &fileinfo) == 0) {
997 if (!S_ISLNK(fileinfo.st_mode)) {
998 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1000 rw_size += tmp_size;
1004 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/shared", PKG_RW_PATH, pkgid);
1005 if (lstat(device_path, &fileinfo) == 0) {
1006 if (!S_ISLNK(fileinfo.st_mode)) {
1007 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1009 rw_size += tmp_size;
1013 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/setting", PKG_RW_PATH, pkgid);
1014 if (lstat(device_path, &fileinfo) == 0) {
1015 if (!S_ISLNK(fileinfo.st_mode)) {
1016 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1018 rw_size += tmp_size;
1023 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/bin", PKG_RO_PATH, pkgid);
1024 if (lstat(device_path, &fileinfo) == 0) {
1025 if (!S_ISLNK(fileinfo.st_mode)) {
1026 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1028 ro_size += tmp_size;
1032 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/info", PKG_RO_PATH, pkgid);
1033 if (lstat(device_path, &fileinfo) == 0) {
1034 if (!S_ISLNK(fileinfo.st_mode)) {
1035 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1037 ro_size += tmp_size;
1041 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/res", PKG_RO_PATH, pkgid);
1042 if (lstat(device_path, &fileinfo) == 0) {
1043 if (!S_ISLNK(fileinfo.st_mode)) {
1044 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1046 ro_size += tmp_size;
1050 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/data", PKG_RO_PATH, pkgid);
1051 if (lstat(device_path, &fileinfo) == 0) {
1052 if (!S_ISLNK(fileinfo.st_mode)) {
1053 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1055 ro_size += tmp_size;
1059 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/shared", PKG_RO_PATH, pkgid);
1060 if (lstat(device_path, &fileinfo) == 0) {
1061 if (!S_ISLNK(fileinfo.st_mode)) {
1062 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1064 ro_size += tmp_size;
1068 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/setting", PKG_RO_PATH, pkgid);
1069 if (lstat(device_path, &fileinfo) == 0) {
1070 if (!S_ISLNK(fileinfo.st_mode)) {
1071 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1073 ro_size += tmp_size;
1078 total_size = rw_size + ro_size;
1079 *size = (int)total_size;
1084 API int pkgmgrinfo_pkginfo_get_data_size(pkgmgrinfo_pkginfo_h handle, int *size)
1087 char device_path[PKG_STRING_LEN_MAX] = { '\0', };
1088 long long total_size = 0;
1090 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1091 retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1093 if (pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid) < 0)
1094 return PMINFO_R_ERROR;
1096 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/data", PKG_RW_PATH, pkgid);
1097 if (access(device_path, R_OK) == 0)
1098 total_size = _pkgmgr_calculate_dir_size(device_path);
1100 return PMINFO_R_ERROR;
1102 *size = (int)total_size;
1107 API int pkgmgrinfo_pkginfo_get_icon(pkgmgrinfo_pkginfo_h handle, char **icon)
1112 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1114 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1115 retvm_if(icon == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1117 locale = info->locale;
1118 retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
1120 if (info->pkg_info == NULL)
1121 return PMINFO_R_ERROR;
1123 for (tmp = info->pkg_info->icon; tmp; tmp = tmp->next) {
1124 ptr = (icon_x *)tmp->data;
1125 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1126 !strcasecmp(ptr->text, "(null)") ||
1127 strcmp(ptr->lang, locale))
1129 *icon = (char *)ptr->text;
1133 locale = DEFAULT_LOCALE;
1134 for (tmp = info->pkg_info->icon; tmp; tmp = tmp->next) {
1135 ptr = (icon_x *)tmp->data;
1136 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1137 strcmp(ptr->lang, locale))
1139 *icon = (char *)ptr->text;
1143 return PMINFO_R_ERROR;
1146 API int pkgmgrinfo_pkginfo_get_label(pkgmgrinfo_pkginfo_h handle, char **label)
1151 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1153 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1154 retvm_if(label == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1156 locale = info->locale;
1157 retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
1159 for (tmp = info->pkg_info->label; tmp != NULL; tmp = tmp->next) {
1160 ptr = (label_x *)tmp->data;
1161 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1162 strcmp(ptr->lang, locale))
1164 *label = (char *)ptr->text;
1168 locale = DEFAULT_LOCALE;
1169 for (tmp = info->pkg_info->label; tmp != NULL; tmp = tmp->next) {
1170 ptr = (label_x *)tmp->data;
1171 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1172 strcmp(ptr->lang, locale))
1174 *label = (char *)ptr->text;
1178 return PMINFO_R_ERROR;
1181 API int pkgmgrinfo_pkginfo_get_description(pkgmgrinfo_pkginfo_h handle, char **description)
1186 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1188 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1189 retvm_if(description == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1191 locale = info->locale;
1192 retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
1194 for (tmp = info->pkg_info->description; tmp; tmp = tmp->next) {
1195 ptr = (description_x *)tmp->data;
1196 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1197 strcmp(ptr->lang, locale))
1199 *description = (char *)ptr->text;
1203 locale = DEFAULT_LOCALE;
1204 for (tmp = info->pkg_info->description; tmp; tmp = tmp->next) {
1205 ptr = (description_x *)tmp->data;
1206 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1207 strcmp(ptr->lang, locale))
1209 *description = (char *)ptr->text;
1213 return PMINFO_R_ERROR;
1216 API int pkgmgrinfo_pkginfo_get_author_name(pkgmgrinfo_pkginfo_h handle, char **author_name)
1218 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1221 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1222 retvm_if(author_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1224 if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1225 return PMINFO_R_ERROR;
1227 author = (author_x *)info->pkg_info->author->data;
1228 if (author == NULL || author->text == NULL)
1229 return PMINFO_R_ERROR;
1231 *author_name = (char *)author->text;
1236 API int pkgmgrinfo_pkginfo_get_author_email(pkgmgrinfo_pkginfo_h handle, char **author_email)
1238 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1241 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1242 retvm_if(author_email == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1244 if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1245 return PMINFO_R_ERROR;
1247 author = (author_x *)info->pkg_info->author->data;
1248 if (author == NULL || author->email == NULL)
1249 return PMINFO_R_ERROR;
1251 *author_email = (char *)author->email;
1256 API int pkgmgrinfo_pkginfo_get_author_href(pkgmgrinfo_pkginfo_h handle, char **author_href)
1258 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1261 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1262 retvm_if(author_href == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1264 if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1265 return PMINFO_R_ERROR;
1267 author = (author_x *)info->pkg_info->author->data;
1268 if (author == NULL || author->href == NULL)
1269 return PMINFO_R_ERROR;
1271 *author_href = (char *)author->href;
1276 API int pkgmgrinfo_pkginfo_get_installed_storage(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_installed_storage *storage)
1278 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1280 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1281 retvm_if(storage == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1283 if (info->pkg_info == NULL || info->pkg_info->installed_storage == NULL)
1284 return PMINFO_R_ERROR;
1286 if (strcmp(info->pkg_info->installed_storage,"installed_internal") == 0)
1287 *storage = PMINFO_INTERNAL_STORAGE;
1288 else if (strcmp(info->pkg_info->installed_storage,"installed_external") == 0)
1289 *storage = PMINFO_EXTERNAL_STORAGE;
1291 return PMINFO_R_ERROR;
1296 API int pkgmgrinfo_pkginfo_get_installed_time(pkgmgrinfo_pkginfo_h handle, int *installed_time)
1298 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1300 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1301 retvm_if(installed_time == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1303 if (info->pkg_info == NULL || info->pkg_info->installed_time == NULL)
1304 return PMINFO_R_ERROR;
1306 *installed_time = atoi(info->pkg_info->installed_time);
1311 API int pkgmgrinfo_pkginfo_get_storeclientid(pkgmgrinfo_pkginfo_h handle, char **storeclientid)
1313 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1315 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1316 retvm_if(storeclientid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1318 if (info->pkg_info == NULL || info->pkg_info->storeclient_id == NULL)
1319 return PMINFO_R_ERROR;
1321 *storeclientid = (char *)info->pkg_info->storeclient_id;
1326 API int pkgmgrinfo_pkginfo_get_mainappid(pkgmgrinfo_pkginfo_h handle, char **mainappid)
1328 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1330 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1331 retvm_if(mainappid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1333 if (info->pkg_info == NULL || info->pkg_info->mainapp_id == NULL)
1334 return PMINFO_R_ERROR;
1336 *mainappid = (char *)info->pkg_info->mainapp_id;
1341 API int pkgmgrinfo_pkginfo_get_url(pkgmgrinfo_pkginfo_h handle, char **url)
1343 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1345 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1346 retvm_if(url == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1348 if (info->pkg_info == NULL || info->pkg_info->package_url == NULL)
1349 return PMINFO_R_ERROR;
1351 *url = (char *)info->pkg_info->package_url;
1356 API int pkgmgrinfo_pkginfo_get_size_from_xml(const char *manifest, int *size)
1358 const char *val = NULL;
1359 const xmlChar *node;
1360 xmlTextReaderPtr reader;
1361 retvm_if(manifest == NULL, PMINFO_R_EINVAL, "Input argument is NULL\n");
1362 retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1365 reader = xmlReaderForFile(manifest, NULL, 0);
1368 if (__child_element(reader, -1)) {
1369 node = xmlTextReaderConstName(reader);
1371 _LOGE("xmlTextReaderConstName value is NULL\n");
1372 xmlFreeTextReader(reader);
1374 return PMINFO_R_ERROR;
1377 if (!strcmp(ASC_CHAR(node), "manifest")) {
1378 if (xmlTextReaderGetAttribute(reader, XML_CHAR("size")))
1379 val = ASC_CHAR(xmlTextReaderGetAttribute(reader, XML_CHAR("size")));
1385 _LOGE("package size is not specified\n");
1386 xmlFreeTextReader(reader);
1388 return PMINFO_R_ERROR;
1391 _LOGE("Unable to create xml reader\n");
1392 xmlFreeTextReader(reader);
1394 return PMINFO_R_ERROR;
1398 _LOGE("xmlReaderForFile value is NULL\n");
1400 return PMINFO_R_ERROR;
1403 xmlFreeTextReader(reader);
1409 API int pkgmgrinfo_pkginfo_get_location_from_xml(const char *manifest, pkgmgrinfo_install_location *location)
1411 const char *val = NULL;
1412 const xmlChar *node;
1413 xmlTextReaderPtr reader;
1414 retvm_if(manifest == NULL, PMINFO_R_EINVAL, "Input argument is NULL\n");
1415 retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1418 reader = xmlReaderForFile(manifest, NULL, 0);
1421 if ( __child_element(reader, -1)) {
1422 node = xmlTextReaderConstName(reader);
1424 _LOGE("xmlTextReaderConstName value is NULL\n");
1425 xmlFreeTextReader(reader);
1427 return PMINFO_R_ERROR;
1430 if (!strcmp(ASC_CHAR(node), "manifest")) {
1431 if (xmlTextReaderGetAttribute(reader, XML_CHAR("install-location")))
1432 val = ASC_CHAR(xmlTextReaderGetAttribute(reader, XML_CHAR("install-location")));
1435 if (strcmp(val, "internal-only") == 0)
1436 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
1437 else if (strcmp(val, "prefer-external") == 0)
1438 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
1440 *location = PMINFO_INSTALL_LOCATION_AUTO;
1443 _LOGE("Unable to create xml reader\n");
1444 xmlFreeTextReader(reader);
1446 return PMINFO_R_ERROR;
1450 _LOGE("xmlReaderForFile value is NULL\n");
1452 return PMINFO_R_ERROR;
1455 xmlFreeTextReader(reader);
1462 API int pkgmgrinfo_pkginfo_get_root_path(pkgmgrinfo_pkginfo_h handle, char **path)
1464 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1466 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1467 retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1469 if (info->pkg_info == NULL || info->pkg_info->root_path == NULL)
1470 return PMINFO_R_ERROR;
1472 *path = (char *)info->pkg_info->root_path;
1477 API int pkgmgrinfo_pkginfo_get_csc_path(pkgmgrinfo_pkginfo_h handle, char **path)
1479 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1481 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1482 retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1484 if (info->pkg_info == NULL || info->pkg_info->csc_path == NULL)
1485 return PMINFO_R_ERROR;
1487 *path = (char *)info->pkg_info->csc_path;
1493 API int pkgmgrinfo_pkginfo_is_accessible(pkgmgrinfo_pkginfo_h handle, bool *accessible)
1495 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1496 retvm_if(accessible == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1498 #if 0 //smack issue occured, check later
1500 pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
1502 _LOGD("invalid func parameters\n");
1503 return PMINFO_R_ERROR;
1505 _LOGD("pkgmgr_get_pkg_external_validation() called\n");
1508 char app_mmc_path[FILENAME_MAX] = { 0, };
1509 char app_dir_path[FILENAME_MAX] = { 0, };
1510 char app_mmc_internal_path[FILENAME_MAX] = { 0, };
1511 snprintf(app_dir_path, FILENAME_MAX,"%s%s", PKG_INSTALLATION_PATH, pkgid);
1512 snprintf(app_mmc_path, FILENAME_MAX,"%s%s", PKG_SD_PATH, pkgid);
1513 snprintf(app_mmc_internal_path, FILENAME_MAX,"%s%s/.mmc", PKG_INSTALLATION_PATH, pkgid);
1515 /*check whether application is in external memory or not */
1516 fp = fopen(app_mmc_path, "r");
1518 _LOGD(" app path in external memory not accesible\n");
1523 _LOGD("pkgmgr_get_pkg_external_validation() : SD_CARD \n");
1527 /*check whether application is in internal or not */
1528 fp = fopen(app_dir_path, "r");
1530 _LOGD(" app path in internal memory not accesible\n");
1532 return PMINFO_R_ERROR;
1535 /*check whether the application is installed in SD card
1536 but SD card is not present*/
1537 fp = fopen(app_mmc_internal_path, "r");
1540 _LOGD("pkgmgr_get_pkg_external_validation() : INTERNAL_MEM \n");
1545 _LOGD("pkgmgr_get_pkg_external_validation() : ERROR_MMC_STATUS \n");
1550 _LOGD("pkgmgr_get_pkg_external_validation() end\n");
1557 API int pkgmgrinfo_pkginfo_is_removable(pkgmgrinfo_pkginfo_h handle, bool *removable)
1559 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1561 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1562 retvm_if(removable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1564 if (info->pkg_info == NULL || info->pkg_info->removable == NULL)
1565 return PMINFO_R_ERROR;
1567 *removable = _get_bool_value(info->pkg_info->removable);
1572 API int pkgmgrinfo_pkginfo_is_movable(pkgmgrinfo_pkginfo_h handle, bool *movable)
1575 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1577 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1578 retvm_if(movable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1580 if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
1581 return PMINFO_R_ERROR;
1583 val = (char *)info->pkg_info->installlocation;
1584 if (strcmp(val, "internal-only") == 0)
1586 else if (strcmp(val, "prefer-external") == 0)
1594 API int pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo_h handle, bool *preload)
1596 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1598 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1599 retvm_if(preload == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1601 if (info->pkg_info == NULL || info->pkg_info->preload == NULL)
1602 return PMINFO_R_ERROR;
1604 *preload = _get_bool_value(info->pkg_info->preload);
1609 API int pkgmgrinfo_pkginfo_is_system(pkgmgrinfo_pkginfo_h handle, bool *system)
1611 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1613 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1614 retvm_if(system == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1616 if (info->pkg_info == NULL || info->pkg_info->system == NULL)
1617 return PMINFO_R_ERROR;
1619 *system = _get_bool_value(info->pkg_info->system);
1624 API int pkgmgrinfo_pkginfo_is_readonly(pkgmgrinfo_pkginfo_h handle, bool *readonly)
1626 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1628 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1629 retvm_if(readonly == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1631 if (info->pkg_info == NULL || info->pkg_info->readonly == NULL)
1632 return PMINFO_R_ERROR;
1634 *readonly = _get_bool_value(info->pkg_info->readonly);
1639 API int pkgmgrinfo_pkginfo_is_update(pkgmgrinfo_pkginfo_h handle, bool *update)
1641 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1643 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1644 retvm_if(update == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1646 if (info->pkg_info == NULL || info->pkg_info->update == NULL)
1647 return PMINFO_R_ERROR;
1649 *update = _get_bool_value(info->pkg_info->update);
1654 API int pkgmgrinfo_pkginfo_is_support_disable(pkgmgrinfo_pkginfo_h handle, bool *support_disable)
1656 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1658 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1659 retvm_if(support_disable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1661 if (info->pkg_info == NULL || info->pkg_info->support_disable == NULL)
1662 return PMINFO_R_ERROR;
1664 *support_disable = _get_bool_value(info->pkg_info->support_disable);
1669 API int pkgmgrinfo_pkginfo_is_global(pkgmgrinfo_pkginfo_h handle, bool *global)
1671 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1673 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1674 retvm_if(global == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1676 if (info->pkg_info == NULL || info->pkg_info->for_all_users == NULL)
1677 return PMINFO_R_ERROR;
1679 *global = _get_bool_value(info->pkg_info->for_all_users);
1684 API int pkgmgrinfo_pkginfo_is_for_all_users(pkgmgrinfo_pkginfo_h handle, bool *for_all_users)
1686 return pkgmgrinfo_pkginfo_is_global(handle, for_all_users);
1689 API int pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo_h handle)
1691 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1693 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1695 __cleanup_pkginfo(info);
1700 API int pkgmgrinfo_pkginfo_filter_create(pkgmgrinfo_pkginfo_filter_h *handle)
1702 pkgmgrinfo_filter_x *filter;
1704 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle output parameter is NULL\n");
1706 filter = (pkgmgrinfo_filter_x*)calloc(1, sizeof(pkgmgrinfo_filter_x));
1707 if (filter == NULL) {
1708 _LOGE("Out of Memory!!!");
1709 return PMINFO_R_ERROR;
1717 API int pkgmgrinfo_pkginfo_filter_destroy(pkgmgrinfo_pkginfo_filter_h handle)
1719 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1721 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1724 g_slist_foreach(filter->list, __destroy_each_node, NULL);
1725 g_slist_free(filter->list);
1733 API int pkgmgrinfo_pkginfo_filter_add_int(pkgmgrinfo_pkginfo_filter_h handle,
1734 const char *property, const int value)
1736 char buf[PKG_VALUE_STRING_LEN_MAX] = {'\0'};
1740 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1741 pkgmgrinfo_node_x *node;
1743 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1744 retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1746 prop = _pminfo_pkginfo_convert_to_prop_int(property);
1747 if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_INT ||
1748 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_INT) {
1749 _LOGE("Invalid Integer Property\n");
1750 return PMINFO_R_EINVAL;
1752 node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1754 _LOGE("Out of Memory!!!\n");
1755 return PMINFO_R_ERROR;
1757 snprintf(buf, PKG_VALUE_STRING_LEN_MAX - 1, "%d", value);
1758 val = strndup(buf, PKG_VALUE_STRING_LEN_MAX - 1);
1760 _LOGE("Out of Memory\n");
1762 return PMINFO_R_ERROR;
1766 /*If API is called multiple times for same property, we should override the previous values.
1767 Last value set will be used for filtering.*/
1768 link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1770 filter->list = g_slist_delete_link(filter->list, link);
1771 filter->list = g_slist_append(filter->list, (gpointer)node);
1776 API int pkgmgrinfo_pkginfo_filter_add_bool(pkgmgrinfo_pkginfo_filter_h handle,
1777 const char *property, const bool value)
1782 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1783 pkgmgrinfo_node_x *node;
1785 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1786 retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1788 prop = _pminfo_pkginfo_convert_to_prop_bool(property);
1789 if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_BOOL ||
1790 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_BOOL) {
1791 _LOGE("Invalid Boolean Property\n");
1792 return PMINFO_R_EINVAL;
1794 node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1796 _LOGE("Out of Memory!!!\n");
1797 return PMINFO_R_ERROR;
1800 val = strndup("('true','True')", 15);
1802 val = strndup("('false','False')", 17);
1804 _LOGE("Out of Memory\n");
1806 return PMINFO_R_ERROR;
1810 /*If API is called multiple times for same property, we should override the previous values.
1811 Last value set will be used for filtering.*/
1812 link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1814 filter->list = g_slist_delete_link(filter->list, link);
1815 filter->list = g_slist_append(filter->list, (gpointer)node);
1820 API int pkgmgrinfo_pkginfo_filter_add_string(pkgmgrinfo_pkginfo_filter_h handle,
1821 const char *property, const char *value)
1826 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1827 pkgmgrinfo_node_x *node;
1829 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1830 retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1831 retvm_if(value == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1833 prop = _pminfo_pkginfo_convert_to_prop_str(property);
1834 if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_STR ||
1835 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_STR) {
1836 _LOGE("Invalid String Property\n");
1837 return PMINFO_R_EINVAL;
1839 node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1841 _LOGE("Out of Memory!!!\n");
1842 return PMINFO_R_ERROR;
1844 if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_AUTO) == 0)
1845 val = strndup("auto", PKG_STRING_LEN_MAX - 1);
1846 else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_INTERNAL) == 0)
1847 val = strndup("internal-only", PKG_STRING_LEN_MAX - 1);
1848 else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_EXTERNAL) == 0)
1849 val = strndup("prefer-external", PKG_STRING_LEN_MAX - 1);
1850 else if (strcmp(value, "installed_internal") == 0)
1851 val = strndup("installed_internal", PKG_STRING_LEN_MAX - 1);
1852 else if (strcmp(value, "installed_external") == 0)
1853 val = strndup("installed_external", PKG_STRING_LEN_MAX - 1);
1855 val = strndup(value, PKG_STRING_LEN_MAX - 1);
1857 _LOGE("Out of Memory\n");
1859 return PMINFO_R_ERROR;
1863 /*If API is called multiple times for same property, we should override the previous values.
1864 Last value set will be used for filtering.*/
1865 link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1867 filter->list = g_slist_delete_link(filter->list, link);
1868 filter->list = g_slist_append(filter->list, (gpointer)node);
1873 API int pkgmgrinfo_pkginfo_usr_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count, uid_t uid)
1878 if (handle == NULL || count == NULL) {
1879 _LOGE("invalid parameter");
1880 return PMINFO_R_EINVAL;
1883 ret = _pkginfo_get_filtered_list((pkgmgrinfo_filter_x *)handle, uid, &list);
1884 if (ret != PMINFO_R_OK)
1885 return PMINFO_R_ERROR;
1887 *count = g_list_length(list);
1889 g_list_free_full(list, free);
1894 API int pkgmgrinfo_pkginfo_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count)
1896 return pkgmgrinfo_pkginfo_usr_filter_count(handle, count, GLOBAL_USER);
1899 API int pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(
1900 pkgmgrinfo_pkginfo_filter_h handle,
1901 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data, uid_t uid)
1903 if (handle == NULL || pkg_cb == NULL) {
1904 LOGE("invalid parameter");
1905 return PMINFO_R_EINVAL;
1908 return _pkginfo_get_filtered_foreach_pkginfo(handle, pkg_cb, user_data,
1912 API int pkgmgrinfo_pkginfo_filter_foreach_pkginfo(pkgmgrinfo_pkginfo_filter_h handle,
1913 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data)
1915 return pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(handle, pkg_cb, user_data, GLOBAL_USER);
1918 API int pkgmgrinfo_pkginfo_foreach_privilege(pkgmgrinfo_pkginfo_h handle,
1919 pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data)
1921 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1922 retvm_if(privilege_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
1924 const char *privilege;
1926 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1928 if (info->pkg_info == NULL)
1929 return PMINFO_R_ERROR;
1931 for (tmp = info->pkg_info->privileges; tmp; tmp = tmp->next) {
1932 privilege = (const char *)tmp->data;
1933 if (privilege == NULL)
1935 ret = privilege_func(privilege, user_data);