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, *result;
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 _LOGE("Couldn't open the directory\n");
155 for (ret = readdir_r(dp, &ep, &result);
156 ret == 0 && result != NULL;
157 ret = readdir_r(dp, &ep, &result)) {
158 if (!strcmp(ep.d_name, ".") ||
159 !strcmp(ep.d_name, "..")) {
162 snprintf(abs_filename, FILENAME_MAX, "%s/%s", dirname,
164 if (lstat(abs_filename, &fileinfo) < 0)
165 perror(abs_filename);
167 if (S_ISDIR(fileinfo.st_mode)) {
168 total += fileinfo.st_size;
169 if (strcmp(ep.d_name, ".")
170 && strcmp(ep.d_name, "..")) {
171 ret = _pkgmgr_calculate_dir_size
175 } else if (S_ISLNK(fileinfo.st_mode)) {
178 /*It is a file. Calculate the actual
179 size occupied (in terms of 4096 blocks)*/
180 q = (fileinfo.st_size / BLOCK_SIZE);
181 r = (fileinfo.st_size % BLOCK_SIZE);
185 total += q * BLOCK_SIZE;
194 static gint __list_strcmp(gconstpointer a, gconstpointer b)
196 return strcmp((char *)a, (char *)b);
199 static int _pkginfo_get_list(sqlite3 *db, const char *locale,
200 pkgmgrinfo_filter_x *filter, GList **list)
202 static const char query_raw[] =
203 "SELECT DISTINCT package_info.package FROM package_info"
204 " LEFT OUTER JOIN package_localized_info"
205 " ON package_info.package=package_localized_info.package"
206 " AND package_localized_info.package_locale=%Q "
207 " LEFT OUTER JOIN package_privilege_info"
208 " ON package_info.package=package_privilege_info.package";
211 char *query_localized;
215 query = _get_filtered_query(query_raw, filter);
218 query_localized = sqlite3_mprintf(query, locale);
220 if (query_localized == NULL)
223 ret = sqlite3_prepare_v2(db, query_localized,
224 strlen(query_localized), &stmt, NULL);
225 sqlite3_free(query_localized);
226 if (ret != SQLITE_OK) {
227 LOGE("prepare failed: %s", sqlite3_errmsg(db));
231 while (sqlite3_step(stmt) == SQLITE_ROW) {
232 _save_column_str(stmt, 0, &pkgid);
234 *list = g_list_insert_sorted(*list, pkgid,
238 sqlite3_finalize(stmt);
243 static int _pkginfo_get_filtered_list(pkgmgrinfo_filter_x *filter, uid_t uid,
253 locale = _get_system_locale();
255 return PMINFO_R_ERROR;
257 dbpath = getUserPkgParserDBPathUID(uid);
258 if (dbpath == NULL) {
260 return PMINFO_R_ERROR;
263 ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
264 if (ret != SQLITE_OK) {
265 _LOGE("failed to open db: %d", ret);
267 return PMINFO_R_ERROR;
270 if (_pkginfo_get_list(db, locale, filter, list)) {
272 sqlite3_close_v2(db);
273 return PMINFO_R_ERROR;
275 sqlite3_close_v2(db);
277 if (uid == GLOBAL_USER) {
282 /* search again from global */
283 dbpath = getUserPkgParserDBPathUID(GLOBAL_USER);
284 if (dbpath == NULL) {
286 return PMINFO_R_ERROR;
289 ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
290 if (ret != SQLITE_OK) {
291 _LOGE("failed to open db: %d", ret);
293 return PMINFO_R_ERROR;
296 if (_pkginfo_get_list(db, locale, filter, list)) {
298 sqlite3_close_v2(db);
299 return PMINFO_R_ERROR;
301 sqlite3_close_v2(db);
303 /* remove duplicate element:
304 * since the list is sorted, we can remove duplicates in linear time
306 for (tmp = *list, tmp2 = g_list_next(tmp); tmp;
307 tmp = tmp2, tmp2 = g_list_next(tmp)) {
308 if (tmp->prev == NULL || tmp->data == NULL)
310 if (strcmp((const char *)tmp->prev->data,
311 (const char *)tmp->data) == 0)
312 *list = g_list_delete_link(*list, tmp);
321 static int _pkginfo_get_filtered_foreach_pkginfo(pkgmgrinfo_filter_x *filter,
322 pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data, uid_t uid)
325 pkgmgr_pkginfo_x *info;
331 ret = _pkginfo_get_filtered_list(filter, uid, &list);
332 if (ret != PMINFO_R_OK)
333 return PMINFO_R_ERROR;
335 for (tmp = list; tmp; tmp = tmp->next) {
336 pkgid = (char *)tmp->data;
338 ret = _pkginfo_get_pkginfo(pkgid, uid, &info);
339 if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
340 ret = _pkginfo_get_pkginfo(pkgid, GLOBAL_USER,
342 if (ret != PMINFO_R_OK) {
346 if (pkg_list_cb(info, user_data) < 0)
348 pkgmgrinfo_pkginfo_destroy_pkginfo(info);
358 API int pkgmgrinfo_pkginfo_get_usr_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
359 void *user_data, uid_t uid)
361 if (pkg_list_cb == NULL) {
362 LOGE("invalid parameter");
363 return PMINFO_R_EINVAL;
366 return _pkginfo_get_filtered_foreach_pkginfo(NULL, pkg_list_cb,
370 API int pkgmgrinfo_pkginfo_get_list(pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data)
372 return pkgmgrinfo_pkginfo_get_usr_list(pkg_list_cb, user_data, _getuid());
375 static int _pkginfo_get_author(sqlite3 *db, const char *pkgid,
378 static const char query_raw[] =
379 "SELECT author_name, author_email, author_href "
380 "FROM package_info WHERE package=%Q";
387 query = sqlite3_mprintf(query_raw, pkgid);
389 LOGE("out of memory");
390 return PMINFO_R_ERROR;
393 ret = sqlite3_prepare_v2(db, query, strlen(query),
396 if (ret != SQLITE_OK) {
397 LOGE("prepare failed: %s", sqlite3_errmsg(db));
398 return PMINFO_R_ERROR;
401 if (sqlite3_step(stmt) == SQLITE_ERROR) {
402 LOGE("step error: %s", sqlite3_errmsg(db));
403 sqlite3_finalize(stmt);
404 return PMINFO_R_ERROR;
407 /* one author per one package */
408 info = calloc(1, sizeof(author_x));
410 LOGE("out of memory");
411 sqlite3_finalize(stmt);
412 return PMINFO_R_ERROR;
415 _save_column_str(stmt, idx++, &info->text);
416 _save_column_str(stmt, idx++, &info->email);
417 _save_column_str(stmt, idx++, &info->href);
420 *author = g_list_append(*author, info);
422 sqlite3_finalize(stmt);
427 static int _pkginfo_get_label(sqlite3 *db, const char *pkgid,
428 const char *locale, GList **label)
430 static const char query_raw[] =
431 "SELECT package_label, package_locale "
432 "FROM package_localized_info "
433 "WHERE package=%Q AND package_locale IN (%Q, %Q)";
440 query = sqlite3_mprintf(query_raw, pkgid, locale, DEFAULT_LOCALE);
442 LOGE("out of memory");
443 return PMINFO_R_ERROR;
446 ret = sqlite3_prepare_v2(db, query, strlen(query),
449 if (ret != SQLITE_OK) {
450 LOGE("prepare failed: %s", sqlite3_errmsg(db));
451 return PMINFO_R_ERROR;
454 while (sqlite3_step(stmt) == SQLITE_ROW) {
455 info = calloc(1, sizeof(label_x));
457 LOGE("out of memory");
458 sqlite3_finalize(stmt);
459 return PMINFO_R_ERROR;
462 _save_column_str(stmt, idx++, &info->text);
463 _save_column_str(stmt, idx++, &info->lang);
464 *label = g_list_append(*label, info);
467 sqlite3_finalize(stmt);
472 static int _pkginfo_get_icon(sqlite3 *db, const char *pkgid, const char *locale,
475 static const char query_raw[] =
476 "SELECT package_icon, package_locale "
477 "FROM package_localized_info "
478 "WHERE package=%Q AND package_locale IN (%Q, %Q)";
485 query = sqlite3_mprintf(query_raw, pkgid, locale, DEFAULT_LOCALE);
487 LOGE("out of memory");
488 return PMINFO_R_ERROR;
491 ret = sqlite3_prepare_v2(db, query, strlen(query),
494 if (ret != SQLITE_OK) {
495 LOGE("prepare failed: %s", sqlite3_errmsg(db));
496 return PMINFO_R_ERROR;
499 while (sqlite3_step(stmt) == SQLITE_ROW) {
500 info = calloc(1, sizeof(icon_x));
502 LOGE("out of memory");
503 sqlite3_finalize(stmt);
504 return PMINFO_R_ERROR;
507 _save_column_str(stmt, idx++, &info->text);
508 _save_column_str(stmt, idx++, &info->lang);
509 *icon = g_list_append(*icon, info);
512 sqlite3_finalize(stmt);
517 static int _pkginfo_get_description(sqlite3 *db, const char *pkgid,
518 const char *locale, GList **description)
520 static const char query_raw[] =
521 "SELECT package_description, package_locale "
522 "FROM package_localized_info "
523 "WHERE package=%Q AND package_locale IN (%Q, %Q)";
530 query = sqlite3_mprintf(query_raw, pkgid, locale, DEFAULT_LOCALE);
532 LOGE("out of memory");
533 return PMINFO_R_ERROR;
536 ret = sqlite3_prepare_v2(db, query, strlen(query),
539 if (ret != SQLITE_OK) {
540 LOGE("prepare failed: %s", sqlite3_errmsg(db));
541 return PMINFO_R_ERROR;
544 while (sqlite3_step(stmt) == SQLITE_ROW) {
545 info = calloc(1, sizeof(description_x));
547 LOGE("out of memory");
548 sqlite3_finalize(stmt);
549 return PMINFO_R_ERROR;
552 _save_column_str(stmt, idx++, &info->text);
553 _save_column_str(stmt, idx++, &info->lang);
554 *description = g_list_append(*description, info);
557 sqlite3_finalize(stmt);
562 static int _pkginfo_get_privilege(sqlite3 *db, const char *pkgid,
565 static const char query_raw[] =
566 "SELECT privilege FROM package_privilege_info WHERE package=%Q";
572 query = sqlite3_mprintf(query_raw, pkgid);
574 LOGE("out of memory");
575 return PMINFO_R_ERROR;
578 ret = sqlite3_prepare_v2(db, query, strlen(query),
581 if (ret != SQLITE_OK) {
582 LOGE("prepare failed: %s", sqlite3_errmsg(db));
583 return PMINFO_R_ERROR;
586 while (sqlite3_step(stmt) == SQLITE_ROW) {
588 _save_column_str(stmt, 0, &privilege);
590 *privileges = g_list_append(*privileges,
591 (gpointer)privilege);
594 sqlite3_finalize(stmt);
599 static char *_get_filtered_query(const char *query_raw,
600 pkgmgrinfo_filter_x *filter)
602 char buf[MAX_QUERY_LEN] = { 0, };
611 strncat(buf, query_raw, MAX_QUERY_LEN - 1);
613 for (list = head; list; list = list->next) {
614 /* TODO: revise condition getter function */
615 __get_filter_condition(list->data, &condition);
616 if (condition == NULL)
618 if (buf[strlen(query_raw)] == '\0') {
619 len += strlen(" WHERE ");
620 strncat(buf, " WHERE ", MAX_QUERY_LEN - len - 1);
622 len += strlen(" AND ");
623 strncat(buf, " AND ", MAX_QUERY_LEN -len - 1);
625 len += strlen(condition);
626 strncat(buf, condition, sizeof(buf) - len - 1);
634 static int _pkginfo_get_package(sqlite3 *db, const char *pkgid,
635 const char *locale, package_x **package)
637 static const char query_raw[] =
638 "SELECT package, package_version, "
639 "install_location, package_removable, package_preload, "
640 "package_readonly, package_update, package_appsetting, "
641 "package_system, package_type, package_size, installed_time, "
642 "installed_storage, storeclient_id, mainapp_id, package_url, "
643 "root_path, csc_path, package_nodisplay, package_api_version, "
644 "package_support_disable, package_tep_name, package_zip_mount_file "
645 "FROM package_info WHERE package=%Q AND package_disable='false'";
652 query = sqlite3_mprintf(query_raw, pkgid);
654 LOGE("out of memory");
655 return PMINFO_R_ERROR;
658 ret = sqlite3_prepare_v2(db, query, strlen(query),
661 if (ret != SQLITE_OK) {
662 LOGE("prepare failed: %s", sqlite3_errmsg(db));
663 return PMINFO_R_ERROR;
666 ret = sqlite3_step(stmt);
667 if (ret == SQLITE_DONE) {
668 sqlite3_finalize(stmt);
669 return PMINFO_R_ENOENT;
670 } else if (ret != SQLITE_ROW) {
671 LOGE("step failed: %s", sqlite3_errmsg(db));
672 sqlite3_finalize(stmt);
673 return PMINFO_R_ERROR;
676 info = calloc(1, sizeof(package_x));
678 LOGE("out of memory");
679 sqlite3_finalize(stmt);
680 return PMINFO_R_ERROR;
683 _save_column_str(stmt, idx++, &info->package);
684 _save_column_str(stmt, idx++, &info->version);
685 _save_column_str(stmt, idx++, &info->installlocation);
686 _save_column_str(stmt, idx++, &info->removable);
687 _save_column_str(stmt, idx++, &info->preload);
688 _save_column_str(stmt, idx++, &info->readonly);
689 _save_column_str(stmt, idx++, &info->update);
690 _save_column_str(stmt, idx++, &info->appsetting);
691 _save_column_str(stmt, idx++, &info->system);
692 _save_column_str(stmt, idx++, &info->type);
693 _save_column_str(stmt, idx++, &info->package_size);
694 _save_column_str(stmt, idx++, &info->installed_time);
695 _save_column_str(stmt, idx++, &info->installed_storage);
696 _save_column_str(stmt, idx++, &info->storeclient_id);
697 _save_column_str(stmt, idx++, &info->mainapp_id);
698 _save_column_str(stmt, idx++, &info->package_url);
699 _save_column_str(stmt, idx++, &info->root_path);
700 _save_column_str(stmt, idx++, &info->csc_path);
701 _save_column_str(stmt, idx++, &info->nodisplay_setting);
702 _save_column_str(stmt, idx++, &info->api_version);
703 _save_column_str(stmt, idx++, &info->support_disable);
704 _save_column_str(stmt, idx++, &info->tep_name);
705 _save_column_str(stmt, idx++, &info->zip_mount_file);
707 if (_pkginfo_get_author(db, info->package, &info->author)) {
708 pkgmgrinfo_basic_free_package(info);
709 sqlite3_finalize(stmt);
710 return PMINFO_R_ERROR;
713 if (_pkginfo_get_label(db, info->package, locale, &info->label)) {
714 pkgmgrinfo_basic_free_package(info);
715 sqlite3_finalize(stmt);
716 return PMINFO_R_ERROR;
719 if (_pkginfo_get_icon(db, info->package, locale, &info->icon)) {
720 pkgmgrinfo_basic_free_package(info);
721 sqlite3_finalize(stmt);
722 return PMINFO_R_ERROR;
725 if (_pkginfo_get_description(db, info->package, locale,
726 &info->description)) {
727 pkgmgrinfo_basic_free_package(info);
728 sqlite3_finalize(stmt);
729 return PMINFO_R_ERROR;
732 if (_pkginfo_get_privilege(db, info->package, &info->privileges)) {
733 pkgmgrinfo_basic_free_package(info);
734 sqlite3_finalize(stmt);
735 return PMINFO_R_ERROR;
739 sqlite3_finalize(stmt);
744 static int _pkginfo_get_pkginfo(const char *pkgid, uid_t uid,
745 pkgmgr_pkginfo_x **pkginfo)
751 pkgmgr_pkginfo_x *info;
753 dbpath = getUserPkgParserDBPathUID(uid);
755 return PMINFO_R_ERROR;
757 locale = _get_system_locale();
759 return PMINFO_R_ERROR;
761 ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
762 if (ret != SQLITE_OK) {
763 _LOGE("failed to open db: %d", ret);
765 return PMINFO_R_ERROR;
768 info = calloc(1, sizeof(pkgmgr_pkginfo_x));
770 _LOGE("out of memory");
772 sqlite3_close_v2(db);
773 return PMINFO_R_ERROR;
776 ret = _pkginfo_get_package(db, pkgid, locale, &info->pkg_info);
777 if (ret != PMINFO_R_OK) {
780 sqlite3_close_v2(db);
784 info->locale = locale;
786 info->pkg_info->for_all_users = strdup(
787 uid != GLOBAL_USER ? "false" : "true");
791 sqlite3_close_v2(db);
796 API int pkgmgrinfo_pkginfo_get_usr_pkginfo(const char *pkgid, uid_t uid,
797 pkgmgrinfo_pkginfo_h *handle)
801 if (pkgid == NULL || handle == NULL) {
802 LOGE("invalid parameter");
803 return PMINFO_R_EINVAL;
806 ret = _pkginfo_get_pkginfo(pkgid, uid, (pkgmgr_pkginfo_x **)handle);
807 if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
808 ret = _pkginfo_get_pkginfo(pkgid, GLOBAL_USER,
809 (pkgmgr_pkginfo_x **)handle);
811 if (ret != PMINFO_R_OK)
812 _LOGI("pkginfo for [%s] is not existed for user [%d]", pkgid, uid);
817 API int pkgmgrinfo_pkginfo_get_pkginfo(const char *pkgid, pkgmgrinfo_pkginfo_h *handle)
819 return pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, _getuid(), handle);
822 API int pkgmgrinfo_pkginfo_get_pkgname(pkgmgrinfo_pkginfo_h handle, char **pkg_name)
824 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
826 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
827 retvm_if(pkg_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
829 if (info->pkg_info == NULL || info->pkg_info->package == NULL)
830 return PMINFO_R_ERROR;
832 *pkg_name = (char *)info->pkg_info->package;
837 API int pkgmgrinfo_pkginfo_get_pkgid(pkgmgrinfo_pkginfo_h handle, char **pkgid)
839 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
841 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
842 retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
844 if (info->pkg_info == NULL || info->pkg_info->package == NULL)
845 return PMINFO_R_ERROR;
847 *pkgid = (char *)info->pkg_info->package;
852 API int pkgmgrinfo_pkginfo_get_type(pkgmgrinfo_pkginfo_h handle, char **type)
854 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
856 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
857 retvm_if(type == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
859 if (info->pkg_info == NULL || info->pkg_info->type == NULL)
860 return PMINFO_R_ERROR;
862 *type = (char *)info->pkg_info->type;
867 API int pkgmgrinfo_pkginfo_get_version(pkgmgrinfo_pkginfo_h handle, char **version)
869 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
871 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
872 retvm_if(version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
874 if (info->pkg_info == NULL || info->pkg_info->version == NULL)
875 return PMINFO_R_ERROR;
877 *version = (char *)info->pkg_info->version;
882 API int pkgmgrinfo_pkginfo_get_api_version(pkgmgrinfo_pkginfo_h handle, char **api_version)
884 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
886 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
887 retvm_if(api_version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
889 if (info->pkg_info == NULL || info->pkg_info->api_version == NULL)
890 return PMINFO_R_ERROR;
892 *api_version = (char *)info->pkg_info->api_version;
897 API int pkgmgrinfo_pkginfo_get_tep_name(pkgmgrinfo_pkginfo_h handle, char **tep_name)
899 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
901 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
902 retvm_if(tep_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
904 if (info->pkg_info == NULL || info->pkg_info->tep_name == NULL)
905 return PMINFO_R_ERROR;
907 if (strlen(info->pkg_info->tep_name) == 0)
908 return PMINFO_R_ERROR;
910 *tep_name = (char *)info->pkg_info->tep_name;
915 API int pkgmgrinfo_pkginfo_get_zip_mount_file(pkgmgrinfo_pkginfo_h handle, char **zip_mount_file)
917 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
919 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
920 retvm_if(zip_mount_file == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
922 if (info->pkg_info == NULL)
923 return PMINFO_R_ERROR;
925 if (strlen(info->pkg_info->zip_mount_file) > 0)
926 *zip_mount_file = (char *)info->pkg_info->zip_mount_file;
931 API int pkgmgrinfo_pkginfo_get_install_location(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_install_location *location)
934 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
936 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
937 retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
939 if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
940 return PMINFO_R_ERROR;
942 val = (char *)info->pkg_info->installlocation;
943 if (strcmp(val, "internal-only") == 0)
944 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
945 else if (strcmp(val, "prefer-external") == 0)
946 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
948 *location = PMINFO_INSTALL_LOCATION_AUTO;
953 API int pkgmgrinfo_pkginfo_get_package_size(pkgmgrinfo_pkginfo_h handle, int *size)
955 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
957 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
958 retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
960 if (info->pkg_info == NULL || info->pkg_info->package_size == NULL)
961 return PMINFO_R_ERROR;
963 *size = atoi((char *)info->pkg_info->package_size);
968 API int pkgmgrinfo_pkginfo_get_total_size(pkgmgrinfo_pkginfo_h handle, int *size)
971 char device_path[PKG_STRING_LEN_MAX] = { '\0', };
972 long long rw_size = 0;
973 long long ro_size = 0;
974 long long tmp_size = 0;
975 long long total_size = 0;
976 struct stat fileinfo;
979 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
980 retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
982 ret = pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
984 return PMINFO_R_ERROR;
987 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/bin", PKG_RW_PATH, pkgid);
988 if (lstat(device_path, &fileinfo) == 0) {
989 if (!S_ISLNK(fileinfo.st_mode)) {
990 tmp_size = _pkgmgr_calculate_dir_size(device_path);
996 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/info", PKG_RW_PATH, pkgid);
997 if (lstat(device_path, &fileinfo) == 0) {
998 if (!S_ISLNK(fileinfo.st_mode)) {
999 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1001 rw_size += tmp_size;
1005 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/res", PKG_RW_PATH, pkgid);
1006 if (lstat(device_path, &fileinfo) == 0) {
1007 if (!S_ISLNK(fileinfo.st_mode)) {
1008 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1010 rw_size += tmp_size;
1014 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/data", PKG_RW_PATH, pkgid);
1015 if (lstat(device_path, &fileinfo) == 0) {
1016 if (!S_ISLNK(fileinfo.st_mode)) {
1017 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1019 rw_size += tmp_size;
1023 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/shared", PKG_RW_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 rw_size += tmp_size;
1032 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/setting", PKG_RW_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 rw_size += tmp_size;
1042 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/bin", PKG_RO_PATH, pkgid);
1043 if (lstat(device_path, &fileinfo) == 0) {
1044 if (!S_ISLNK(fileinfo.st_mode)) {
1045 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1047 ro_size += tmp_size;
1051 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/info", PKG_RO_PATH, pkgid);
1052 if (lstat(device_path, &fileinfo) == 0) {
1053 if (!S_ISLNK(fileinfo.st_mode)) {
1054 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1056 ro_size += tmp_size;
1060 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/res", PKG_RO_PATH, pkgid);
1061 if (lstat(device_path, &fileinfo) == 0) {
1062 if (!S_ISLNK(fileinfo.st_mode)) {
1063 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1065 ro_size += tmp_size;
1069 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/data", PKG_RO_PATH, pkgid);
1070 if (lstat(device_path, &fileinfo) == 0) {
1071 if (!S_ISLNK(fileinfo.st_mode)) {
1072 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1074 ro_size += tmp_size;
1078 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/shared", PKG_RO_PATH, pkgid);
1079 if (lstat(device_path, &fileinfo) == 0) {
1080 if (!S_ISLNK(fileinfo.st_mode)) {
1081 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1083 ro_size += tmp_size;
1087 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/setting", PKG_RO_PATH, pkgid);
1088 if (lstat(device_path, &fileinfo) == 0) {
1089 if (!S_ISLNK(fileinfo.st_mode)) {
1090 tmp_size = _pkgmgr_calculate_dir_size(device_path);
1092 ro_size += tmp_size;
1097 total_size = rw_size + ro_size;
1098 *size = (int)total_size;
1103 API int pkgmgrinfo_pkginfo_get_data_size(pkgmgrinfo_pkginfo_h handle, int *size)
1106 char device_path[PKG_STRING_LEN_MAX] = { '\0', };
1107 long long total_size = 0;
1109 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1110 retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1112 if (pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid) < 0)
1113 return PMINFO_R_ERROR;
1115 snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/data", PKG_RW_PATH, pkgid);
1116 if (access(device_path, R_OK) == 0)
1117 total_size = _pkgmgr_calculate_dir_size(device_path);
1119 return PMINFO_R_ERROR;
1121 *size = (int)total_size;
1126 API int pkgmgrinfo_pkginfo_get_icon(pkgmgrinfo_pkginfo_h handle, char **icon)
1131 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1133 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1134 retvm_if(icon == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1136 locale = info->locale;
1137 retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
1139 if (info->pkg_info == NULL)
1140 return PMINFO_R_ERROR;
1142 for (tmp = info->pkg_info->icon; tmp; tmp = tmp->next) {
1143 ptr = (icon_x *)tmp->data;
1144 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1145 !strcasecmp(ptr->text, "(null)") ||
1146 strcmp(ptr->lang, locale))
1148 *icon = (char *)ptr->text;
1152 locale = DEFAULT_LOCALE;
1153 for (tmp = info->pkg_info->icon; tmp; tmp = tmp->next) {
1154 ptr = (icon_x *)tmp->data;
1155 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1156 strcmp(ptr->lang, locale))
1158 *icon = (char *)ptr->text;
1162 return PMINFO_R_ERROR;
1165 API int pkgmgrinfo_pkginfo_get_label(pkgmgrinfo_pkginfo_h handle, char **label)
1170 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1172 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1173 retvm_if(label == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1175 locale = info->locale;
1176 retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
1178 for (tmp = info->pkg_info->label; tmp != NULL; tmp = tmp->next) {
1179 ptr = (label_x *)tmp->data;
1180 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1181 strcmp(ptr->lang, locale))
1183 *label = (char *)ptr->text;
1187 locale = DEFAULT_LOCALE;
1188 for (tmp = info->pkg_info->label; tmp != NULL; tmp = tmp->next) {
1189 ptr = (label_x *)tmp->data;
1190 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1191 strcmp(ptr->lang, locale))
1193 *label = (char *)ptr->text;
1197 return PMINFO_R_ERROR;
1200 API int pkgmgrinfo_pkginfo_get_description(pkgmgrinfo_pkginfo_h handle, char **description)
1205 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1207 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1208 retvm_if(description == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1210 locale = info->locale;
1211 retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
1213 for (tmp = info->pkg_info->description; tmp; tmp = tmp->next) {
1214 ptr = (description_x *)tmp->data;
1215 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1216 strcmp(ptr->lang, locale))
1218 *description = (char *)ptr->text;
1222 locale = DEFAULT_LOCALE;
1223 for (tmp = info->pkg_info->description; tmp; tmp = tmp->next) {
1224 ptr = (description_x *)tmp->data;
1225 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1226 strcmp(ptr->lang, locale))
1228 *description = (char *)ptr->text;
1232 return PMINFO_R_ERROR;
1235 API int pkgmgrinfo_pkginfo_get_author_name(pkgmgrinfo_pkginfo_h handle, char **author_name)
1237 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1240 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1241 retvm_if(author_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1243 if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1244 return PMINFO_R_ERROR;
1246 author = (author_x *)info->pkg_info->author->data;
1247 if (author == NULL || author->text == NULL)
1248 return PMINFO_R_ERROR;
1250 *author_name = (char *)author->text;
1255 API int pkgmgrinfo_pkginfo_get_author_email(pkgmgrinfo_pkginfo_h handle, char **author_email)
1257 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1260 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1261 retvm_if(author_email == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1263 if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1264 return PMINFO_R_ERROR;
1266 author = (author_x *)info->pkg_info->author->data;
1267 if (author == NULL || author->email == NULL)
1268 return PMINFO_R_ERROR;
1270 *author_email = (char *)author->email;
1275 API int pkgmgrinfo_pkginfo_get_author_href(pkgmgrinfo_pkginfo_h handle, char **author_href)
1277 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1280 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1281 retvm_if(author_href == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1283 if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1284 return PMINFO_R_ERROR;
1286 author = (author_x *)info->pkg_info->author->data;
1287 if (author == NULL || author->href == NULL)
1288 return PMINFO_R_ERROR;
1290 *author_href = (char *)author->href;
1295 API int pkgmgrinfo_pkginfo_get_installed_storage(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_installed_storage *storage)
1297 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1299 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1300 retvm_if(storage == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1302 if (info->pkg_info == NULL || info->pkg_info->installed_storage == NULL)
1303 return PMINFO_R_ERROR;
1305 if (strcmp(info->pkg_info->installed_storage,"installed_internal") == 0)
1306 *storage = PMINFO_INTERNAL_STORAGE;
1307 else if (strcmp(info->pkg_info->installed_storage,"installed_external") == 0)
1308 *storage = PMINFO_EXTERNAL_STORAGE;
1310 return PMINFO_R_ERROR;
1315 API int pkgmgrinfo_pkginfo_get_installed_time(pkgmgrinfo_pkginfo_h handle, int *installed_time)
1317 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1319 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1320 retvm_if(installed_time == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1322 if (info->pkg_info == NULL || info->pkg_info->installed_time == NULL)
1323 return PMINFO_R_ERROR;
1325 *installed_time = atoi(info->pkg_info->installed_time);
1330 API int pkgmgrinfo_pkginfo_get_storeclientid(pkgmgrinfo_pkginfo_h handle, char **storeclientid)
1332 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1334 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1335 retvm_if(storeclientid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1337 if (info->pkg_info == NULL || info->pkg_info->storeclient_id == NULL)
1338 return PMINFO_R_ERROR;
1340 *storeclientid = (char *)info->pkg_info->storeclient_id;
1345 API int pkgmgrinfo_pkginfo_get_mainappid(pkgmgrinfo_pkginfo_h handle, char **mainappid)
1347 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1349 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1350 retvm_if(mainappid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1352 if (info->pkg_info == NULL || info->pkg_info->mainapp_id == NULL)
1353 return PMINFO_R_ERROR;
1355 *mainappid = (char *)info->pkg_info->mainapp_id;
1360 API int pkgmgrinfo_pkginfo_get_url(pkgmgrinfo_pkginfo_h handle, char **url)
1362 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1364 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1365 retvm_if(url == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1367 if (info->pkg_info == NULL || info->pkg_info->package_url == NULL)
1368 return PMINFO_R_ERROR;
1370 *url = (char *)info->pkg_info->package_url;
1375 API int pkgmgrinfo_pkginfo_get_size_from_xml(const char *manifest, int *size)
1377 const char *val = NULL;
1378 const xmlChar *node;
1379 xmlTextReaderPtr reader;
1380 retvm_if(manifest == NULL, PMINFO_R_EINVAL, "Input argument is NULL\n");
1381 retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1384 reader = xmlReaderForFile(manifest, NULL, 0);
1387 if (__child_element(reader, -1)) {
1388 node = xmlTextReaderConstName(reader);
1390 _LOGE("xmlTextReaderConstName value is NULL\n");
1391 xmlFreeTextReader(reader);
1393 return PMINFO_R_ERROR;
1396 if (!strcmp(ASC_CHAR(node), "manifest")) {
1397 if (xmlTextReaderGetAttribute(reader, XML_CHAR("size")))
1398 val = ASC_CHAR(xmlTextReaderGetAttribute(reader, XML_CHAR("size")));
1404 _LOGE("package size is not specified\n");
1405 xmlFreeTextReader(reader);
1407 return PMINFO_R_ERROR;
1410 _LOGE("Unable to create xml reader\n");
1411 xmlFreeTextReader(reader);
1413 return PMINFO_R_ERROR;
1417 _LOGE("xmlReaderForFile value is NULL\n");
1419 return PMINFO_R_ERROR;
1422 xmlFreeTextReader(reader);
1428 API int pkgmgrinfo_pkginfo_get_location_from_xml(const char *manifest, pkgmgrinfo_install_location *location)
1430 const char *val = NULL;
1431 const xmlChar *node;
1432 xmlTextReaderPtr reader;
1433 retvm_if(manifest == NULL, PMINFO_R_EINVAL, "Input argument is NULL\n");
1434 retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1437 reader = xmlReaderForFile(manifest, NULL, 0);
1440 if ( __child_element(reader, -1)) {
1441 node = xmlTextReaderConstName(reader);
1443 _LOGE("xmlTextReaderConstName value is NULL\n");
1444 xmlFreeTextReader(reader);
1446 return PMINFO_R_ERROR;
1449 if (!strcmp(ASC_CHAR(node), "manifest")) {
1450 if (xmlTextReaderGetAttribute(reader, XML_CHAR("install-location")))
1451 val = ASC_CHAR(xmlTextReaderGetAttribute(reader, XML_CHAR("install-location")));
1454 if (strcmp(val, "internal-only") == 0)
1455 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
1456 else if (strcmp(val, "prefer-external") == 0)
1457 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
1459 *location = PMINFO_INSTALL_LOCATION_AUTO;
1462 _LOGE("Unable to create xml reader\n");
1463 xmlFreeTextReader(reader);
1465 return PMINFO_R_ERROR;
1469 _LOGE("xmlReaderForFile value is NULL\n");
1471 return PMINFO_R_ERROR;
1474 xmlFreeTextReader(reader);
1481 API int pkgmgrinfo_pkginfo_get_root_path(pkgmgrinfo_pkginfo_h handle, char **path)
1483 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1485 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1486 retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1488 if (info->pkg_info == NULL || info->pkg_info->root_path == NULL)
1489 return PMINFO_R_ERROR;
1491 *path = (char *)info->pkg_info->root_path;
1496 API int pkgmgrinfo_pkginfo_get_csc_path(pkgmgrinfo_pkginfo_h handle, char **path)
1498 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1500 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1501 retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1503 if (info->pkg_info == NULL || info->pkg_info->csc_path == NULL)
1504 return PMINFO_R_ERROR;
1506 *path = (char *)info->pkg_info->csc_path;
1512 API int pkgmgrinfo_pkginfo_is_accessible(pkgmgrinfo_pkginfo_h handle, bool *accessible)
1514 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1515 retvm_if(accessible == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1517 #if 0 //smack issue occured, check later
1519 pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
1521 _LOGD("invalid func parameters\n");
1522 return PMINFO_R_ERROR;
1524 _LOGD("pkgmgr_get_pkg_external_validation() called\n");
1527 char app_mmc_path[FILENAME_MAX] = { 0, };
1528 char app_dir_path[FILENAME_MAX] = { 0, };
1529 char app_mmc_internal_path[FILENAME_MAX] = { 0, };
1530 snprintf(app_dir_path, FILENAME_MAX,"%s%s", PKG_INSTALLATION_PATH, pkgid);
1531 snprintf(app_mmc_path, FILENAME_MAX,"%s%s", PKG_SD_PATH, pkgid);
1532 snprintf(app_mmc_internal_path, FILENAME_MAX,"%s%s/.mmc", PKG_INSTALLATION_PATH, pkgid);
1534 /*check whether application is in external memory or not */
1535 fp = fopen(app_mmc_path, "r");
1537 _LOGD(" app path in external memory not accesible\n");
1542 _LOGD("pkgmgr_get_pkg_external_validation() : SD_CARD \n");
1546 /*check whether application is in internal or not */
1547 fp = fopen(app_dir_path, "r");
1549 _LOGD(" app path in internal memory not accesible\n");
1551 return PMINFO_R_ERROR;
1554 /*check whether the application is installed in SD card
1555 but SD card is not present*/
1556 fp = fopen(app_mmc_internal_path, "r");
1559 _LOGD("pkgmgr_get_pkg_external_validation() : INTERNAL_MEM \n");
1564 _LOGD("pkgmgr_get_pkg_external_validation() : ERROR_MMC_STATUS \n");
1569 _LOGD("pkgmgr_get_pkg_external_validation() end\n");
1576 API int pkgmgrinfo_pkginfo_is_removable(pkgmgrinfo_pkginfo_h handle, bool *removable)
1578 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1580 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1581 retvm_if(removable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1583 if (info->pkg_info == NULL || info->pkg_info->removable == NULL)
1584 return PMINFO_R_ERROR;
1586 *removable = _get_bool_value(info->pkg_info->removable);
1591 API int pkgmgrinfo_pkginfo_is_movable(pkgmgrinfo_pkginfo_h handle, bool *movable)
1594 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1596 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1597 retvm_if(movable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1599 if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
1600 return PMINFO_R_ERROR;
1602 val = (char *)info->pkg_info->installlocation;
1603 if (strcmp(val, "internal-only") == 0)
1605 else if (strcmp(val, "prefer-external") == 0)
1613 API int pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo_h handle, bool *preload)
1615 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1617 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1618 retvm_if(preload == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1620 if (info->pkg_info == NULL || info->pkg_info->preload == NULL)
1621 return PMINFO_R_ERROR;
1623 *preload = _get_bool_value(info->pkg_info->preload);
1628 API int pkgmgrinfo_pkginfo_is_system(pkgmgrinfo_pkginfo_h handle, bool *system)
1630 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1632 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1633 retvm_if(system == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1635 if (info->pkg_info == NULL || info->pkg_info->system == NULL)
1636 return PMINFO_R_ERROR;
1638 *system = _get_bool_value(info->pkg_info->system);
1643 API int pkgmgrinfo_pkginfo_is_readonly(pkgmgrinfo_pkginfo_h handle, bool *readonly)
1645 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1647 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1648 retvm_if(readonly == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1650 if (info->pkg_info == NULL || info->pkg_info->readonly == NULL)
1651 return PMINFO_R_ERROR;
1653 *readonly = _get_bool_value(info->pkg_info->readonly);
1658 API int pkgmgrinfo_pkginfo_is_update(pkgmgrinfo_pkginfo_h handle, bool *update)
1660 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1662 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1663 retvm_if(update == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1665 if (info->pkg_info == NULL || info->pkg_info->update == NULL)
1666 return PMINFO_R_ERROR;
1668 *update = _get_bool_value(info->pkg_info->update);
1673 API int pkgmgrinfo_pkginfo_is_support_disable(pkgmgrinfo_pkginfo_h handle, bool *support_disable)
1675 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1677 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1678 retvm_if(support_disable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1680 if (info->pkg_info == NULL || info->pkg_info->support_disable == NULL)
1681 return PMINFO_R_ERROR;
1683 *support_disable = _get_bool_value(info->pkg_info->support_disable);
1688 API int pkgmgrinfo_pkginfo_is_global(pkgmgrinfo_pkginfo_h handle, bool *global)
1690 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1692 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1693 retvm_if(global == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1695 if (info->pkg_info == NULL || info->pkg_info->for_all_users == NULL)
1696 return PMINFO_R_ERROR;
1698 *global = _get_bool_value(info->pkg_info->for_all_users);
1703 API int pkgmgrinfo_pkginfo_is_for_all_users(pkgmgrinfo_pkginfo_h handle, bool *for_all_users)
1705 return pkgmgrinfo_pkginfo_is_global(handle, for_all_users);
1708 API int pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo_h handle)
1710 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1712 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1714 __cleanup_pkginfo(info);
1719 API int pkgmgrinfo_pkginfo_filter_create(pkgmgrinfo_pkginfo_filter_h *handle)
1721 pkgmgrinfo_filter_x *filter;
1723 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle output parameter is NULL\n");
1725 filter = (pkgmgrinfo_filter_x*)calloc(1, sizeof(pkgmgrinfo_filter_x));
1726 if (filter == NULL) {
1727 _LOGE("Out of Memory!!!");
1728 return PMINFO_R_ERROR;
1736 API int pkgmgrinfo_pkginfo_filter_destroy(pkgmgrinfo_pkginfo_filter_h handle)
1738 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1740 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1743 g_slist_foreach(filter->list, __destroy_each_node, NULL);
1744 g_slist_free(filter->list);
1752 API int pkgmgrinfo_pkginfo_filter_add_int(pkgmgrinfo_pkginfo_filter_h handle,
1753 const char *property, const int value)
1755 char buf[PKG_VALUE_STRING_LEN_MAX] = {'\0'};
1759 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1760 pkgmgrinfo_node_x *node;
1762 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1763 retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1765 prop = _pminfo_pkginfo_convert_to_prop_int(property);
1766 if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_INT ||
1767 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_INT) {
1768 _LOGE("Invalid Integer Property\n");
1769 return PMINFO_R_EINVAL;
1771 node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1773 _LOGE("Out of Memory!!!\n");
1774 return PMINFO_R_ERROR;
1776 snprintf(buf, PKG_VALUE_STRING_LEN_MAX - 1, "%d", value);
1777 val = strndup(buf, PKG_VALUE_STRING_LEN_MAX - 1);
1779 _LOGE("Out of Memory\n");
1781 return PMINFO_R_ERROR;
1785 /*If API is called multiple times for same property, we should override the previous values.
1786 Last value set will be used for filtering.*/
1787 link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1789 filter->list = g_slist_delete_link(filter->list, link);
1790 filter->list = g_slist_append(filter->list, (gpointer)node);
1795 API int pkgmgrinfo_pkginfo_filter_add_bool(pkgmgrinfo_pkginfo_filter_h handle,
1796 const char *property, const bool value)
1801 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1802 pkgmgrinfo_node_x *node;
1804 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1805 retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1807 prop = _pminfo_pkginfo_convert_to_prop_bool(property);
1808 if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_BOOL ||
1809 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_BOOL) {
1810 _LOGE("Invalid Boolean Property\n");
1811 return PMINFO_R_EINVAL;
1813 node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1815 _LOGE("Out of Memory!!!\n");
1816 return PMINFO_R_ERROR;
1819 val = strndup("('true','True')", 15);
1821 val = strndup("('false','False')", 17);
1823 _LOGE("Out of Memory\n");
1825 return PMINFO_R_ERROR;
1829 /*If API is called multiple times for same property, we should override the previous values.
1830 Last value set will be used for filtering.*/
1831 link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1833 filter->list = g_slist_delete_link(filter->list, link);
1834 filter->list = g_slist_append(filter->list, (gpointer)node);
1839 API int pkgmgrinfo_pkginfo_filter_add_string(pkgmgrinfo_pkginfo_filter_h handle,
1840 const char *property, const char *value)
1845 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1846 pkgmgrinfo_node_x *node;
1848 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1849 retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1850 retvm_if(value == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1852 prop = _pminfo_pkginfo_convert_to_prop_str(property);
1853 if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_STR ||
1854 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_STR) {
1855 _LOGE("Invalid String Property\n");
1856 return PMINFO_R_EINVAL;
1858 node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1860 _LOGE("Out of Memory!!!\n");
1861 return PMINFO_R_ERROR;
1863 if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_AUTO) == 0)
1864 val = strndup("auto", PKG_STRING_LEN_MAX - 1);
1865 else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_INTERNAL) == 0)
1866 val = strndup("internal-only", PKG_STRING_LEN_MAX - 1);
1867 else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_EXTERNAL) == 0)
1868 val = strndup("prefer-external", PKG_STRING_LEN_MAX - 1);
1869 else if (strcmp(value, "installed_internal") == 0)
1870 val = strndup("installed_internal", PKG_STRING_LEN_MAX - 1);
1871 else if (strcmp(value, "installed_external") == 0)
1872 val = strndup("installed_external", PKG_STRING_LEN_MAX - 1);
1874 val = strndup(value, PKG_STRING_LEN_MAX - 1);
1876 _LOGE("Out of Memory\n");
1878 return PMINFO_R_ERROR;
1882 /*If API is called multiple times for same property, we should override the previous values.
1883 Last value set will be used for filtering.*/
1884 link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1886 filter->list = g_slist_delete_link(filter->list, link);
1887 filter->list = g_slist_append(filter->list, (gpointer)node);
1892 API int pkgmgrinfo_pkginfo_usr_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count, uid_t uid)
1897 if (handle == NULL || count == NULL) {
1898 _LOGE("invalid parameter");
1899 return PMINFO_R_EINVAL;
1902 ret = _pkginfo_get_filtered_list((pkgmgrinfo_filter_x *)handle, uid, &list);
1903 if (ret != PMINFO_R_OK)
1904 return PMINFO_R_ERROR;
1906 *count = g_list_length(list);
1908 g_list_free_full(list, free);
1913 API int pkgmgrinfo_pkginfo_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count)
1915 return pkgmgrinfo_pkginfo_usr_filter_count(handle, count, _getuid());
1918 API int pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(
1919 pkgmgrinfo_pkginfo_filter_h handle,
1920 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data, uid_t uid)
1922 if (handle == NULL || pkg_cb == NULL) {
1923 LOGE("invalid parameter");
1924 return PMINFO_R_EINVAL;
1927 return _pkginfo_get_filtered_foreach_pkginfo(handle, pkg_cb, user_data,
1931 API int pkgmgrinfo_pkginfo_filter_foreach_pkginfo(pkgmgrinfo_pkginfo_filter_h handle,
1932 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data)
1934 return pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(handle, pkg_cb, user_data, _getuid());
1937 API int pkgmgrinfo_pkginfo_foreach_privilege(pkgmgrinfo_pkginfo_h handle,
1938 pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data)
1940 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1941 retvm_if(privilege_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
1943 const char *privilege;
1945 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1947 if (info->pkg_info == NULL)
1948 return PMINFO_R_ERROR;
1950 for (tmp = info->pkg_info->privileges; tmp; tmp = tmp->next) {
1951 privilege = (const char *)tmp->data;
1952 if (privilege == NULL)
1954 ret = privilege_func(privilege, user_data);