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>
38 #include "pkgmgr_parser.h"
39 #include "pkgmgrinfo_basic.h"
40 #include "pkgmgrinfo_private.h"
41 #include "pkgmgrinfo_debug.h"
42 #include "pkgmgr-info.h"
43 #include "pkgmgr_parser_db.h"
44 #include "pkgmgr_parser_internal.h"
46 static bool _get_bool_value(const char *str)
48 if (str && !strcmp(str, "true"))
54 static gint __compare_func(gconstpointer data1, gconstpointer data2)
56 pkgmgrinfo_node_x *node1 = (pkgmgrinfo_node_x *)data1;
57 pkgmgrinfo_node_x *node2 = (pkgmgrinfo_node_x *)data2;
58 if (node1->prop == node2->prop)
60 else if (node1->prop > node2->prop)
66 static void __destroy_each_node(gpointer data, gpointer user_data)
69 pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x *)data;
82 static void __cleanup_pkginfo(pkgmgr_pkginfo_x *data)
86 free((void *)data->locale);
90 pkgmgrinfo_basic_free_package(data->pkg_info);
96 long long _pkgmgr_calculate_dir_size(char *dirname)
100 int q = 0; /*quotient*/
101 int r = 0; /*remainder*/
103 struct dirent ep, *result;
104 struct stat fileinfo;
105 char abs_filename[FILENAME_MAX] = { 0, };
106 retvm_if(dirname == NULL, PMINFO_R_ERROR, "dirname is NULL");
108 dp = opendir(dirname);
110 _LOGE("Couldn't open the directory\n");
114 for (ret = readdir_r(dp, &ep, &result);
115 ret == 0 && result != NULL;
116 ret = readdir_r(dp, &ep, &result)) {
117 if (!strcmp(ep.d_name, ".") ||
118 !strcmp(ep.d_name, "..")) {
121 snprintf(abs_filename, FILENAME_MAX, "%s/%s", dirname,
123 if (lstat(abs_filename, &fileinfo) < 0)
124 perror(abs_filename);
126 if (S_ISDIR(fileinfo.st_mode)) {
127 total += fileinfo.st_size;
128 if (strcmp(ep.d_name, ".")
129 && strcmp(ep.d_name, "..")) {
130 ret = _pkgmgr_calculate_dir_size
134 } else if (S_ISLNK(fileinfo.st_mode)) {
137 /*It is a file. Calculate the actual
138 size occupied (in terms of 4096 blocks)*/
139 q = (fileinfo.st_size / BLOCK_SIZE);
140 r = (fileinfo.st_size % BLOCK_SIZE);
143 total += q * BLOCK_SIZE;
152 static int _pkginfo_add_description_info_into_list(const char *locale,
153 char *record, GList **description)
157 info = calloc(1, sizeof(description_x));
159 LOGE("out of memory");
160 return PMINFO_R_ERROR;
162 info->lang = strdup(locale);
164 *description = g_list_append(*description, info);
169 static int _pkginfo_get_privilege(sqlite3 *db, const char *pkgid,
172 static const char query_raw[] =
173 "SELECT DISTINCT privilege FROM package_privilege_info "
178 privilege_x *privilege;
180 query = sqlite3_mprintf(query_raw, pkgid);
182 LOGE("out of memory");
183 return PMINFO_R_ERROR;
186 ret = sqlite3_prepare_v2(db, query, strlen(query),
189 if (ret != SQLITE_OK) {
190 LOGE("prepare failed: %s", sqlite3_errmsg(db));
191 return PMINFO_R_ERROR;
194 while (sqlite3_step(stmt) == SQLITE_ROW) {
195 privilege = calloc(1, sizeof(privilege_x));
196 _save_column_str(stmt, 0, &privilege->value);
197 _save_column_str(stmt, 1, &privilege->type);
198 *privileges = g_list_append(*privileges,
199 (gpointer)privilege);
202 sqlite3_finalize(stmt);
207 static const char join_localized_info[] =
208 " LEFT OUTER JOIN package_localized_info"
209 " ON pi.package=package_localized_info.package"
210 " AND package_localized_info.package_locale=?";
211 static const char join_privilege_info[] =
212 " LEFT OUTER JOIN package_privilege_info"
213 " ON pi.package=package_privilege_info.package";
215 static int _get_filtered_query(pkgmgrinfo_filter_x *filter,
216 const char *locale, char **query, GList **bind_params)
219 char buf[MAX_QUERY_LEN] = { '\0' };
220 char buf2[MAX_QUERY_LEN] = { '\0' };
221 char *condition = NULL;
228 len += strlen(" WHERE 1=1 ");
229 strncat(buf, " WHERE 1=1 ", MAX_QUERY_LEN - len - 1);
230 for (list = filter->list; list; list = list->next) {
231 joined |= __get_filter_condition(list->data, &condition,
233 if (condition == NULL)
236 len += strlen(" AND ");
237 strncat(buf, " AND ", MAX_QUERY_LEN - len - 1);
239 len += strlen(condition);
240 strncat(buf, condition, sizeof(buf) - len - 1);
245 if (joined & E_PMINFO_PKGINFO_JOIN_LOCALIZED_INFO) {
246 strncat(buf2, join_localized_info, MAX_QUERY_LEN - len - 1);
247 len += strlen(join_localized_info);
248 *bind_params = g_list_append(*bind_params, strdup(locale));
250 if (joined & E_PMINFO_PKGINFO_JOIN_PRIVILEGE_INFO) {
251 strncat(buf2, join_privilege_info, MAX_QUERY_LEN - len - 1);
252 len += strlen(join_privilege_info);
254 strncat(buf2, buf, MAX_QUERY_LEN - len - 1);
256 *query = strdup(buf2);
258 return PMINFO_R_ERROR;
263 static void __free_packages(gpointer data)
265 pkgmgrinfo_basic_free_package((package_x *)data);
268 static int __bind_params(sqlite3_stmt *stmt, GList *params)
270 GList *tmp_list = NULL;
274 if (stmt == NULL || params == NULL)
275 return PMINFO_R_EINVAL;
279 ret = sqlite3_bind_text(stmt, ++idx, (char *)tmp_list->data, -1, SQLITE_STATIC);
280 if (ret != SQLITE_OK)
281 return PMINFO_R_ERROR;
282 tmp_list = tmp_list->next;
288 static int _pkginfo_get_packages(uid_t uid, const char *locale,
289 pkgmgrinfo_filter_x *filter, int flag, GHashTable *packages)
291 static const char query_raw[] =
292 "SELECT DISTINCT pi.package, pi.package_version, "
293 "pi.install_location, pi.package_removable, "
294 "pi.package_preload, pi.package_readonly, pi.package_update, "
295 "pi.package_appsetting, pi.package_system, pi.package_type, "
296 "pi.package_size, pi.installed_time, pi.installed_storage, "
297 "pi.storeclient_id, pi.mainapp_id, pi.package_url, "
298 "pi.root_path, pi.csc_path, pi.package_nodisplay, "
299 "pi.package_api_version, pi.package_support_disable, "
300 "pi.package_tep_name, pi.package_zip_mount_file, pi.external_path";
301 static const char query_author[] =
302 ", pi.author_name, pi.author_email, pi.author_href";
303 static const char query_label[] =
305 "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
306 "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
307 static const char query_icon[] =
309 "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
310 "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
311 static const char query_description[] =
313 "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
314 "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
315 static const char query_from_clause[] = " FROM package_info as pi";
316 int ret = PMINFO_R_ERROR;
320 char *tmp_record = NULL;
321 char *constraints = NULL;
322 char query[MAX_QUERY_LEN] = { '\0' };
323 package_x *info = NULL;
324 author_x *author = NULL;
325 GList *bind_params = NULL;
328 pkgmgrinfo_filter_x *tmp_filter = NULL;
330 dbpath = getUserPkgParserDBPathUID(uid);
332 return PMINFO_R_ERROR;
334 ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
335 if (ret != SQLITE_OK) {
336 _LOGD("failed to open db: %d", ret);
338 return PMINFO_R_ERROR;
342 if (filter != NULL) {
345 ret = pkgmgrinfo_pkginfo_filter_create((void *)&tmp_filter);
346 if (ret != PMINFO_R_OK) {
347 _LOGE("Failed to create filter");
348 return PMINFO_R_ERROR;
352 /* add package_disable='false' clause by default */
353 pkgmgrinfo_pkginfo_filter_add_bool(tmp_filter, PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false);
355 query_len = strlen(query_raw);
356 snprintf(query, MAX_QUERY_LEN - 1, "%s", query_raw);
357 if (flag & PMINFO_PKGINFO_GET_AUTHOR) {
358 strncat(query, query_author, MAX_QUERY_LEN - query_len - 1);
359 query_len += strlen(query_author);
361 if (flag & PMINFO_PKGINFO_GET_LABEL) {
362 strncat(query, query_label, MAX_QUERY_LEN - query_len - 1);
363 query_len += strlen(query_label);
364 bind_params = g_list_append(bind_params, strdup(locale));
366 if (flag & PMINFO_PKGINFO_GET_ICON) {
367 strncat(query, query_icon, MAX_QUERY_LEN - query_len - 1);
368 query_len += strlen(query_icon);
369 bind_params = g_list_append(bind_params, strdup(locale));
371 if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) {
372 strncat(query, query_description, MAX_QUERY_LEN - query_len - 1);
373 query_len += strlen(query_description);
374 bind_params = g_list_append(bind_params, strdup(locale));
377 strncat(query, query_from_clause, MAX_QUERY_LEN - query_len - 1);
378 query_len += strlen(query_from_clause);
380 ret = _get_filtered_query(tmp_filter, locale, &constraints, &bind_params);
381 if (ret != PMINFO_R_OK) {
382 LOGE("Failed to get WHERE clause");
387 strncat(query, constraints, MAX_QUERY_LEN - query_len - 1);
389 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
390 if (ret != SQLITE_OK) {
391 LOGE("prepare failed: %s", sqlite3_errmsg(db));
392 ret = PMINFO_R_ERROR;
396 ret = __bind_params(stmt, bind_params);
397 if (ret != SQLITE_OK) {
398 LOGE("Failed to bind parameters");
402 while (sqlite3_step(stmt) == SQLITE_ROW) {
403 info = calloc(1, sizeof(package_x));
405 LOGE("out of memory");
406 sqlite3_finalize(stmt);
407 sqlite3_close_v2(db);
408 return PMINFO_R_ERROR;
411 _save_column_str(stmt, idx++, &info->package);
412 if (g_hash_table_contains(packages,
413 (gconstpointer)info->package)) {
418 _save_column_str(stmt, idx++, &info->version);
419 _save_column_str(stmt, idx++, &info->installlocation);
420 _save_column_str(stmt, idx++, &info->removable);
421 _save_column_str(stmt, idx++, &info->preload);
422 _save_column_str(stmt, idx++, &info->readonly);
423 _save_column_str(stmt, idx++, &info->update);
424 _save_column_str(stmt, idx++, &info->appsetting);
425 _save_column_str(stmt, idx++, &info->system);
426 _save_column_str(stmt, idx++, &info->type);
427 _save_column_str(stmt, idx++, &info->package_size);
428 _save_column_str(stmt, idx++, &info->installed_time);
429 _save_column_str(stmt, idx++, &info->installed_storage);
430 _save_column_str(stmt, idx++, &info->storeclient_id);
431 _save_column_str(stmt, idx++, &info->mainapp_id);
432 _save_column_str(stmt, idx++, &info->package_url);
433 _save_column_str(stmt, idx++, &info->root_path);
434 _save_column_str(stmt, idx++, &info->csc_path);
435 _save_column_str(stmt, idx++, &info->nodisplay_setting);
436 _save_column_str(stmt, idx++, &info->api_version);
437 _save_column_str(stmt, idx++, &info->support_disable);
438 _save_column_str(stmt, idx++, &info->tep_name);
439 _save_column_str(stmt, idx++, &info->zip_mount_file);
440 _save_column_str(stmt, idx++, &info->external_path);
441 info->for_all_users =
442 strdup((uid != GLOBAL_USER) ? "false" : "true");
444 if (flag & PMINFO_PKGINFO_GET_AUTHOR) {
445 /* TODO : author should be retrieved at package_localized_info */
446 author = calloc(1, sizeof(author_x));
447 if (author == NULL) {
448 pkgmgrinfo_basic_free_package(info);
449 sqlite3_finalize(stmt);
450 sqlite3_close_v2(db);
451 return PMINFO_R_ERROR;
453 _save_column_str(stmt, idx++, &author->text);
454 _save_column_str(stmt, idx++, &author->email);
455 _save_column_str(stmt, idx++, &author->href);
456 info->author = g_list_append(info->author, author);
459 if (flag & PMINFO_PKGINFO_GET_LABEL) {
461 _save_column_str(stmt, idx++, &tmp_record);
463 if (_add_label_info_into_list(locale, tmp_record, &info->label)) {
464 pkgmgrinfo_basic_free_package(info);
465 sqlite3_finalize(stmt);
466 sqlite3_close_v2(db);
467 return PMINFO_R_ERROR;
471 if (flag & PMINFO_PKGINFO_GET_ICON) {
473 _save_column_str(stmt, idx++, &tmp_record);
474 if (_add_icon_info_into_list(locale, tmp_record, &info->icon)) {
475 pkgmgrinfo_basic_free_package(info);
476 sqlite3_finalize(stmt);
477 sqlite3_close_v2(db);
478 return PMINFO_R_ERROR;
482 if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) {
484 _save_column_str(stmt, idx++, &tmp_record);
485 if (_pkginfo_add_description_info_into_list(locale, tmp_record,
486 &info->description)) {
487 pkgmgrinfo_basic_free_package(info);
488 sqlite3_finalize(stmt);
489 sqlite3_close_v2(db);
490 return PMINFO_R_ERROR;
494 if (flag & PMINFO_PKGINFO_GET_PRIVILEGE) {
495 if (_pkginfo_get_privilege(db, info->package,
496 &info->privileges)) {
497 pkgmgrinfo_basic_free_package(info);
498 sqlite3_finalize(stmt);
499 sqlite3_close_v2(db);
500 return PMINFO_R_ERROR;
504 if (__pkginfo_check_installed_storage(info) != PMINFO_R_OK) {
505 ret = PMINFO_R_ERROR;
506 pkgmgrinfo_basic_free_package(info);
511 g_hash_table_insert(packages, (gpointer)info->package,
521 if (ret != PMINFO_R_OK && info != NULL)
522 pkgmgrinfo_basic_free_package(info);
525 pkgmgrinfo_pkginfo_filter_destroy(tmp_filter);
527 g_list_free_full(bind_params, free);
528 sqlite3_close_v2(db);
529 sqlite3_finalize(stmt);
534 static int _pkginfo_get_filtered_foreach_pkginfo(uid_t uid,
535 pkgmgrinfo_filter_x *filter, int flag,
536 pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data)
541 pkgmgr_pkginfo_x info;
546 locale = _get_system_locale();
548 return PMINFO_R_ERROR;
550 list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
554 return PMINFO_R_ERROR;
557 ret = _pkginfo_get_packages(uid, locale, filter, flag, list);
558 if (ret == PMINFO_R_OK && uid != GLOBAL_USER)
559 ret = _pkginfo_get_packages(GLOBAL_USER, locale, filter,
562 if (ret != PMINFO_R_OK) {
563 g_hash_table_destroy(list);
565 return PMINFO_R_ERROR;
568 g_hash_table_iter_init(&iter, list);
569 while (g_hash_table_iter_next(&iter, NULL, &value)) {
570 pkg = (package_x *)value;
573 info.locale = locale;
574 if (pkg_list_cb(&info, user_data) < 0)
578 g_hash_table_destroy(list);
584 API int pkgmgrinfo_pkginfo_get_usr_pkginfo(const char *pkgid, uid_t uid,
585 pkgmgrinfo_pkginfo_h *handle)
590 pkgmgrinfo_pkginfo_filter_h filter;
591 pkgmgr_pkginfo_x *info;
593 if (pkgid == NULL || handle == NULL) {
594 LOGE("invalid parameter");
595 return PMINFO_R_EINVAL;
598 locale = _get_system_locale();
600 return PMINFO_R_ERROR;
602 ret = pkgmgrinfo_pkginfo_filter_create(&filter);
603 if (ret != PMINFO_R_OK) {
608 ret = pkgmgrinfo_pkginfo_filter_add_string(filter,
609 PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid);
610 if (ret != PMINFO_R_OK) {
611 pkgmgrinfo_pkginfo_filter_destroy(filter);
613 return PMINFO_R_ERROR;
616 list = g_hash_table_new(g_str_hash, g_str_equal);
618 pkgmgrinfo_pkginfo_filter_destroy(filter);
620 return PMINFO_R_ERROR;
623 ret = _pkginfo_get_packages(uid, locale, filter,
624 PMINFO_PKGINFO_GET_ALL, list);
625 if (!g_hash_table_size(list) && uid != GLOBAL_USER)
626 ret = _pkginfo_get_packages(GLOBAL_USER, locale, filter,
627 PMINFO_PKGINFO_GET_ALL, list);
629 pkgmgrinfo_pkginfo_filter_destroy(filter);
630 if (ret != PMINFO_R_OK) {
631 g_hash_table_destroy(list);
636 if (!g_hash_table_size(list)) {
637 _LOGI("pkginfo for [%s] is not existed for user [%d]",
639 g_hash_table_destroy(list);
641 return PMINFO_R_ENOENT;
644 info = calloc(1, sizeof(pkgmgr_pkginfo_x));
646 _LOGE("out of memory");
647 g_hash_table_destroy(list);
649 return PMINFO_R_ERROR;
653 info->pkg_info = (package_x *)g_hash_table_lookup(list, pkgid);
654 info->locale = locale;
656 /* just free list only */
657 g_hash_table_destroy(list);
664 API int pkgmgrinfo_pkginfo_get_pkginfo(const char *pkgid,
665 pkgmgrinfo_pkginfo_h *handle)
667 return pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, _getuid(), handle);
670 API int pkgmgrinfo_pkginfo_get_usr_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb,
671 int flag, void *user_data, uid_t uid)
673 if (pkg_list_cb == NULL) {
674 LOGE("invalid parameter");
675 return PMINFO_R_EINVAL;
678 return _pkginfo_get_filtered_foreach_pkginfo(uid, NULL, flag,
679 pkg_list_cb, user_data);
682 API int pkgmgrinfo_pkginfo_get_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb,
683 int flag, void *user_data)
685 return pkgmgrinfo_pkginfo_get_usr_list_full(pkg_list_cb, flag,
686 user_data, _getuid());
689 API int pkgmgrinfo_pkginfo_get_usr_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
690 void *user_data, uid_t uid)
692 if (pkg_list_cb == NULL) {
693 LOGE("invalid parameter");
694 return PMINFO_R_EINVAL;
697 return _pkginfo_get_filtered_foreach_pkginfo(uid, NULL,
698 PMINFO_PKGINFO_GET_ALL, pkg_list_cb, user_data);
701 API int pkgmgrinfo_pkginfo_get_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
704 return pkgmgrinfo_pkginfo_get_usr_list(pkg_list_cb, user_data,
708 API int pkgmgrinfo_pkginfo_get_pkgname(pkgmgrinfo_pkginfo_h handle, char **pkg_name)
710 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
712 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
713 retvm_if(pkg_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
715 if (info->pkg_info == NULL || info->pkg_info->package == NULL)
716 return PMINFO_R_ERROR;
718 *pkg_name = (char *)info->pkg_info->package;
723 API int pkgmgrinfo_pkginfo_get_pkgid(pkgmgrinfo_pkginfo_h handle, char **pkgid)
725 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
727 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
728 retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
730 if (info->pkg_info == NULL || info->pkg_info->package == NULL)
731 return PMINFO_R_ERROR;
733 *pkgid = (char *)info->pkg_info->package;
738 API int pkgmgrinfo_pkginfo_get_type(pkgmgrinfo_pkginfo_h handle, char **type)
740 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
742 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
743 retvm_if(type == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
745 if (info->pkg_info == NULL)
746 return PMINFO_R_ERROR;
748 if (info->pkg_info->type == NULL)
751 *type = (char *)info->pkg_info->type;
756 API int pkgmgrinfo_pkginfo_get_version(pkgmgrinfo_pkginfo_h handle, char **version)
758 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
760 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
761 retvm_if(version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
763 if (info->pkg_info == NULL)
764 return PMINFO_R_ERROR;
766 if (info->pkg_info->version == NULL)
769 *version = (char *)info->pkg_info->version;
774 API int pkgmgrinfo_pkginfo_get_api_version(pkgmgrinfo_pkginfo_h handle, char **api_version)
776 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
778 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
779 retvm_if(api_version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
781 if (info->pkg_info == NULL)
782 return PMINFO_R_ERROR;
784 if (info->pkg_info->api_version == NULL)
787 *api_version = (char *)info->pkg_info->api_version;
792 API int pkgmgrinfo_pkginfo_get_tep_name(pkgmgrinfo_pkginfo_h handle, char **tep_name)
794 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
796 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
797 retvm_if(tep_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
799 if (info->pkg_info == NULL || info->pkg_info->tep_name == NULL)
800 return PMINFO_R_ERROR;
802 *tep_name = (char *)info->pkg_info->tep_name;
807 API int pkgmgrinfo_pkginfo_get_zip_mount_file(pkgmgrinfo_pkginfo_h handle, char **zip_mount_file)
809 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
811 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
812 retvm_if(zip_mount_file == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
814 if (info->pkg_info == NULL)
815 return PMINFO_R_ERROR;
817 if (info->pkg_info->zip_mount_file == NULL)
818 *zip_mount_file = "";
820 *zip_mount_file = (char *)info->pkg_info->zip_mount_file;
825 API int pkgmgrinfo_pkginfo_get_install_location(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_install_location *location)
828 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
830 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
831 retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
833 if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
834 return PMINFO_R_ERROR;
836 val = (char *)info->pkg_info->installlocation;
837 if (strcmp(val, "internal-only") == 0)
838 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
839 else if (strcmp(val, "prefer-external") == 0)
840 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
842 *location = PMINFO_INSTALL_LOCATION_AUTO;
847 API int pkgmgrinfo_pkginfo_get_package_size(pkgmgrinfo_pkginfo_h handle, int *size)
849 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
852 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
853 retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
855 if (info->pkg_info == NULL)
856 return PMINFO_R_ERROR;
858 if (info->pkg_info->package_size == NULL) {
861 _LOGE("out of memory");
862 return PMINFO_R_ERROR;
864 info->pkg_info->package_size = temp;
868 *size = atoi((char *)info->pkg_info->package_size);
873 API int pkgmgrinfo_pkginfo_get_icon(pkgmgrinfo_pkginfo_h handle, char **icon)
876 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
878 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
879 retvm_if(icon == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
881 if (info->pkg_info == NULL || info->pkg_info->icon == NULL)
882 return PMINFO_R_ERROR;
884 ptr = (icon_x *)info->pkg_info->icon->data;
886 return PMINFO_R_ERROR;
888 /* TODO : should we return empty string if there was no icon? */
889 if (ptr->text == NULL)
897 API int pkgmgrinfo_pkginfo_get_label(pkgmgrinfo_pkginfo_h handle, char **label)
900 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
902 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
903 retvm_if(label == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
905 if (info->pkg_info == NULL || info->pkg_info->label == NULL)
906 return PMINFO_R_ERROR;
908 ptr = (label_x *)info->pkg_info->label->data;
910 return PMINFO_R_ERROR;
912 /* TODO : should we return empty string if there was no label? */
913 if (ptr->text == NULL)
921 API int pkgmgrinfo_pkginfo_get_description(pkgmgrinfo_pkginfo_h handle, char **description)
924 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
926 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
927 retvm_if(description == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
929 if (info->pkg_info == NULL || info->pkg_info->description == NULL)
930 return PMINFO_R_ERROR;
932 ptr = (description_x *)info->pkg_info->description->data;
934 return PMINFO_R_ERROR;
936 if (ptr->text == NULL)
939 *description = (char *)ptr->text;
944 API int pkgmgrinfo_pkginfo_get_author_name(pkgmgrinfo_pkginfo_h handle, char **author_name)
946 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
949 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
950 retvm_if(author_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
952 if (info->pkg_info == NULL || info->pkg_info->author == NULL)
953 return PMINFO_R_ERROR;
955 author = (author_x *)info->pkg_info->author->data;
957 return PMINFO_R_ERROR;
959 if (author->text == NULL)
962 *author_name = (char *)author->text;
967 API int pkgmgrinfo_pkginfo_get_author_email(pkgmgrinfo_pkginfo_h handle, char **author_email)
969 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
972 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
973 retvm_if(author_email == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
975 if (info->pkg_info == NULL || info->pkg_info->author == NULL)
976 return PMINFO_R_ERROR;
978 author = (author_x *)info->pkg_info->author->data;
980 return PMINFO_R_ERROR;
982 if (author->email == NULL)
985 *author_email = (char *)author->email;
990 API int pkgmgrinfo_pkginfo_get_author_href(pkgmgrinfo_pkginfo_h handle, char **author_href)
992 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
995 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
996 retvm_if(author_href == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
998 if (info->pkg_info == NULL || info->pkg_info->author == NULL)
999 return PMINFO_R_ERROR;
1001 author = (author_x *)info->pkg_info->author->data;
1003 return PMINFO_R_ERROR;
1005 if (author->href == NULL)
1008 *author_href = (char *)author->href;
1013 API int pkgmgrinfo_pkginfo_get_installed_storage(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_installed_storage *storage)
1015 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1017 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1018 retvm_if(storage == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1020 if (info->pkg_info == NULL || info->pkg_info->installed_storage == NULL)
1021 return PMINFO_R_ERROR;
1023 if (strcmp(info->pkg_info->installed_storage, "installed_internal") == 0)
1024 *storage = PMINFO_INTERNAL_STORAGE;
1025 else if (strcmp(info->pkg_info->installed_storage, "installed_external") == 0)
1026 *storage = PMINFO_EXTERNAL_STORAGE;
1028 return PMINFO_R_ERROR;
1033 API int pkgmgrinfo_pkginfo_get_installed_time(pkgmgrinfo_pkginfo_h handle, int *installed_time)
1035 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1037 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1038 retvm_if(installed_time == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1040 if (info->pkg_info == NULL || info->pkg_info->installed_time == NULL)
1041 return PMINFO_R_ERROR;
1043 *installed_time = atoi(info->pkg_info->installed_time);
1048 API int pkgmgrinfo_pkginfo_get_storeclientid(pkgmgrinfo_pkginfo_h handle, char **storeclientid)
1050 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1052 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1053 retvm_if(storeclientid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1055 if (info->pkg_info == NULL)
1056 return PMINFO_R_ERROR;
1058 if (info->pkg_info->storeclient_id == NULL)
1059 *storeclientid = "";
1061 *storeclientid = (char *)info->pkg_info->storeclient_id;
1066 API int pkgmgrinfo_pkginfo_get_mainappid(pkgmgrinfo_pkginfo_h handle, char **mainappid)
1068 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1070 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1071 retvm_if(mainappid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1073 if (info->pkg_info == NULL || info->pkg_info->mainapp_id == NULL)
1074 return PMINFO_R_ERROR;
1076 *mainappid = (char *)info->pkg_info->mainapp_id;
1081 API int pkgmgrinfo_pkginfo_get_url(pkgmgrinfo_pkginfo_h handle, char **url)
1083 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1085 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1086 retvm_if(url == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1088 if (info->pkg_info == NULL)
1089 return PMINFO_R_ERROR;
1091 if (info->pkg_info->package_url == NULL)
1094 *url = (char *)info->pkg_info->package_url;
1099 API int pkgmgrinfo_pkginfo_get_root_path(pkgmgrinfo_pkginfo_h handle, char **path)
1101 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1103 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1104 retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1106 if (info->pkg_info == NULL || info->pkg_info->root_path == NULL)
1107 return PMINFO_R_ERROR;
1109 *path = (char *)info->pkg_info->root_path;
1114 API int pkgmgrinfo_pkginfo_get_csc_path(pkgmgrinfo_pkginfo_h handle, char **path)
1116 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1118 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1119 retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1121 if (info->pkg_info == NULL)
1122 return PMINFO_R_ERROR;
1124 if (info->pkg_info->csc_path == NULL)
1127 *path = (char *)info->pkg_info->csc_path;
1133 API int pkgmgrinfo_pkginfo_is_accessible(pkgmgrinfo_pkginfo_h handle, bool *accessible)
1135 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1136 retvm_if(accessible == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1138 #if 0 /* smack issue occured, check later */
1140 pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
1141 if (pkgid == NULL) {
1142 _LOGD("invalid func parameters\n");
1143 return PMINFO_R_ERROR;
1145 _LOGD("pkgmgr_get_pkg_external_validation() called\n");
1148 char app_mmc_path[FILENAME_MAX] = { 0, };
1149 char app_dir_path[FILENAME_MAX] = { 0, };
1150 char app_mmc_internal_path[FILENAME_MAX] = { 0, };
1151 snprintf(app_dir_path, FILENAME_MAX, "%s%s", PKG_INSTALLATION_PATH, pkgid);
1152 snprintf(app_mmc_path, FILENAME_MAX, "%s%s", PKG_SD_PATH, pkgid);
1153 snprintf(app_mmc_internal_path, FILENAME_MAX, "%s%s/.mmc", PKG_INSTALLATION_PATH, pkgid);
1155 /*check whether application is in external memory or not */
1156 fp = fopen(app_mmc_path, "r");
1158 _LOGD(" app path in external memory not accesible\n");
1163 _LOGD("pkgmgr_get_pkg_external_validation() : SD_CARD \n");
1167 /*check whether application is in internal or not */
1169 _LOGD(" app path in internal memory not accesible\n");
1171 return PMINFO_R_ERROR;
1174 /*check whether the application is installed in SD card
1175 but SD card is not present*/
1176 fp = fopen(app_mmc_internal_path, "r");
1179 _LOGD("pkgmgr_get_pkg_external_validation() : INTERNAL_MEM \n");
1183 _LOGD("pkgmgr_get_pkg_external_validation() : ERROR_MMC_STATUS \n");
1188 _LOGD("pkgmgr_get_pkg_external_validation() end\n");
1195 API int pkgmgrinfo_pkginfo_is_removable(pkgmgrinfo_pkginfo_h handle, bool *removable)
1197 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1199 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1200 retvm_if(removable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1202 if (info->pkg_info == NULL || info->pkg_info->removable == NULL)
1203 return PMINFO_R_ERROR;
1205 *removable = _get_bool_value(info->pkg_info->removable);
1210 API int pkgmgrinfo_pkginfo_is_movable(pkgmgrinfo_pkginfo_h handle, bool *movable)
1213 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1215 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1216 retvm_if(movable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1218 if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
1219 return PMINFO_R_ERROR;
1221 val = (char *)info->pkg_info->installlocation;
1222 if (strcmp(val, "internal-only") == 0)
1224 else if (strcmp(val, "prefer-external") == 0)
1232 API int pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo_h handle, bool *preload)
1234 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1236 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1237 retvm_if(preload == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1239 if (info->pkg_info == NULL || info->pkg_info->preload == NULL)
1240 return PMINFO_R_ERROR;
1242 *preload = _get_bool_value(info->pkg_info->preload);
1247 API int pkgmgrinfo_pkginfo_is_system(pkgmgrinfo_pkginfo_h handle, bool *system)
1249 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1251 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1252 retvm_if(system == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1254 if (info->pkg_info == NULL || info->pkg_info->system == NULL)
1255 return PMINFO_R_ERROR;
1257 *system = _get_bool_value(info->pkg_info->system);
1262 API int pkgmgrinfo_pkginfo_is_readonly(pkgmgrinfo_pkginfo_h handle, bool *readonly)
1264 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1266 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1267 retvm_if(readonly == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1269 if (info->pkg_info == NULL || info->pkg_info->readonly == NULL)
1270 return PMINFO_R_ERROR;
1272 *readonly = _get_bool_value(info->pkg_info->readonly);
1277 API int pkgmgrinfo_pkginfo_is_update(pkgmgrinfo_pkginfo_h handle, bool *update)
1279 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1281 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1282 retvm_if(update == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1284 if (info->pkg_info == NULL || info->pkg_info->update == NULL)
1285 return PMINFO_R_ERROR;
1287 *update = _get_bool_value(info->pkg_info->update);
1292 API int pkgmgrinfo_pkginfo_is_support_disable(pkgmgrinfo_pkginfo_h handle, bool *support_disable)
1294 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1296 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1297 retvm_if(support_disable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1299 if (info->pkg_info == NULL || info->pkg_info->support_disable == NULL)
1300 return PMINFO_R_ERROR;
1302 *support_disable = _get_bool_value(info->pkg_info->support_disable);
1307 API int pkgmgrinfo_pkginfo_is_global(pkgmgrinfo_pkginfo_h handle, bool *global)
1309 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1311 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1312 retvm_if(global == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1314 if (info->pkg_info == NULL || info->pkg_info->for_all_users == NULL)
1315 return PMINFO_R_ERROR;
1317 *global = _get_bool_value(info->pkg_info->for_all_users);
1322 API int pkgmgrinfo_pkginfo_is_for_all_users(pkgmgrinfo_pkginfo_h handle, bool *for_all_users)
1324 return pkgmgrinfo_pkginfo_is_global(handle, for_all_users);
1327 API int pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo_h handle)
1329 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1331 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1333 __cleanup_pkginfo(info);
1338 API int pkgmgrinfo_pkginfo_filter_create(pkgmgrinfo_pkginfo_filter_h *handle)
1340 pkgmgrinfo_filter_x *filter;
1342 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle output parameter is NULL\n");
1344 filter = (pkgmgrinfo_filter_x*)calloc(1, sizeof(pkgmgrinfo_filter_x));
1345 if (filter == NULL) {
1346 _LOGE("Out of Memory!!!");
1347 return PMINFO_R_ERROR;
1355 API int pkgmgrinfo_pkginfo_filter_destroy(pkgmgrinfo_pkginfo_filter_h handle)
1357 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1359 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1362 g_slist_foreach(filter->list, __destroy_each_node, NULL);
1363 g_slist_free(filter->list);
1371 API int pkgmgrinfo_pkginfo_filter_add_int(pkgmgrinfo_pkginfo_filter_h handle,
1372 const char *property, const int value)
1374 char buf[PKG_VALUE_STRING_LEN_MAX] = {'\0'};
1378 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1379 pkgmgrinfo_node_x *node;
1381 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1382 retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1384 prop = _pminfo_pkginfo_convert_to_prop_int(property);
1385 if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_INT ||
1386 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_INT) {
1387 _LOGE("Invalid Integer Property\n");
1388 return PMINFO_R_EINVAL;
1390 node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1392 _LOGE("Out of Memory!!!\n");
1393 return PMINFO_R_ERROR;
1395 snprintf(buf, PKG_VALUE_STRING_LEN_MAX - 1, "%d", value);
1396 val = strndup(buf, PKG_VALUE_STRING_LEN_MAX - 1);
1398 _LOGE("Out of Memory\n");
1400 return PMINFO_R_ERROR;
1404 /*If API is called multiple times for same property, we should override the previous values.
1405 Last value set will be used for filtering.*/
1406 link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1408 filter->list = g_slist_delete_link(filter->list, link);
1409 filter->list = g_slist_append(filter->list, (gpointer)node);
1414 API int pkgmgrinfo_pkginfo_filter_add_bool(pkgmgrinfo_pkginfo_filter_h handle,
1415 const char *property, const bool value)
1420 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1421 pkgmgrinfo_node_x *node;
1423 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1424 retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1426 prop = _pminfo_pkginfo_convert_to_prop_bool(property);
1427 if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_BOOL ||
1428 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_BOOL) {
1429 _LOGE("Invalid Boolean Property\n");
1430 return PMINFO_R_EINVAL;
1432 node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1434 _LOGE("Out of Memory!!!\n");
1435 return PMINFO_R_ERROR;
1438 val = strndup("true", 4);
1440 val = strndup("false", 5);
1442 _LOGE("Out of Memory\n");
1444 return PMINFO_R_ERROR;
1448 /*If API is called multiple times for same property, we should override the previous values.
1449 Last value set will be used for filtering.*/
1450 link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1452 filter->list = g_slist_delete_link(filter->list, link);
1453 filter->list = g_slist_append(filter->list, (gpointer)node);
1458 API int pkgmgrinfo_pkginfo_filter_add_string(pkgmgrinfo_pkginfo_filter_h handle,
1459 const char *property, const char *value)
1464 pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1465 pkgmgrinfo_node_x *node;
1467 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1468 retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1469 retvm_if(value == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1471 prop = _pminfo_pkginfo_convert_to_prop_str(property);
1472 if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_STR ||
1473 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_STR) {
1474 _LOGE("Invalid String Property\n");
1475 return PMINFO_R_EINVAL;
1477 node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1479 _LOGE("Out of Memory!!!\n");
1480 return PMINFO_R_ERROR;
1482 if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_AUTO) == 0)
1483 val = strndup("auto", PKG_STRING_LEN_MAX - 1);
1484 else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_INTERNAL) == 0)
1485 val = strndup("internal-only", PKG_STRING_LEN_MAX - 1);
1486 else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_EXTERNAL) == 0)
1487 val = strndup("prefer-external", PKG_STRING_LEN_MAX - 1);
1488 else if (strcmp(value, "installed_internal") == 0)
1489 val = strndup("installed_internal", PKG_STRING_LEN_MAX - 1);
1490 else if (strcmp(value, "installed_external") == 0)
1491 val = strndup("installed_external", PKG_STRING_LEN_MAX - 1);
1493 val = strndup(value, PKG_STRING_LEN_MAX - 1);
1495 _LOGE("Out of Memory\n");
1497 return PMINFO_R_ERROR;
1501 /*If API is called multiple times for same property, we should override the previous values.
1502 Last value set will be used for filtering.*/
1503 link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1505 filter->list = g_slist_delete_link(filter->list, link);
1506 filter->list = g_slist_append(filter->list, (gpointer)node);
1511 API int pkgmgrinfo_pkginfo_usr_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count, uid_t uid)
1515 GHashTable *list = NULL;
1517 if (handle == NULL || count == NULL) {
1518 _LOGE("invalid parameter");
1519 return PMINFO_R_EINVAL;
1522 locale = _get_system_locale();
1524 return PMINFO_R_ERROR;
1526 list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
1530 return PMINFO_R_ERROR;
1533 ret = _pkginfo_get_packages(uid, locale,
1534 (pkgmgrinfo_filter_x *)handle, 0, list);
1535 if (ret == PMINFO_R_OK && uid != GLOBAL_USER)
1536 ret = _pkginfo_get_packages(GLOBAL_USER, locale, handle, 0,
1539 if (ret != PMINFO_R_OK) {
1540 g_hash_table_destroy(list);
1542 return PMINFO_R_ERROR;
1545 *count = g_hash_table_size(list);
1547 g_hash_table_destroy(list);
1553 API int pkgmgrinfo_pkginfo_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count)
1555 return pkgmgrinfo_pkginfo_usr_filter_count(handle, count, _getuid());
1558 API int pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(
1559 pkgmgrinfo_pkginfo_filter_h handle,
1560 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data, uid_t uid)
1562 if (handle == NULL || pkg_cb == NULL) {
1563 LOGE("invalid parameter");
1564 return PMINFO_R_EINVAL;
1567 return _pkginfo_get_filtered_foreach_pkginfo(uid, handle,
1568 PMINFO_PKGINFO_GET_ALL, pkg_cb, user_data);
1571 API int pkgmgrinfo_pkginfo_filter_foreach_pkginfo(pkgmgrinfo_pkginfo_filter_h handle,
1572 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data)
1574 return pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(handle, pkg_cb, user_data, _getuid());
1577 API int pkgmgrinfo_pkginfo_foreach_privilege(pkgmgrinfo_pkginfo_h handle,
1578 pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data)
1580 retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1581 retvm_if(privilege_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
1583 privilege_x *privilege;
1585 pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1587 if (info->pkg_info == NULL)
1588 return PMINFO_R_ERROR;
1590 for (tmp = info->pkg_info->privileges; tmp; tmp = tmp->next) {
1591 privilege = (privilege_x *)tmp->data;
1592 if (privilege == NULL)
1594 ret = privilege_func(privilege->value, user_data);