2 * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
24 #include <sys/smack.h>
25 #include <linux/limits.h>
31 #include <system_info.h>
33 #include "pkgmgr_parser.h"
34 #include "pkgmgrinfo_basic.h"
35 #include "pkgmgrinfo_internal.h"
36 #include "pkgmgrinfo_private.h"
37 #include "pkgmgrinfo_debug.h"
38 #include "pkgmgr-info.h"
44 #define XXHDPI "xxhdpi"
54 #define XXHDPI_MIN 481
55 #define XXHDPI_MAX 600
57 static const char join_localized_info[] =
58 " LEFT OUTER JOIN package_localized_info"
59 " ON pi.package=package_localized_info.package"
60 " AND package_localized_info.package_locale=?";
61 static const char join_privilege_info[] =
62 " LEFT OUTER JOIN package_privilege_info"
63 " ON pi.package=package_privilege_info.package";
64 static const char join_res_info[] =
65 " LEFT OUTER JOIN package_res_info"
66 " ON pi.package=package_res_info.package";
68 static int _get_filtered_query(pkgmgrinfo_filter_x *filter,
69 const char *locale, uid_t uid,
70 char **query, GList **bind_params)
74 char buf[MAX_QUERY_LEN] = { '\0' };
75 char buf2[MAX_QUERY_LEN] = { '\0' };
76 char *condition = NULL;
77 GList *tmp_params = NULL;
83 if (filter->cache_flag) {
84 joined = E_PMINFO_PKGINFO_JOIN_LOCALIZED_INFO |
85 E_PMINFO_PKGINFO_JOIN_PRIVILEGE_INFO |
86 E_PMINFO_PKGINFO_JOIN_RES_INFO;
89 snprintf(buf, sizeof(buf), "%s", " WHERE 1=1 ");
90 for (list = filter->list; list; list = list->next) {
91 joined |= __get_filter_condition(list->data, uid, &condition,
93 if (condition == NULL)
96 strncat(buf, " AND ", sizeof(buf) - strlen(buf) - 1);
98 strncat(buf, condition, sizeof(buf) - strlen(buf) - 1);
103 if (joined & E_PMINFO_PKGINFO_JOIN_LOCALIZED_INFO) {
104 strncat(buf2, join_localized_info,
105 sizeof(buf2) - strlen(buf2) - 1);
106 *bind_params = g_list_append(*bind_params, strdup(locale));
108 if (joined & E_PMINFO_PKGINFO_JOIN_PRIVILEGE_INFO)
109 strncat(buf2, join_privilege_info,
110 sizeof(buf2) - strlen(buf2) - 1);
111 if (joined & E_PMINFO_PKGINFO_JOIN_RES_INFO)
112 strncat(buf2, join_res_info,
113 sizeof(buf2) - strlen(buf2) - 1);
115 *bind_params = g_list_concat(*bind_params, tmp_params);
116 size = strlen(buf2) + strlen(buf) + 1;
117 *query = (char *)calloc(1, size);
119 return PMINFO_R_ERROR;
120 snprintf(*query, size, "%s%s", buf2, buf);
125 static int __bind_params(sqlite3_stmt *stmt, GList *params)
127 GList *tmp_list = NULL;
131 if (stmt == NULL || params == NULL)
132 return PMINFO_R_EINVAL;
136 ret = sqlite3_bind_text(stmt, ++idx,
137 (char *)tmp_list->data, -1, SQLITE_STATIC);
138 if (ret != SQLITE_OK)
139 return PMINFO_R_ERROR;
140 tmp_list = tmp_list->next;
146 bool __check_package_storage_status(pkgmgrinfo_filter_x *tmp_filter)
148 GSList *tmp_list = NULL;
149 pkgmgrinfo_node_x *tmp_node = NULL;
152 if (tmp_filter->cache_flag)
155 property = _pminfo_pkginfo_convert_to_prop_bool(
156 PMINFO_PKGINFO_PROP_PACKAGE_CHECK_STORAGE);
157 for (tmp_list = tmp_filter->list; tmp_list != NULL;
158 tmp_list = g_slist_next(tmp_list)) {
159 tmp_node = (pkgmgrinfo_node_x *)tmp_list->data;
160 if (property == tmp_node->prop) {
161 if (strcmp(tmp_node->value, "true") == 0)
170 static int _pkginfo_add_description_info_into_list(const char *locale,
171 char *record, GList **description)
175 info = calloc(1, sizeof(description_x));
177 LOGE("out of memory");
178 return PMINFO_R_ERROR;
180 info->lang = strdup(locale);
182 *description = g_list_prepend(*description, info);
187 static int _pkginfo_get_plugin_execution_info(sqlite3 *db, const char *pkgid,
190 static const char query_raw[] =
191 "SELECT appid, plugin_type, plugin_name FROM package_plugin_info "
198 query = sqlite3_mprintf(query_raw, pkgid);
200 LOGE("out of memory");
201 return PMINFO_R_ERROR;
204 ret = sqlite3_prepare_v2(db, query, strlen(query),
207 if (ret != SQLITE_OK) {
208 LOGE("prepare failed: %s", sqlite3_errmsg(db));
209 return PMINFO_R_ERROR;
212 while (sqlite3_step(stmt) == SQLITE_ROW) {
213 plugin = calloc(1, sizeof(plugin_x));
215 LOGE("out of memory");
216 sqlite3_finalize(stmt);
217 return PMINFO_R_ERROR;
219 plugin->pkgid = strdup(pkgid);
220 _save_column_str(stmt, 0, &plugin->appid);
221 _save_column_str(stmt, 1, &plugin->plugin_type);
222 _save_column_str(stmt, 2, &plugin->plugin_name);
223 *plugins = g_list_prepend(*plugins,
227 sqlite3_finalize(stmt);
232 static int _pkginfo_get_privilege(sqlite3 *db, const char *pkgid,
235 static const char query_raw[] =
236 "SELECT DISTINCT privilege, type FROM package_privilege_info "
241 privilege_x *privilege;
243 query = sqlite3_mprintf(query_raw, pkgid);
245 LOGE("out of memory");
246 return PMINFO_R_ERROR;
249 ret = sqlite3_prepare_v2(db, query, strlen(query),
252 if (ret != SQLITE_OK) {
253 LOGE("prepare failed: %s", sqlite3_errmsg(db));
254 return PMINFO_R_ERROR;
257 while (sqlite3_step(stmt) == SQLITE_ROW) {
258 privilege = calloc(1, sizeof(privilege_x));
260 LOGE("failed to alloc memory");
261 sqlite3_finalize(stmt);
262 return PMINFO_R_ERROR;
264 _save_column_str(stmt, 0, &privilege->value);
265 _save_column_str(stmt, 1, &privilege->type);
266 *privileges = g_list_prepend(*privileges,
267 (gpointer)privilege);
270 sqlite3_finalize(stmt);
275 static int _pkginfo_get_appdefined_privilege(sqlite3 *db, const char *pkgid,
278 static const char query_raw[] =
279 "SELECT DISTINCT privilege, license, type FROM "
280 "package_appdefined_privilege_info WHERE package=%Q";
284 appdefined_privilege_x *privilege;
286 query = sqlite3_mprintf(query_raw, pkgid);
288 LOGE("out of memory");
289 return PMINFO_R_ERROR;
292 ret = sqlite3_prepare_v2(db, query, strlen(query),
295 if (ret != SQLITE_OK) {
296 LOGE("prepare failed: %s", sqlite3_errmsg(db));
297 return PMINFO_R_ERROR;
300 while (sqlite3_step(stmt) == SQLITE_ROW) {
301 privilege = calloc(1, sizeof(appdefined_privilege_x));
303 LOGE("failed to alloc memory");
304 sqlite3_finalize(stmt);
305 return PMINFO_R_ERROR;
307 _save_column_str(stmt, 0, &privilege->value);
308 _save_column_str(stmt, 1, &privilege->license);
309 _save_column_str(stmt, 2, &privilege->type);
310 *privileges = g_list_prepend(*privileges,
311 (gpointer)privilege);
314 sqlite3_finalize(stmt);
319 static int _pkginfo_get_dependency(sqlite3 *db, const char *pkgid,
320 GList **dependencies)
322 static const char query_raw[] =
323 "SELECT DISTINCT depends_on, type, required_version "
324 "FROM package_dependency_info WHERE package=%Q";
328 dependency_x *dependency;
330 query = sqlite3_mprintf(query_raw, pkgid);
332 LOGE("out of memory");
333 return PMINFO_R_ERROR;
336 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
338 if (ret != SQLITE_OK) {
339 LOGE("prepare failed: %s", sqlite3_errmsg(db));
340 return PMINFO_R_ERROR;
343 while (sqlite3_step(stmt) == SQLITE_ROW) {
344 dependency = calloc(1, sizeof(dependency_x));
346 LOGE("failed to alloc memory");
347 sqlite3_finalize(stmt);
348 return PMINFO_R_ERROR;
350 _save_column_str(stmt, 0, &dependency->depends_on);
351 _save_column_str(stmt, 1, &dependency->type);
352 _save_column_str(stmt, 2, &dependency->required_version);
353 *dependencies = g_list_prepend(*dependencies,
354 (gpointer)dependency);
357 sqlite3_finalize(stmt);
362 static int _pkginfo_get_res_allowed_packages(sqlite3 *db, const char *pkgid,
363 GList **allowed_packages)
365 static const char query_raw[] =
366 "SELECT DISTINCT allowed_package, required_privilege "
367 "FROM package_res_allowed_package WHERE package=%Q";
373 res_allowed_package_x *allowed_package_x;
376 query = sqlite3_mprintf(query_raw, pkgid);
378 LOGE("out of memory");
379 return PMINFO_R_ERROR;
382 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
384 if (ret != SQLITE_OK) {
385 LOGE("prepare failed: %s", sqlite3_errmsg(db));
386 return PMINFO_R_ERROR;
389 while (sqlite3_step(stmt) == SQLITE_ROW) {
390 allowed_package_x = NULL;
394 _save_column_str(stmt, 0, &package);
398 for (l = *allowed_packages; l; l = l->next) {
399 allowed_package_x = (res_allowed_package_x *)l->data;
400 if (!strcmp(package, (char *)l->data))
402 allowed_package_x = NULL;
405 if (allowed_package_x) {
408 allowed_package_x = calloc(1,
409 sizeof(res_allowed_package_x));
410 if (allowed_package_x == NULL) {
411 LOGE("failed to alloc memory");
412 sqlite3_finalize(stmt);
414 return PMINFO_R_ERROR;
416 allowed_package_x->allowed_package = package;
417 *allowed_packages = g_list_prepend(*allowed_packages,
418 (gpointer)allowed_package_x);
421 _save_column_str(stmt, 1, &privilege);
425 allowed_package_x->required_privileges = g_list_prepend(
426 allowed_package_x->required_privileges,
430 sqlite3_finalize(stmt);
435 static int _pkginfo_get_res_info(sqlite3 *db, const char *pkgid,
436 char **res_type, char **res_version,
437 GList **res_allowed_packages)
439 static const char query_raw[] =
440 "SELECT DISTINCT res_type, res_version "
441 "FROM package_res_info WHERE package=%Q";
446 query = sqlite3_mprintf(query_raw, pkgid);
448 LOGE("out of memory");
449 return PMINFO_R_ERROR;
452 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
454 if (ret != SQLITE_OK) {
455 LOGE("prepare failed: %s", sqlite3_errmsg(db));
456 return PMINFO_R_ERROR;
459 if (sqlite3_step(stmt) != SQLITE_ROW) {
460 sqlite3_finalize(stmt);
464 _save_column_str(stmt, 0, res_type);
465 _save_column_str(stmt, 1, res_version);
467 if (_pkginfo_get_res_allowed_packages(db, pkgid,
468 res_allowed_packages) != PMINFO_R_OK) {
469 sqlite3_finalize(stmt);
470 return PMINFO_R_ERROR;
473 sqlite3_finalize(stmt);
478 static int _pkginfo_get_packages(sqlite3 *db, uid_t uid, const char *locale,
479 pkgmgrinfo_filter_x *filter, int flag, GHashTable *packages)
481 static const char query_raw[] =
482 "SELECT DISTINCT pi.package, pi.installed_storage, pi.external_path";
483 static const char query_basic[] =
484 ", pi.package_version, pi.install_location, "
485 "pi.package_removable, pi.package_preload, pi.package_readonly, "
486 "pi.package_update, pi.package_appsetting, pi.package_system, "
487 "pi.package_type, pi.package_size, pi.installed_time, "
488 "pi.storeclient_id, pi.mainapp_id, pi.package_url, pi.root_path, "
489 "pi.csc_path, pi.package_nodisplay, pi.package_api_version, "
490 "pi.package_support_disable, pi.package_tep_name, "
491 "pi.package_zip_mount_file, pi.package_support_mode, pi.package_disable, "
492 "pi.light_user_switch_mode";
493 static const char query_author[] =
494 ", pi.author_name, pi.author_email, pi.author_href";
495 static const char query_label[] =
497 "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
498 "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
499 static const char query_icon[] =
501 "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
502 "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
503 static const char query_description[] =
505 "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
506 "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
507 static const char query_res_type[] =
508 ", (SELECT res_type FROM package_res_info WHERE pi.package=package)";
509 static const char query_res_version[] =
510 ", (SELECT res_version FROM package_res_info WHERE pi.package=package)";
511 static const char query_from_clause[] = " FROM package_info as pi";
512 int ret = PMINFO_R_ERROR;
514 char *tmp_record = NULL;
515 char *constraints = NULL;
516 char query[MAX_QUERY_LEN] = { '\0' };
517 package_x *info = NULL;
518 author_x *author = NULL;
519 GList *bind_params = NULL;
520 sqlite3_stmt *stmt = NULL;
521 bool is_check_storage = true;
522 const uid_t global_user_uid = GLOBAL_USER;
524 if (db == NULL || locale == NULL || filter == NULL) {
525 LOGE("Invalid parameter");
526 return PMINFO_R_EINVAL;
529 is_check_storage = __check_package_storage_status(filter);
531 snprintf(query, MAX_QUERY_LEN - 1, "%s", query_raw);
532 if (flag & PMINFO_APPINFO_GET_BASICINFO)
533 strncat(query, query_basic, sizeof(query) - strlen(query) - 1);
534 if (flag & PMINFO_PKGINFO_GET_AUTHOR)
535 strncat(query, query_author, sizeof(query) - strlen(query) - 1);
536 if (flag & PMINFO_PKGINFO_GET_LABEL) {
537 strncat(query, query_label, sizeof(query) - strlen(query) - 1);
538 bind_params = g_list_append(bind_params, strdup(locale));
540 if (flag & PMINFO_PKGINFO_GET_ICON) {
541 strncat(query, query_icon, sizeof(query) - strlen(query) - 1);
542 bind_params = g_list_append(bind_params, strdup(locale));
544 if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) {
545 strncat(query, query_description,
546 sizeof(query) - strlen(query) - 1);
547 bind_params = g_list_append(bind_params, strdup(locale));
549 if (flag & PMINFO_PKGINFO_GET_RES_INFO) {
550 strncat(query, query_res_type,
551 sizeof(query) - strlen(query) - 1);
552 strncat(query, query_res_version,
553 sizeof(query) - strlen(query) - 1);
556 strncat(query, query_from_clause, sizeof(query) - strlen(query) - 1);
558 ret = _get_filtered_query(filter, locale, uid,
559 &constraints, &bind_params);
560 if (ret != PMINFO_R_OK) {
561 LOGE("Failed to get WHERE clause");
566 strncat(query, constraints, sizeof(query) - strlen(query) - 1);
568 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
569 if (ret != SQLITE_OK) {
570 LOGE("prepare failed: %s", sqlite3_errmsg(db));
571 ret = PMINFO_R_ERROR;
575 ret = __bind_params(stmt, bind_params);
576 if (ret != SQLITE_OK) {
577 LOGE("Failed to bind parameters");
581 while (sqlite3_step(stmt) == SQLITE_ROW) {
582 info = calloc(1, sizeof(package_x));
584 LOGE("out of memory");
585 ret = PMINFO_R_ERROR;
588 info->locale = strdup(locale);
589 if (info->locale == NULL) {
590 LOGE("Out of memory");
591 ret = PMINFO_R_ERROR;
596 _save_column_str(stmt, idx++, &info->package);
597 _save_column_str(stmt, idx++, &info->installed_storage);
598 _save_column_str(stmt, idx++, &info->external_path);
600 if (flag & PMINFO_APPINFO_GET_BASICINFO) {
601 _save_column_str(stmt, idx++, &info->version);
602 _save_column_str(stmt, idx++, &info->installlocation);
603 _save_column_str(stmt, idx++, &info->removable);
604 _save_column_str(stmt, idx++, &info->preload);
605 _save_column_str(stmt, idx++, &info->readonly);
606 _save_column_str(stmt, idx++, &info->update);
607 _save_column_str(stmt, idx++, &info->appsetting);
608 _save_column_str(stmt, idx++, &info->system);
609 _save_column_str(stmt, idx++, &info->type);
610 _save_column_str(stmt, idx++, &info->package_size);
611 _save_column_str(stmt, idx++, &info->installed_time);
612 _save_column_str(stmt, idx++, &info->storeclient_id);
613 _save_column_str(stmt, idx++, &info->mainapp_id);
614 _save_column_str(stmt, idx++, &info->package_url);
615 _save_column_str(stmt, idx++, &info->root_path);
616 _save_column_str(stmt, idx++, &info->csc_path);
617 _save_column_str(stmt, idx++, &info->nodisplay_setting);
618 _save_column_str(stmt, idx++, &info->api_version);
619 _save_column_str(stmt, idx++, &info->support_disable);
620 _save_column_str(stmt, idx++, &info->tep_name);
621 _save_column_str(stmt, idx++, &info->zip_mount_file);
622 _save_column_str(stmt, idx++, &info->support_mode);
623 _save_column_str(stmt, idx++, &info->is_disabled);
624 _save_column_str(stmt, idx++, &info->light_user_switch_mode);
627 info->for_all_users =
628 strdup((uid != global_user_uid) ? "false" : "true");
630 if (_pkginfo_get_plugin_execution_info(db,
631 info->package, &info->plugin)) {
632 ret = PMINFO_R_ERROR;
636 if (flag & PMINFO_PKGINFO_GET_AUTHOR) {
637 /* TODO : author should be retrieved at package_localized_info */
638 author = calloc(1, sizeof(author_x));
639 if (author == NULL) {
640 ret = PMINFO_R_ERROR;
643 _save_column_str(stmt, idx++, &author->text);
644 _save_column_str(stmt, idx++, &author->email);
645 _save_column_str(stmt, idx++, &author->href);
646 info->author = g_list_prepend(info->author, author);
649 if (flag & PMINFO_PKGINFO_GET_LABEL) {
651 _save_column_str(stmt, idx++, &tmp_record);
653 if (_add_label_info_into_list(locale,
654 tmp_record, &info->label)) {
655 ret = PMINFO_R_ERROR;
660 if (flag & PMINFO_PKGINFO_GET_ICON) {
662 _save_column_str(stmt, idx++, &tmp_record);
663 if (_add_icon_info_into_list(locale,
664 tmp_record, &info->icon)) {
665 ret = PMINFO_R_ERROR;
670 if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) {
672 _save_column_str(stmt, idx++, &tmp_record);
673 if (_pkginfo_add_description_info_into_list(locale,
674 tmp_record, &info->description)) {
675 ret = PMINFO_R_ERROR;
680 if (flag & PMINFO_PKGINFO_GET_PRIVILEGE) {
681 if (_pkginfo_get_privilege(db, info->package,
682 &info->privileges)) {
683 ret = PMINFO_R_ERROR;
688 if (flag & PMINFO_PKGINFO_GET_APPDEFINED_PRIVILEGE) {
689 if (_pkginfo_get_appdefined_privilege(db, info->package,
690 &info->appdefined_privileges)) {
691 ret = PMINFO_R_ERROR;
696 if (flag & PMINFO_PKGINFO_GET_DEPENDENCY) {
697 if (_pkginfo_get_dependency(db, info->package,
698 &info->dependencies)) {
699 ret = PMINFO_R_ERROR;
704 if (flag & PMINFO_PKGINFO_GET_RES_INFO) {
705 if (_pkginfo_get_res_info(db, info->package,
708 &info->res_allowed_packages) < 0) {
709 ret = PMINFO_R_ERROR;
714 if (is_check_storage &&
715 __pkginfo_check_installed_storage(info) !=
717 ret = PMINFO_R_ERROR;
718 pkgmgrinfo_basic_free_package(info);
723 g_hash_table_insert(packages, (gpointer)info->package,
730 sqlite3_finalize(stmt);
735 if (ret != PMINFO_R_OK && info != NULL)
736 pkgmgrinfo_basic_free_package(info);
738 g_list_free_full(bind_params, free);
743 API int pkginfo_internal_filter_get_list(
744 sqlite3 *db, pkgmgrinfo_pkginfo_filter_h filter,
745 uid_t uid, const char *locale, GHashTable *pkginfo_list)
749 if (filter == NULL || pkginfo_list == NULL) {
750 LOGE("Invalid argument");
751 return PMINFO_R_EINVAL;
754 ret = _pkginfo_get_packages(db, uid, locale, filter,
755 PMINFO_PKGINFO_GET_ALL, pkginfo_list);
759 API int get_query_result(sqlite3 *db, const char *query, GList *param,
760 GList **list, int *row, int *col)
766 sqlite3_stmt *stmt = NULL;
769 if (db == NULL || query == NULL) {
770 LOGE("Invalid parameter");
771 return PMINFO_R_EINVAL;
774 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
775 if (ret != SQLITE_OK) {
776 LOGE("prepare failed: %s", sqlite3_errmsg(db));
777 return PMINFO_R_ERROR;
780 if (g_list_length(param) != 0) {
781 ret = __bind_params(stmt, param);
782 if (ret != PMINFO_R_OK) {
783 LOGE("failed to bind parameters: %s", sqlite3_errmsg(db));
784 sqlite3_finalize(stmt);
789 col_cnt = sqlite3_column_count(stmt);
791 while (sqlite3_step(stmt) == SQLITE_ROW) {
793 for (idx = 0; idx < col_cnt; ++idx) {
794 _save_column_str(stmt, idx, &result);
795 *list = g_list_append(*list, result);
803 sqlite3_finalize(stmt);
808 static int _get_depends_on(sqlite3 *db, const char *pkgid, GQueue **queue,
809 GHashTable **table, GList **pkg_list)
811 static const char query[] =
812 "SELECT package, depends_on, type, required_version "
813 "FROM package_dependency_info WHERE depends_on=?";
818 /* already checked */
819 if (!g_hash_table_insert(*table, strdup(pkgid), GINT_TO_POINTER(1)))
822 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
823 if (ret != SQLITE_OK) {
824 LOGE("prepare failed: %s", sqlite3_errmsg(db));
825 return PMINFO_R_ERROR;
828 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC);
829 if (ret != SQLITE_OK) {
830 LOGE("bind failed: %s", sqlite3_errmsg(db));
831 sqlite3_finalize(stmt);
832 return PMINFO_R_ERROR;
835 while (sqlite3_step(stmt) == SQLITE_ROW) {
836 req = calloc(1, sizeof(dependency_x));
838 LOGE("out of memory");
839 sqlite3_finalize(stmt);
840 return PMINFO_R_ERROR;
842 _save_column_str(stmt, 0, &req->pkgid);
843 _save_column_str(stmt, 1, &req->depends_on);
844 _save_column_str(stmt, 2, &req->type);
845 _save_column_str(stmt, 3, &req->required_version);
847 *pkg_list = g_list_prepend(*pkg_list, req);
848 g_queue_push_tail(*queue, strdup(req->pkgid));
851 sqlite3_finalize(stmt);
856 static void __free_depends_on(gpointer data)
858 struct dependency_x *dep = (struct dependency_x *)data;
861 free(dep->depends_on);
863 free(dep->required_version);
867 API int pkginfo_internal_filter_get_depends_on(sqlite3 *db, const char *pkgid,
875 if (db == NULL || pkgid == NULL) {
876 LOGE("Invalid parameter");
877 return PMINFO_R_EINVAL;
880 queue = g_queue_new();
882 LOGE("out of memory");
883 return PMINFO_R_ERROR;
885 table = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL);
887 g_queue_push_tail(queue, strdup(pkgid));
888 while (!g_queue_is_empty(queue)) {
889 item = g_queue_pop_head(queue);
890 ret = _get_depends_on(db, item, &queue, &table, list);
892 if (ret != PMINFO_R_OK) {
893 LOGE("failed to get pkgs depends on %s", pkgid);
894 g_hash_table_destroy(table);
895 g_list_free_full(*list, __free_depends_on);
896 g_queue_free_full(queue, free);
897 return PMINFO_R_ERROR;
901 g_hash_table_destroy(table);
902 g_queue_free_full(queue, free);
906 static int __execute_query(sqlite3 *db, const char *query, GList *param)
909 sqlite3_stmt *stmt = NULL;
911 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
912 if (ret != SQLITE_OK) {
913 LOGE("prepare failed: %s", sqlite3_errmsg(db));
917 if (g_list_length(param) != 0) {
918 ret = __bind_params(stmt, param);
919 if (ret != PMINFO_R_OK) {
920 LOGE("failed to bind parameters: %s", sqlite3_errmsg(db));
921 sqlite3_finalize(stmt);
926 ret = sqlite3_step(stmt);
927 if (ret != SQLITE_DONE && ret != SQLITE_OK) {
928 LOGE("step failed:%d %s", ret, sqlite3_errmsg(db));
929 sqlite3_finalize(stmt);
933 sqlite3_finalize(stmt);
938 API int execute_write_queries(sqlite3 *db, GList *queries, GList *params_list)
941 query_args *tmp_ptr = NULL;
943 if (db == NULL || queries == NULL) {
944 _LOGE("Invalid parameter");
945 return PMINFO_R_EINVAL;
948 __BEGIN_TRANSACTION(db);
949 for (i = 0; i < g_list_length(queries); ++i) {
950 tmp_ptr = (query_args *)g_list_nth_data(params_list, i);
951 if (tmp_ptr == NULL) {
952 _LOGE("Failed to get parameter list");
953 sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
954 return PMINFO_R_ERROR;
958 __execute_query(db, g_list_nth_data(queries, i),
961 __END_TRANSACTION(db);
966 static int __check_dpi(const char *dpi_char, int dpi_int)
968 if (dpi_char == NULL)
971 if (strcasecmp(dpi_char, LDPI) == 0) {
972 if (dpi_int >= LDPI_MIN && dpi_int <= LDPI_MAX)
976 } else if (strcasecmp(dpi_char, MDPI) == 0) {
977 if (dpi_int >= MDPI_MIN && dpi_int <= MDPI_MAX)
981 } else if (strcasecmp(dpi_char, HDPI) == 0) {
982 if (dpi_int >= HDPI_MIN && dpi_int <= HDPI_MAX)
986 } else if (strcasecmp(dpi_char, XHDPI) == 0) {
987 if (dpi_int >= XHDPI_MIN && dpi_int <= XHDPI_MAX)
991 } else if (strcasecmp(dpi_char, XXHDPI) == 0) {
992 if (dpi_int >= XXHDPI_MIN && dpi_int <= XXHDPI_MAX)
1000 static void __find_appcontrol_splashscreen_with_dpi(gpointer data,
1003 splashscreen_x *ss = (splashscreen_x *)data;
1004 GList **list = (GList **)user_data;
1008 if (ss->operation == NULL || ss->dpi == NULL)
1011 ret = system_info_get_platform_int(
1012 "http://tizen.org/feature/screen.dpi", &dpi);
1013 if (ret != SYSTEM_INFO_ERROR_NONE)
1016 if (__check_dpi(ss->dpi, dpi) != 0)
1019 *list = g_list_prepend(*list, ss);
1022 static void __find_appcontrol_splashscreen(gpointer data, gpointer user_data)
1024 splashscreen_x *ss = (splashscreen_x *)data;
1025 GList **list = (GList **)user_data;
1026 splashscreen_x *ss_tmp;
1029 if (ss->operation == NULL || ss->dpi)
1032 for (tmp = *list; tmp; tmp = tmp->next) {
1033 ss_tmp = (splashscreen_x *)tmp->data;
1034 if (ss_tmp->operation
1035 && strcmp(ss_tmp->operation, ss->operation) == 0
1036 && strcmp(ss_tmp->orientation, ss->orientation) == 0)
1040 *list = g_list_prepend(*list, ss);
1043 static gint __compare_splashscreen_with_orientation_dpi(gconstpointer a,
1046 splashscreen_x *ss = (splashscreen_x *)a;
1047 const char *orientation = (const char *)b;
1051 if (ss->operation || ss->dpi == NULL)
1054 ret = system_info_get_platform_int(
1055 "http://tizen.org/feature/screen.dpi", &dpi);
1056 if (ret != SYSTEM_INFO_ERROR_NONE)
1059 if (strcasecmp(ss->orientation, orientation) == 0 &&
1060 __check_dpi(ss->dpi, dpi) == 0)
1066 static gint __compare_splashscreen_with_orientation(gconstpointer a,
1069 splashscreen_x *ss = (splashscreen_x *)a;
1070 const char *orientation = (const char *)b;
1072 if (ss->operation || ss->dpi)
1075 if (strcasecmp(ss->orientation, orientation) == 0)
1081 static splashscreen_x *__find_default_splashscreen(GList *splashscreens,
1082 const char *orientation)
1086 tmp = g_list_find_custom(splashscreens, orientation,
1088 __compare_splashscreen_with_orientation_dpi);
1090 return (splashscreen_x *)tmp->data;
1092 tmp = g_list_find_custom(splashscreens, orientation,
1093 (GCompareFunc)__compare_splashscreen_with_orientation);
1095 return (splashscreen_x *)tmp->data;
1100 static GList *__find_splashscreens(GList *splashscreens)
1105 if (splashscreens == NULL)
1108 g_list_foreach(splashscreens,
1109 __find_appcontrol_splashscreen_with_dpi, &list);
1110 g_list_foreach(splashscreens,
1111 __find_appcontrol_splashscreen, &list);
1113 ss = __find_default_splashscreen(splashscreens, "portrait");
1115 list = g_list_prepend(list, ss);
1116 ss = __find_default_splashscreen(splashscreens, "landscape");
1118 list = g_list_prepend(list, ss);
1123 static int __insert_splashscreen_info(sqlite3 *db, application_x *app,
1126 static const char query[] =
1127 "INSERT INTO package_app_splash_screen (app_id, src, type,"
1128 " orientation, indicatordisplay, operation, color_depth) "
1129 "VALUES (?, ?, ?, ?, ?, ?, ?)";
1136 if (app->splashscreens == NULL)
1139 if (ss_list == NULL)
1142 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1143 if (ret != SQLITE_OK) {
1144 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1148 for (tmp = ss_list; tmp; tmp = tmp->next) {
1149 ss = (splashscreen_x *)tmp->data;
1153 __BIND_TEXT(db, stmt, idx++, app->appid);
1154 __BIND_TEXT(db, stmt, idx++, ss->src);
1155 __BIND_TEXT(db, stmt, idx++, ss->type);
1156 __BIND_TEXT(db, stmt, idx++, ss->orientation);
1157 __BIND_TEXT(db, stmt, idx++, ss->indicatordisplay);
1158 __BIND_TEXT(db, stmt, idx++, ss->operation);
1159 __BIND_TEXT(db, stmt, idx++, ss->color_depth);
1161 ret = sqlite3_step(stmt);
1162 if (ret != SQLITE_DONE) {
1163 _LOGE("step failed: %s", sqlite3_errmsg(db));
1164 sqlite3_finalize(stmt);
1168 sqlite3_reset(stmt);
1171 sqlite3_finalize(stmt);
1176 static void __trimfunc(GList *trim_list)
1180 GList *list = g_list_first(trim_list);
1183 trim_data = (char *)list->data;
1186 if (strcmp(trim_data, prev) == 0) {
1187 trim_list = g_list_remove(trim_list,
1189 list = g_list_first(trim_list);
1198 list = g_list_next(list);
1202 static int __insert_package_appdefined_privilege_info(sqlite3 *db,
1205 static const char query[] =
1206 "INSERT INTO package_appdefined_privilege_info "
1207 "(package, privilege, license, type) "
1208 "VALUES (?, ?, ?, ?)";
1213 appdefined_privilege_x *priv;
1215 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1216 if (ret != SQLITE_OK) {
1217 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1221 for (tmp = mfx->appdefined_privileges; tmp; tmp = tmp->next) {
1222 priv = (appdefined_privilege_x *)tmp->data;
1227 __BIND_TEXT(db, stmt, idx++, mfx->package);
1228 __BIND_TEXT(db, stmt, idx++, priv->value);
1229 __BIND_TEXT(db, stmt, idx++, priv->license);
1230 __BIND_TEXT(db, stmt, idx++, priv->type);
1232 ret = sqlite3_step(stmt);
1233 if (ret != SQLITE_DONE) {
1234 _LOGE("step failed: %s", sqlite3_errmsg(db));
1235 sqlite3_finalize(stmt);
1238 sqlite3_reset(stmt);
1241 sqlite3_finalize(stmt);
1246 static int __insert_package_dependency_info(sqlite3 *db, manifest_x *mfx)
1248 static const char query[] =
1249 "INSERT INTO package_dependency_info"
1250 " (package, depends_on, type, required_version) "
1251 "VALUES (?, ?, ?, ?)";
1258 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1259 if (ret != SQLITE_OK) {
1260 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1264 for (tmp = mfx->dependencies; tmp; tmp = tmp->next) {
1265 dep = (dependency_x *)tmp->data;
1270 __BIND_TEXT(db, stmt, idx++, mfx->package);
1271 __BIND_TEXT(db, stmt, idx++, dep->depends_on);
1272 __BIND_TEXT(db, stmt, idx++, dep->type);
1273 __BIND_TEXT(db, stmt, idx++, dep->required_version);
1275 ret = sqlite3_step(stmt);
1276 if (ret != SQLITE_DONE) {
1277 _LOGE("step failed: %s", sqlite3_errmsg(db));
1278 sqlite3_finalize(stmt);
1281 sqlite3_reset(stmt);
1284 sqlite3_finalize(stmt);
1289 static int __insert_mainapp_localized_info(sqlite3 *db, application_x *app,
1290 const char *locale, const char *label, const char *icon)
1292 static const char query[] =
1293 "INSERT OR REPLACE INTO package_localized_info ("
1294 " package, package_locale, package_label, package_icon,"
1295 " package_description, package_license, package_author) "
1297 " COALESCE((SELECT package_label FROM package_localized_info"
1298 " WHERE package=? AND package_locale=?), ?),"
1299 " COALESCE((SELECT package_icon FROM package_localized_info"
1300 " WHERE package=? AND package_icon=?), ?),"
1301 " (SELECT package_description FROM package_localized_info"
1302 " WHERE package=? AND package_locale=?),"
1303 " (SELECT package_description FROM package_localized_info"
1304 " WHERE package=? AND package_locale=?),"
1305 " (SELECT package_description FROM package_localized_info"
1306 " WHERE package=? AND package_locale=?))";
1311 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1312 if (ret != SQLITE_OK) {
1313 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1317 __BIND_TEXT(db, stmt, idx++, app->package);
1318 __BIND_TEXT(db, stmt, idx++, locale);
1319 __BIND_TEXT(db, stmt, idx++, app->package);
1320 __BIND_TEXT(db, stmt, idx++, locale);
1321 __BIND_TEXT(db, stmt, idx++, label);
1322 __BIND_TEXT(db, stmt, idx++, app->package);
1323 __BIND_TEXT(db, stmt, idx++, locale);
1324 __BIND_TEXT(db, stmt, idx++, icon);
1325 __BIND_TEXT(db, stmt, idx++, app->package);
1326 __BIND_TEXT(db, stmt, idx++, locale);
1327 __BIND_TEXT(db, stmt, idx++, app->package);
1328 __BIND_TEXT(db, stmt, idx++, locale);
1329 __BIND_TEXT(db, stmt, idx++, app->package);
1330 __BIND_TEXT(db, stmt, idx++, locale);
1332 ret = sqlite3_step(stmt);
1333 if (ret != SQLITE_DONE) {
1334 _LOGE("step failed: %s", sqlite3_errmsg(db));
1335 sqlite3_finalize(stmt);
1339 sqlite3_finalize(stmt);
1344 static gint __comparefunc(gconstpointer a, gconstpointer b, gpointer userdata)
1346 if (a == NULL || b == NULL)
1348 if (strcmp((char *)a, (char *)b) == 0)
1350 if (strcmp((char *)a, (char *)b) < 0)
1352 if (strcmp((char *)a, (char *)b) > 0)
1357 static GList *__create_locale_list(GList *lbls, GList *lcns, GList *icns,
1358 GList *dcns, GList *aths)
1360 GList *locale = NULL;
1368 for (tmp = lbls; tmp; tmp = tmp->next) {
1369 lbl = (label_x *)tmp->data;
1373 locale = g_list_insert_sorted_with_data(
1374 locale, (gpointer)lbl->lang,
1375 __comparefunc, NULL);
1377 for (tmp = lcns; tmp; tmp = tmp->next) {
1378 lcn = (license_x *)tmp->data;
1382 locale = g_list_insert_sorted_with_data(
1383 locale, (gpointer)lcn->lang,
1384 __comparefunc, NULL);
1386 for (tmp = icns; tmp; tmp = tmp->next) {
1387 icn = (icon_x *)tmp->data;
1391 locale = g_list_insert_sorted_with_data(
1392 locale, (gpointer)icn->lang,
1393 __comparefunc, NULL);
1395 for (tmp = dcns; tmp; tmp = tmp->next) {
1396 dcn = (description_x *)tmp->data;
1400 locale = g_list_insert_sorted_with_data(
1401 locale, (gpointer)dcn->lang,
1402 __comparefunc, NULL);
1404 for (tmp = aths; tmp; tmp = tmp->next) {
1405 ath = (author_x *)tmp->data;
1409 locale = g_list_insert_sorted_with_data(
1410 locale, (gpointer)ath->lang,
1411 __comparefunc, NULL);
1417 static gint __check_icon_resolution(const char *orig_icon_path,
1418 char **new_icon_path)
1422 char *icon_filename;
1423 char modified_iconpath[BUFSIZE];
1424 char icon_path[BUFSIZE];
1428 if (orig_icon_path == NULL)
1431 ret = system_info_get_platform_int(
1432 "http://tizen.org/feature/screen.dpi", &dpi);
1433 if (ret != SYSTEM_INFO_ERROR_NONE)
1436 if (dpi >= LDPI_MIN && dpi <= LDPI_MAX) {
1437 dpi_path[0] = "LDPI";
1438 dpi_path[1] = "ldpi";
1439 } else if (dpi >= MDPI_MIN && dpi <= MDPI_MAX) {
1440 dpi_path[0] = "MDPI";
1441 dpi_path[1] = "mdpi";
1442 } else if (dpi >= HDPI_MIN && dpi <= HDPI_MAX) {
1443 dpi_path[0] = "HDPI";
1444 dpi_path[1] = "hdpi";
1445 } else if (dpi >= XHDPI_MIN && dpi <= XHDPI_MAX) {
1446 dpi_path[0] = "XHDPI";
1447 dpi_path[1] = "xhdpi";
1448 } else if (dpi >= XXHDPI_MIN && dpi <= XXHDPI_MAX) {
1449 dpi_path[0] = "XXHDPI";
1450 dpi_path[1] = "xxhdpi";
1452 _LOGE("Unidentified dpi[%d]", dpi);
1456 icon_filename = strrchr(orig_icon_path, '/');
1457 if (icon_filename == NULL)
1461 strlen(orig_icon_path) - (strlen(icon_filename) - 1),
1462 "%s", orig_icon_path);
1463 for (i = 0; i < 2; i++) {
1464 ret = snprintf(modified_iconpath, BUFSIZE - 1, "%s/%s%s",
1465 icon_path, dpi_path[i], icon_filename);
1466 if (ret < 0 || ret > BUFSIZE - 1) {
1467 _LOGE("snprintf fail");
1470 if (access(modified_iconpath, F_OK) != -1) {
1471 /* if exists, return modified icon path */
1472 *new_icon_path = strdup(modified_iconpath);
1480 static gint __compare_icon(gconstpointer a, gconstpointer b)
1482 icon_x *icon = (icon_x *)a;
1485 if (icon->lang != NULL && strcasecmp(icon->lang, DEFAULT_LOCALE) != 0)
1488 if (icon->dpi != NULL)
1491 if (__check_icon_resolution(icon->text, &icon_path) == 0) {
1493 icon->text = icon_path;
1499 static gint __compare_icon_with_lang(gconstpointer a, gconstpointer b)
1501 icon_x *icon = (icon_x *)a;
1502 char *lang = (char *)b;
1505 if (icon->dpi != NULL)
1508 if (strcasecmp(icon->lang, lang) == 0) {
1509 if (strcasecmp(icon->lang, DEFAULT_LOCALE) == 0) {
1510 /* icon for no locale. check existance of
1511 * folder-hierachied default icons
1513 if (__check_icon_resolution(icon->text,
1516 icon->text = icon_path;
1525 static gint __compare_icon_with_dpi(gconstpointer a, gconstpointer b)
1527 icon_x *icon = (icon_x *)a;
1528 int dpi = GPOINTER_TO_INT(b);
1530 if (icon->lang != NULL && strcasecmp(icon->lang, DEFAULT_LOCALE) != 0)
1533 if (icon->dpi == NULL)
1536 if (__check_dpi(icon->dpi, dpi) == 0)
1542 static gint __compare_icon_with_lang_dpi(gconstpointer a, gconstpointer b)
1545 icon_x *icon = (icon_x *)a;
1546 char *lang = (char *)b;
1549 ret = system_info_get_platform_int(
1550 "http://tizen.org/feature/screen.dpi", &dpi);
1551 if (ret != SYSTEM_INFO_ERROR_NONE)
1554 if (strcasecmp(icon->lang, lang) == 0 &&
1555 __check_dpi(icon->dpi, dpi) == 0)
1561 static char *__find_icon(GList *icons, const char *lang)
1568 /* first, find icon whose locale and dpi with given lang and
1569 * system's dpi has matched
1571 tmp = g_list_find_custom(icons, lang,
1572 (GCompareFunc)__compare_icon_with_lang_dpi);
1574 icon = (icon_x *)tmp->data;
1575 return (char *)icon->text;
1578 /* if first has failed, find icon whose locale has matched */
1579 tmp = g_list_find_custom(icons, lang,
1580 (GCompareFunc)__compare_icon_with_lang);
1582 icon = (icon_x *)tmp->data;
1583 return (char *)icon->text;
1586 /* if second has failed, find icon whose dpi has matched with
1589 ret = system_info_get_platform_int(
1590 "http://tizen.org/feature/screen.dpi", &dpi);
1591 if (ret == SYSTEM_INFO_ERROR_NONE) {
1592 tmp = g_list_find_custom(icons, GINT_TO_POINTER(dpi),
1593 (GCompareFunc)__compare_icon_with_dpi);
1595 icon = (icon_x *)tmp->data;
1596 return (char *)icon->text;
1600 /* last, find default icon marked as "No Locale" */
1601 tmp = g_list_find_custom(icons, NULL, (GCompareFunc)__compare_icon);
1603 icon = (icon_x *)tmp->data;
1604 return (char *)icon->text;
1610 static void __extract_data(const char *locale, GList *lbls, GList *lcns,
1611 GList *icns, GList *dcns, GList *aths, char **label,
1612 char **license, char **icon, char **description, char **author)
1620 for (tmp = lbls; tmp; tmp = tmp->next) {
1621 lbl = (label_x *)tmp->data;
1625 if (strcmp(lbl->lang, locale) == 0) {
1626 *label = (char *)lbl->text;
1631 for (tmp = lcns; tmp; tmp = tmp->next) {
1632 lcn = (license_x *)tmp->data;
1636 if (strcmp(lcn->lang, locale) == 0) {
1637 *license = (char *)lcn->text;
1643 *icon = __find_icon(icns, locale);
1645 for (tmp = dcns; tmp; tmp = tmp->next) {
1646 dcn = (description_x *)tmp->data;
1650 if (strcmp(dcn->lang, locale) == 0) {
1651 *description = (char *)dcn->text;
1656 for (tmp = aths; tmp; tmp = tmp->next) {
1657 ath = (author_x *)tmp->data;
1661 if (strcmp(ath->lang, locale) == 0) {
1662 *author = (char *)ath->text;
1669 static int __insert_app_localized_info(sqlite3 *db, application_x *app)
1671 static const char query[] =
1672 "INSERT INTO package_app_localized_info (app_id, app_locale,"
1673 " app_label, app_icon) "
1674 "VALUES (?, ?, ?, ?)";
1684 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1685 if (ret != SQLITE_OK) {
1686 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1690 locales = __create_locale_list(app->label, NULL, app->icon, NULL, NULL);
1691 for (tmp = locales; tmp; tmp = tmp->next) {
1692 locale = (const char *)tmp->data;
1695 __extract_data(locale, app->label, NULL, app->icon, NULL, NULL,
1696 &label, NULL, &icon, NULL, NULL);
1697 if (!label && !icon)
1701 __BIND_TEXT(db, stmt, idx++, app->appid);
1702 __BIND_TEXT(db, stmt, idx++, locale);
1703 __BIND_TEXT(db, stmt, idx++, label);
1704 __BIND_TEXT(db, stmt, idx++, icon);
1706 ret = sqlite3_step(stmt);
1707 if (ret != SQLITE_DONE) {
1708 _LOGE("step failed: %s", sqlite3_errmsg(db));
1709 g_list_free(locales);
1710 sqlite3_finalize(stmt);
1714 sqlite3_reset(stmt);
1716 if (strcasecmp(app->mainapp, "true") == 0) {
1717 if (__insert_mainapp_localized_info(db, app, locale,
1719 _LOGE("insert mainapp localized info failed");
1723 g_list_free(locales);
1724 sqlite3_finalize(stmt);
1729 static int __insert_app_res_control(sqlite3 *db, application_x *app)
1731 static const char query[] =
1732 "INSERT INTO package_app_res_control (app_id, res_type,"
1733 " min_res_version, max_res_version, auto_close) "
1734 "VALUES (?, ?, ?, ?, ?)";
1741 if (app->res_control == NULL)
1744 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1745 if (ret != SQLITE_OK) {
1746 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1750 for (tmp = app->res_control; tmp; tmp = tmp->next) {
1751 rc = (res_control_x *)tmp->data;
1755 __BIND_TEXT(db, stmt, idx++, app->appid);
1756 __BIND_TEXT(db, stmt, idx++, rc->res_type);
1757 __BIND_TEXT(db, stmt, idx++, rc->min_res_version);
1758 __BIND_TEXT(db, stmt, idx++, rc->max_res_version);
1759 __BIND_TEXT(db, stmt, idx++, rc->auto_close);
1761 ret = sqlite3_step(stmt);
1762 if (ret != SQLITE_DONE) {
1763 _LOGE("step failed: %s", sqlite3_errmsg(db));
1764 sqlite3_finalize(stmt);
1768 sqlite3_reset(stmt);
1771 sqlite3_finalize(stmt);
1776 static int __insert_package_privilege_info(sqlite3 *db, manifest_x *mfx)
1778 static const char query[] =
1779 "INSERT INTO package_privilege_info (package, privilege, type) "
1787 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1788 if (ret != SQLITE_OK) {
1789 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1793 for (tmp = mfx->privileges; tmp; tmp = tmp->next) {
1794 priv = (privilege_x *)tmp->data;
1799 __BIND_TEXT(db, stmt, idx++, mfx->package);
1800 __BIND_TEXT(db, stmt, idx++, priv->value);
1801 __BIND_TEXT(db, stmt, idx++, priv->type);
1803 ret = sqlite3_step(stmt);
1804 if (ret != SQLITE_DONE) {
1805 _LOGE("step failed: %s", sqlite3_errmsg(db));
1806 sqlite3_finalize(stmt);
1809 sqlite3_reset(stmt);
1812 sqlite3_finalize(stmt);
1817 static int __insert_app_data_control_privilege_info(sqlite3 *db,
1818 datacontrol_x *datacontrol)
1820 static const char query[] =
1821 "INSERT INTO package_app_data_control_privilege (providerid,"
1822 " privilege, type) VALUES (?, ?, ?)";
1830 if (datacontrol == NULL)
1833 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1834 if (ret != SQLITE_OK) {
1835 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1839 for (privileges = datacontrol->privileges; privileges;
1840 privileges = privileges->next) {
1841 priv = (char *)privileges->data;
1846 __BIND_TEXT(db, stmt, idx++, datacontrol->providerid);
1847 __BIND_TEXT(db, stmt, idx++, priv);
1848 __BIND_TEXT(db, stmt, idx++, datacontrol->type);
1850 ret = sqlite3_step(stmt);
1851 if (ret != SQLITE_DONE) {
1852 _LOGE("step failed: %s", sqlite3_errmsg(db));
1853 sqlite3_finalize(stmt);
1857 sqlite3_reset(stmt);
1860 sqlite3_finalize(stmt);
1864 static int __insert_datacontrol_info(sqlite3 *db, application_x *app)
1866 static const char query[] =
1867 "INSERT INTO package_app_data_control (app_id, providerid,"
1868 " access, type, trusted) VALUES (?, ?, ?, ?, ?)";
1875 if (app->datacontrol == NULL)
1878 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1879 if (ret != SQLITE_OK) {
1880 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1884 for (tmp = app->datacontrol; tmp; tmp = tmp->next) {
1885 dc = (datacontrol_x *)tmp->data;
1889 __BIND_TEXT(db, stmt, idx++, app->appid);
1890 __BIND_TEXT(db, stmt, idx++, dc->providerid);
1891 __BIND_TEXT(db, stmt, idx++, dc->access);
1892 __BIND_TEXT(db, stmt, idx++, dc->type);
1893 __BIND_TEXT(db, stmt, idx++, dc->trusted);
1895 ret = sqlite3_step(stmt);
1896 if (ret != SQLITE_DONE) {
1897 _LOGE("step failed: %s", sqlite3_errmsg(db));
1898 sqlite3_finalize(stmt);
1902 if (dc->privileges &&
1903 __insert_app_data_control_privilege_info(
1905 sqlite3_finalize(stmt);
1909 sqlite3_reset(stmt);
1912 sqlite3_finalize(stmt);
1917 static int __insert_category_info(sqlite3 *db, application_x *app)
1919 static const char query[] =
1920 "INSERT INTO package_app_app_category (app_id, category) "
1926 const char *category;
1928 if (app->category == NULL)
1931 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1932 if (ret != SQLITE_OK) {
1933 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1937 for (tmp = app->category; tmp; tmp = tmp->next) {
1938 category = (const char *)tmp->data;
1939 if (category == NULL)
1942 __BIND_TEXT(db, stmt, idx++, app->appid);
1943 __BIND_TEXT(db, stmt, idx++, category);
1945 ret = sqlite3_step(stmt);
1946 if (ret != SQLITE_DONE) {
1947 _LOGE("step failed: %s", sqlite3_errmsg(db));
1948 sqlite3_finalize(stmt);
1952 sqlite3_reset(stmt);
1955 sqlite3_finalize(stmt);
1960 static int __insert_metadata_info(sqlite3 *db, application_x *app)
1962 static const char query[] =
1963 "INSERT INTO package_app_app_metadata (app_id,"
1964 " md_key, md_value) VALUES (?, ?, ?)";
1971 if (app->metadata == NULL)
1974 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1975 if (ret != SQLITE_OK) {
1976 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1980 for (tmp = app->metadata; tmp; tmp = tmp->next) {
1981 md = (metadata_x *)tmp->data;
1985 __BIND_TEXT(db, stmt, idx++, app->appid);
1986 __BIND_TEXT(db, stmt, idx++, md->key);
1987 __BIND_TEXT(db, stmt, idx++, md->value);
1989 ret = sqlite3_step(stmt);
1990 if (ret != SQLITE_DONE) {
1991 _LOGE("step failed: %s", sqlite3_errmsg(db));
1992 sqlite3_finalize(stmt);
1996 sqlite3_reset(stmt);
1999 sqlite3_finalize(stmt);
2004 static int __insert_appcontrol_privilege_info(sqlite3 *db, const char *appid,
2007 static const char query[] =
2008 "INSERT INTO package_app_app_control_privilege (app_id,"
2009 " app_control, privilege) VALUES (?, ?, ?)";
2013 char app_control[BUFSIZE];
2020 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2021 if (ret != SQLITE_OK) {
2022 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2026 for (tmp = ac->privileges; tmp; tmp = tmp->next) {
2027 privilege = (char *)tmp->data;
2028 if (privilege == NULL || !strlen(privilege))
2032 snprintf(app_control, sizeof(app_control), "%s|%s|%s",
2033 ac->operation ? (strlen(ac->operation) > 0 ?
2034 ac->operation : "NULL") : "NULL",
2035 ac->uri ? (strlen(ac->uri) > 0 ?
2036 ac->uri : "NULL") : "NULL",
2037 ac->mime ? (strlen(ac->mime) > 0 ?
2038 ac->mime : "NULL") : "NULL");
2039 __BIND_TEXT(db, stmt, idx++, appid);
2040 __BIND_TEXT(db, stmt, idx++, app_control);
2041 __BIND_TEXT(db, stmt, idx++, privilege);
2043 ret = sqlite3_step(stmt);
2044 if (ret != SQLITE_DONE) {
2045 _LOGE("step failed: %s", sqlite3_errmsg(db));
2046 sqlite3_finalize(stmt);
2050 sqlite3_reset(stmt);
2053 sqlite3_finalize(stmt);
2058 static int __insert_appcontrol_info(sqlite3 *db, application_x *app)
2060 static const char query[] =
2061 "INSERT INTO package_app_app_control (app_id, app_control,"
2062 " visibility, app_control_id) "
2063 "VALUES (?, ?, ?, ?)";
2067 char app_control[BUFSIZE];
2071 if (app->appcontrol == NULL)
2074 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2075 if (ret != SQLITE_OK) {
2076 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2080 for (tmp = app->appcontrol; tmp; tmp = tmp->next) {
2081 ac = (appcontrol_x *)tmp->data;
2085 snprintf(app_control, sizeof(app_control), "%s|%s|%s",
2086 ac->operation ? (strlen(ac->operation) > 0 ?
2087 ac->operation : "NULL") : "NULL",
2088 ac->uri ? (strlen(ac->uri) > 0 ?
2089 ac->uri : "NULL") : "NULL",
2090 ac->mime ? (strlen(ac->mime) > 0 ?
2091 ac->mime : "NULL") : "NULL");
2092 __BIND_TEXT(db, stmt, idx++, app->appid);
2093 __BIND_TEXT(db, stmt, idx++, app_control);
2094 __BIND_TEXT(db, stmt, idx++, ac->visibility);
2095 __BIND_TEXT(db, stmt, idx++, ac->id);
2097 ret = sqlite3_step(stmt);
2098 if (ret != SQLITE_DONE) {
2099 _LOGE("step failed: %s", sqlite3_errmsg(db));
2100 sqlite3_finalize(stmt);
2104 if (__insert_appcontrol_privilege_info(db, app->appid, ac)) {
2105 sqlite3_finalize(stmt);
2109 sqlite3_reset(stmt);
2112 sqlite3_finalize(stmt);
2117 static const char *__get_bool(char *value, bool is_true)
2119 if (value != NULL) {
2120 if (!strcmp(value, ""))
2121 return (is_true) ? "true" : "false";
2125 return (is_true) ? "true" : "false";
2128 #define EFFECTIVE_APPID_KEY "http://tizen.org/metadata/effective-appid"
2129 static const char *__find_effective_appid(GList *metadata_list)
2134 for (tmp = metadata_list; tmp; tmp = tmp->next) {
2135 md = (metadata_x *)tmp->data;
2136 if (md == NULL || md->key == NULL)
2139 if (strcmp(md->key, EFFECTIVE_APPID_KEY) == 0) {
2148 static int __convert_background_category(GList *category_list)
2152 char *category_data;
2154 if (category_list == NULL)
2157 for (tmp = category_list; tmp; tmp = tmp->next) {
2158 category_data = (char *)tmp->data;
2159 if (category_data == NULL)
2161 if (!strcmp(category_data, APP_BG_CATEGORY_MEDIA_STR))
2162 ret |= APP_BG_CATEGORY_MEDIA_VAL;
2163 else if (!strcmp(category_data, APP_BG_CATEGORY_DOWNLOAD_STR))
2164 ret |= APP_BG_CATEGORY_DOWNLOAD_VAL;
2165 else if (!strcmp(category_data, APP_BG_CATEGORY_BGNETWORK_STR))
2166 ret |= APP_BG_CATEGORY_BGNETWORK_VAL;
2167 else if (!strcmp(category_data, APP_BG_CATEGORY_LOCATION_STR))
2168 ret |= APP_BG_CATEGORY_LOCATION_VAL;
2169 else if (!strcmp(category_data, APP_BG_CATEGORY_SENSOR_STR))
2170 ret |= APP_BG_CATEGORY_SENSOR_VAL;
2171 else if (!strcmp(category_data, APP_BG_CATEGORY_IOTCOMM_STR))
2172 ret |= APP_BG_CATEGORY_IOTCOMM_VAL;
2173 else if (!strcmp(category_data, APP_BG_CATEGORY_SYSTEM))
2174 ret |= APP_BG_CATEGORY_SYSTEM_VAL;
2176 _LOGE("Unidentified category [%s]", category_data);
2182 static int __insert_package_res_info_allowed_package(sqlite3 *db,
2183 const char *pkgid, GList *rap_list)
2185 static const char query[] =
2186 "INSERT INTO package_res_allowed_package (package,"
2187 " allowed_package, required_privilege) VALUES (?, ?, ?)";
2193 res_allowed_package_x *rap;
2195 if (rap_list == NULL)
2198 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2199 if (ret != SQLITE_OK) {
2200 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2204 for (tmp = rap_list; tmp; tmp = tmp->next) {
2205 rap = (res_allowed_package_x *)tmp->data;
2209 if (!rap->required_privileges) {
2211 __BIND_TEXT(db, stmt, idx++, pkgid);
2212 __BIND_TEXT(db, stmt, idx++, rap->allowed_package);
2213 __BIND_TEXT(db, stmt, idx++, NULL);
2215 ret = sqlite3_step(stmt);
2216 if (ret != SQLITE_DONE) {
2217 _LOGE("step failed: %s", sqlite3_errmsg(db));
2218 sqlite3_finalize(stmt);
2222 sqlite3_reset(stmt);
2226 for (priv_list = rap->required_privileges; priv_list;
2227 priv_list = priv_list->next) {
2229 __BIND_TEXT(db, stmt, idx++, pkgid);
2230 __BIND_TEXT(db, stmt, idx++, rap->allowed_package);
2231 __BIND_TEXT(db, stmt, idx++, (char *)priv_list->data);
2233 ret = sqlite3_step(stmt);
2234 if (ret != SQLITE_DONE) {
2235 _LOGE("step failed: %s", sqlite3_errmsg(db));
2236 sqlite3_finalize(stmt);
2240 sqlite3_reset(stmt);
2244 sqlite3_finalize(stmt);
2249 static int __insert_package_res_info(sqlite3 *db, manifest_x *mfx)
2251 static const char query[] =
2252 "INSERT INTO package_res_info (package, res_type,"
2253 " res_version) VALUES (?, ?, ?)";
2258 if (mfx->res_type == NULL || mfx->res_version == NULL)
2261 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2262 if (ret != SQLITE_OK) {
2263 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2268 __BIND_TEXT(db, stmt, idx++, mfx->package);
2269 __BIND_TEXT(db, stmt, idx++, mfx->res_type);
2270 __BIND_TEXT(db, stmt, idx++, mfx->res_version);
2272 ret = sqlite3_step(stmt);
2273 if (ret != SQLITE_DONE) {
2274 _LOGE("step failed: %s", sqlite3_errmsg(db));
2275 sqlite3_finalize(stmt);
2279 if (__insert_package_res_info_allowed_package(db, mfx->package,
2280 mfx->res_allowed_packages) < 0) {
2281 sqlite3_finalize(stmt);
2285 sqlite3_finalize(stmt);
2290 static int __insert_application_info(sqlite3 *db, manifest_x *mfx)
2292 static const char query[] =
2293 "INSERT INTO package_app_info (app_id, app_component,"
2294 " app_exec, app_nodisplay, app_type, app_onboot, app_multiple,"
2295 " app_autorestart, app_taskmanage, app_hwacceleration,"
2296 " app_screenreader, app_mainapp, app_recentimage,"
2297 " app_launchcondition, app_indicatordisplay, app_portraitimg,"
2298 " app_landscapeimg, app_guestmodevisibility,"
2299 " app_permissiontype, app_preload, app_submode,"
2300 " app_submode_mainid, app_installed_storage, app_process_pool,"
2301 " app_launch_mode, app_ui_gadget, app_support_mode,"
2302 " app_support_disable, component_type, package, app_tep_name,"
2303 " app_zip_mount_file, app_background_category,"
2304 " app_package_type, app_root_path, app_api_version,"
2305 " app_effective_appid, app_splash_screen_display,"
2306 " app_package_system, app_removable,"
2307 " app_package_installed_time, app_support_ambient,"
2308 " app_external_path, app_setup_appid, light_user_switch_mode) "
2310 " ?, LOWER(?), ?, LOWER(?), LOWER(?),"
2311 " LOWER(?), LOWER(?), ?,"
2315 " ?, LOWER(?), LOWER(?),"
2317 " COALESCE(?, 'single'), LOWER(?), ?,"
2318 " LOWER(?), ?, ?, ?,"
2322 " LOWER(?), LOWER(?),"
2331 const char *effective_appid;
2334 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2335 if (ret != SQLITE_OK) {
2336 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2340 for (tmp = mfx->application; tmp; tmp = tmp->next) {
2341 app = (application_x *)tmp->data;
2345 bg_category = __convert_background_category(
2346 app->background_category);
2347 effective_appid = __find_effective_appid(app->metadata);
2350 __BIND_TEXT(db, stmt, idx++, app->appid);
2351 __BIND_TEXT(db, stmt, idx++, app->component_type);
2352 __BIND_TEXT(db, stmt, idx++, app->exec);
2353 __BIND_TEXT(db, stmt, idx++, __get_bool(app->nodisplay, false));
2354 __BIND_TEXT(db, stmt, idx++, app->type);
2355 __BIND_TEXT(db, stmt, idx++, __get_bool(app->onboot, false));
2356 __BIND_TEXT(db, stmt, idx++, __get_bool(app->multiple, false));
2357 __BIND_TEXT(db, stmt, idx++,
2358 __get_bool(app->autorestart, false));
2359 __BIND_TEXT(db, stmt, idx++,
2360 __get_bool(app->taskmanage, false));
2361 __BIND_TEXT(db, stmt, idx++, app->hwacceleration);
2362 __BIND_TEXT(db, stmt, idx++, app->screenreader);
2363 __BIND_TEXT(db, stmt, idx++, __get_bool(app->mainapp, false));
2364 __BIND_TEXT(db, stmt, idx++, app->recentimage);
2365 __BIND_TEXT(db, stmt, idx++, app->launchcondition);
2366 __BIND_TEXT(db, stmt, idx++,
2367 __get_bool(app->indicatordisplay, true));
2368 __BIND_TEXT(db, stmt, idx++, app->portraitimg);
2369 __BIND_TEXT(db, stmt, idx++, app->landscapeimg);
2370 __BIND_TEXT(db, stmt, idx++,
2371 __get_bool(app->guestmode_visibility, true));
2372 __BIND_TEXT(db, stmt, idx++, app->permission_type);
2373 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->preload, false));
2374 __BIND_TEXT(db, stmt, idx++, __get_bool(app->submode, false));
2375 __BIND_TEXT(db, stmt, idx++, app->submode_mainid);
2376 __BIND_TEXT(db, stmt, idx++, mfx->installed_storage);
2377 __BIND_TEXT(db, stmt, idx++,
2378 __get_bool(app->process_pool, false));
2379 __BIND_TEXT(db, stmt, idx++, app->launch_mode);
2380 __BIND_TEXT(db, stmt, idx++, __get_bool(app->ui_gadget, false));
2381 __BIND_TEXT(db, stmt, idx++,
2382 app->support_mode ? app->support_mode : "0");
2383 __BIND_TEXT(db, stmt, idx++,
2384 __get_bool(mfx->support_disable, false));
2385 __BIND_TEXT(db, stmt, idx++, app->component_type);
2386 __BIND_TEXT(db, stmt, idx++, mfx->package);
2387 __BIND_TEXT(db, stmt, idx++, mfx->tep_name);
2388 __BIND_TEXT(db, stmt, idx++, mfx->zip_mount_file);
2389 __BIND_INT(db, stmt, idx++, bg_category);
2390 __BIND_TEXT(db, stmt, idx++, mfx->type ? mfx->type : "tpk");
2391 __BIND_TEXT(db, stmt, idx++, mfx->root_path);
2392 __BIND_TEXT(db, stmt, idx++, app->api_version);
2393 __BIND_TEXT(db, stmt, idx++, effective_appid);
2394 __BIND_TEXT(db, stmt, idx++,
2395 __get_bool(app->splash_screen_display, true));
2396 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->system, false));
2397 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->removable, false));
2398 __BIND_TEXT(db, stmt, idx++, mfx->installed_time);
2399 __BIND_TEXT(db, stmt, idx++,
2400 __get_bool(app->support_ambient, false));
2401 __BIND_TEXT(db, stmt, idx++, mfx->external_path);
2402 __BIND_TEXT(db, stmt, idx++, app->setup_appid);
2403 __BIND_TEXT(db, stmt, idx++, mfx->light_user_switch_mode);
2405 ret = sqlite3_step(stmt);
2406 if (ret != SQLITE_DONE) {
2407 _LOGE("step failed: %s", sqlite3_errmsg(db));
2408 sqlite3_finalize(stmt);
2412 sqlite3_reset(stmt);
2414 if (__insert_appcontrol_info(db, app)) {
2415 sqlite3_finalize(stmt);
2418 if (__insert_category_info(db, app)) {
2419 sqlite3_finalize(stmt);
2422 if (__insert_metadata_info(db, app)) {
2423 sqlite3_finalize(stmt);
2426 if (__insert_datacontrol_info(db, app)) {
2427 sqlite3_finalize(stmt);
2430 ss_list = __find_splashscreens(app->splashscreens);
2431 if (__insert_splashscreen_info(db, app, ss_list)) {
2432 g_list_free(ss_list);
2433 sqlite3_finalize(stmt);
2436 g_list_free(ss_list);
2437 if (__insert_app_localized_info(db, app)) {
2438 sqlite3_finalize(stmt);
2441 if (__insert_app_res_control(db, app)) {
2442 sqlite3_finalize(stmt);
2447 sqlite3_finalize(stmt);
2452 static int __insert_package_update_info(sqlite3 *db, manifest_x *mfx)
2454 static const char query[] =
2455 "INSERT INTO package_update_info (package, update_version) "
2461 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2462 if (ret != SQLITE_OK) {
2463 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2468 __BIND_TEXT(db, stmt, idx++, mfx->package);
2469 __BIND_TEXT(db, stmt, idx, mfx->version);
2470 ret = sqlite3_step(stmt);
2471 if (ret != SQLITE_DONE) {
2472 _LOGE("step failed: %s", sqlite3_errmsg(db));
2473 sqlite3_finalize(stmt);
2476 sqlite3_finalize(stmt);
2481 static int __insert_package_localized_info(sqlite3 *db, manifest_x *mfx)
2483 static const char query[] =
2484 "INSERT INTO package_localized_info (package, package_locale,"
2485 " package_label, package_icon, package_description,"
2486 " package_license, package_author) "
2487 "VALUES (?, ?, ?, ?, ?, ?, ?)";
2500 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2501 if (ret != SQLITE_OK) {
2502 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2506 locales = __create_locale_list(mfx->label, mfx->license, mfx->icon,
2507 mfx->description, mfx->author);
2508 for (tmp = locales; tmp; tmp = tmp->next) {
2509 locale = (const char *)tmp->data;
2515 __extract_data(locale, mfx->label, mfx->license, mfx->icon,
2516 mfx->description, mfx->author,
2517 &label, &license, &icon, &description, &author);
2518 if (!label && !license && !icon && !description && !author)
2522 __BIND_TEXT(db, stmt, idx++, mfx->package);
2523 __BIND_TEXT(db, stmt, idx++, locale);
2524 __BIND_TEXT(db, stmt, idx++, label);
2525 __BIND_TEXT(db, stmt, idx++, icon);
2526 __BIND_TEXT(db, stmt, idx++, description);
2527 __BIND_TEXT(db, stmt, idx++, license);
2528 __BIND_TEXT(db, stmt, idx++, author);
2530 ret = sqlite3_step(stmt);
2531 if (ret != SQLITE_DONE) {
2532 _LOGE("step failed: %s", sqlite3_errmsg(db));
2533 g_list_free(locales);
2534 sqlite3_finalize(stmt);
2538 sqlite3_reset(stmt);
2541 g_list_free(locales);
2542 sqlite3_finalize(stmt);
2547 static int __insert_package_info(sqlite3 *db, manifest_x *mfx)
2549 static const char query[] =
2550 "INSERT INTO package_info (package, package_type,"
2551 " package_version, package_api_version, package_tep_name,"
2552 " package_zip_mount_file, install_location, package_size,"
2553 " package_removable, package_preload, package_readonly,"
2554 " package_update, package_appsetting, package_nodisplay,"
2555 " package_system, author_name, author_email, author_href,"
2556 " installed_time, installed_storage, storeclient_id,"
2557 " mainapp_id, package_url, root_path, external_path,"
2558 " csc_path, package_support_mode, package_support_disable,"
2559 " light_user_switch_mode)"
2563 " LOWER(?), LOWER(?), LOWER(?),"
2564 " LOWER(?), LOWER(?), LOWER(?),"
2565 " LOWER(?), ?, ?, ?,"
2568 " ?, ?, LOWER(?), ?)";
2572 const char *author_name = NULL;
2573 const char *author_email = NULL;
2574 const char *author_href = NULL;
2576 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2577 if (ret != SQLITE_OK) {
2578 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2582 if (mfx->author && mfx->author->data) {
2583 author_name = ((author_x *)mfx->author->data)->text;
2584 author_email = ((author_x *)mfx->author->data)->email;
2585 author_href = ((author_x *)mfx->author->data)->href;
2588 __BIND_TEXT(db, stmt, idx++, mfx->package);
2589 __BIND_TEXT(db, stmt, idx++, mfx->type);
2590 __BIND_TEXT(db, stmt, idx++, mfx->version);
2591 __BIND_TEXT(db, stmt, idx++, mfx->api_version);
2592 __BIND_TEXT(db, stmt, idx++, mfx->tep_name);
2593 __BIND_TEXT(db, stmt, idx++, mfx->zip_mount_file);
2594 __BIND_TEXT(db, stmt, idx++, mfx->installlocation);
2595 __BIND_TEXT(db, stmt, idx++, mfx->package_size);
2596 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->removable, true));
2597 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->preload, false));
2598 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->readonly, false));
2599 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->update, false));
2600 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->appsetting, false));
2601 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->nodisplay_setting, false));
2602 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->system, false));
2603 __BIND_TEXT(db, stmt, idx++, author_name);
2604 __BIND_TEXT(db, stmt, idx++, author_email);
2605 __BIND_TEXT(db, stmt, idx++, author_href);
2606 __BIND_TEXT(db, stmt, idx++, mfx->installed_time);
2607 __BIND_TEXT(db, stmt, idx++, mfx->installed_storage);
2608 __BIND_TEXT(db, stmt, idx++, mfx->storeclient_id);
2609 __BIND_TEXT(db, stmt, idx++, mfx->mainapp_id);
2610 __BIND_TEXT(db, stmt, idx++, mfx->package_url);
2611 __BIND_TEXT(db, stmt, idx++, mfx->root_path);
2612 __BIND_TEXT(db, stmt, idx++, mfx->external_path);
2613 __BIND_TEXT(db, stmt, idx++, mfx->csc_path);
2614 __BIND_TEXT(db, stmt, idx++,
2615 mfx->support_mode ? mfx->support_mode : "0");
2616 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->support_disable, false));
2617 __BIND_TEXT(db, stmt, idx++, mfx->light_user_switch_mode);
2619 ret = sqlite3_step(stmt);
2620 if (ret != SQLITE_DONE) {
2621 _LOGE("step failed: %s", sqlite3_errmsg(db));
2622 sqlite3_finalize(stmt);
2626 sqlite3_finalize(stmt);
2628 if (__insert_package_update_info(db, mfx))
2630 if (__insert_package_localized_info(db, mfx))
2632 if (__insert_application_info(db, mfx))
2634 if (__insert_package_privilege_info(db, mfx))
2636 if (__insert_package_appdefined_privilege_info(db, mfx))
2638 if (__insert_package_dependency_info(db, mfx))
2640 if (__insert_package_res_info(db, mfx))
2646 static int __delete_package_info(sqlite3 *db, const char *pkgid)
2648 static const char query[] =
2649 "DELETE FROM package_info WHERE package=?";
2653 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2654 if (ret != SQLITE_OK) {
2655 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2659 __BIND_TEXT(db, stmt, 1, pkgid);
2661 ret = sqlite3_step(stmt);
2662 if (ret != SQLITE_DONE) {
2663 _LOGE("step failed: %s", sqlite3_errmsg(db));
2664 sqlite3_finalize(stmt);
2668 sqlite3_finalize(stmt);
2673 API int pkgmgr_parser_delete_pkg_info(sqlite3 *db,
2674 const char *package, uid_t uid)
2676 if (db == NULL || package == NULL) {
2677 _LOGE("invalid parameter");
2678 return PM_PARSER_R_EINVAL;
2681 __BEGIN_TRANSACTION(db);
2682 __DO_TRANSACTION(db, __delete_package_info(db, package));
2683 __END_TRANSACTION(db);
2685 return PM_PARSER_R_OK;
2688 API int pkgmgr_parser_update_pkg_info(sqlite3 *db, manifest_x *mfx, uid_t uid)
2690 if (db == NULL || mfx == NULL) {
2691 _LOGE("invalid parameter");
2692 return PM_PARSER_R_EINVAL;
2695 __BEGIN_TRANSACTION(db);
2696 __DO_TRANSACTION(db, __delete_package_info(db, mfx->package));
2697 __DO_TRANSACTION(db, __insert_package_info(db, mfx));
2698 __END_TRANSACTION(db);
2700 return PM_PARSER_R_OK;
2703 API int pkgmgr_parser_insert_pkg_info(sqlite3 *db, manifest_x *mfx, uid_t uid)
2705 if (db == NULL || mfx == NULL) {
2706 _LOGE("invalid parameter");
2707 return PM_PARSER_R_EINVAL;
2710 __BEGIN_TRANSACTION(db);
2711 __DO_TRANSACTION(db, __insert_package_info(db, mfx));
2712 __END_TRANSACTION(db);
2714 return PM_PARSER_R_OK;