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 _get_filtered_query(pkgmgrinfo_filter_x *filter, char **query, GList **bind_params);
52 static bool _get_bool_value(const char *str)
56 else if (!strcasecmp(str, "true"))
62 static gint __compare_func(gconstpointer data1, gconstpointer data2)
64 pkgmgrinfo_node_x *node1 = (pkgmgrinfo_node_x*)data1;
65 pkgmgrinfo_node_x *node2 = (pkgmgrinfo_node_x*)data2;
66 if (node1->prop == node2->prop)
68 else if (node1->prop > node2->prop)
74 static void __destroy_each_node(gpointer data, gpointer user_data)
77 pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x*)data;
90 static void __cleanup_pkginfo(pkgmgr_pkginfo_x *data)
94 free((void *)data->locale);
98 pkgmgrinfo_basic_free_package(data->pkg_info);
104 static int __child_element(xmlTextReaderPtr reader, int depth)
106 int ret = xmlTextReaderRead(reader);
107 int cur = xmlTextReaderDepth(reader);
110 switch (xmlTextReaderNodeType(reader)) {
111 case XML_READER_TYPE_ELEMENT:
112 if (cur == depth + 1)
115 case XML_READER_TYPE_TEXT:
116 /*text is handled by each function separately*/
117 if (cur == depth + 1)
120 case XML_READER_TYPE_END_ELEMENT:
129 ret = xmlTextReaderRead(reader);
130 cur = xmlTextReaderDepth(reader);
135 long long _pkgmgr_calculate_dir_size(char *dirname)
139 int q = 0; /*quotient*/
140 int r = 0; /*remainder*/
142 struct dirent ep, *result;
143 struct stat fileinfo;
144 char abs_filename[FILENAME_MAX] = { 0, };
145 retvm_if(dirname == NULL, PMINFO_R_ERROR, "dirname is NULL");
147 dp = opendir(dirname);
149 _LOGE("Couldn't open the directory\n");
153 for (ret = readdir_r(dp, &ep, &result);
154 ret == 0 && result != NULL;
155 ret = readdir_r(dp, &ep, &result)) {
156 if (!strcmp(ep.d_name, ".") ||
157 !strcmp(ep.d_name, "..")) {
160 snprintf(abs_filename, FILENAME_MAX, "%s/%s", dirname,
162 if (lstat(abs_filename, &fileinfo) < 0)
163 perror(abs_filename);
165 if (S_ISDIR(fileinfo.st_mode)) {
166 total += fileinfo.st_size;
167 if (strcmp(ep.d_name, ".")
168 && strcmp(ep.d_name, "..")) {
169 ret = _pkgmgr_calculate_dir_size
173 } else if (S_ISLNK(fileinfo.st_mode)) {
176 /*It is a file. Calculate the actual
177 size occupied (in terms of 4096 blocks)*/
178 q = (fileinfo.st_size / BLOCK_SIZE);
179 r = (fileinfo.st_size % BLOCK_SIZE);
183 total += q * BLOCK_SIZE;
192 static int _pkginfo_get_author(sqlite3 *db, const char *pkgid,
195 static const char query_raw[] =
196 "SELECT author_name, author_email, author_href "
197 "FROM package_info WHERE package=%Q";
204 query = sqlite3_mprintf(query_raw, pkgid);
206 LOGE("out of memory");
207 return PMINFO_R_ERROR;
210 ret = sqlite3_prepare_v2(db, query, strlen(query),
213 if (ret != SQLITE_OK) {
214 LOGE("prepare failed: %s", sqlite3_errmsg(db));
215 return PMINFO_R_ERROR;
218 if (sqlite3_step(stmt) == SQLITE_ERROR) {
219 LOGE("step error: %s", sqlite3_errmsg(db));
220 sqlite3_finalize(stmt);
221 return PMINFO_R_ERROR;
224 /* one author per one package */
225 info = calloc(1, sizeof(author_x));
227 LOGE("out of memory");
228 sqlite3_finalize(stmt);
229 return PMINFO_R_ERROR;
232 _save_column_str(stmt, idx++, &info->text);
233 _save_column_str(stmt, idx++, &info->email);
234 _save_column_str(stmt, idx++, &info->href);
237 *author = g_list_append(*author, info);
239 sqlite3_finalize(stmt);
244 static int _pkginfo_get_label(sqlite3 *db, const char *pkgid,
245 const char *locale, GList **label)
247 static const char query_raw[] =
248 "SELECT package_label, package_locale "
249 "FROM package_localized_info "
250 "WHERE package=%Q AND package_locale IN (%Q, %Q)";
257 query = sqlite3_mprintf(query_raw, pkgid, locale, DEFAULT_LOCALE);
259 LOGE("out of memory");
260 return PMINFO_R_ERROR;
263 ret = sqlite3_prepare_v2(db, query, strlen(query),
266 if (ret != SQLITE_OK) {
267 LOGE("prepare failed: %s", sqlite3_errmsg(db));
268 return PMINFO_R_ERROR;
271 while (sqlite3_step(stmt) == SQLITE_ROW) {
272 info = calloc(1, sizeof(label_x));
274 LOGE("out of memory");
275 sqlite3_finalize(stmt);
276 return PMINFO_R_ERROR;
279 _save_column_str(stmt, idx++, &info->text);
280 _save_column_str(stmt, idx++, &info->lang);
281 *label = g_list_append(*label, info);
284 sqlite3_finalize(stmt);
289 static int _pkginfo_get_icon(sqlite3 *db, const char *pkgid, const char *locale,
292 static const char query_raw[] =
293 "SELECT package_icon, package_locale "
294 "FROM package_localized_info "
295 "WHERE package=%Q AND package_locale IN (%Q, %Q)";
302 query = sqlite3_mprintf(query_raw, pkgid, locale, DEFAULT_LOCALE);
304 LOGE("out of memory");
305 return PMINFO_R_ERROR;
308 ret = sqlite3_prepare_v2(db, query, strlen(query),
311 if (ret != SQLITE_OK) {
312 LOGE("prepare failed: %s", sqlite3_errmsg(db));
313 return PMINFO_R_ERROR;
316 while (sqlite3_step(stmt) == SQLITE_ROW) {
317 info = calloc(1, sizeof(icon_x));
319 LOGE("out of memory");
320 sqlite3_finalize(stmt);
321 return PMINFO_R_ERROR;
324 _save_column_str(stmt, idx++, &info->text);
325 _save_column_str(stmt, idx++, &info->lang);
326 *icon = g_list_append(*icon, info);
329 sqlite3_finalize(stmt);
334 static int _pkginfo_get_description(sqlite3 *db, const char *pkgid,
335 const char *locale, GList **description)
337 static const char query_raw[] =
338 "SELECT package_description, package_locale "
339 "FROM package_localized_info "
340 "WHERE package=%Q AND package_locale IN (%Q, %Q)";
347 query = sqlite3_mprintf(query_raw, pkgid, locale, DEFAULT_LOCALE);
349 LOGE("out of memory");
350 return PMINFO_R_ERROR;
353 ret = sqlite3_prepare_v2(db, query, strlen(query),
356 if (ret != SQLITE_OK) {
357 LOGE("prepare failed: %s", sqlite3_errmsg(db));
358 return PMINFO_R_ERROR;
361 while (sqlite3_step(stmt) == SQLITE_ROW) {
362 info = calloc(1, sizeof(description_x));
364 LOGE("out of memory");
365 sqlite3_finalize(stmt);
366 return PMINFO_R_ERROR;
369 _save_column_str(stmt, idx++, &info->text);
370 _save_column_str(stmt, idx++, &info->lang);
371 *description = g_list_append(*description, info);
374 sqlite3_finalize(stmt);
379 static int _pkginfo_get_privilege(sqlite3 *db, const char *pkgid,
382 static const char query_raw[] =
383 "SELECT privilege FROM package_privilege_info WHERE package=%Q";
389 query = sqlite3_mprintf(query_raw, pkgid);
391 LOGE("out of memory");
392 return PMINFO_R_ERROR;
395 ret = sqlite3_prepare_v2(db, query, strlen(query),
398 if (ret != SQLITE_OK) {
399 LOGE("prepare failed: %s", sqlite3_errmsg(db));
400 return PMINFO_R_ERROR;
403 while (sqlite3_step(stmt) == SQLITE_ROW) {
405 _save_column_str(stmt, 0, &privilege);
407 *privileges = g_list_append(*privileges,
408 (gpointer)privilege);
411 sqlite3_finalize(stmt);
416 static int _get_filtered_query(pkgmgrinfo_filter_x *filter, char **query, GList **bind_params)
418 char buf[MAX_QUERY_LEN] = { '\0' };
419 char *condition = NULL;
420 int ret = PMINFO_R_ERROR;
427 len += strlen(" WHERE 1=1 ");
428 strncat(buf, " WHERE 1=1 ", MAX_QUERY_LEN - len - 1);
429 for (list = filter->list; list; list = list->next) {
430 ret = __get_filter_condition(list->data, &condition, bind_params);
431 if (condition == NULL)
434 len += strlen(" AND ");
435 strncat(buf, " AND ", MAX_QUERY_LEN - len - 1);
437 len += strlen(condition);
438 strncat(buf, condition, sizeof(buf) - len - 1);
443 *query = strdup(buf);
445 return PMINFO_R_ERROR;
450 static void __free_packages(gpointer data)
452 pkgmgrinfo_basic_free_package((package_x *)data);
455 static int __bind_params(sqlite3_stmt *stmt, GList *params)
457 GList *tmp_list = NULL;
461 if (stmt == NULL || params == NULL)
462 return PMINFO_R_EINVAL;
466 ret = sqlite3_bind_text(stmt, ++idx, (char *)tmp_list->data, -1, SQLITE_STATIC);
467 if (ret != SQLITE_OK)
468 return PMINFO_R_ERROR;
469 tmp_list = tmp_list->next;
475 static int _pkginfo_get_packages(uid_t uid, const char *locale,
476 pkgmgrinfo_filter_x *filter, int flag, GHashTable *packages)
478 static const char query_raw[] =
479 "SELECT DISTINCT pi.package, pi.package_version, "
480 "pi.install_location, pi.package_removable, "
481 "pi.package_preload, pi.package_readonly, pi.package_update, "
482 "pi.package_appsetting, pi.package_system, pi.package_type, "
483 "pi.package_size, pi.installed_time, pi.installed_storage, "
484 "pi.storeclient_id, pi.mainapp_id, pi.package_url, "
485 "pi.root_path, pi.csc_path, pi.package_nodisplay, "
486 "pi.package_api_version, pi.package_support_disable, "
487 "pi.package_tep_name, pi.package_zip_mount_file "
488 "FROM package_info as pi ";
489 int ret = PMINFO_R_ERROR;
492 char *constraints = NULL;
493 char query[MAX_QUERY_LEN] = { '\0' };
494 package_x *info = NULL;
495 GList *bind_params = NULL;
499 dbpath = getUserPkgParserDBPathUID(uid);
501 return PMINFO_R_ERROR;
503 ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
504 if (ret != SQLITE_OK) {
505 _LOGE("failed to open db: %d", ret);
506 return PMINFO_R_ERROR;
509 /* add package_disable='false' clause by default */
510 pkgmgrinfo_pkginfo_filter_add_bool(filter, PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false);
512 ret = _get_filtered_query(filter, &constraints, &bind_params);
513 if (ret != PMINFO_R_OK) {
514 LOGE("Failed to get WHERE clause");
519 snprintf(query, MAX_QUERY_LEN - 1, "%s%s", query_raw, constraints);
521 snprintf(query, MAX_QUERY_LEN - 1, "%s", query_raw);
523 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
524 if (ret != SQLITE_OK) {
525 LOGE("prepare failed: %s", sqlite3_errmsg(db));
526 ret = PMINFO_R_ERROR;
530 ret = __bind_params(stmt, bind_params);
531 if (ret != SQLITE_OK) {
532 LOGE("Failed to bind parameters");
536 while (sqlite3_step(stmt) == SQLITE_ROW) {
537 info = calloc(1, sizeof(package_x));
539 LOGE("out of memory");
540 sqlite3_finalize(stmt);
541 sqlite3_close_v2(db);
542 return PMINFO_R_ERROR;
545 _save_column_str(stmt, idx++, &info->package);
546 if (g_hash_table_contains(packages,
547 (gconstpointer)info->package)) {
552 _save_column_str(stmt, idx++, &info->version);
553 _save_column_str(stmt, idx++, &info->installlocation);
554 _save_column_str(stmt, idx++, &info->removable);
555 _save_column_str(stmt, idx++, &info->preload);
556 _save_column_str(stmt, idx++, &info->readonly);
557 _save_column_str(stmt, idx++, &info->update);
558 _save_column_str(stmt, idx++, &info->appsetting);
559 _save_column_str(stmt, idx++, &info->system);
560 _save_column_str(stmt, idx++, &info->type);
561 _save_column_str(stmt, idx++, &info->package_size);
562 _save_column_str(stmt, idx++, &info->installed_time);
563 _save_column_str(stmt, idx++, &info->installed_storage);
564 _save_column_str(stmt, idx++, &info->storeclient_id);
565 _save_column_str(stmt, idx++, &info->mainapp_id);
566 _save_column_str(stmt, idx++, &info->package_url);
567 _save_column_str(stmt, idx++, &info->root_path);
568 _save_column_str(stmt, idx++, &info->csc_path);
569 _save_column_str(stmt, idx++, &info->nodisplay_setting);
570 _save_column_str(stmt, idx++, &info->api_version);
571 _save_column_str(stmt, idx++, &info->support_disable);
572 _save_column_str(stmt, idx++, &info->tep_name);
573 _save_column_str(stmt, idx++, &info->zip_mount_file);
574 info->for_all_users =
575 strdup((uid != GLOBAL_USER) ? "false" : "true");
577 if (flag & PMINFO_PKGINFO_GET_AUTHOR) {
578 if (_pkginfo_get_author(db, info->package,
580 pkgmgrinfo_basic_free_package(info);
581 sqlite3_finalize(stmt);
582 sqlite3_close_v2(db);
583 return PMINFO_R_ERROR;
587 if (flag & PMINFO_PKGINFO_GET_LABEL) {
588 if (_pkginfo_get_label(db, info->package, locale,
590 pkgmgrinfo_basic_free_package(info);
591 sqlite3_finalize(stmt);
592 sqlite3_close_v2(db);
593 return PMINFO_R_ERROR;
597 if (flag & PMINFO_PKGINFO_GET_ICON) {
598 if (_pkginfo_get_icon(db, info->package, locale,
600 pkgmgrinfo_basic_free_package(info);
601 sqlite3_finalize(stmt);
602 sqlite3_close_v2(db);
603 return PMINFO_R_ERROR;
607 if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) {
608 if (_pkginfo_get_description(db, info->package, locale,
609 &info->description)) {
610 pkgmgrinfo_basic_free_package(info);
611 sqlite3_finalize(stmt);
612 sqlite3_close_v2(db);
613 return PMINFO_R_ERROR;
617 if (flag & PMINFO_PKGINFO_GET_PRIVILEGE) {
618 if (_pkginfo_get_privilege(db, info->package,
619 &info->privileges)) {
620 pkgmgrinfo_basic_free_package(info);
621 sqlite3_finalize(stmt);
622 sqlite3_close_v2(db);
623 return PMINFO_R_ERROR;
627 g_hash_table_insert(packages, (gpointer)info->package,
637 if (ret != PMINFO_R_OK && info != NULL)
638 pkgmgrinfo_basic_free_package(info);
640 g_list_free_full(bind_params, free);
641 sqlite3_close_v2(db);
642 sqlite3_finalize(stmt);
647 static int _pkginfo_get_filtered_foreach_pkginfo(uid_t uid,
648 pkgmgrinfo_filter_x *filter, int flag,
649 pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data)
654 pkgmgr_pkginfo_x info;
659 locale = _get_system_locale();
661 return PMINFO_R_ERROR;
663 list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
667 return PMINFO_R_ERROR;
670 ret = _pkginfo_get_packages(uid, locale, filter, flag, list);
671 if (ret == PMINFO_R_OK && uid != GLOBAL_USER)
672 ret = _pkginfo_get_packages(GLOBAL_USER, locale, filter,
675 if (ret != PMINFO_R_OK) {
676 g_hash_table_destroy(list);
678 return PMINFO_R_ERROR;
681 g_hash_table_iter_init(&iter, list);
682 while (g_hash_table_iter_next(&iter, NULL, &value)) {
683 pkg = (package_x *)value;
686 info.locale = locale;
687 if (pkg_list_cb(&info, user_data) < 0)
691 g_hash_table_destroy(list);
697 API int pkgmgrinfo_pkginfo_get_usr_pkginfo(const char *pkgid, uid_t uid,
698 pkgmgrinfo_pkginfo_h *handle)
703 pkgmgrinfo_pkginfo_filter_h filter;
704 pkgmgr_pkginfo_x *info;
706 if (pkgid == NULL || handle == NULL) {
707 LOGE("invalid parameter");
708 return PMINFO_R_EINVAL;
711 locale = _get_system_locale();
713 return PMINFO_R_ERROR;
715 ret = pkgmgrinfo_pkginfo_filter_create(&filter);
716 if (ret != PMINFO_R_OK) {
721 ret = pkgmgrinfo_pkginfo_filter_add_string(filter,
722 PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid);
723 if (ret != PMINFO_R_OK) {
724 pkgmgrinfo_pkginfo_filter_destroy(filter);
726 return PMINFO_R_ERROR;
729 list = g_hash_table_new(g_str_hash, g_str_equal);
731 pkgmgrinfo_pkginfo_filter_destroy(filter);
733 return PMINFO_R_ERROR;
736 ret = _pkginfo_get_packages(uid, locale, filter,
737 PMINFO_PKGINFO_GET_ALL, list);
738 if (!g_hash_table_size(list) && uid != GLOBAL_USER)
739 ret = _pkginfo_get_packages(GLOBAL_USER, locale, filter,
740 PMINFO_PKGINFO_GET_ALL, list);
742 pkgmgrinfo_pkginfo_filter_destroy(filter);
743 if (ret != PMINFO_R_OK) {
744 g_hash_table_destroy(list);
749 if (!g_hash_table_size(list)) {
750 _LOGI("pkginfo for [%s] is not existed for user [%d]",
752 g_hash_table_destroy(list);
754 return PMINFO_R_ENOENT;
757 info = calloc(1, sizeof(pkgmgr_pkginfo_x));
759 _LOGE("out of memory");
760 g_hash_table_destroy(list);
762 return PMINFO_R_ERROR;
766 info->pkg_info = (package_x *)g_hash_table_lookup(list, pkgid);
767 info->locale = locale;
769 /* just free list only */
770 g_hash_table_destroy(list);
777 API int pkgmgrinfo_pkginfo_get_pkginfo(const char *pkgid,
778 pkgmgrinfo_pkginfo_h *handle)
780 return pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, _getuid(), handle);
783 API int pkgmgrinfo_pkginfo_get_usr_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb,
784 int flag, void *user_data, uid_t uid)
786 if (pkg_list_cb == NULL) {
787 LOGE("invalid parameter");
788 return PMINFO_R_EINVAL;
791 return _pkginfo_get_filtered_foreach_pkginfo(uid, NULL, flag,
792 pkg_list_cb, user_data);
795 API int pkgmgrinfo_pkginfo_get_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb,
796 int flag, void *user_data)
798 return pkgmgrinfo_pkginfo_get_usr_list_full(pkg_list_cb, flag,
799 user_data, _getuid());
802 API int pkgmgrinfo_pkginfo_get_usr_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
803 void *user_data, uid_t uid)
805 if (pkg_list_cb == NULL) {
806 LOGE("invalid parameter");
807 return PMINFO_R_EINVAL;
810 return _pkginfo_get_filtered_foreach_pkginfo(uid, NULL,
811 PMINFO_PKGINFO_GET_ALL, pkg_list_cb, user_data);
814 API int pkgmgrinfo_pkginfo_get_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
817 return pkgmgrinfo_pkginfo_get_usr_list(pkg_list_cb, user_data,
821 API int pkgmgrinfo_pkginfo_get_pkgname(pkgmgrinfo_pkginfo_h handle, char **pkg_name)
823 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
825 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
826 retvm_if(pkg_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
828 if (info->pkg_info == NULL || info->pkg_info->package == NULL)
829 return PMINFO_R_ERROR;
831 *pkg_name = (char *)info->pkg_info->package;
836 API int pkgmgrinfo_pkginfo_get_pkgid(pkgmgrinfo_pkginfo_h handle, char **pkgid)
838 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
840 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
841 retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
843 if (info->pkg_info == NULL || info->pkg_info->package == NULL)
844 return PMINFO_R_ERROR;
846 *pkgid = (char *)info->pkg_info->package;
851 API int pkgmgrinfo_pkginfo_get_type(pkgmgrinfo_pkginfo_h handle, char **type)
853 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
855 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
856 retvm_if(type == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
858 if (info->pkg_info == NULL || info->pkg_info->type == NULL)
859 return PMINFO_R_ERROR;
861 *type = (char *)info->pkg_info->type;
866 API int pkgmgrinfo_pkginfo_get_version(pkgmgrinfo_pkginfo_h handle, char **version)
868 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
870 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
871 retvm_if(version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
873 if (info->pkg_info == NULL || info->pkg_info->version == NULL)
874 return PMINFO_R_ERROR;
876 *version = (char *)info->pkg_info->version;
881 API int pkgmgrinfo_pkginfo_get_api_version(pkgmgrinfo_pkginfo_h handle, char **api_version)
883 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
885 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
886 retvm_if(api_version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
888 if (info->pkg_info == NULL || info->pkg_info->api_version == NULL)
889 return PMINFO_R_ERROR;
891 *api_version = (char *)info->pkg_info->api_version;
896 API int pkgmgrinfo_pkginfo_get_tep_name(pkgmgrinfo_pkginfo_h handle, char **tep_name)
898 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
900 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
901 retvm_if(tep_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
903 if (info->pkg_info == NULL || info->pkg_info->tep_name == NULL)
904 return PMINFO_R_ERROR;
906 if (strlen(info->pkg_info->tep_name) == 0)
907 return PMINFO_R_ERROR;
909 *tep_name = (char *)info->pkg_info->tep_name;
914 API int pkgmgrinfo_pkginfo_get_zip_mount_file(pkgmgrinfo_pkginfo_h handle, char **zip_mount_file)
916 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
918 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
919 retvm_if(zip_mount_file == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
921 if (info->pkg_info == NULL)
922 return PMINFO_R_ERROR;
924 if (strlen(info->pkg_info->zip_mount_file) > 0)
925 *zip_mount_file = (char *)info->pkg_info->zip_mount_file;
930 API int pkgmgrinfo_pkginfo_get_install_location(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_install_location *location)
933 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
935 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
936 retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
938 if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
939 return PMINFO_R_ERROR;
941 val = (char *)info->pkg_info->installlocation;
942 if (strcmp(val, "internal-only") == 0)
943 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
944 else if (strcmp(val, "prefer-external") == 0)
945 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
947 *location = PMINFO_INSTALL_LOCATION_AUTO;
952 API int pkgmgrinfo_pkginfo_get_package_size(pkgmgrinfo_pkginfo_h handle, int *size)
954 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
956 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
957 retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
959 if (info->pkg_info == NULL || info->pkg_info->package_size == NULL)
960 return PMINFO_R_ERROR;
962 *size = atoi((char *)info->pkg_info->package_size);
967 API int pkgmgrinfo_pkginfo_get_total_size(pkgmgrinfo_pkginfo_h handle, int *size)
970 char device_path[PKG_STRING_LEN_MAX] = { '\0', };
971 long long rw_size = 0;
972 long long ro_size = 0;
973 long long tmp_size = 0;
974 long long total_size = 0;
975 struct stat fileinfo;
978 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
979 retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
981 ret = pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
983 return PMINFO_R_ERROR;
986 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/bin", 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/info", 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/res", 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/data", 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;
1022 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/shared", PKG_RW_PATH, pkgid);
1023 if (lstat(device_path, &fileinfo) == 0) {
1024 if (!S_ISLNK(fileinfo.st_mode)) {
1025 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1027 rw_size += tmp_size;
1031 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/setting", PKG_RW_PATH, pkgid);
1032 if (lstat(device_path, &fileinfo) == 0) {
1033 if (!S_ISLNK(fileinfo.st_mode)) {
1034 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1036 rw_size += tmp_size;
1041 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/bin", 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/info", 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/res", 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/data", 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;
1077 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/shared", PKG_RO_PATH, pkgid);
1078 if (lstat(device_path, &fileinfo) == 0) {
1079 if (!S_ISLNK(fileinfo.st_mode)) {
1080 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1082 ro_size += tmp_size;
1086 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/setting", PKG_RO_PATH, pkgid);
1087 if (lstat(device_path, &fileinfo) == 0) {
1088 if (!S_ISLNK(fileinfo.st_mode)) {
1089 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1091 ro_size += tmp_size;
1096 total_size = rw_size + ro_size;
1097 *size = (int)total_size;
1102 API int pkgmgrinfo_pkginfo_get_data_size(pkgmgrinfo_pkginfo_h handle, int *size)
1105 char device_path[PKG_STRING_LEN_MAX] = { '\0', };
1106 long long total_size = 0;
1108 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1109 retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1111 if (pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid) < 0)
1112 return PMINFO_R_ERROR;
1114 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/data", PKG_RW_PATH, pkgid);
1115 if (access(device_path, R_OK) == 0)
1116 total_size = _pkgmgr_calculate_dir_size(device_path);
1118 return PMINFO_R_ERROR;
1120 *size = (int)total_size;
1125 API int pkgmgrinfo_pkginfo_get_icon(pkgmgrinfo_pkginfo_h handle, char **icon)
1130 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1132 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1133 retvm_if(icon == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1135 locale = info->locale;
1136 retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
1138 if (info->pkg_info == NULL)
1139 return PMINFO_R_ERROR;
1141 for (tmp = info->pkg_info->icon; tmp; tmp = tmp->next) {
1142 ptr = (icon_x *)tmp->data;
1143 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1144 !strcasecmp(ptr->text, "(null)") ||
1145 strcmp(ptr->lang, locale))
1147 *icon = (char *)ptr->text;
1151 locale = DEFAULT_LOCALE;
1152 for (tmp = info->pkg_info->icon; tmp; tmp = tmp->next) {
1153 ptr = (icon_x *)tmp->data;
1154 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1155 strcmp(ptr->lang, locale))
1157 *icon = (char *)ptr->text;
1161 return PMINFO_R_ERROR;
1164 API int pkgmgrinfo_pkginfo_get_label(pkgmgrinfo_pkginfo_h handle, char **label)
1169 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1171 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1172 retvm_if(label == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1174 locale = info->locale;
1175 retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
1177 for (tmp = info->pkg_info->label; tmp != NULL; tmp = tmp->next) {
1178 ptr = (label_x *)tmp->data;
1179 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1180 strcmp(ptr->lang, locale))
1182 *label = (char *)ptr->text;
1186 locale = DEFAULT_LOCALE;
1187 for (tmp = info->pkg_info->label; tmp != NULL; tmp = tmp->next) {
1188 ptr = (label_x *)tmp->data;
1189 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1190 strcmp(ptr->lang, locale))
1192 *label = (char *)ptr->text;
1196 return PMINFO_R_ERROR;
1199 API int pkgmgrinfo_pkginfo_get_description(pkgmgrinfo_pkginfo_h handle, char **description)
1204 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1206 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1207 retvm_if(description == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1209 locale = info->locale;
1210 retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
1212 for (tmp = info->pkg_info->description; tmp; tmp = tmp->next) {
1213 ptr = (description_x *)tmp->data;
1214 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1215 strcmp(ptr->lang, locale))
1217 *description = (char *)ptr->text;
1221 locale = DEFAULT_LOCALE;
1222 for (tmp = info->pkg_info->description; tmp; tmp = tmp->next) {
1223 ptr = (description_x *)tmp->data;
1224 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1225 strcmp(ptr->lang, locale))
1227 *description = (char *)ptr->text;
1231 return PMINFO_R_ERROR;
1234 API int pkgmgrinfo_pkginfo_get_author_name(pkgmgrinfo_pkginfo_h handle, char **author_name)
1236 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1239 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1240 retvm_if(author_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1242 if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1243 return PMINFO_R_ERROR;
1245 author = (author_x *)info->pkg_info->author->data;
1246 if (author == NULL || author->text == NULL)
1247 return PMINFO_R_ERROR;
1249 *author_name = (char *)author->text;
1254 API int pkgmgrinfo_pkginfo_get_author_email(pkgmgrinfo_pkginfo_h handle, char **author_email)
1256 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1259 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1260 retvm_if(author_email == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1262 if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1263 return PMINFO_R_ERROR;
1265 author = (author_x *)info->pkg_info->author->data;
1266 if (author == NULL || author->email == NULL)
1267 return PMINFO_R_ERROR;
1269 *author_email = (char *)author->email;
1274 API int pkgmgrinfo_pkginfo_get_author_href(pkgmgrinfo_pkginfo_h handle, char **author_href)
1276 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1279 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1280 retvm_if(author_href == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1282 if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1283 return PMINFO_R_ERROR;
1285 author = (author_x *)info->pkg_info->author->data;
1286 if (author == NULL || author->href == NULL)
1287 return PMINFO_R_ERROR;
1289 *author_href = (char *)author->href;
1294 API int pkgmgrinfo_pkginfo_get_installed_storage(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_installed_storage *storage)
1296 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1298 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1299 retvm_if(storage == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1301 if (info->pkg_info == NULL || info->pkg_info->installed_storage == NULL)
1302 return PMINFO_R_ERROR;
1304 if (strcmp(info->pkg_info->installed_storage,"installed_internal") == 0)
1305 *storage = PMINFO_INTERNAL_STORAGE;
1306 else if (strcmp(info->pkg_info->installed_storage,"installed_external") == 0)
1307 *storage = PMINFO_EXTERNAL_STORAGE;
1309 return PMINFO_R_ERROR;
1314 API int pkgmgrinfo_pkginfo_get_installed_time(pkgmgrinfo_pkginfo_h handle, int *installed_time)
1316 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1318 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1319 retvm_if(installed_time == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1321 if (info->pkg_info == NULL || info->pkg_info->installed_time == NULL)
1322 return PMINFO_R_ERROR;
1324 *installed_time = atoi(info->pkg_info->installed_time);
1329 API int pkgmgrinfo_pkginfo_get_storeclientid(pkgmgrinfo_pkginfo_h handle, char **storeclientid)
1331 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1333 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1334 retvm_if(storeclientid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1336 if (info->pkg_info == NULL || info->pkg_info->storeclient_id == NULL)
1337 return PMINFO_R_ERROR;
1339 *storeclientid = (char *)info->pkg_info->storeclient_id;
1344 API int pkgmgrinfo_pkginfo_get_mainappid(pkgmgrinfo_pkginfo_h handle, char **mainappid)
1346 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1348 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1349 retvm_if(mainappid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1351 if (info->pkg_info == NULL || info->pkg_info->mainapp_id == NULL)
1352 return PMINFO_R_ERROR;
1354 *mainappid = (char *)info->pkg_info->mainapp_id;
1359 API int pkgmgrinfo_pkginfo_get_url(pkgmgrinfo_pkginfo_h handle, char **url)
1361 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1363 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1364 retvm_if(url == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1366 if (info->pkg_info == NULL || info->pkg_info->package_url == NULL)
1367 return PMINFO_R_ERROR;
1369 *url = (char *)info->pkg_info->package_url;
1374 API int pkgmgrinfo_pkginfo_get_size_from_xml(const char *manifest, int *size)
1376 const char *val = NULL;
1377 const xmlChar *node;
1378 xmlTextReaderPtr reader;
1379 retvm_if(manifest == NULL, PMINFO_R_EINVAL, "Input argument is NULL\n");
1380 retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1383 reader = xmlReaderForFile(manifest, NULL, 0);
1386 if (__child_element(reader, -1)) {
1387 node = xmlTextReaderConstName(reader);
1389 _LOGE("xmlTextReaderConstName value is NULL\n");
1390 xmlFreeTextReader(reader);
1392 return PMINFO_R_ERROR;
1395 if (!strcmp(ASC_CHAR(node), "manifest")) {
1396 if (xmlTextReaderGetAttribute(reader, XML_CHAR("size")))
1397 val = ASC_CHAR(xmlTextReaderGetAttribute(reader, XML_CHAR("size")));
1403 _LOGE("package size is not specified\n");
1404 xmlFreeTextReader(reader);
1406 return PMINFO_R_ERROR;
1409 _LOGE("Unable to create xml reader\n");
1410 xmlFreeTextReader(reader);
1412 return PMINFO_R_ERROR;
1416 _LOGE("xmlReaderForFile value is NULL\n");
1418 return PMINFO_R_ERROR;
1421 xmlFreeTextReader(reader);
1427 API int pkgmgrinfo_pkginfo_get_location_from_xml(const char *manifest, pkgmgrinfo_install_location *location)
1429 const char *val = NULL;
1430 const xmlChar *node;
1431 xmlTextReaderPtr reader;
1432 retvm_if(manifest == NULL, PMINFO_R_EINVAL, "Input argument is NULL\n");
1433 retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1436 reader = xmlReaderForFile(manifest, NULL, 0);
1439 if ( __child_element(reader, -1)) {
1440 node = xmlTextReaderConstName(reader);
1442 _LOGE("xmlTextReaderConstName value is NULL\n");
1443 xmlFreeTextReader(reader);
1445 return PMINFO_R_ERROR;
1448 if (!strcmp(ASC_CHAR(node), "manifest")) {
1449 if (xmlTextReaderGetAttribute(reader, XML_CHAR("install-location")))
1450 val = ASC_CHAR(xmlTextReaderGetAttribute(reader, XML_CHAR("install-location")));
1453 if (strcmp(val, "internal-only") == 0)
1454 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
1455 else if (strcmp(val, "prefer-external") == 0)
1456 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
1458 *location = PMINFO_INSTALL_LOCATION_AUTO;
1461 _LOGE("Unable to create xml reader\n");
1462 xmlFreeTextReader(reader);
1464 return PMINFO_R_ERROR;
1468 _LOGE("xmlReaderForFile value is NULL\n");
1470 return PMINFO_R_ERROR;
1473 xmlFreeTextReader(reader);
1480 API int pkgmgrinfo_pkginfo_get_root_path(pkgmgrinfo_pkginfo_h handle, char **path)
1482 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1484 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1485 retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1487 if (info->pkg_info == NULL || info->pkg_info->root_path == NULL)
1488 return PMINFO_R_ERROR;
1490 *path = (char *)info->pkg_info->root_path;
1495 API int pkgmgrinfo_pkginfo_get_csc_path(pkgmgrinfo_pkginfo_h handle, char **path)
1497 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1499 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1500 retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1502 if (info->pkg_info == NULL || info->pkg_info->csc_path == NULL)
1503 return PMINFO_R_ERROR;
1505 *path = (char *)info->pkg_info->csc_path;
1511 API int pkgmgrinfo_pkginfo_is_accessible(pkgmgrinfo_pkginfo_h handle, bool *accessible)
1513 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1514 retvm_if(accessible == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1516 #if 0 //smack issue occured, check later
1518 pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
1520 _LOGD("invalid func parameters\n");
1521 return PMINFO_R_ERROR;
1523 _LOGD("pkgmgr_get_pkg_external_validation() called\n");
1526 char app_mmc_path[FILENAME_MAX] = { 0, };
1527 char app_dir_path[FILENAME_MAX] = { 0, };
1528 char app_mmc_internal_path[FILENAME_MAX] = { 0, };
1529 snprintf(app_dir_path, FILENAME_MAX,"%s%s", PKG_INSTALLATION_PATH, pkgid);
1530 snprintf(app_mmc_path, FILENAME_MAX,"%s%s", PKG_SD_PATH, pkgid);
1531 snprintf(app_mmc_internal_path, FILENAME_MAX,"%s%s/.mmc", PKG_INSTALLATION_PATH, pkgid);
1533 /*check whether application is in external memory or not */
1534 fp = fopen(app_mmc_path, "r");
1536 _LOGD(" app path in external memory not accesible\n");
1541 _LOGD("pkgmgr_get_pkg_external_validation() : SD_CARD \n");
1545 /*check whether application is in internal or not */
1546 fp = fopen(app_dir_path, "r");
1548 _LOGD(" app path in internal memory not accesible\n");
1550 return PMINFO_R_ERROR;
1553 /*check whether the application is installed in SD card
1554 but SD card is not present*/
1555 fp = fopen(app_mmc_internal_path, "r");
1558 _LOGD("pkgmgr_get_pkg_external_validation() : INTERNAL_MEM \n");
1563 _LOGD("pkgmgr_get_pkg_external_validation() : ERROR_MMC_STATUS \n");
1568 _LOGD("pkgmgr_get_pkg_external_validation() end\n");
1575 API int pkgmgrinfo_pkginfo_is_removable(pkgmgrinfo_pkginfo_h handle, bool *removable)
1577 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1579 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1580 retvm_if(removable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1582 if (info->pkg_info == NULL || info->pkg_info->removable == NULL)
1583 return PMINFO_R_ERROR;
1585 *removable = _get_bool_value(info->pkg_info->removable);
1590 API int pkgmgrinfo_pkginfo_is_movable(pkgmgrinfo_pkginfo_h handle, bool *movable)
1593 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1595 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1596 retvm_if(movable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1598 if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
1599 return PMINFO_R_ERROR;
1601 val = (char *)info->pkg_info->installlocation;
1602 if (strcmp(val, "internal-only") == 0)
1604 else if (strcmp(val, "prefer-external") == 0)
1612 API int pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo_h handle, bool *preload)
1614 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1616 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1617 retvm_if(preload == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1619 if (info->pkg_info == NULL || info->pkg_info->preload == NULL)
1620 return PMINFO_R_ERROR;
1622 *preload = _get_bool_value(info->pkg_info->preload);
1627 API int pkgmgrinfo_pkginfo_is_system(pkgmgrinfo_pkginfo_h handle, bool *system)
1629 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1631 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1632 retvm_if(system == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1634 if (info->pkg_info == NULL || info->pkg_info->system == NULL)
1635 return PMINFO_R_ERROR;
1637 *system = _get_bool_value(info->pkg_info->system);
1642 API int pkgmgrinfo_pkginfo_is_readonly(pkgmgrinfo_pkginfo_h handle, bool *readonly)
1644 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1646 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1647 retvm_if(readonly == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1649 if (info->pkg_info == NULL || info->pkg_info->readonly == NULL)
1650 return PMINFO_R_ERROR;
1652 *readonly = _get_bool_value(info->pkg_info->readonly);
1657 API int pkgmgrinfo_pkginfo_is_update(pkgmgrinfo_pkginfo_h handle, bool *update)
1659 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1661 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1662 retvm_if(update == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1664 if (info->pkg_info == NULL || info->pkg_info->update == NULL)
1665 return PMINFO_R_ERROR;
1667 *update = _get_bool_value(info->pkg_info->update);
1672 API int pkgmgrinfo_pkginfo_is_support_disable(pkgmgrinfo_pkginfo_h handle, bool *support_disable)
1674 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1676 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1677 retvm_if(support_disable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1679 if (info->pkg_info == NULL || info->pkg_info->support_disable == NULL)
1680 return PMINFO_R_ERROR;
1682 *support_disable = _get_bool_value(info->pkg_info->support_disable);
1687 API int pkgmgrinfo_pkginfo_is_global(pkgmgrinfo_pkginfo_h handle, bool *global)
1689 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1691 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1692 retvm_if(global == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1694 if (info->pkg_info == NULL || info->pkg_info->for_all_users == NULL)
1695 return PMINFO_R_ERROR;
1697 *global = _get_bool_value(info->pkg_info->for_all_users);
1702 API int pkgmgrinfo_pkginfo_is_for_all_users(pkgmgrinfo_pkginfo_h handle, bool *for_all_users)
1704 return pkgmgrinfo_pkginfo_is_global(handle, for_all_users);
1707 API int pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo_h handle)
1709 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1711 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1713 __cleanup_pkginfo(info);
1718 API int pkgmgrinfo_pkginfo_filter_create(pkgmgrinfo_pkginfo_filter_h *handle)
1720 pkgmgrinfo_filter_x *filter;
1722 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle output parameter is NULL\n");
1724 filter = (pkgmgrinfo_filter_x*)calloc(1, sizeof(pkgmgrinfo_filter_x));
1725 if (filter == NULL) {
1726 _LOGE("Out of Memory!!!");
1727 return PMINFO_R_ERROR;
1735 API int pkgmgrinfo_pkginfo_filter_destroy(pkgmgrinfo_pkginfo_filter_h handle)
1737 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1739 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1742 g_slist_foreach(filter->list, __destroy_each_node, NULL);
1743 g_slist_free(filter->list);
1751 API int pkgmgrinfo_pkginfo_filter_add_int(pkgmgrinfo_pkginfo_filter_h handle,
1752 const char *property, const int value)
1754 char buf[PKG_VALUE_STRING_LEN_MAX] = {'\0'};
1758 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1759 pkgmgrinfo_node_x *node;
1761 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1762 retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1764 prop = _pminfo_pkginfo_convert_to_prop_int(property);
1765 if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_INT ||
1766 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_INT) {
1767 _LOGE("Invalid Integer Property\n");
1768 return PMINFO_R_EINVAL;
1770 node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1772 _LOGE("Out of Memory!!!\n");
1773 return PMINFO_R_ERROR;
1775 snprintf(buf, PKG_VALUE_STRING_LEN_MAX - 1, "%d", value);
1776 val = strndup(buf, PKG_VALUE_STRING_LEN_MAX - 1);
1778 _LOGE("Out of Memory\n");
1780 return PMINFO_R_ERROR;
1784 /*If API is called multiple times for same property, we should override the previous values.
1785 Last value set will be used for filtering.*/
1786 link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1788 filter->list = g_slist_delete_link(filter->list, link);
1789 filter->list = g_slist_append(filter->list, (gpointer)node);
1794 API int pkgmgrinfo_pkginfo_filter_add_bool(pkgmgrinfo_pkginfo_filter_h handle,
1795 const char *property, const bool value)
1800 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1801 pkgmgrinfo_node_x *node;
1803 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1804 retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1806 prop = _pminfo_pkginfo_convert_to_prop_bool(property);
1807 if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_BOOL ||
1808 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_BOOL) {
1809 _LOGE("Invalid Boolean Property\n");
1810 return PMINFO_R_EINVAL;
1812 node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1814 _LOGE("Out of Memory!!!\n");
1815 return PMINFO_R_ERROR;
1818 val = strndup("true", 4);
1820 val = strndup("false", 5);
1822 _LOGE("Out of Memory\n");
1824 return PMINFO_R_ERROR;
1828 /*If API is called multiple times for same property, we should override the previous values.
1829 Last value set will be used for filtering.*/
1830 link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1832 filter->list = g_slist_delete_link(filter->list, link);
1833 filter->list = g_slist_append(filter->list, (gpointer)node);
1838 API int pkgmgrinfo_pkginfo_filter_add_string(pkgmgrinfo_pkginfo_filter_h handle,
1839 const char *property, const char *value)
1844 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1845 pkgmgrinfo_node_x *node;
1847 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1848 retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1849 retvm_if(value == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1851 prop = _pminfo_pkginfo_convert_to_prop_str(property);
1852 if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_STR ||
1853 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_STR) {
1854 _LOGE("Invalid String Property\n");
1855 return PMINFO_R_EINVAL;
1857 node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1859 _LOGE("Out of Memory!!!\n");
1860 return PMINFO_R_ERROR;
1862 if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_AUTO) == 0)
1863 val = strndup("auto", PKG_STRING_LEN_MAX - 1);
1864 else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_INTERNAL) == 0)
1865 val = strndup("internal-only", PKG_STRING_LEN_MAX - 1);
1866 else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_EXTERNAL) == 0)
1867 val = strndup("prefer-external", PKG_STRING_LEN_MAX - 1);
1868 else if (strcmp(value, "installed_internal") == 0)
1869 val = strndup("installed_internal", PKG_STRING_LEN_MAX - 1);
1870 else if (strcmp(value, "installed_external") == 0)
1871 val = strndup("installed_external", PKG_STRING_LEN_MAX - 1);
1873 val = strndup(value, PKG_STRING_LEN_MAX - 1);
1875 _LOGE("Out of Memory\n");
1877 return PMINFO_R_ERROR;
1881 /*If API is called multiple times for same property, we should override the previous values.
1882 Last value set will be used for filtering.*/
1883 link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1885 filter->list = g_slist_delete_link(filter->list, link);
1886 filter->list = g_slist_append(filter->list, (gpointer)node);
1891 API int pkgmgrinfo_pkginfo_usr_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count, uid_t uid)
1895 GHashTable *list = NULL;
1897 if (handle == NULL || count == NULL) {
1898 _LOGE("invalid parameter");
1899 return PMINFO_R_EINVAL;
1902 locale = _get_system_locale();
1904 return PMINFO_R_ERROR;
1906 list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
1910 return PMINFO_R_ERROR;
1913 ret = _pkginfo_get_packages(uid, locale,
1914 (pkgmgrinfo_filter_x *)handle, 0, list);
1915 if (ret == PMINFO_R_OK && uid != GLOBAL_USER)
1916 ret = _pkginfo_get_packages(GLOBAL_USER, locale, handle, 0,
1919 if (ret != PMINFO_R_OK) {
1920 g_hash_table_destroy(list);
1922 return PMINFO_R_ERROR;
1925 *count = g_hash_table_size(list);
1927 g_hash_table_destroy(list);
1933 API int pkgmgrinfo_pkginfo_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count)
1935 return pkgmgrinfo_pkginfo_usr_filter_count(handle, count, _getuid());
1938 API int pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(
1939 pkgmgrinfo_pkginfo_filter_h handle,
1940 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data, uid_t uid)
1942 if (handle == NULL || pkg_cb == NULL) {
1943 LOGE("invalid parameter");
1944 return PMINFO_R_EINVAL;
1947 return _pkginfo_get_filtered_foreach_pkginfo(uid, handle,
1948 PMINFO_PKGINFO_GET_ALL, pkg_cb, user_data);
1951 API int pkgmgrinfo_pkginfo_filter_foreach_pkginfo(pkgmgrinfo_pkginfo_filter_h handle,
1952 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data)
1954 return pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(handle, pkg_cb, user_data, _getuid());
1957 API int pkgmgrinfo_pkginfo_foreach_privilege(pkgmgrinfo_pkginfo_h handle,
1958 pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data)
1960 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1961 retvm_if(privilege_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
1963 const char *privilege;
1965 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1967 if (info->pkg_info == NULL)
1968 return PMINFO_R_ERROR;
1970 for (tmp = info->pkg_info->privileges; tmp; tmp = tmp->next) {
1971 privilege = (const char *)tmp->data;
1972 if (privilege == NULL)
1974 ret = privilege_func(privilege, user_data);