From: 연정현/Tizen Platform Lab(SR)/Staff Engineer/삼성전자 Date: Wed, 17 Feb 2021 07:11:28 +0000 (+0900) Subject: Separate pkgmgr-info legacy library and implement dbhandler (#52) X-Git-Tag: submit/tizen/20210317.082331~134 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=b3ff4ec736900e9ce14b9cfe4ef33b58eb5b0844;p=platform%2Fcore%2Fappfw%2Fpkgmgr-info.git Separate pkgmgr-info legacy library and implement dbhandler (#52) separate db access codes from pkgmgr-info internal APIs and add codes at db handlers to use it. --- diff --git a/parser/include/pkgmgr_parser_db.h b/parser/include/pkgmgr_parser_db.h index 2e84101..e4187aa 100644 --- a/parser/include/pkgmgr_parser_db.h +++ b/parser/include/pkgmgr_parser_db.h @@ -45,8 +45,14 @@ #ifdef __cplusplus extern "C" { #endif + #include "pkgmgr_parser.h" #include "pkgmgrinfo_type.h" + +// TODO: add descriptions +int pkgmgr_parser_insert_pkg_info(manifest_x *mfx, uid_t uid); +int pkgmgr_parser_delete_pkg_info(const char *package, uid_t uid); + /** * @fn int pkgmgr_parser_insert_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid) * @fn int pkgmgr_parser_insert_manifest_info_in_db(manifest_x *mfx) diff --git a/parser/src/pkgmgr_parser_db.c b/parser/src/pkgmgr_parser_db.c index 5772c70..3dd0eda 100644 --- a/parser/src/pkgmgr_parser_db.c +++ b/parser/src/pkgmgr_parser_db.c @@ -118,7 +118,6 @@ do { \ if (sqlite3_exec(db, "BEGIN DEFERRED", NULL, NULL, NULL) != \ SQLITE_OK) { \ _LOGE("begin transaction failed: %s", sqlite3_errmsg(db)); \ - sqlite3_close_v2(db); \ return PM_PARSER_R_ERROR; \ } \ } while (0) \ @@ -131,7 +130,6 @@ do { \ SQLITE_OK) \ _LOGE("roll back transaction failed: %s", \ sqlite3_errmsg(db)); \ - sqlite3_close_v2(db); \ return PM_PARSER_R_ERROR; \ } \ } while (0) \ @@ -145,7 +143,6 @@ do { \ SQLITE_OK) \ _LOGE("roll back transaction failed: %s", \ sqlite3_errmsg(db)); \ - sqlite3_close_v2(db); \ return PM_PARSER_R_ERROR; \ } \ } while (0) \ @@ -576,51 +573,6 @@ API int pkgmgr_parser_create_and_initialize_db(uid_t uid) return PM_PARSER_R_OK; } -static int __open_db(uid_t uid, const char *path, sqlite3 **db, int flags) -{ - int ret; - - /* FIXME: always open with OPEN_CREATE flag for keeping previous - * implementation - */ - if (flags & SQLITE_OPEN_READWRITE) - flags = flags | SQLITE_OPEN_CREATE; - - ret = sqlite3_open_v2(path, db, flags, NULL); - if (ret != SQLITE_OK) { - sqlite3_close_v2(*db); - return ret; - } - - ret = sqlite3_busy_handler(*db, __db_busy_handler, (void *)path); - if (ret != SQLITE_OK) { - _LOGE("failed to register busy handler: %s", - sqlite3_errmsg(*db)); - sqlite3_close_v2(*db); - return ret; - } - - if (flags & SQLITE_OPEN_CREATE) { - ret = __initialize_db(*db, path, uid); - if (ret) { - _LOGE("failed to initialize db: %s", path); - sqlite3_close_v2(*db); - return -1; - } - } - - ret = sqlite3_exec(*db, "PRAGMA foreign_keys=ON", NULL, NULL, NULL); - if (ret != SQLITE_OK) { - _LOGE("failed to enable foreign key support: %s", - sqlite3_errmsg(*db)); - sqlite3_close_v2(*db); - return ret; - } - - return ret; -} - - static int __convert_background_category(GList *category_list) { int ret = 0; @@ -1693,79 +1645,53 @@ static int __insert_package_privilege_info(sqlite3 *db, manifest_x *mfx) return 0; } -static int __insert_package_plugin_execution_info(sqlite3 *db, - manifest_x *mfx) +static int __insert_package_plugin_execution_info( + manifest_x *mfx, uid_t uid) { - static const char query[] = - "INSERT INTO package_plugin_info " - "(pkgid, appid, plugin_type, plugin_name) " - "VALUES (?, ?, ?, ?)"; - int ret; - sqlite3_stmt *stmt; - int idx; + char *query = NULL; GList *tmp; plugin_x *plugin; if (!mfx->plugin) - return 0; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return -1; - } + return PM_PARSER_R_OK; for (tmp = mfx->plugin; tmp; tmp = tmp->next) { plugin = (plugin_x *)tmp->data; if (plugin == NULL) continue; - idx = 1; - __BIND_TEXT(db, stmt, idx++, plugin->pkgid); - __BIND_TEXT(db, stmt, idx++, plugin->appid); - __BIND_TEXT(db, stmt, idx++, plugin->plugin_type); - __BIND_TEXT(db, stmt, idx++, plugin->plugin_name); - - ret = sqlite3_step(stmt); - if (ret != SQLITE_DONE) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return -1; + query = sqlite3_mprintf("INSERT INTO package_plugin_info " + "(pkgid, appid, plugin_type, plugin_name) " + "VALUES (%Q, %Q, %Q, %Q)", + plugin->pkgid, plugin->appid, + plugin->plugin_type, plugin->plugin_name); + if (query == NULL) { + _LOGE("Out of memory"); + return PM_PARSER_R_ERROR; } - sqlite3_reset(stmt); - } - - sqlite3_finalize(stmt); - return 0; + // TODO: send query to server + sqlite3_free(query); + query = NULL; + } + return PM_PARSER_R_OK; } -static int __delete_package_plugin_execution_info(sqlite3 *db, - const char *pkgid) +static int __delete_package_plugin_execution_info(const char *pkgid, uid_t uid) { - static const char query[] = - "DELETE FROM package_plugin_info WHERE pkgid=?"; - int ret; - sqlite3_stmt *stmt; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return -1; - } - - __BIND_TEXT(db, stmt, 1, pkgid); + char *query = NULL; - ret = sqlite3_step(stmt); - if (ret != SQLITE_DONE) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return -1; + query = sqlite3_mprintf( + "DELETE FROM package_plugin_info WHERE pkgid=%Q", pkgid); + if (query == NULL) { + _LOGE("Out of memory"); + return PM_PARSER_R_ERROR; } - sqlite3_finalize(stmt); + // TODO: send query to server + sqlite3_free(query); - return 0; + return PM_PARSER_R_OK; } static int __insert_package_appdefined_privilege_info(sqlite3 *db, @@ -2206,37 +2132,33 @@ static int __insert_package_info(sqlite3 *db, manifest_x *mfx) return 0; } -API int pkgmgr_parser_insert_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid) +static int __open_db(uid_t uid, const char *path, sqlite3 **db, int flags) { int ret; - const char *dbpath; - sqlite3 *db; - if (mfx == NULL) { - _LOGE("invalid parameter"); - return PM_PARSER_R_EINVAL; + ret = sqlite3_open_v2(path, db, flags, NULL); + if (ret != SQLITE_OK) { + sqlite3_close_v2(*db); + return ret; } - dbpath = __get_parser_db_path(uid); - - ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE); + ret = sqlite3_busy_handler(*db, __db_busy_handler, (void *)path); if (ret != SQLITE_OK) { - _LOGE("open db failed: %d", ret); - return PM_PARSER_R_ERROR; + _LOGE("failed to register busy handler: %s", + sqlite3_errmsg(*db)); + sqlite3_close_v2(*db); + return ret; } - __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __insert_package_info(db, mfx)); - __END_TRANSACTION(db); - - sqlite3_close_v2(db); - - return PM_PARSER_R_OK; -} + ret = sqlite3_exec(*db, "PRAGMA foreign_keys=ON", NULL, NULL, NULL); + if (ret != SQLITE_OK) { + _LOGE("failed to enable foreign key support: %s", + sqlite3_errmsg(*db)); + sqlite3_close_v2(*db); + return ret; + } -API int pkgmgr_parser_insert_manifest_info_in_db(manifest_x *mfx) -{ - return pkgmgr_parser_insert_manifest_info_in_usr_db(mfx, __getuid()); + return ret; } static int __delete_package_info(sqlite3 *db, const char *pkgid) @@ -2266,8 +2188,7 @@ static int __delete_package_info(sqlite3 *db, const char *pkgid) return 0; } -API int pkgmgr_parser_delete_manifest_info_from_usr_db(manifest_x *mfx, - uid_t uid) +API int pkgmgr_parser_insert_pkg_info(manifest_x *mfx, uid_t uid) { int ret; const char *dbpath; @@ -2288,6 +2209,7 @@ API int pkgmgr_parser_delete_manifest_info_from_usr_db(manifest_x *mfx, __BEGIN_TRANSACTION(db); __DO_TRANSACTION(db, __delete_package_info(db, mfx->package)); + __DO_TRANSACTION(db, __insert_package_info(db, mfx)); __END_TRANSACTION(db); sqlite3_close_v2(db); @@ -2295,18 +2217,24 @@ API int pkgmgr_parser_delete_manifest_info_from_usr_db(manifest_x *mfx, return PM_PARSER_R_OK; } -API int pkgmgr_parser_delete_manifest_info_from_db(manifest_x *mfx) +API int pkgmgr_parser_insert_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid) { - return pkgmgr_parser_delete_manifest_info_from_usr_db(mfx, __getuid()); + // TODO: use pkginfo-client APIs to send manifest_x to server + return 0; } -API int pkgmgr_parser_update_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid) +API int pkgmgr_parser_insert_manifest_info_in_db(manifest_x *mfx) +{ + return pkgmgr_parser_insert_manifest_info_in_usr_db(mfx, __getuid()); +} + +API int pkgmgr_parser_delete_pkg_info(const char *package, uid_t uid) { int ret; const char *dbpath; sqlite3 *db; - if (mfx == NULL) { + if (package == NULL) { _LOGE("invalid parameter"); return PM_PARSER_R_EINVAL; } @@ -2320,341 +2248,140 @@ API int pkgmgr_parser_update_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid) } __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __delete_package_info(db, mfx->package)); - __DO_TRANSACTION(db, __insert_package_info(db, mfx)); + __DO_TRANSACTION(db, __delete_package_info(db, package)); __END_TRANSACTION(db); - sqlite3_close_v2(db); - return PM_PARSER_R_OK; } -API int pkgmgr_parser_update_manifest_info_in_db(manifest_x *mfx) +API int pkgmgr_parser_delete_manifest_info_from_usr_db(manifest_x *mfx, + uid_t uid) { - return pkgmgr_parser_update_manifest_info_in_usr_db(mfx, __getuid()); + // TODO: use pkginfo-client APIs to send package id to server + return 0; } -static int __set_global_app_disable_for_uid(sqlite3 *db, const char *appid, - uid_t uid, bool is_disable) +API int pkgmgr_parser_delete_manifest_info_from_db(manifest_x *mfx) { - static const char query[] = - "INSERT OR REPLACE INTO package_app_info_for_uid (" - " app_id, uid, is_disabled, is_splash_screen_enabled) " - "VALUES (?, ?, ?," - " (SELECT app_splash_screen_display FROM package_app_info" - " WHERE app_id=?))"; - int ret; - sqlite3_stmt *stmt; - int idx = 1; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return -1; - } - - __BIND_TEXT(db, stmt, idx++, appid); - __BIND_INT(db, stmt, idx++, uid); - __BIND_TEXT(db, stmt, idx++, is_disable ? "true" : "false"); - __BIND_TEXT(db, stmt, idx++, appid); - - ret = sqlite3_step(stmt); - if (ret != SQLITE_DONE) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return -1; - } + return pkgmgr_parser_delete_manifest_info_from_usr_db(mfx, __getuid()); +} - sqlite3_finalize(stmt); +API int pkgmgr_parser_update_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid) +{ + return pkgmgr_parser_insert_manifest_info_in_usr_db(mfx, uid); +} - return 0; +API int pkgmgr_parser_update_manifest_info_in_db(manifest_x *mfx) +{ + return pkgmgr_parser_update_manifest_info_in_usr_db(mfx, __getuid()); } API int pkgmgr_parser_update_global_app_disable_for_uid_info_in_db( const char *appid, uid_t uid, int is_disable) { - int ret; - const char *dbpath; - sqlite3 *db; - - if (appid == NULL) { - _LOGE("invalid parameter"); - return PM_PARSER_R_EINVAL; - } - - dbpath = __get_parser_db_path(GLOBAL_USER); + // TODO: construct query at here and send it to server + char *query = NULL; - ret = __open_db(GLOBAL_USER, dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("open db failed: %d", ret); + query = sqlite3_mprintf("INSERT OR REPLACE INTO package_app_info_for_uid (" + " app_id, uid, is_disabled, is_splash_screen_enabled) " + "VALUES (%Q, %Q, %Q," + " (SELECT app_splash_screen_display FROM package_app_info" + " WHERE app_id=%Q))", appid, uid, + (is_disable ? "true" : "false"), appid); + if (query == NULL) { + _LOGE("Out of memory"); return PM_PARSER_R_ERROR; } - __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __set_global_app_disable_for_uid(db, appid, - uid, (bool)is_disable)); - __END_TRANSACTION(db); - - sqlite3_close_v2(db); + // TODO: send query to server + sqlite3_free(query); return PM_PARSER_R_OK; } -static int __set_app_disable(sqlite3 *db, const char *appid, uid_t uid, - bool is_disable) +API int pkgmgr_parser_update_app_disable_info_in_usr_db(const char *appid, + uid_t uid, int is_disable) { - static const char query[] = - "UPDATE package_app_info SET app_disable=? " - "WHERE app_id=?"; - int ret; - sqlite3_stmt *stmt; - int idx = 1; + char *query = NULL; - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return -1; + query = sqlite3_mprintf("UPDATE package_app_info SET app_disable=%Q " + "WHERE app_id=%Q", (is_disable ? "true" : "false"), appid); + if (query == NULL) { + _LOGE("Out of memory"); + return PM_PARSER_R_ERROR; } - __BIND_TEXT(db, stmt, idx++, is_disable ? "true" : "false"); - __BIND_TEXT(db, stmt, idx++, appid); - - ret = sqlite3_step(stmt); - if (ret != SQLITE_DONE) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return -1; - } + // TODO: construct query and send it to server + sqlite3_free(query); - sqlite3_finalize(stmt); + return PM_PARSER_R_OK; +} - return 0; +API int pkgmgr_parser_update_app_disable_info_in_db(const char *appid, + int is_disable) +{ + return pkgmgr_parser_update_app_disable_info_in_usr_db(appid, + __getuid(), is_disable); } -API int pkgmgr_parser_update_app_disable_info_in_usr_db(const char *appid, +API int pkgmgr_parser_update_pkg_disable_info_in_usr_db(const char *pkgid, uid_t uid, int is_disable) { - int ret; - const char *dbpath; - sqlite3 *db; - - if (appid == NULL) { - _LOGE("invalid parameter"); - return PM_PARSER_R_EINVAL; - } - - dbpath = __get_parser_db_path(uid); + char *query = NULL; - ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("open db failed: %d", ret); + query = sqlite3_mprintf("UPDATE package_info SET package_disable=%Q " + "WHERE package=%Q", (is_disable ? "true" : "false"), pkgid); + if (query == NULL) { + _LOGE("Out of memory"); return PM_PARSER_R_ERROR; } - __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __set_app_disable(db, appid, uid, - (bool)is_disable)); - __END_TRANSACTION(db); - - sqlite3_close_v2(db); + // TODO: construct query and send it to server + sqlite3_free(query); return PM_PARSER_R_OK; } -API int pkgmgr_parser_update_app_disable_info_in_db(const char *appid, +API int pkgmgr_parser_update_pkg_disable_info_in_db(const char *pkgid, int is_disable) { - return pkgmgr_parser_update_app_disable_info_in_usr_db(appid, + return pkgmgr_parser_update_pkg_disable_info_in_usr_db(pkgid, __getuid(), is_disable); } -static int __set_pkg_disable(sqlite3 *db, const char *pkgid, uid_t uid, - bool is_disable) -{ - static const char query[] = - "UPDATE package_info SET package_disable=? " - "WHERE package=?"; - int ret; - sqlite3_stmt *stmt; - int idx = 1; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return -1; - } - - __BIND_TEXT(db, stmt, idx++, is_disable ? "true" : "false"); - __BIND_TEXT(db, stmt, idx++, pkgid); - - ret = sqlite3_step(stmt); - if (ret != SQLITE_DONE) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return -1; - } - - sqlite3_finalize(stmt); - - return 0; -} - -API int pkgmgr_parser_update_pkg_disable_info_in_usr_db(const char *pkgid, - uid_t uid, int is_disable) -{ - int ret; - const char *dbpath; - sqlite3 *db; - - if (pkgid == NULL) { - _LOGE("invalid parameter"); - return PM_PARSER_R_EINVAL; - } - - dbpath = __get_parser_db_path(uid); - - ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("open db failed: %d", ret); - return PM_PARSER_R_ERROR; - } - - __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __set_pkg_disable(db, pkgid, uid, - (bool)is_disable)); - __END_TRANSACTION(db); - - sqlite3_close_v2(db); - - return PM_PARSER_R_OK; -} - -API int pkgmgr_parser_update_pkg_disable_info_in_db(const char *pkgid, - int is_disable) -{ - return pkgmgr_parser_update_pkg_disable_info_in_usr_db(pkgid, - __getuid(), is_disable); -} - -static int __set_global_app_splash_screen_for_uid(sqlite3 *db, - const char *appid, uid_t uid, bool is_enabled) -{ - static const char query[] = - "INSERT OR REPLACE INTO package_app_info_for_uid(" - " appid, uid, is_splash_screen_enabled) " - "VALUES (?, ?, ?)"; - int ret; - sqlite3_stmt *stmt; - int idx = 1; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return -1; - } - - __BIND_TEXT(db, stmt, idx++, appid); - __BIND_INT(db, stmt, idx++, uid); - __BIND_TEXT(db, stmt, idx++, is_enabled ? "true" : "false"); - - ret = sqlite3_step(stmt); - if (ret != SQLITE_DONE) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return -1; - } - - sqlite3_finalize(stmt); - - return 0; -} - API int pkgmgr_parser_update_global_app_splash_screen_display_info_in_usr_db( const char *appid, uid_t uid, int flag) { - int ret; - const char *dbpath; - sqlite3 *db; - - if (appid == NULL) { - _LOGE("invalid parameter"); - return PM_PARSER_R_EINVAL; - } - - dbpath = __get_parser_db_path(GLOBAL_USER); + char *query = NULL; - ret = __open_db(GLOBAL_USER, dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("open db failed: %d", ret); + query = sqlite3_mprintf("INSERT OR REPLACE INTO package_app_info_for_uid(" + " appid, uid, is_splash_screen_enabled) " + "VALUES (%Q, %Q, Q%)", appid, uid, (flag == 1 ? "true" : "false")); + if (query == NULL) { + _LOGE("Out of memory"); return PM_PARSER_R_ERROR; } - __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __set_global_app_splash_screen_for_uid(db, - appid, uid, (bool)flag)); - __END_TRANSACTION(db); - - sqlite3_close_v2(db); + // TODO: construct query and send it to server + sqlite3_free(query); return PM_PARSER_R_OK; } -static int __set_app_splash_screen(sqlite3 *db, const char *appid, - bool is_enabled) -{ - static const char query[] = - "UPDATE package_app_info SET app_splash_screen_display=? " - "WHERE app_id=?"; - int ret; - sqlite3_stmt *stmt; - int idx = 1; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return -1; - } - - __BIND_TEXT(db, stmt, idx++, is_enabled ? "true" : "false"); - __BIND_TEXT(db, stmt, idx++, appid); - - ret = sqlite3_step(stmt); - if (ret != SQLITE_DONE) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return -1; - } - - sqlite3_finalize(stmt); - - return 0; -} - API int pkgmgr_parser_update_app_splash_screen_display_info_in_usr_db( const char *appid, uid_t uid, int flag) { - int ret; - const char *dbpath; - sqlite3 *db; - - if (appid == NULL) { - _LOGE("invalid parameter"); - return PM_PARSER_R_EINVAL; - } - - dbpath = __get_parser_db_path(uid); + char *query = NULL; - ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("open db failed: %d", ret); + query = sqlite3_mprintf("UPDATE package_app_info SET app_splash_screen_display=%Q " + "WHERE app_id=%Q", (flag == 1 ? "true" : "false"), appid); + if (query == NULL) { + _LOGE("Out of memory"); return PM_PARSER_R_ERROR; } - __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __set_app_splash_screen(db, appid, (bool)flag)); - __END_TRANSACTION(db); - - sqlite3_close_v2(db); + // TODO: construct query and send it to server + sqlite3_free(query); return PM_PARSER_R_OK; } @@ -2666,61 +2393,20 @@ API int pkgmgr_parser_update_app_splash_screen_display_info_in_db( appid, __getuid(), flag); } -static int __set_app_label(sqlite3 *db, const char *appid, const char *label) -{ - static const char query[] = - "UPDATE package_app_localized_info SET app_label=? " - "WHERE app_id=? AND app_label IS NOT NULL"; - int ret; - sqlite3_stmt *stmt; - int idx = 1; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return -1; - } - - __BIND_TEXT(db, stmt, idx++, label); - __BIND_TEXT(db, stmt, idx++, appid); - - ret = sqlite3_step(stmt); - if (ret != SQLITE_DONE) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return -1; - } - - sqlite3_finalize(stmt); - - return 0; -} - API int pkgmgr_parser_update_app_label_info_in_usr_db(const char *appid, uid_t uid, const char *label) { - int ret; - const char *dbpath; - sqlite3 *db; - - if (appid == NULL) { - _LOGE("invalid parameter"); - return PM_PARSER_R_EINVAL; - } - - dbpath = __get_parser_db_path(uid); + char *query = NULL; - ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("open db failed: %d", ret); + query = sqlite3_mprintf("UPDATE package_app_localized_info SET app_label=%Q " + "WHERE app_id=%Q AND app_label IS NOT NULL", label, appid); + if (query == NULL) { + _LOGE("Out of memory"); return PM_PARSER_R_ERROR; } - __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __set_app_label(db, appid, label)); - __END_TRANSACTION(db); - - sqlite3_close_v2(db); + // TODO: construct query and send it to server + sqlite3_free(query); return PM_PARSER_R_OK; } @@ -2732,61 +2418,20 @@ API int pkgmgr_parser_update_app_label_info_in_db(const char *appid, label); } -static int __set_app_icon(sqlite3 *db, const char *appid, const char *icon_path) -{ - static const char query[] = - "UPDATE package_app_localized_info SET app_icon=? " - "WHERE app_id=? AND app_icon IS NOT NULL"; - int ret; - sqlite3_stmt *stmt; - int idx = 1; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return -1; - } - - __BIND_TEXT(db, stmt, idx++, icon_path); - __BIND_TEXT(db, stmt, idx++, appid); - - ret = sqlite3_step(stmt); - if (ret != SQLITE_DONE) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return -1; - } - - sqlite3_finalize(stmt); - - return 0; -} - API int pkgmgr_parser_update_app_icon_info_in_usr_db(const char *appid, uid_t uid, const char *icon_path) { - int ret; - const char *dbpath; - sqlite3 *db; - - if (appid == NULL) { - _LOGE("invalid parameter"); - return PM_PARSER_R_EINVAL; - } - - dbpath = __get_parser_db_path(uid); + char *query = NULL; - ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("open db failed: %d", ret); + query = sqlite3_mprintf("UPDATE package_app_localized_info SET app_icon=%Q " + "WHERE app_id=TQ AND app_icon IS NOT NULL", icon_path, appid); + if (query == NULL) { + _LOGE("Out of memory"); return PM_PARSER_R_ERROR; } - __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __set_app_icon(db, appid, icon_path)); - __END_TRANSACTION(db); - - sqlite3_close_v2(db); + // TODO: construct query and send it to server + sqlite3_free(query); return PM_PARSER_R_OK; } @@ -2798,61 +2443,20 @@ API int pkgmgr_parser_update_app_icon_info_in_db(const char *appid, icon_path); } -static int __set_tep_path(sqlite3 *db, const char *pkgid, const char *tep_path) -{ - static const char query[] = - "UPDATE package_info SET package_tep_name=? " - "WHERE package=?"; - int ret; - sqlite3_stmt *stmt; - int idx = 1; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return -1; - } - - __BIND_TEXT(db, stmt, idx++, tep_path); - __BIND_TEXT(db, stmt, idx++, pkgid); - - ret = sqlite3_step(stmt); - if (ret != SQLITE_DONE) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return -1; - } - - sqlite3_finalize(stmt); - - return 0; -} - API int pkgmgr_parser_update_tep_info_in_usr_db(const char *pkgid, const char *tep_path, uid_t uid) { - int ret; - const char *dbpath; - sqlite3 *db; - - if (pkgid == NULL) { - _LOGE("invalid parameter"); - return PM_PARSER_R_EINVAL; - } - - dbpath = __get_parser_db_path(uid); + char *query = NULL; - ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("open db failed: %d", ret); + query = sqlite3_mprintf("UPDATE package_info SET package_tep_name=%Q " + "WHERE package=%Q", tep_path, pkgid); + if (query == NULL) { + _LOGE("Out of memory"); return PM_PARSER_R_ERROR; } - __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __set_tep_path(db, pkgid, tep_path)); - __END_TRANSACTION(db); - - sqlite3_close_v2(db); + // TODO: construct query and send it to server + sqlite3_free(query); return PM_PARSER_R_OK; } @@ -2878,37 +2482,23 @@ static int __convert_update_type(pkgmgrinfo_updateinfo_update_type type, return 0; } -static int __register_pkg_update_info(sqlite3 *db, updateinfo_x *info, +static int __register_pkg_update_info(updateinfo_x *info, const char *update_type) { - static const char query[] = - "UPDATE package_update_info " - "SET update_version=?, update_type=? " - "WHERE package=?"; - int ret; - sqlite3_stmt *stmt; - int idx = 1; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return -1; - } - - __BIND_TEXT(db, stmt, idx++, info->version); - __BIND_TEXT(db, stmt, idx++, update_type); - __BIND_TEXT(db, stmt, idx++, info->pkgid); + char *query = NULL; - ret = sqlite3_step(stmt); - if (ret != SQLITE_DONE) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return -1; + query = sqlite3_mprintf("UPDATE package_update_info " + "SET update_version=%Q, update_type=%Q " + "WHERE package=%Q", info->version, update_type, info->pkgid); + if (query == NULL) { + _LOGE("Out of memory"); + return PM_PARSER_R_ERROR; } - sqlite3_finalize(stmt); + // TODO: send query to server + sqlite3_free(query); - return 0; + return PM_PARSER_R_OK; } API int pkgmgr_parser_register_pkg_update_info_in_usr_db( @@ -2922,8 +2512,6 @@ API int pkgmgr_parser_register_pkg_update_info_in_usr_db( pkgmgrinfo_version_compare_type compare_result; bool is_global_pkg; const char *update_type; - const char *dbpath; - sqlite3 *db; if (handle == NULL) { _LOGE("invalid parameter"); @@ -2971,22 +2559,7 @@ API int pkgmgr_parser_register_pkg_update_info_in_usr_db( } pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo); - dbpath = __get_parser_db_path(is_global_pkg ? GLOBAL_USER : uid); - - ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("open db failed: %d", ret); - return PM_PARSER_R_ERROR; - } - - __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __register_pkg_update_info(db, update_info, - update_type)); - __END_TRANSACTION(db); - - sqlite3_close_v2(db); - - return PM_PARSER_R_OK; + return __register_pkg_update_info(update_info, update_type); } API int pkgmgr_parser_register_pkg_update_info_in_db( @@ -2996,43 +2569,30 @@ API int pkgmgr_parser_register_pkg_update_info_in_db( __getuid()); } -static int __unregister_pkg_update_info(sqlite3 *db, const char *pkgid) +static int __unregister_pkg_update_info(const char *pkgid, uid_t uid) { - static const char query[] = - "UPDATE package_update_info SET update_type='none' " - "WHERE package=?"; - int ret; - sqlite3_stmt *stmt; - int idx = 1; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return -1; - } - - __BIND_TEXT(db, stmt, idx++, pkgid); + char *query = NULL; - ret = sqlite3_step(stmt); - if (ret != SQLITE_DONE) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return -1; + query = sqlite3_mprintf("UPDATE package_update_info " + "SET update_type='none' WHERE package=%Q", pkgid); + if (query == NULL) { + _LOGE("Out of memory"); + return PM_PARSER_R_ERROR; } - sqlite3_finalize(stmt); + // TODO: send query to server + sqlite3_free(query); - return 0; + return PM_PARSER_R_OK; } API int pkgmgr_parser_unregister_pkg_update_info_in_usr_db(const char *pkgid, uid_t uid) { int ret; - const char *dbpath; - sqlite3 *db; pkgmgrinfo_pkginfo_h pkginfo; bool is_global_pkg; + uid_t target_uid; if (pkgid == NULL) { _LOGE("invalid parameter"); @@ -3048,21 +2608,10 @@ API int pkgmgr_parser_unregister_pkg_update_info_in_usr_db(const char *pkgid, if (ret != PMINFO_R_OK) return PM_PARSER_R_ERROR; - dbpath = __get_parser_db_path(is_global_pkg ? GLOBAL_USER : uid); - - ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("open db failed: %d", ret); - return PM_PARSER_R_ERROR; - } - - __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __unregister_pkg_update_info(db, pkgid)); - __END_TRANSACTION(db); - - sqlite3_close_v2(db); + target_uid = is_global_pkg ? GLOBAL_USER : uid; - return PM_PARSER_R_OK; + // TODO: what we do with is_global_pkg? + return __unregister_pkg_update_info(pkgid, target_uid); } API int pkgmgr_parser_unregister_pkg_update_info_in_db(const char *pkgid) @@ -3071,50 +2620,19 @@ API int pkgmgr_parser_unregister_pkg_update_info_in_db(const char *pkgid) __getuid()); } -static int __unregister_all_pkg_update_info(sqlite3 *db) -{ - static const char query[] = - "UPDATE package_update_info SET update_type='none'"; - int ret; - sqlite3_stmt *stmt; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return -1; - } - - ret = sqlite3_step(stmt); - if (ret != SQLITE_DONE) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return -1; - } - - sqlite3_finalize(stmt); - - return 0; -} - API int pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(uid_t uid) { - int ret; - const char *dbpath; - sqlite3 *db; - - dbpath = __get_parser_db_path(uid); + char *query = NULL; - ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("open db failed: %d", ret); + query = sqlite3_mprintf("UPDATE package_update_info " + "SET update_type='none'"); + if (query == NULL) { + _LOGE("Out of memory"); return PM_PARSER_R_ERROR; } - __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __unregister_all_pkg_update_info(db)); - __END_TRANSACTION(db); - - sqlite3_close_v2(db); + // TODO: send query to server + sqlite3_free(query); return PM_PARSER_R_OK; } @@ -3128,26 +2646,7 @@ API int pkgmgr_parser_unregister_all_pkg_update_info_in_db(void) API int pkgmgr_parser_register_pkg_plugin_info_in_usr_db( manifest_x *mfx, uid_t uid) { - int ret; - const char *dbpath; - sqlite3 *db; - - if (!mfx) - return PM_PARSER_R_EINVAL; - dbpath = __get_parser_db_path(uid); - ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("open db failed: %d", ret); - return PM_PARSER_R_ERROR; - } - - __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __insert_package_plugin_execution_info(db, mfx)); - __END_TRANSACTION(db); - - sqlite3_close_v2(db); - - return PM_PARSER_R_OK; + return __insert_package_plugin_execution_info(mfx, uid); } API int pkgmgr_parser_register_pkg_plugin_info_in_db(manifest_x *mfx) @@ -3158,25 +2657,15 @@ API int pkgmgr_parser_register_pkg_plugin_info_in_db(manifest_x *mfx) API int pkgmgr_parser_update_pkg_plugin_info_in_usr_db( manifest_x *mfx, uid_t uid) { + // TODO: construct query and send to server int ret; - const char *dbpath; - sqlite3 *db; - if (!mfx) - return PM_PARSER_R_EINVAL; - dbpath = __get_parser_db_path(uid); - ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("open db failed: %d", ret); - return PM_PARSER_R_ERROR; - } - - __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __delete_package_plugin_execution_info(db, mfx->package)); - __DO_TRANSACTION(db, __insert_package_plugin_execution_info(db, mfx)); - __END_TRANSACTION(db); - - sqlite3_close_v2(db); + ret = __delete_package_plugin_execution_info(mfx->package, uid); + if (ret != PM_PARSER_R_OK) + return ret; + ret = __insert_package_plugin_execution_info(mfx, uid); + if (ret != PM_PARSER_R_OK) + return ret; return PM_PARSER_R_OK; } @@ -3189,24 +2678,7 @@ API int pkgmgr_parser_update_pkg_plugin_info_in_db(manifest_x *mfx) API int pkgmgr_parser_unregister_pkg_plugin_info_in_usr_db( const char *pkgid, uid_t uid) { - int ret; - const char *dbpath; - sqlite3 *db; - - dbpath = __get_parser_db_path(uid); - ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("open db failed: %d", ret); - return PM_PARSER_R_ERROR; - } - - __BEGIN_TRANSACTION(db); - __DO_TRANSACTION(db, __delete_package_plugin_execution_info(db, pkgid)); - __END_TRANSACTION(db); - - sqlite3_close_v2(db); - - return PM_PARSER_R_OK; + return __delete_package_plugin_execution_info(pkgid, uid); } API int pkgmgr_parser_unregister_pkg_plugin_info_in_db(const char *pkgid) diff --git a/parser/src/pkgmgr_parser_internal.h b/parser/src/pkgmgr_parser_internal.h index e8e6046..1806039 100644 --- a/parser/src/pkgmgr_parser_internal.h +++ b/parser/src/pkgmgr_parser_internal.h @@ -1,26 +1,4 @@ -/* - * pkgmgr-info - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: Jayoun Lee , Sewook Park , - * Jaeho Lee , Shobhit Srivastava - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - - +// copyright diff --git a/src/appinfo_internal.c b/src/appinfo_internal.c new file mode 100644 index 0000000..499fe76 --- /dev/null +++ b/src/appinfo_internal.c @@ -0,0 +1,718 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "pkgmgr-info.h" +#include "pkgmgrinfo_debug.h" +#include "pkgmgrinfo_private.h" +#include "pkgmgr_parser.h" + + +static void __free_applications(gpointer data) +{ + pkgmgrinfo_basic_free_application((application_x *)data); +} + +static void __parse_appcontrol(GList **appcontrol, char *appcontrol_str, + char *visibility, char *id) +{ + char *dup; + char *token; + char *ptr = NULL; + appcontrol_x *ac; + + if (appcontrol_str == NULL) + return; + + dup = strdup(appcontrol_str); + if (dup == NULL) { + _LOGE("out of memory"); + return; + } + + do { + ac = calloc(1, sizeof(appcontrol_x)); + if (ac == NULL) { + _LOGE("out of memory"); + break; + } + token = strtok_r(dup, "|", &ptr); + if (token && strcmp(token, "NULL")) + ac->operation = strdup(token); + token = strtok_r(NULL, "|", &ptr); + if (token && strcmp(token, "NULL")) + ac->uri = strdup(token); + token = strtok_r(NULL, "|", &ptr); + if (token && strcmp(token, "NULL")) + ac->mime = strdup(token); + ac->visibility = strdup(visibility); + ac->id = strdup(id); + *appcontrol = g_list_prepend(*appcontrol, ac); + } while ((token = strtok_r(NULL, ";", &ptr))); + + free(dup); +} + +static int _appinfo_get_splashscreens(sqlite3 *db, const char *appid, + GList **splashscreens) +{ + static const char query_raw[] = + "SELECT src, type, orientation, indicatordisplay, operation, color_depth " + "FROM package_app_splash_screen WHERE app_id=%Q"; + int ret; + char *query; + sqlite3_stmt *stmt; + int idx; + splashscreen_x *info; + + query = sqlite3_mprintf(query_raw, appid); + if (query == NULL) { + LOGE("out of memory"); + return PMINFO_R_ERROR; + } + + ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); + sqlite3_free(query); + if (ret != SQLITE_OK) { + LOGE("prepare failed: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + while (sqlite3_step(stmt) == SQLITE_ROW) { + info = calloc(1, sizeof(splashscreen_x)); + if (info == NULL) { + LOGE("out of memory"); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + idx = 0; + _save_column_str(stmt, idx++, &info->src); + _save_column_str(stmt, idx++, &info->type); + _save_column_str(stmt, idx++, &info->orientation); + _save_column_str(stmt, idx++, &info->indicatordisplay); + _save_column_str(stmt, idx++, &info->operation); + _save_column_str(stmt, idx++, &info->color_depth); + *splashscreens = g_list_prepend(*splashscreens, info); + } + + sqlite3_finalize(stmt); + + return PMINFO_R_OK; +} + +static int _appinfo_get_metadata(sqlite3 *db, const char *appid, + GList **metadata) +{ + static const char query_raw[] = + "SELECT md_key, md_value " + "FROM package_app_app_metadata WHERE app_id=%Q"; + int ret; + char *query; + sqlite3_stmt *stmt; + int idx; + metadata_x *info; + + query = sqlite3_mprintf(query_raw, appid); + if (query == NULL) { + LOGE("out of memory"); + return PMINFO_R_ERROR; + } + + ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); + sqlite3_free(query); + if (ret != SQLITE_OK) { + LOGE("prepare failed: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + while (sqlite3_step(stmt) == SQLITE_ROW) { + info = calloc(1, sizeof(metadata_x)); + if (info == NULL) { + LOGE("out of memory"); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + idx = 0; + _save_column_str(stmt, idx++, &info->key); + _save_column_str(stmt, idx++, &info->value); + *metadata = g_list_prepend(*metadata, info); + } + + sqlite3_finalize(stmt); + + return PMINFO_R_OK; + +} + +static int _appinfo_get_app_control(sqlite3 *db, const char *appid, + GList **appcontrol) +{ + static const char query_raw[] = + "SELECT app_control, visibility, app_control_id " + "FROM package_app_app_control WHERE app_id=%Q"; + int ret; + int idx; + char *query; + sqlite3_stmt *stmt; + char *str; + char *visibility; + char *id; + + query = sqlite3_mprintf(query_raw, appid); + if (query == NULL) { + LOGE("out of memory"); + return PMINFO_R_ERROR; + } + + ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); + sqlite3_free(query); + if (ret != SQLITE_OK) { + LOGE("prepare failed: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + while (sqlite3_step(stmt) == SQLITE_ROW) { + str = NULL; + visibility = NULL; + id = NULL; + idx = 0; + _save_column_str(stmt, idx++, &str); + _save_column_str(stmt, idx++, &visibility); + _save_column_str(stmt, idx++, &id); + /* TODO: revise */ + __parse_appcontrol(appcontrol, str, visibility, id); + free(str); + free(visibility); + free(id); + } + + sqlite3_finalize(stmt); + + return PMINFO_R_OK; +} + +static int _appinfo_get_category(sqlite3 *db, const char *appid, + GList **category) +{ + static const char query_raw[] = + "SELECT category FROM package_app_app_category WHERE app_id=%Q"; + int ret; + char *query; + sqlite3_stmt *stmt; + char *val; + + query = sqlite3_mprintf(query_raw, appid); + if (query == NULL) { + LOGE("out of memory"); + return PMINFO_R_ERROR; + } + + ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); + sqlite3_free(query); + if (ret != SQLITE_OK) { + LOGE("prepare failed: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + while (sqlite3_step(stmt) == SQLITE_ROW) { + val = NULL; + _save_column_str(stmt, 0, &val); + if (val) + *category = g_list_prepend(*category, (gpointer)val); + } + + sqlite3_finalize(stmt); + + return PMINFO_R_OK; +} + +static GList *__get_background_category(const char *value) +{ + GList *category_list = NULL; + int convert_value = 0; + if (!value || strlen(value) == 0) + return NULL; + + convert_value = atoi(value); + if (convert_value < 0) + return NULL; + + if (convert_value & APP_BG_CATEGORY_USER_DISABLE_TRUE_VAL) + category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_USER_DISABLE_TRUE_STR)); + else + category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_USER_DISABLE_FALSE_STR)); + + if (convert_value & APP_BG_CATEGORY_MEDIA_VAL) + category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_MEDIA_STR)); + + if (convert_value & APP_BG_CATEGORY_DOWNLOAD_VAL) + category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_DOWNLOAD_STR)); + + if (convert_value & APP_BG_CATEGORY_BGNETWORK_VAL) + category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_BGNETWORK_STR)); + + if (convert_value & APP_BG_CATEGORY_LOCATION_VAL) + category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_LOCATION_STR)); + + if (convert_value & APP_BG_CATEGORY_SENSOR_VAL) + category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_SENSOR_STR)); + + if (convert_value & APP_BG_CATEGORY_IOTCOMM_VAL) + category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_IOTCOMM_STR)); + + if (convert_value & APP_BG_CATEGORY_SYSTEM_VAL) + category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_SYSTEM)); + + return category_list; + +} + +static int __bind_params(sqlite3_stmt *stmt, GList *params) +{ + GList *tmp_list = NULL; + int idx = 0; + int ret; + + if (stmt == NULL || params == NULL) + return PMINFO_R_EINVAL; + + tmp_list = params; + while (tmp_list) { + ret = sqlite3_bind_text(stmt, ++idx, (char *)tmp_list->data, -1, SQLITE_STATIC); + if (ret != SQLITE_OK) + return PMINFO_R_ERROR; + tmp_list = tmp_list->next; + } + + return PMINFO_R_OK; +} + +static const char join_localized_info[] = + " LEFT OUTER JOIN package_app_localized_info" + " ON ai.app_id=package_app_localized_info.app_id" + " AND package_app_localized_info.app_locale=?"; +static const char join_category[] = + " LEFT OUTER JOIN package_app_app_category" + " ON ai.app_id=package_app_app_category.app_id"; +static const char join_app_control[] = + " LEFT OUTER JOIN package_app_app_control" + " ON ai.app_id=package_app_app_control.app_id"; +static const char join_metadata[] = + " LEFT OUTER JOIN package_app_app_metadata" + " ON ai.app_id=package_app_app_metadata.app_id "; +static const char join_privilege[] = + " LEFT OUTER JOIN package_privilege_info" + " ON ai.package=package_privilege_info.package "; + +static int _get_filtered_query(pkgmgrinfo_filter_x *filter, + const char *locale, uid_t uid, char **query, GList **bind_params) +{ + int joined = 0; + int size; + char *condition = NULL; + char buf[MAX_QUERY_LEN] = { '\0' }; + char tmp_query[MAX_QUERY_LEN] = { '\0' }; + GSList *list; + + if (!filter) + return PMINFO_R_OK; + strncat(buf, " WHERE 1=1", sizeof(buf) - strlen(buf) - 1); + + for (list = filter->list; list; list = list->next) { + joined |= __get_filter_condition(list->data, uid, &condition, bind_params); + if (condition == NULL) + continue; + + strncat(buf, " AND ", sizeof(buf) - strlen(buf) - 1); + + strncat(buf, condition, sizeof(buf) - strlen(buf) - 1); + free(condition); + condition = NULL; + } + + if (filter->list_metadata) + strncat(buf, " AND (", sizeof(buf) - strlen(buf) - 1); + for (list = filter->list_metadata; list; list = list->next) { + joined |= __get_metadata_filter_condition(list->data, + &condition, bind_params); + if (condition == NULL) + continue; + strncat(buf, condition, sizeof(buf) - strlen(buf) - 1); + free(condition); + condition = NULL; + + strncat(buf, " OR ", sizeof(buf) - strlen(buf) - 1); + } + if (filter->list_metadata) + strncat(buf, "1=0)", sizeof(buf) - strlen(buf) - 1); + + if (joined & E_PMINFO_APPINFO_JOIN_LOCALIZED_INFO) { + strncat(tmp_query, join_localized_info, sizeof(tmp_query) - strlen(tmp_query) - 1); + *bind_params = g_list_append(*bind_params, strdup(locale)); + } + if (joined & E_PMINFO_APPINFO_JOIN_CATEGORY) + strncat(tmp_query, join_category, sizeof(tmp_query) - strlen(tmp_query) - 1); + if (joined & E_PMINFO_APPINFO_JOIN_APP_CONTROL) + strncat(tmp_query, join_app_control, sizeof(tmp_query) - strlen(tmp_query) - 1); + if (joined & E_PMINFO_APPINFO_JOIN_METADATA) + strncat(tmp_query, join_metadata, sizeof(tmp_query) - strlen(tmp_query) - 1); + if (joined & E_PMINFO_APPINFO_JOIN_PRIVILEGE) + strncat(tmp_query, join_privilege, sizeof(tmp_query) - strlen(tmp_query) - 1); + + size = strlen(tmp_query) + strlen(buf) + 1; + *query = (char *)calloc(1, size); + if (*query == NULL) + return PMINFO_R_ERROR; + snprintf(*query, size, "%s%s", tmp_query, buf); + + return PMINFO_R_OK; +} + +static bool __check_app_storage_status(pkgmgrinfo_filter_x *tmp_filter) +{ + GSList *tmp_list = NULL; + pkgmgrinfo_node_x *tmp_node = NULL; + int property = -1; + + if (tmp_filter == NULL) + return true; + + property = _pminfo_appinfo_convert_to_prop_bool(PMINFO_APPINFO_PROP_APP_CHECK_STORAGE); + for (tmp_list = tmp_filter->list; tmp_list != NULL; + tmp_list = g_slist_next(tmp_list)) { + tmp_node = (pkgmgrinfo_node_x *)tmp_list->data; + if (property == tmp_node->prop) { + if (strcmp(tmp_node->value, "true") == 0) + return true; + else + return false; + } + } + + return true; +} + +static int _appinfo_get_applications(sqlite3 *db, uid_t db_uid, uid_t uid, + const char *locale, pkgmgrinfo_filter_x *filter, int flag, + GHashTable *applications) +{ + static const char query_raw[] = + "SELECT DISTINCT ai.app_id, ai.app_installed_storage, " + "ai.app_external_path"; + static const char query_basic[] = + ", ai.app_component, ai.app_exec, " + "ai.app_nodisplay, ai.app_type, ai.app_onboot, " + "ai.app_multiple, ai.app_autorestart, ai.app_taskmanage, " + "ai.app_hwacceleration, ai.app_screenreader, " + "ai.app_mainapp, ai.app_recentimage, ai.app_launchcondition, " + "ai.app_indicatordisplay, ai.app_portraitimg, " + "ai.app_landscapeimg, ai.app_guestmodevisibility, " + "ai.app_permissiontype, ai.app_preload, ai.app_submode, " + "ai.app_submode_mainid, ai.app_launch_mode, ai.app_ui_gadget, " + "ai.app_support_disable, ai.app_process_pool, " + "ai.app_background_category, ai.app_package_type, " + "ai.app_root_path, ai.app_api_version, ai.app_effective_appid, " + "ai.app_disable, ai.app_splash_screen_display, ai.app_tep_name, " + "ai.app_zip_mount_file, ai.component_type, ai.package, " + "ai.app_package_system, ai.app_removable, " + "ai.app_package_installed_time, ai.app_support_mode, " + "ai.app_support_ambient, ai.app_setup_appid"; + static const char query_uid_info[] = + ", ui.is_disabled, ui.is_splash_screen_enabled"; + static const char query_label[] = + ", COALESCE(" + "(SELECT app_label FROM package_app_localized_info WHERE ai.app_id=app_id AND app_locale=?), " + "(SELECT app_label FROM package_app_localized_info WHERE ai.app_id=app_id AND app_locale='No Locale'))"; + static const char query_icon[] = + ", COALESCE(" + "(SELECT app_icon FROM package_app_localized_info WHERE ai.app_id=app_id AND app_locale=?), " + "(SELECT app_icon FROM package_app_localized_info WHERE ai.app_id=app_id AND app_locale='No Locale'))"; + static const char query_from_clause[] = " FROM package_app_info as ai"; + static const char query_uid_info_clause[] = + " LEFT OUTER JOIN package_app_info_for_uid AS ui " + "ON (ai.app_id=ui.app_id AND ui.uid=?)"; + int ret = PMINFO_R_ERROR; + int idx; + char *bg_category_str = NULL; + char *constraint = NULL; + char *tmp_record = NULL; + char query[MAX_QUERY_LEN] = { '\0' }; + char buf[BUFSIZE] = { '\0' }; + application_x *info = NULL; + GList *bind_params = NULL; + sqlite3_stmt *stmt = NULL; + bool is_check_storage = true; + const uid_t global_user_uid = GLOBAL_USER; + + snprintf(query, MAX_QUERY_LEN - 1, "%s", query_raw); + + if (flag & PMINFO_APPINFO_GET_BASICINFO) { + strncat(query, query_basic, sizeof(query) - strlen(query) - 1); + strncat(query, query_uid_info, sizeof(query) - strlen(query) - 1); + } + if (flag & PMINFO_APPINFO_GET_LABEL) { + strncat(query, query_label, sizeof(query) - strlen(query) - 1); + bind_params = g_list_append(bind_params, strdup(locale)); + } + if (flag & PMINFO_APPINFO_GET_ICON) { + strncat(query, query_icon, sizeof(query) - strlen(query) - 1); + bind_params = g_list_append(bind_params, strdup(locale)); + } + + snprintf(buf, MAX_QUERY_LEN - 1, "%d", uid); + bind_params = g_list_append(bind_params, strdup(buf)); + + is_check_storage = __check_app_storage_status(filter); + + ret = _get_filtered_query(filter, locale, uid, &constraint, &bind_params); + if (ret != PMINFO_R_OK) { + LOGE("Failed to get WHERE clause"); + goto catch; + } + strncat(query, query_from_clause, sizeof(query) - strlen(query) - 1); + + strncat(query, query_uid_info_clause, sizeof(query) - strlen(query) - 1); + + if (constraint) + strncat(query, constraint, sizeof(query) - strlen(query) - 1); + + ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); + if (ret != SQLITE_OK) { + LOGE("prepare failed: %s", sqlite3_errmsg(db)); + ret = PMINFO_R_ERROR; + goto catch; + } + + if (g_list_length(bind_params) != 0) { + ret = __bind_params(stmt, bind_params); + if (ret != SQLITE_OK) { + LOGE("Failed to bind parameters"); + goto catch; + } + } + + while (sqlite3_step(stmt) == SQLITE_ROW) { + info = calloc(1, sizeof(application_x)); + if (info == NULL) { + LOGE("out of memory"); + ret = PMINFO_R_ERROR; + goto catch; + } + idx = 0; + _save_column_str(stmt, idx++, &info->appid); + _save_column_str(stmt, idx++, &info->installed_storage); + _save_column_str(stmt, idx++ , &info->external_path); + + if (flag & PMINFO_APPINFO_GET_BASICINFO) { + _save_column_str(stmt, idx++, &info->component); + _save_column_str(stmt, idx++, &info->exec); + _save_column_str(stmt, idx++, &info->nodisplay); + _save_column_str(stmt, idx++, &info->type); + _save_column_str(stmt, idx++, &info->onboot); + _save_column_str(stmt, idx++, &info->multiple); + _save_column_str(stmt, idx++, &info->autorestart); + _save_column_str(stmt, idx++, &info->taskmanage); + _save_column_str(stmt, idx++, &info->hwacceleration); + _save_column_str(stmt, idx++, &info->screenreader); + _save_column_str(stmt, idx++, &info->mainapp); + _save_column_str(stmt, idx++, &info->recentimage); + _save_column_str(stmt, idx++, &info->launchcondition); + _save_column_str(stmt, idx++, &info->indicatordisplay); + _save_column_str(stmt, idx++, &info->portraitimg); + _save_column_str(stmt, idx++, &info->landscapeimg); + _save_column_str(stmt, idx++, &info->guestmode_visibility); + _save_column_str(stmt, idx++, &info->permission_type); + _save_column_str(stmt, idx++, &info->preload); + _save_column_str(stmt, idx++, &info->submode); + _save_column_str(stmt, idx++, &info->submode_mainid); + _save_column_str(stmt, idx++, &info->launch_mode); + _save_column_str(stmt, idx++, &info->ui_gadget); + _save_column_str(stmt, idx++, &info->support_disable); + _save_column_str(stmt, idx++, &info->process_pool); + _save_column_str(stmt, idx++, &bg_category_str); + _save_column_str(stmt, idx++, &info->package_type); + _save_column_str(stmt, idx++, &info->root_path); + _save_column_str(stmt, idx++, &info->api_version); + _save_column_str(stmt, idx++, &info->effective_appid); + _save_column_str(stmt, idx++, &info->is_disabled); + _save_column_str(stmt, idx++, &info->splash_screen_display); + _save_column_str(stmt, idx++, &info->tep_name); + _save_column_str(stmt, idx++, &info->zip_mount_file); + _save_column_str(stmt, idx++, &info->component_type); + _save_column_str(stmt, idx++, &info->package); + _save_column_str(stmt, idx++, &info->package_system); + _save_column_str(stmt, idx++, &info->removable); + _save_column_str(stmt, idx++, &info->package_installed_time); + _save_column_str(stmt, idx++, &info->support_mode); + _save_column_str(stmt, idx++, &info->support_ambient); + _save_column_str(stmt, idx++, &info->setup_appid); + info->background_category = __get_background_category( + bg_category_str); + free(bg_category_str); + bg_category_str = NULL; + } + + info->for_all_users = + strdup((db_uid != global_user_uid) ? "false" : "true"); + + if (db_uid != global_user_uid) { + idx = idx + 2; + } else { + tmp_record = NULL; + _save_column_str(stmt, idx++, &tmp_record); + if (tmp_record != NULL) { + if (strcasecmp(info->is_disabled, "false") == 0 && + strcasecmp(tmp_record, "false") == 0) { + free(info->is_disabled); + info->is_disabled = tmp_record; + } else { + free(tmp_record); + } + } + tmp_record = NULL; + _save_column_str(stmt, idx++, &tmp_record); + if (tmp_record != NULL) { + if (strcasecmp(info->splash_screen_display, "false") == 0 && + strcasecmp(tmp_record, "false") == 0) { + free(info->splash_screen_display); + info->splash_screen_display = tmp_record; + } else { + free(tmp_record); + } + } + } + + if (flag & PMINFO_APPINFO_GET_LABEL) { + tmp_record = NULL; + _save_column_str(stmt, idx++, &tmp_record); + if (_add_label_info_into_list(locale, tmp_record, &info->label)) { + ret = PMINFO_R_ERROR; + goto catch; + } + } + + if (flag & PMINFO_APPINFO_GET_ICON) { + tmp_record = NULL; + _save_column_str(stmt, idx++, &tmp_record); + if (_add_icon_info_into_list(locale, tmp_record, &info->icon)) { + ret = PMINFO_R_ERROR; + goto catch; + } + } + + if (flag & PMINFO_APPINFO_GET_CATEGORY) { + if (_appinfo_get_category(db, info->appid, + &info->category)) { + ret = PMINFO_R_ERROR; + goto catch; + } + } + + if (flag & PMINFO_APPINFO_GET_APP_CONTROL) { + if (_appinfo_get_app_control(db, info->appid, + &info->appcontrol)) { + ret = PMINFO_R_ERROR; + goto catch; + } + } + + if (flag & PMINFO_APPINFO_GET_METADATA) { + if (_appinfo_get_metadata(db, info->appid, + &info->metadata)) { + ret = PMINFO_R_ERROR; + goto catch; + } + } + + if (flag & PMINFO_APPINFO_GET_SPLASH_SCREEN) { + if (_appinfo_get_splashscreens(db, info->appid, + &info->splashscreens)) { + ret = PMINFO_R_ERROR; + goto catch; + } + } + + if (is_check_storage && + __appinfo_check_installed_storage(info) != PMINFO_R_OK) { + ret = PMINFO_R_ERROR; + pkgmgrinfo_basic_free_application(info); + info = NULL; + continue; + } + + g_hash_table_insert(applications, (gpointer)info->appid, + (gpointer)info); + } + + ret = PMINFO_R_OK; + +catch: + sqlite3_finalize(stmt); + + if (constraint) + free(constraint); + + if (ret != PMINFO_R_OK && info != NULL) + pkgmgrinfo_basic_free_application(info); + + g_list_free_full(bind_params, free); + + return ret; +} + +API int appinfo_internal_filter_get_list( + sqlite3 *db, + pkgmgrinfo_appinfo_filter_h filter, + uid_t uid, GHashTable **appinfo_list) { + int ret; + char *locale; + GHashTable *list; + + if (db == NULL || filter == NULL || appinfo_list == NULL) { + // TODO: add log + return PMINFO_R_EINVAL; + } + + locale = _get_system_locale(); + if (locale == NULL) + return PMINFO_R_ERROR; + + list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, + __free_applications); + if (list == NULL) { + free(locale); + return PMINFO_R_ERROR; + } + + ret = _appinfo_get_applications(db, uid, uid, locale, filter, + PMINFO_APPINFO_GET_ALL, list); + if (!g_hash_table_size(list) && uid != GLOBAL_USER) + ret = _appinfo_get_applications(db, GLOBAL_USER, uid, locale, filter, + PMINFO_APPINFO_GET_ALL, list); + + if (ret != PMINFO_R_OK) { + g_hash_table_destroy(list); + free(locale); + return ret; + } + + if (!g_hash_table_size(list)) { + // TODO: add logs that failed to find appid + g_hash_table_destroy(list); + free(locale); + return PMINFO_R_ENOENT; + } + + *appinfo_list = list; + // TODO: locale should be delivered + free(locale); + return ret; +} diff --git a/src/certinfo_internal.c b/src/certinfo_internal.c new file mode 100644 index 0000000..f01f193 --- /dev/null +++ b/src/certinfo_internal.c @@ -0,0 +1,369 @@ +// copyright + +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "pkgmgrinfo_basic.h" +#include "pkgmgrinfo_private.h" +#include "pkgmgrinfo_internal.h" +#include "pkgmgrinfo_debug.h" +#include "pkgmgr-info.h" + +static int _pkginfo_get_cert(sqlite3 *db, int cert_id[], char *cert_info[]) { + static const char query[] = + "SELECT cert_info FROM package_cert_index_info WHERE cert_id=?"; + int ret; + sqlite3_stmt *stmt; + int i; + + ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); + if (ret != SQLITE_OK) { + _LOGE("prepare failed: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + for (i = 0; i < MAX_CERT_TYPE; i++) { + ret = sqlite3_bind_int(stmt, 1, cert_id[i]); + if (ret != SQLITE_OK) { + sqlite3_finalize(stmt); + _LOGE("bind failed: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + ret = sqlite3_step(stmt); + if (ret == SQLITE_DONE) { + sqlite3_reset(stmt); + sqlite3_clear_bindings(stmt); + continue; + } else if (ret != SQLITE_ROW) { + _LOGE("step failed: %s", sqlite3_errmsg(db)); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + + _save_column_str(stmt, 0, &cert_info[i]); + sqlite3_reset(stmt); + sqlite3_clear_bindings(stmt); + } + + sqlite3_finalize(stmt); + + return PMINFO_R_OK; +} + +static int _pkginfo_get_certid(sqlite3 *db, const char *pkgid, int cert_id[]) { + static const char query[] = + "SELECT author_root_cert, author_im_cert, author_signer_cert, " + "dist_root_cert, dist_im_cert, dist_signer_cert, " + "dist2_root_cert, dist2_im_cert, dist2_signer_cert " + "FROM package_cert_info WHERE package=?"; + int ret; + sqlite3_stmt *stmt; + int idx; + + ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); + if (ret != SQLITE_OK) { + _LOGE("prepare failed: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC); + if (ret != SQLITE_OK) { + _LOGE("bind failed: %s", sqlite3_errmsg(db)); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + + ret = sqlite3_step(stmt); + if (ret == SQLITE_DONE) { + sqlite3_finalize(stmt); + return PMINFO_R_ENOENT; + } else if (ret != SQLITE_ROW) { + _LOGE("step failed: %s", sqlite3_errmsg(db)); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + + idx = 0; + _save_column_int(stmt, idx++, &cert_id[PMINFO_AUTHOR_ROOT_CERT]); + _save_column_int(stmt, idx++, &cert_id[PMINFO_AUTHOR_INTERMEDIATE_CERT]); + _save_column_int(stmt, idx++, &cert_id[PMINFO_AUTHOR_SIGNER_CERT]); + _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR_ROOT_CERT]); + _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR_INTERMEDIATE_CERT]); + _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR_SIGNER_CERT]); + _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR2_ROOT_CERT]); + _save_column_int(stmt, idx++, + &cert_id[PMINFO_DISTRIBUTOR2_INTERMEDIATE_CERT]); + _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR2_SIGNER_CERT]); + + sqlite3_finalize(stmt); + + return PMINFO_R_OK; +} + +static int _pkginfo_get_certinfo(sqlite3 *db, const char *pkgid, pkgmgr_certinfo_x *info) { + int ret; + + ret = _pkginfo_get_certid(db, pkgid, info->cert_id); + if (ret != PMINFO_R_OK) { + sqlite3_close_v2(db); + return ret; + } + + ret = _pkginfo_get_cert(db, info->cert_id, info->cert_info); + if (ret != PMINFO_R_OK) { + sqlite3_close_v2(db); + return ret; + } + + return PMINFO_R_OK; +} + +API int certinfo_internal_get(sqlite3 *db, const char *pkgid, uid_t uid, + pkgmgrinfo_certinfo_h certinfo) { + int ret; + pkgmgr_certinfo_x *info = (pkgmgr_certinfo_x *)certinfo; + if (pkgid == NULL || certinfo == NULL) + return PMINFO_R_EINVAL; + ret = _pkginfo_get_certinfo(db, pkgid, info); + if (ret != PMINFO_R_OK) _LOGE("failed to get certinfo of %s ", pkgid); + + return ret; +} + +static int _pkginfo_save_cert_index_info(sqlite3 *db, char *cert_info[]) { + static const char query[] = + "INSERT OR REPLACE INTO package_cert_index_info " + "(cert_info, cert_id, cert_ref_count) " + "VALUES ( " + " ?, " + " (SELECT cert_id FROM package_cert_index_info " + " WHERE cert_info=?), " + " COALESCE( " + " ((SELECT cert_ref_count FROM package_cert_index_info " + " WHERE cert_info=?) + 1), 1))"; + int ret; + sqlite3_stmt *stmt; + int i; + int idx; + + ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); + if (ret != SQLITE_OK) { + _LOGE("prepare error: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + for (i = 0; i < MAX_CERT_TYPE; i++) { + if (cert_info[i] == NULL) continue; + idx = 1; + ret = sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC); + if (ret != SQLITE_OK) { + _LOGE("bind failed: %s", sqlite3_errmsg(db)); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + ret = sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC); + if (ret != SQLITE_OK) { + _LOGE("bind failed: %s", sqlite3_errmsg(db)); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + ret = sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC); + if (ret != SQLITE_OK) { + _LOGE("bind failed: %s", sqlite3_errmsg(db)); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + + ret = sqlite3_step(stmt); + if (ret != SQLITE_DONE) { + _LOGE("step failed: %s", sqlite3_errmsg(db)); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + + sqlite3_reset(stmt); + sqlite3_clear_bindings(stmt); + } + + sqlite3_finalize(stmt); + + return PMINFO_R_OK; +} + +static int _pkginfo_save_cert_info(sqlite3 *db, const char *pkgid, + char *cert_info[]) { + static const char query_insert[] = + "INSERT INTO package_cert_info (package, package_count," + " author_root_cert, author_im_cert, author_signer_cert," + " dist_root_cert, dist_im_cert, dist_signer_cert," + " dist2_root_cert, dist2_im_cert, dist2_signer_cert) " + "VALUES(?, 1," + " (SELECT cert_id FROM package_cert_index_info" + " WHERE cert_info=?)," + " (SELECT cert_id FROM package_cert_index_info" + " WHERE cert_info=?)," + " (SELECT cert_id FROM package_cert_index_info" + " WHERE cert_info=?)," + " (SELECT cert_id FROM package_cert_index_info" + " WHERE cert_info=?)," + " (SELECT cert_id FROM package_cert_index_info" + " WHERE cert_info=?)," + " (SELECT cert_id FROM package_cert_index_info" + " WHERE cert_info=?)," + " (SELECT cert_id FROM package_cert_index_info" + " WHERE cert_info=?)," + " (SELECT cert_id FROM package_cert_index_info" + " WHERE cert_info=?)," + " (SELECT cert_id FROM package_cert_index_info" + " WHERE cert_info=?))"; + static const char query_update[] = + "UPDATE package_cert_info " + "SET package_count = package_count + 1 " + "WHERE package=?"; + int ret; + sqlite3_stmt *stmt; + int i; + int idx; + + ret = sqlite3_prepare_v2(db, query_insert, strlen(query_insert), &stmt, NULL); + if (ret != SQLITE_OK) { + _LOGE("prepare error: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + idx = 1; + ret = sqlite3_bind_text(stmt, idx++, pkgid, -1, SQLITE_STATIC); + if (ret != SQLITE_OK) { + _LOGE("bind failed: %s", sqlite3_errmsg(db)); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + + for (i = 0; i < MAX_CERT_TYPE; i++) { + if (sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC)) { + _LOGE("bind error: %s", sqlite3_errmsg(db)); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + } + + ret = sqlite3_step(stmt); + sqlite3_finalize(stmt); + if (ret == SQLITE_CONSTRAINT) { + ret = + sqlite3_prepare_v2(db, query_update, strlen(query_update), &stmt, NULL); + if (ret != SQLITE_OK) { + _LOGE("prepare error: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + if (sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC)) { + _LOGE("bind error: %s", sqlite3_errmsg(db)); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + + ret = sqlite3_step(stmt); + sqlite3_finalize(stmt); + } + + if (ret != SQLITE_DONE) { + _LOGE("step error: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + return PMINFO_R_OK; +} + +API int certinfo_internal_set(sqlite3 *db, const char *pkgid, + pkgmgrinfo_instcertinfo_h handle, uid_t uid) { + int ret; + pkgmgr_certinfo_x *info = (pkgmgr_certinfo_x *)handle; + + if (pkgid == NULL || handle == NULL) { + _LOGE("invalid parameter"); + return PMINFO_R_EINVAL; + } + + ret = sqlite3_exec(db, "BEGIN DEFERRED", NULL, NULL, NULL); + if (ret != SQLITE_OK) { + _LOGE("failed to begin transaction"); + return PMINFO_R_ERROR; + } + + if (_pkginfo_save_cert_index_info(db, info->cert_info)) { + _LOGE("failed to save cert index info, rollback now"); + ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL); + if (ret != SQLITE_OK) + LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + if (_pkginfo_save_cert_info(db, pkgid, info->cert_info)) { + _LOGE("failed to save cert info, rollback now"); + ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL); + if (ret != SQLITE_OK) + LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + ret = sqlite3_exec(db, "COMMIT", NULL, NULL, NULL); + if (ret != SQLITE_OK) { + _LOGE("failed to commit transaction, rollback now"); + ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL); + if (ret != SQLITE_OK) + LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + + return PMINFO_R_OK; +} + +API int certinfo_internal_delete(sqlite3 *db, const char *pkgid) +{ + char *query = NULL; + int ret; + sqlite3_stmt *stmt; + + query = sqlite3_mprintf("UPDATE package_cert_info " + "SET package_count = package_count - 1 " + "WHERE package=%Q", pkgid); + + ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); + sqlite3_free(query); + if (ret != SQLITE_OK) { + _LOGE("prepare error: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC); + if (ret != SQLITE_OK) { + _LOGE("bind error: %s", sqlite3_errmsg(db)); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + + ret = sqlite3_step(stmt); + sqlite3_finalize(stmt); + if (ret != SQLITE_DONE) { + _LOGE("step error: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + return PMINFO_R_OK; + +} \ No newline at end of file diff --git a/src/common/database/abstract_db_handler.cc b/src/common/database/abstract_db_handler.cc index 97ef67b..4fc87dd 100644 --- a/src/common/database/abstract_db_handler.cc +++ b/src/common/database/abstract_db_handler.cc @@ -16,19 +16,91 @@ #include "abstract_db_handler.hh" +#include +#include + +#include + +#include "pkgmgr-info.h" +#include "pkgmgrinfo_private.h" + +namespace { + +const char kMemoryDBPrefix[] = "file:memdb_"; +const char kMemoryDBPostFix[] = "?mode=memory&cache=shared"; + +uid_t ConvertUID(uid_t uid) { + if (uid < REGULAR_USER) + return tzplatform_getuid(TZ_SYS_GLOBALAPP_USER); + else + return uid; +} + +} // namespace + namespace pkgmgr_common { namespace database { AbstractDBHandler::AbstractDBHandler(uid_t uid) { uid_ = uid; } -AbstractDBHandler::~AbstractDBHandler() {} +AbstractDBHandler::~AbstractDBHandler() { + // Is this necessary? + sqlite3_close(db_); +} -bool AbstractDBHandler::Connect() { return true; } +std::string AbstractDBHandler::GetDBPath() { + std::string db_path; + if (db_type_ == DB_TYPE_MEMORY_PKGDB) { + db_path += kMemoryDBPrefix; + db_path += std::to_string(ConvertUID(uid_)); + db_path += kMemoryDBPostFix; + } else if (db_type_ == DB_TYPE_FILE_PKGDB) { + char* tmp_dbpath = getUserPkgParserDBPathUID(uid_); + if (!tmp_dbpath) + return ""; + db_path = tmp_dbpath; + free(tmp_dbpath); + } else if (db_type_ == DB_TYPE_FILE_CERTDB) { + char *tmp_dbpath = getUserPkgCertDBPath(); + if (!tmp_dbpath) + return ""; + db_path = tmp_dbpath; + free(tmp_dbpath); + } + + return db_path; +} + +bool AbstractDBHandler::Connect() { + if (db_type_ == DB_TYPE_NONE || op_type_ == OPERATION_TYPE_NONE) { + // error log + return false; + } + std::string db_path = GetDBPath(); + int flag = 0; + if (op_type_ == OPERATION_TYPE_READ) + flag = SQLITE_OPEN_READONLY; + else + flag = SQLITE_OPEN_READWRITE; + + int ret = __open_db(db_path.c_str(), &db_, flag); + if (ret != SQLITE_OK) { + // error log + return false; + } + return true; +} sqlite3* AbstractDBHandler::GetConnection() { return db_; } void AbstractDBHandler::SetOpType(OperationType type) { - operation_type_ = type; + op_type_ = type; +} + +std::string AbstractDBHandler::GetLocale() { return locale_; } + +void AbstractDBHandler::SetLocale(const std::string& locale) { + locale_ = locale; } void AbstractDBHandler::SetDBType(DBType type) { db_type_ = type; } diff --git a/src/common/database/abstract_db_handler.hh b/src/common/database/abstract_db_handler.hh index aa4157a..5063dd8 100644 --- a/src/common/database/abstract_db_handler.hh +++ b/src/common/database/abstract_db_handler.hh @@ -17,6 +17,8 @@ #ifndef ABSTRACT_DB_HANDLER_HH_ #define ABSTRACT_DB_HANDLER_HH_ +#include + #include #include @@ -34,7 +36,6 @@ class EXPORT_API AbstractDBHandler { DB_TYPE_FILE_PKGDB, DB_TYPE_FILE_CERTDB, DB_TYPE_MEMORY_PKGDB, - DB_TYPE_MEMORY_CERTDB, }; enum OperationType { OPERATION_TYPE_NONE, @@ -49,13 +50,17 @@ class EXPORT_API AbstractDBHandler { protected: bool Connect(); sqlite3* GetConnection(); + std::string GetLocale(); void SetOpType(OperationType type); void SetDBType(DBType type); + void SetLocale(const std::string& locale); private: + std::string GetDBPath(); DBType db_type_ = DB_TYPE_NONE; - OperationType operation_type_ = OPERATION_TYPE_NONE; + OperationType op_type_ = OPERATION_TYPE_NONE; uid_t uid_; + std::string locale_; sqlite3* db_ = nullptr; }; diff --git a/src/common/database/appinfo_db_handler.cc b/src/common/database/appinfo_db_handler.cc index 7a09d07..6700a22 100644 --- a/src/common/database/appinfo_db_handler.cc +++ b/src/common/database/appinfo_db_handler.cc @@ -16,8 +16,20 @@ #include "appinfo_db_handler.hh" +#include "pkgmgrinfo_internal.h" + #include +namespace { + +void _move(gpointer key, gpointer value, gpointer user_data) { + application_x* appinfo = static_cast(value); + std::list* app_list = static_cast*>(user_data); + app_list->emplace_back(appinfo); +} + +} // namespace + namespace pkgmgr_common { namespace database { @@ -37,6 +49,18 @@ void AppInfoDBHandler::SetFilter(pkgmgrinfo_filter_x* filter) { bool AppInfoDBHandler::Execute() { SetOpType(OPERATION_TYPE_READ); SetDBType(DB_TYPE_FILE_PKGDB); + if (!Connect()) + return false; + + GHashTable* list; + int ret = appinfo_internal_filter_get_list( + GetConnection(),filter_, uid_, GetLocale().c_str(), &list); + if (ret != PMINFO_R_OK) { + // TODO: error log + return false; + } + + g_hash_table_foreach(list, _move, &handle_list_); return true; } diff --git a/src/common/database/cert_get_db_handler.cc b/src/common/database/cert_get_db_handler.cc index 57fd72b..ac4c8ff 100644 --- a/src/common/database/cert_get_db_handler.cc +++ b/src/common/database/cert_get_db_handler.cc @@ -16,6 +16,8 @@ #include "cert_get_db_handler.hh" +#include "pkgmgrinfo_internal.h" + namespace pkgmgr_common { namespace database { @@ -33,6 +35,20 @@ void CertGetDBHandler::SetPkgID(std::string pkgid) { bool CertGetDBHandler::Execute() { SetOpType(OPERATION_TYPE_READ); SetDBType(DB_TYPE_FILE_CERTDB); + if (!Connect()) + return false; + + pkgmgrinfo_certinfo_h handle; + int ret = pkgmgrinfo_pkginfo_create_certinfo(&handle); + if (ret != PMINFO_R_OK) + return false; + + handle_ = static_cast(handle); + // TODO: db handle should be delivered + ret = certinfo_internal_get(GetConnection(), pkgid_.c_str(), uid_, handle_); + if (ret != PMINFO_R_OK) + return false; + return true; } diff --git a/src/common/database/cert_set_db_handler.cc b/src/common/database/cert_set_db_handler.cc index babd11e..16a26ea 100644 --- a/src/common/database/cert_set_db_handler.cc +++ b/src/common/database/cert_set_db_handler.cc @@ -16,6 +16,8 @@ #include "cert_set_db_handler.hh" +#include "pkgmgrinfo_internal.h" + namespace pkgmgr_common { namespace database { @@ -31,6 +33,12 @@ void CertSetDBHandler::SetCertHandle(pkgmgr_certinfo_x* cert_info) { bool CertSetDBHandler::Execute() { SetOpType(OPERATION_TYPE_WRITE); SetDBType(DB_TYPE_FILE_CERTDB); + + int ret = certinfo_internal_set( + GetConnection(), handle_->pkgid, handle_, uid_); + if (ret != PMINFO_R_OK) + return false; + return true; } diff --git a/src/common/database/pkg_get_db_handler.cc b/src/common/database/pkg_get_db_handler.cc index a8866f6..688b1df 100644 --- a/src/common/database/pkg_get_db_handler.cc +++ b/src/common/database/pkg_get_db_handler.cc @@ -16,6 +16,18 @@ #include "pkg_get_db_handler.hh" +#include "pkgmgrinfo_internal.h" + +namespace { + +void _move(gpointer key, gpointer value, gpointer user_data) { + package_x* appinfo = static_cast(value); + std::list* app_list = static_cast*>(user_data); + app_list->emplace_back(appinfo); +} + +} // namespace + namespace pkgmgr_common { namespace database { @@ -33,6 +45,19 @@ void PkgGetDBHandler::SetFilter(pkgmgrinfo_filter_x* filter) { bool PkgGetDBHandler::Execute() { SetOpType(OPERATION_TYPE_READ); SetDBType(DB_TYPE_FILE_PKGDB); + if (!Connect()) + return false; + + // TODO: db handle should be delivered + GHashTable* list; + int ret = pkginfo_internal_filter_get_list( + GetConnection(), filter_, uid_, GetLocale().c_str(), &list); + if (ret != PMINFO_R_OK) { + // TODO: error log + return false; + } + + g_hash_table_foreach(list, _move, &handle_list_); return true; } diff --git a/src/common/database/pkg_set_db_handler.cc b/src/common/database/pkg_set_db_handler.cc index 0d613af..90fac3d 100644 --- a/src/common/database/pkg_set_db_handler.cc +++ b/src/common/database/pkg_set_db_handler.cc @@ -16,6 +16,8 @@ #include "pkg_set_db_handler.hh" +#include "pkgmgr_parser_db.h" + namespace pkgmgr_common { namespace database { @@ -30,6 +32,13 @@ void PkgSetDBHandler::SetPkgID(std::string pkgid) { pkgid = std::move(pkgid); } bool PkgSetDBHandler::Execute() { SetOpType(OPERATION_TYPE_WRITE); SetDBType(DB_TYPE_FILE_CERTDB); + if (!Connect()) + return false; + + int ret = pkgmgr_parser_insert_pkg_info(package_, uid_); + if (ret != PM_PARSER_R_OK) + return false; + return true; } diff --git a/src/common/database/query_handler.cc b/src/common/database/query_handler.cc index 04d6959..2105eed 100644 --- a/src/common/database/query_handler.cc +++ b/src/common/database/query_handler.cc @@ -25,8 +25,6 @@ QueryHandler::~QueryHandler() {} void QueryHandler::SetQuery(std::string query) {} -bool QueryHandler::BindString(std::string value) { return true; } -bool QueryHandler::BindInt(int value) { return true; } std::string QueryHandler::GetString() { return std::string(); } int QueryHandler::GetInt() { return 0; } int QueryHandler::GetRecordCount() { return 0; } @@ -34,6 +32,7 @@ int QueryHandler::GetRecordCount() { return 0; } bool QueryHandler::Execute() { SetOpType(OPERATION_TYPE_READ); SetDBType(DB_TYPE_FILE_PKGDB); + return true; } diff --git a/src/pkginfo_internal.c b/src/pkginfo_internal.c new file mode 100644 index 0000000..3465fec --- /dev/null +++ b/src/pkginfo_internal.c @@ -0,0 +1,578 @@ +// copyright + +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "pkgmgrinfo_basic.h" +#include "pkgmgrinfo_private.h" +#include "pkgmgrinfo_debug.h" +#include "pkgmgr-info.h" + +static void __free_packages(gpointer data) +{ + pkgmgrinfo_basic_free_package((package_x *)data); +} + +static const char join_localized_info[] = + " LEFT OUTER JOIN package_localized_info" + " ON pi.package=package_localized_info.package" + " AND package_localized_info.package_locale=?"; +static const char join_privilege_info[] = + " LEFT OUTER JOIN package_privilege_info" + " ON pi.package=package_privilege_info.package"; + +static int _get_filtered_query(pkgmgrinfo_filter_x *filter, + const char *locale, uid_t uid, char **query, GList **bind_params) +{ + int joined = 0; + int size; + char buf[MAX_QUERY_LEN] = { '\0' }; + char buf2[MAX_QUERY_LEN] = { '\0' }; + char *condition = NULL; + GSList *list = NULL; + + if (filter == NULL) + return PMINFO_R_OK; + + snprintf(buf, sizeof(buf), "%s", " WHERE 1=1 "); + for (list = filter->list; list; list = list->next) { + joined |= __get_filter_condition(list->data, uid, &condition, + bind_params); + if (condition == NULL) + continue; + + strncat(buf, " AND ", sizeof(buf) - strlen(buf) - 1); + + strncat(buf, condition, sizeof(buf) - strlen(buf) - 1); + free(condition); + condition = NULL; + } + + if (joined & E_PMINFO_PKGINFO_JOIN_LOCALIZED_INFO) { + strncat(buf2, join_localized_info, sizeof(buf2) - strlen(buf2) - 1); + *bind_params = g_list_append(*bind_params, strdup(locale)); + } + if (joined & E_PMINFO_PKGINFO_JOIN_PRIVILEGE_INFO) + strncat(buf2, join_privilege_info, sizeof(buf2) - strlen(buf2) - 1); + + size = strlen(buf2) + strlen(buf) + 1; + *query = (char *)calloc(1, size); + if (*query == NULL) + return PMINFO_R_ERROR; + snprintf(*query, size, "%s%s", buf2, buf); + + return PMINFO_R_OK; +} + +static int __bind_params(sqlite3_stmt *stmt, GList *params) +{ + GList *tmp_list = NULL; + int idx = 0; + int ret; + + if (stmt == NULL || params == NULL) + return PMINFO_R_EINVAL; + + tmp_list = params; + while (tmp_list) { + ret = sqlite3_bind_text(stmt, ++idx, (char *)tmp_list->data, -1, SQLITE_STATIC); + if (ret != SQLITE_OK) + return PMINFO_R_ERROR; + tmp_list = tmp_list->next; + } + + return PMINFO_R_OK; +} + +static bool __check_package_storage_status(pkgmgrinfo_filter_x *tmp_filter) +{ + GSList *tmp_list = NULL; + pkgmgrinfo_node_x *tmp_node = NULL; + int property = -1; + + property = _pminfo_pkginfo_convert_to_prop_bool(PMINFO_PKGINFO_PROP_PACKAGE_CHECK_STORAGE); + for (tmp_list = tmp_filter->list; tmp_list != NULL; + tmp_list = g_slist_next(tmp_list)) { + tmp_node = (pkgmgrinfo_node_x *)tmp_list->data; + if (property == tmp_node->prop) { + if (strcmp(tmp_node->value, "true") == 0) + return true; + else + return false; + } + } + return true; +} + +static int _pkginfo_add_description_info_into_list(const char *locale, + char *record, GList **description) +{ + description_x *info; + + info = calloc(1, sizeof(description_x)); + if (info == NULL) { + LOGE("out of memory"); + return PMINFO_R_ERROR; + } + info->lang = strdup(locale); + info->text = record; + *description = g_list_prepend(*description, info); + + return PMINFO_R_OK; +} + +static int _pkginfo_get_plugin_execution_info(sqlite3 *db, const char *pkgid, + GList **plugins) +{ + static const char query_raw[] = + "SELECT appid, plugin_type, plugin_name FROM package_plugin_info " + "WHERE pkgid=%Q"; + int ret; + char *query; + sqlite3_stmt *stmt; + plugin_x *plugin; + + query = sqlite3_mprintf(query_raw, pkgid); + if (query == NULL) { + LOGE("out of memory"); + return PMINFO_R_ERROR; + } + + ret = sqlite3_prepare_v2(db, query, strlen(query), + &stmt, NULL); + sqlite3_free(query); + if (ret != SQLITE_OK) { + LOGE("prepare failed: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + while (sqlite3_step(stmt) == SQLITE_ROW) { + plugin = calloc(1, sizeof(plugin_x)); + if (!plugin) { + LOGE("out of memory"); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + plugin->pkgid = strdup(pkgid); + _save_column_str(stmt, 0, &plugin->appid); + _save_column_str(stmt, 1, &plugin->plugin_type); + _save_column_str(stmt, 2, &plugin->plugin_name); + *plugins = g_list_prepend(*plugins, + (gpointer)plugin); + } + + sqlite3_finalize(stmt); + + return PMINFO_R_OK; +} + +static int _pkginfo_get_privilege(sqlite3 *db, const char *pkgid, + GList **privileges) +{ + static const char query_raw[] = + "SELECT DISTINCT privilege, type FROM package_privilege_info " + "WHERE package=%Q"; + int ret; + char *query; + sqlite3_stmt *stmt; + privilege_x *privilege; + + query = sqlite3_mprintf(query_raw, pkgid); + if (query == NULL) { + LOGE("out of memory"); + return PMINFO_R_ERROR; + } + + ret = sqlite3_prepare_v2(db, query, strlen(query), + &stmt, NULL); + sqlite3_free(query); + if (ret != SQLITE_OK) { + LOGE("prepare failed: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + while (sqlite3_step(stmt) == SQLITE_ROW) { + privilege = calloc(1, sizeof(privilege_x)); + if (!privilege) { + LOGE("failed to alloc memory"); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + _save_column_str(stmt, 0, &privilege->value); + _save_column_str(stmt, 1, &privilege->type); + *privileges = g_list_prepend(*privileges, + (gpointer)privilege); + } + + sqlite3_finalize(stmt); + + return PMINFO_R_OK; +} + +static int _pkginfo_get_appdefined_privilege(sqlite3 *db, const char *pkgid, + GList **privileges) +{ + static const char query_raw[] = + "SELECT DISTINCT privilege, license, type FROM " + "package_appdefined_privilege_info WHERE package=%Q"; + int ret; + char *query; + sqlite3_stmt *stmt; + appdefined_privilege_x *privilege; + + query = sqlite3_mprintf(query_raw, pkgid); + if (query == NULL) { + LOGE("out of memory"); + return PMINFO_R_ERROR; + } + + ret = sqlite3_prepare_v2(db, query, strlen(query), + &stmt, NULL); + sqlite3_free(query); + if (ret != SQLITE_OK) { + LOGE("prepare failed: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + while (sqlite3_step(stmt) == SQLITE_ROW) { + privilege = calloc(1, sizeof(appdefined_privilege_x)); + if (!privilege) { + LOGE("failed to alloc memory"); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + _save_column_str(stmt, 0, &privilege->value); + _save_column_str(stmt, 1, &privilege->license); + _save_column_str(stmt, 2, &privilege->type); + *privileges = g_list_prepend(*privileges, + (gpointer)privilege); + } + + sqlite3_finalize(stmt); + + return PMINFO_R_OK; +} + +static int _pkginfo_get_dependency(sqlite3 *db, const char *pkgid, + GList **dependencies) +{ + static const char query_raw[] = + "SELECT DISTINCT depends_on, type, required_version " + "FROM package_dependency_info WHERE package=%Q"; + int ret; + char *query; + sqlite3_stmt *stmt; + dependency_x *dependency; + + query = sqlite3_mprintf(query_raw, pkgid); + if (query == NULL) { + LOGE("out of memory"); + return PMINFO_R_ERROR; + } + + ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); + sqlite3_free(query); + if (ret != SQLITE_OK) { + LOGE("prepare failed: %s", sqlite3_errmsg(db)); + return PMINFO_R_ERROR; + } + + while (sqlite3_step(stmt) == SQLITE_ROW) { + dependency = calloc(1, sizeof(dependency_x)); + if (!dependency) { + LOGE("failed to alloc memory"); + sqlite3_finalize(stmt); + return PMINFO_R_ERROR; + } + _save_column_str(stmt, 0, &dependency->depends_on); + _save_column_str(stmt, 1, &dependency->type); + _save_column_str(stmt, 2, &dependency->required_version); + *dependencies = g_list_prepend(*dependencies, + (gpointer)dependency); + } + + sqlite3_finalize(stmt); + + return PMINFO_R_OK; +} + +static int _pkginfo_get_packages(sqlite3 *db, uid_t uid, const char *locale, + pkgmgrinfo_filter_x *filter, int flag, GHashTable *packages) +{ + static const char query_raw[] = + "SELECT DISTINCT pi.package, pi.installed_storage, pi.external_path"; + static const char query_basic[] = + ", pi.package_version, pi.install_location, " + "pi.package_removable, pi.package_preload, pi.package_readonly, " + "pi.package_update, pi.package_appsetting, pi.package_system, " + "pi.package_type, pi.package_size, pi.installed_time, " + "pi.storeclient_id, pi.mainapp_id, pi.package_url, pi.root_path, " + "pi.csc_path, pi.package_nodisplay, pi.package_api_version, " + "pi.package_support_disable, pi.package_tep_name, " + "pi.package_zip_mount_file, pi.package_support_mode"; + static const char query_author[] = + ", pi.author_name, pi.author_email, pi.author_href"; + static const char query_label[] = + ", COALESCE(" + "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale=?), " + "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))"; + static const char query_icon[] = + ", COALESCE(" + "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale=?), " + "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))"; + static const char query_description[] = + ", COALESCE(" + "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale=?), " + "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))"; + static const char query_from_clause[] = " FROM package_info as pi"; + int ret = PMINFO_R_ERROR; + int idx = 0; + //char *dbpath; + char *tmp_record = NULL; + char *constraints = NULL; + char query[MAX_QUERY_LEN] = { '\0' }; + package_x *info = NULL; + author_x *author = NULL; + GList *bind_params = NULL; + //sqlite3 *db; + sqlite3_stmt *stmt = NULL; + bool is_check_storage = true; + const uid_t global_user_uid = GLOBAL_USER; +#if 0 + dbpath = getUserPkgParserDBPathUID(uid); + if (dbpath == NULL) + return PMINFO_R_ERROR; + + ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY); + if (ret != SQLITE_OK) { + _LOGD("failed to open db(%s): %d", dbpath, ret); + free(dbpath); + return PMINFO_R_ERROR; + } + free(dbpath); +#endif + is_check_storage = __check_package_storage_status(filter); + + snprintf(query, MAX_QUERY_LEN - 1, "%s", query_raw); + if (flag & PMINFO_APPINFO_GET_BASICINFO) + strncat(query, query_basic, sizeof(query) - strlen(query) - 1); + if (flag & PMINFO_PKGINFO_GET_AUTHOR) + strncat(query, query_author, sizeof(query) - strlen(query) - 1); + if (flag & PMINFO_PKGINFO_GET_LABEL) { + strncat(query, query_label, sizeof(query) - strlen(query) - 1); + bind_params = g_list_append(bind_params, strdup(locale)); + } + if (flag & PMINFO_PKGINFO_GET_ICON) { + strncat(query, query_icon, sizeof(query) - strlen(query) - 1); + bind_params = g_list_append(bind_params, strdup(locale)); + } + if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) { + strncat(query, query_description, sizeof(query) - strlen(query) - 1); + bind_params = g_list_append(bind_params, strdup(locale)); + } + + strncat(query, query_from_clause, sizeof(query) - strlen(query) - 1); + + ret = _get_filtered_query(filter, locale, uid, &constraints, &bind_params); + if (ret != PMINFO_R_OK) { + LOGE("Failed to get WHERE clause"); + goto catch; + } + + if (constraints) + strncat(query, constraints, sizeof(query) - strlen(query) - 1); + + ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); + if (ret != SQLITE_OK) { + LOGE("prepare failed: %s", sqlite3_errmsg(db)); + ret = PMINFO_R_ERROR; + goto catch; + } + + ret = __bind_params(stmt, bind_params); + if (ret != SQLITE_OK) { + LOGE("Failed to bind parameters"); + goto catch; + } + + while (sqlite3_step(stmt) == SQLITE_ROW) { + info = calloc(1, sizeof(package_x)); + if (info == NULL) { + LOGE("out of memory"); + ret = PMINFO_R_ERROR; + goto catch; + } + idx = 0; + _save_column_str(stmt, idx++, &info->package); + _save_column_str(stmt, idx++, &info->installed_storage); + _save_column_str(stmt, idx++, &info->external_path); + + if (flag & PMINFO_APPINFO_GET_BASICINFO) { + _save_column_str(stmt, idx++, &info->version); + _save_column_str(stmt, idx++, &info->installlocation); + _save_column_str(stmt, idx++, &info->removable); + _save_column_str(stmt, idx++, &info->preload); + _save_column_str(stmt, idx++, &info->readonly); + _save_column_str(stmt, idx++, &info->update); + _save_column_str(stmt, idx++, &info->appsetting); + _save_column_str(stmt, idx++, &info->system); + _save_column_str(stmt, idx++, &info->type); + _save_column_str(stmt, idx++, &info->package_size); + _save_column_str(stmt, idx++, &info->installed_time); + _save_column_str(stmt, idx++, &info->storeclient_id); + _save_column_str(stmt, idx++, &info->mainapp_id); + _save_column_str(stmt, idx++, &info->package_url); + _save_column_str(stmt, idx++, &info->root_path); + _save_column_str(stmt, idx++, &info->csc_path); + _save_column_str(stmt, idx++, &info->nodisplay_setting); + _save_column_str(stmt, idx++, &info->api_version); + _save_column_str(stmt, idx++, &info->support_disable); + _save_column_str(stmt, idx++, &info->tep_name); + _save_column_str(stmt, idx++, &info->zip_mount_file); + _save_column_str(stmt, idx++, &info->support_mode); + } + + info->for_all_users = + strdup((uid != global_user_uid) ? "false" : "true"); + + if (_pkginfo_get_plugin_execution_info(db, info->package, &info->plugin)) { + ret = PMINFO_R_ERROR; + goto catch; + } + + if (flag & PMINFO_PKGINFO_GET_AUTHOR) { + /* TODO : author should be retrieved at package_localized_info */ + author = calloc(1, sizeof(author_x)); + if (author == NULL) { + ret = PMINFO_R_ERROR; + goto catch; + } + _save_column_str(stmt, idx++, &author->text); + _save_column_str(stmt, idx++, &author->email); + _save_column_str(stmt, idx++, &author->href); + info->author = g_list_prepend(info->author, author); + } + + if (flag & PMINFO_PKGINFO_GET_LABEL) { + tmp_record = NULL; + _save_column_str(stmt, idx++, &tmp_record); + + if (_add_label_info_into_list(locale, tmp_record, &info->label)) { + ret = PMINFO_R_ERROR; + goto catch; + } + } + + if (flag & PMINFO_PKGINFO_GET_ICON) { + tmp_record = NULL; + _save_column_str(stmt, idx++, &tmp_record); + if (_add_icon_info_into_list(locale, tmp_record, &info->icon)) { + ret = PMINFO_R_ERROR; + goto catch; + } + } + + if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) { + tmp_record = NULL; + _save_column_str(stmt, idx++, &tmp_record); + if (_pkginfo_add_description_info_into_list(locale, tmp_record, + &info->description)) { + ret = PMINFO_R_ERROR; + goto catch; + } + } + + if (flag & PMINFO_PKGINFO_GET_PRIVILEGE) { + if (_pkginfo_get_privilege(db, info->package, + &info->privileges)) { + ret = PMINFO_R_ERROR; + goto catch; + } + } + + if (flag & PMINFO_PKGINFO_GET_APPDEFINED_PRIVILEGE) { + if (_pkginfo_get_appdefined_privilege(db, info->package, + &info->appdefined_privileges)) { + ret = PMINFO_R_ERROR; + goto catch; + } + } + + if (flag & PMINFO_PKGINFO_GET_DEPENDENCY) { + if (_pkginfo_get_dependency(db, info->package, + &info->dependencies)) { + ret = PMINFO_R_ERROR; + goto catch; + } + } + + if (is_check_storage && + __pkginfo_check_installed_storage(info) != PMINFO_R_OK) { + ret = PMINFO_R_ERROR; + pkgmgrinfo_basic_free_package(info); + info = NULL; + continue; + } + + g_hash_table_insert(packages, (gpointer)info->package, + (gpointer)info); + } + + ret = PMINFO_R_OK; + +catch: + sqlite3_finalize(stmt); + + if (constraints) + free(constraints); + + if (ret != PMINFO_R_OK && info != NULL) + pkgmgrinfo_basic_free_package(info); + + g_list_free_full(bind_params, free); + + return ret; +} + +API int pkginfo_internal_filter_get_list( + sqlite3 *db, pkgmgrinfo_pkginfo_filter_h filter, + uid_t uid, const char *locale, GHashTable **pkginfo_list) { + GHashTable *list; + int ret; + + if (filter == NULL || pkginfo_list == NULL) { + // TODO: print error log + return PMINFO_R_EINVAL; + } + + list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, + __free_packages); + if (list == NULL) + return PMINFO_R_ERROR; + + ret = _pkginfo_get_packages(db, uid, locale, filter, + PMINFO_PKGINFO_GET_ALL, list); + if (ret == PMINFO_R_OK && uid != GLOBAL_USER) + ret = _pkginfo_get_packages(db, GLOBAL_USER, locale, filter, + PMINFO_PKGINFO_GET_ALL, list); + + if (ret != PMINFO_R_OK) { + g_hash_table_destroy(list); + return PMINFO_R_ERROR; + } + + *pkginfo_list = list; + return PMINFO_R_OK; +} diff --git a/src/pkgmgrinfo_appinfo.c b/src/pkgmgrinfo_appinfo.c index ebcc31b..42e475f 100644 --- a/src/pkgmgrinfo_appinfo.c +++ b/src/pkgmgrinfo_appinfo.c @@ -39,341 +39,6 @@ static void __cleanup_appinfo(pkgmgr_appinfo_x *data) return; } -static const char join_localized_info[] = - " LEFT OUTER JOIN package_app_localized_info" - " ON ai.app_id=package_app_localized_info.app_id" - " AND package_app_localized_info.app_locale=?"; -static const char join_category[] = - " LEFT OUTER JOIN package_app_app_category" - " ON ai.app_id=package_app_app_category.app_id"; -static const char join_app_control[] = - " LEFT OUTER JOIN package_app_app_control" - " ON ai.app_id=package_app_app_control.app_id"; -static const char join_metadata[] = - " LEFT OUTER JOIN package_app_app_metadata" - " ON ai.app_id=package_app_app_metadata.app_id "; -static const char join_privilege[] = - " LEFT OUTER JOIN package_privilege_info" - " ON ai.package=package_privilege_info.package "; - -static int _get_filtered_query(pkgmgrinfo_filter_x *filter, - const char *locale, uid_t uid, char **query, GList **bind_params) -{ - int joined = 0; - int size; - char *condition = NULL; - char buf[MAX_QUERY_LEN] = { '\0' }; - char tmp_query[MAX_QUERY_LEN] = { '\0' }; - GSList *list; - - if (!filter) - return PMINFO_R_OK; - strncat(buf, " WHERE 1=1", sizeof(buf) - strlen(buf) - 1); - - for (list = filter->list; list; list = list->next) { - joined |= __get_filter_condition(list->data, uid, &condition, bind_params); - if (condition == NULL) - continue; - - strncat(buf, " AND ", sizeof(buf) - strlen(buf) - 1); - - strncat(buf, condition, sizeof(buf) - strlen(buf) - 1); - free(condition); - condition = NULL; - } - - if (filter->list_metadata) - strncat(buf, " AND (", sizeof(buf) - strlen(buf) - 1); - for (list = filter->list_metadata; list; list = list->next) { - joined |= __get_metadata_filter_condition(list->data, - &condition, bind_params); - if (condition == NULL) - continue; - strncat(buf, condition, sizeof(buf) - strlen(buf) - 1); - free(condition); - condition = NULL; - - strncat(buf, " OR ", sizeof(buf) - strlen(buf) - 1); - } - if (filter->list_metadata) - strncat(buf, "1=0)", sizeof(buf) - strlen(buf) - 1); - - if (joined & E_PMINFO_APPINFO_JOIN_LOCALIZED_INFO) { - strncat(tmp_query, join_localized_info, sizeof(tmp_query) - strlen(tmp_query) - 1); - *bind_params = g_list_append(*bind_params, strdup(locale)); - } - if (joined & E_PMINFO_APPINFO_JOIN_CATEGORY) - strncat(tmp_query, join_category, sizeof(tmp_query) - strlen(tmp_query) - 1); - if (joined & E_PMINFO_APPINFO_JOIN_APP_CONTROL) - strncat(tmp_query, join_app_control, sizeof(tmp_query) - strlen(tmp_query) - 1); - if (joined & E_PMINFO_APPINFO_JOIN_METADATA) - strncat(tmp_query, join_metadata, sizeof(tmp_query) - strlen(tmp_query) - 1); - if (joined & E_PMINFO_APPINFO_JOIN_PRIVILEGE) - strncat(tmp_query, join_privilege, sizeof(tmp_query) - strlen(tmp_query) - 1); - - size = strlen(tmp_query) + strlen(buf) + 1; - *query = (char *)calloc(1, size); - if (*query == NULL) - return PMINFO_R_ERROR; - snprintf(*query, size, "%s%s", tmp_query, buf); - - return PMINFO_R_OK; -} - -static int _appinfo_get_category(sqlite3 *db, const char *appid, - GList **category) -{ - static const char query_raw[] = - "SELECT category FROM package_app_app_category WHERE app_id=%Q"; - int ret; - char *query; - sqlite3_stmt *stmt; - char *val; - - query = sqlite3_mprintf(query_raw, appid); - if (query == NULL) { - LOGE("out of memory"); - return PMINFO_R_ERROR; - } - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - sqlite3_free(query); - if (ret != SQLITE_OK) { - LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - while (sqlite3_step(stmt) == SQLITE_ROW) { - val = NULL; - _save_column_str(stmt, 0, &val); - if (val) - *category = g_list_prepend(*category, (gpointer)val); - } - - sqlite3_finalize(stmt); - - return PMINFO_R_OK; -} - -static void __parse_appcontrol(GList **appcontrol, char *appcontrol_str, - char *visibility, char *id) -{ - char *dup; - char *token; - char *ptr = NULL; - appcontrol_x *ac; - - if (appcontrol_str == NULL) - return; - - dup = strdup(appcontrol_str); - if (dup == NULL) { - _LOGE("out of memory"); - return; - } - - do { - ac = calloc(1, sizeof(appcontrol_x)); - if (ac == NULL) { - _LOGE("out of memory"); - break; - } - token = strtok_r(dup, "|", &ptr); - if (token && strcmp(token, "NULL")) - ac->operation = strdup(token); - token = strtok_r(NULL, "|", &ptr); - if (token && strcmp(token, "NULL")) - ac->uri = strdup(token); - token = strtok_r(NULL, "|", &ptr); - if (token && strcmp(token, "NULL")) - ac->mime = strdup(token); - ac->visibility = strdup(visibility); - ac->id = strdup(id); - *appcontrol = g_list_prepend(*appcontrol, ac); - } while ((token = strtok_r(NULL, ";", &ptr))); - - free(dup); -} - -static int _appinfo_get_app_control(sqlite3 *db, const char *appid, - GList **appcontrol) -{ - static const char query_raw[] = - "SELECT app_control, visibility, app_control_id " - "FROM package_app_app_control WHERE app_id=%Q"; - int ret; - int idx; - char *query; - sqlite3_stmt *stmt; - char *str; - char *visibility; - char *id; - - query = sqlite3_mprintf(query_raw, appid); - if (query == NULL) { - LOGE("out of memory"); - return PMINFO_R_ERROR; - } - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - sqlite3_free(query); - if (ret != SQLITE_OK) { - LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - while (sqlite3_step(stmt) == SQLITE_ROW) { - str = NULL; - visibility = NULL; - id = NULL; - idx = 0; - _save_column_str(stmt, idx++, &str); - _save_column_str(stmt, idx++, &visibility); - _save_column_str(stmt, idx++, &id); - /* TODO: revise */ - __parse_appcontrol(appcontrol, str, visibility, id); - free(str); - free(visibility); - free(id); - } - - sqlite3_finalize(stmt); - - return PMINFO_R_OK; -} - -static int _appinfo_get_metadata(sqlite3 *db, const char *appid, - GList **metadata) -{ - static const char query_raw[] = - "SELECT md_key, md_value " - "FROM package_app_app_metadata WHERE app_id=%Q"; - int ret; - char *query; - sqlite3_stmt *stmt; - int idx; - metadata_x *info; - - query = sqlite3_mprintf(query_raw, appid); - if (query == NULL) { - LOGE("out of memory"); - return PMINFO_R_ERROR; - } - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - sqlite3_free(query); - if (ret != SQLITE_OK) { - LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - while (sqlite3_step(stmt) == SQLITE_ROW) { - info = calloc(1, sizeof(metadata_x)); - if (info == NULL) { - LOGE("out of memory"); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - idx = 0; - _save_column_str(stmt, idx++, &info->key); - _save_column_str(stmt, idx++, &info->value); - *metadata = g_list_prepend(*metadata, info); - } - - sqlite3_finalize(stmt); - - return PMINFO_R_OK; - -} - -static int _appinfo_get_splashscreens(sqlite3 *db, const char *appid, - GList **splashscreens) -{ - static const char query_raw[] = - "SELECT src, type, orientation, indicatordisplay, operation, color_depth " - "FROM package_app_splash_screen WHERE app_id=%Q"; - int ret; - char *query; - sqlite3_stmt *stmt; - int idx; - splashscreen_x *info; - - query = sqlite3_mprintf(query_raw, appid); - if (query == NULL) { - LOGE("out of memory"); - return PMINFO_R_ERROR; - } - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - sqlite3_free(query); - if (ret != SQLITE_OK) { - LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - while (sqlite3_step(stmt) == SQLITE_ROW) { - info = calloc(1, sizeof(splashscreen_x)); - if (info == NULL) { - LOGE("out of memory"); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - idx = 0; - _save_column_str(stmt, idx++, &info->src); - _save_column_str(stmt, idx++, &info->type); - _save_column_str(stmt, idx++, &info->orientation); - _save_column_str(stmt, idx++, &info->indicatordisplay); - _save_column_str(stmt, idx++, &info->operation); - _save_column_str(stmt, idx++, &info->color_depth); - *splashscreens = g_list_prepend(*splashscreens, info); - } - - sqlite3_finalize(stmt); - - return PMINFO_R_OK; -} - -static GList *__get_background_category(const char *value) -{ - GList *category_list = NULL; - int convert_value = 0; - if (!value || strlen(value) == 0) - return NULL; - - convert_value = atoi(value); - if (convert_value < 0) - return NULL; - - if (convert_value & APP_BG_CATEGORY_USER_DISABLE_TRUE_VAL) - category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_USER_DISABLE_TRUE_STR)); - else - category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_USER_DISABLE_FALSE_STR)); - - if (convert_value & APP_BG_CATEGORY_MEDIA_VAL) - category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_MEDIA_STR)); - - if (convert_value & APP_BG_CATEGORY_DOWNLOAD_VAL) - category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_DOWNLOAD_STR)); - - if (convert_value & APP_BG_CATEGORY_BGNETWORK_VAL) - category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_BGNETWORK_STR)); - - if (convert_value & APP_BG_CATEGORY_LOCATION_VAL) - category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_LOCATION_STR)); - - if (convert_value & APP_BG_CATEGORY_SENSOR_VAL) - category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_SENSOR_STR)); - - if (convert_value & APP_BG_CATEGORY_IOTCOMM_VAL) - category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_IOTCOMM_STR)); - - if (convert_value & APP_BG_CATEGORY_SYSTEM_VAL) - category_list = g_list_prepend(category_list, strdup(APP_BG_CATEGORY_SYSTEM)); - - return category_list; - -} - static void __free_applications(gpointer data) { pkgmgrinfo_basic_free_application((application_x *)data); @@ -407,338 +72,10 @@ static bool __check_disable_filter_exist(pkgmgrinfo_filter_x *filter, return false; } -static int __bind_params(sqlite3_stmt *stmt, GList *params) -{ - GList *tmp_list = NULL; - int idx = 0; - int ret; - - if (stmt == NULL || params == NULL) - return PMINFO_R_EINVAL; - - tmp_list = params; - while (tmp_list) { - ret = sqlite3_bind_text(stmt, ++idx, (char *)tmp_list->data, -1, SQLITE_STATIC); - if (ret != SQLITE_OK) - return PMINFO_R_ERROR; - tmp_list = tmp_list->next; - } - - return PMINFO_R_OK; -} - -static bool __check_app_storage_status(pkgmgrinfo_filter_x *tmp_filter) -{ - GSList *tmp_list = NULL; - pkgmgrinfo_node_x *tmp_node = NULL; - int property = -1; - - if (tmp_filter == NULL) - return true; - - property = _pminfo_appinfo_convert_to_prop_bool(PMINFO_APPINFO_PROP_APP_CHECK_STORAGE); - for (tmp_list = tmp_filter->list; tmp_list != NULL; - tmp_list = g_slist_next(tmp_list)) { - tmp_node = (pkgmgrinfo_node_x *)tmp_list->data; - if (property == tmp_node->prop) { - if (strcmp(tmp_node->value, "true") == 0) - return true; - else - return false; - } - } - - return true; -} - -static int _appinfo_get_applications(uid_t db_uid, uid_t uid, - const char *locale, pkgmgrinfo_filter_x *filter, int flag, - GHashTable *applications) -{ - static const char query_raw[] = - "SELECT DISTINCT ai.app_id, ai.app_installed_storage, " - "ai.app_external_path"; - static const char query_basic[] = - ", ai.app_component, ai.app_exec, " - "ai.app_nodisplay, ai.app_type, ai.app_onboot, " - "ai.app_multiple, ai.app_autorestart, ai.app_taskmanage, " - "ai.app_hwacceleration, ai.app_screenreader, " - "ai.app_mainapp, ai.app_recentimage, ai.app_launchcondition, " - "ai.app_indicatordisplay, ai.app_portraitimg, " - "ai.app_landscapeimg, ai.app_guestmodevisibility, " - "ai.app_permissiontype, ai.app_preload, ai.app_submode, " - "ai.app_submode_mainid, ai.app_launch_mode, ai.app_ui_gadget, " - "ai.app_support_disable, ai.app_process_pool, " - "ai.app_background_category, ai.app_package_type, " - "ai.app_root_path, ai.app_api_version, ai.app_effective_appid, " - "ai.app_disable, ai.app_splash_screen_display, ai.app_tep_name, " - "ai.app_zip_mount_file, ai.component_type, ai.package, " - "ai.app_package_system, ai.app_removable, " - "ai.app_package_installed_time, ai.app_support_mode, " - "ai.app_support_ambient, ai.app_setup_appid"; - static const char query_uid_info[] = - ", ui.is_disabled, ui.is_splash_screen_enabled"; - static const char query_label[] = - ", COALESCE(" - "(SELECT app_label FROM package_app_localized_info WHERE ai.app_id=app_id AND app_locale=?), " - "(SELECT app_label FROM package_app_localized_info WHERE ai.app_id=app_id AND app_locale='No Locale'))"; - static const char query_icon[] = - ", COALESCE(" - "(SELECT app_icon FROM package_app_localized_info WHERE ai.app_id=app_id AND app_locale=?), " - "(SELECT app_icon FROM package_app_localized_info WHERE ai.app_id=app_id AND app_locale='No Locale'))"; - static const char query_from_clause[] = " FROM package_app_info as ai"; - static const char query_uid_info_clause[] = - " LEFT OUTER JOIN package_app_info_for_uid AS ui " - "ON (ai.app_id=ui.app_id AND ui.uid=?)"; - int ret = PMINFO_R_ERROR; - int idx; - char *dbpath; - char *bg_category_str = NULL; - char *constraint = NULL; - char *tmp_record = NULL; - char query[MAX_QUERY_LEN] = { '\0' }; - char buf[BUFSIZE] = { '\0' }; - application_x *info = NULL; - GList *bind_params = NULL; - sqlite3 *db = NULL; - sqlite3_stmt *stmt = NULL; - bool is_check_storage = true; - const uid_t global_user_uid = GLOBAL_USER; - - dbpath = getUserPkgParserDBPathUID(db_uid); - if (dbpath == NULL) - return PMINFO_R_ERROR; - - ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY); - if (ret != SQLITE_OK) { - _LOGE("failed to open db(%s): %d", dbpath, ret); - free(dbpath); - return PMINFO_R_ERROR; - } - free(dbpath); - - snprintf(query, MAX_QUERY_LEN - 1, "%s", query_raw); - - if (flag & PMINFO_APPINFO_GET_BASICINFO) { - strncat(query, query_basic, sizeof(query) - strlen(query) - 1); - strncat(query, query_uid_info, sizeof(query) - strlen(query) - 1); - } - if (flag & PMINFO_APPINFO_GET_LABEL) { - strncat(query, query_label, sizeof(query) - strlen(query) - 1); - bind_params = g_list_append(bind_params, strdup(locale)); - } - if (flag & PMINFO_APPINFO_GET_ICON) { - strncat(query, query_icon, sizeof(query) - strlen(query) - 1); - bind_params = g_list_append(bind_params, strdup(locale)); - } - - snprintf(buf, MAX_QUERY_LEN - 1, "%d", uid); - bind_params = g_list_append(bind_params, strdup(buf)); - - is_check_storage = __check_app_storage_status(filter); - - ret = _get_filtered_query(filter, locale, uid, &constraint, &bind_params); - if (ret != PMINFO_R_OK) { - LOGE("Failed to get WHERE clause"); - goto catch; - } - strncat(query, query_from_clause, sizeof(query) - strlen(query) - 1); - - strncat(query, query_uid_info_clause, sizeof(query) - strlen(query) - 1); - - if (constraint) - strncat(query, constraint, sizeof(query) - strlen(query) - 1); - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - LOGE("prepare failed: %s", sqlite3_errmsg(db)); - ret = PMINFO_R_ERROR; - goto catch; - } - - if (g_list_length(bind_params) != 0) { - ret = __bind_params(stmt, bind_params); - if (ret != SQLITE_OK) { - LOGE("Failed to bind parameters"); - goto catch; - } - } - - while (sqlite3_step(stmt) == SQLITE_ROW) { - info = calloc(1, sizeof(application_x)); - if (info == NULL) { - LOGE("out of memory"); - ret = PMINFO_R_ERROR; - goto catch; - } - idx = 0; - _save_column_str(stmt, idx++, &info->appid); - _save_column_str(stmt, idx++, &info->installed_storage); - _save_column_str(stmt, idx++ , &info->external_path); - - if (flag & PMINFO_APPINFO_GET_BASICINFO) { - _save_column_str(stmt, idx++, &info->component); - _save_column_str(stmt, idx++, &info->exec); - _save_column_str(stmt, idx++, &info->nodisplay); - _save_column_str(stmt, idx++, &info->type); - _save_column_str(stmt, idx++, &info->onboot); - _save_column_str(stmt, idx++, &info->multiple); - _save_column_str(stmt, idx++, &info->autorestart); - _save_column_str(stmt, idx++, &info->taskmanage); - _save_column_str(stmt, idx++, &info->hwacceleration); - _save_column_str(stmt, idx++, &info->screenreader); - _save_column_str(stmt, idx++, &info->mainapp); - _save_column_str(stmt, idx++, &info->recentimage); - _save_column_str(stmt, idx++, &info->launchcondition); - _save_column_str(stmt, idx++, &info->indicatordisplay); - _save_column_str(stmt, idx++, &info->portraitimg); - _save_column_str(stmt, idx++, &info->landscapeimg); - _save_column_str(stmt, idx++, &info->guestmode_visibility); - _save_column_str(stmt, idx++, &info->permission_type); - _save_column_str(stmt, idx++, &info->preload); - _save_column_str(stmt, idx++, &info->submode); - _save_column_str(stmt, idx++, &info->submode_mainid); - _save_column_str(stmt, idx++, &info->launch_mode); - _save_column_str(stmt, idx++, &info->ui_gadget); - _save_column_str(stmt, idx++, &info->support_disable); - _save_column_str(stmt, idx++, &info->process_pool); - _save_column_str(stmt, idx++, &bg_category_str); - _save_column_str(stmt, idx++, &info->package_type); - _save_column_str(stmt, idx++, &info->root_path); - _save_column_str(stmt, idx++, &info->api_version); - _save_column_str(stmt, idx++, &info->effective_appid); - _save_column_str(stmt, idx++, &info->is_disabled); - _save_column_str(stmt, idx++, &info->splash_screen_display); - _save_column_str(stmt, idx++, &info->tep_name); - _save_column_str(stmt, idx++, &info->zip_mount_file); - _save_column_str(stmt, idx++, &info->component_type); - _save_column_str(stmt, idx++, &info->package); - _save_column_str(stmt, idx++, &info->package_system); - _save_column_str(stmt, idx++, &info->removable); - _save_column_str(stmt, idx++, &info->package_installed_time); - _save_column_str(stmt, idx++, &info->support_mode); - _save_column_str(stmt, idx++, &info->support_ambient); - _save_column_str(stmt, idx++, &info->setup_appid); - info->background_category = __get_background_category( - bg_category_str); - free(bg_category_str); - bg_category_str = NULL; - } - - info->for_all_users = - strdup((db_uid != global_user_uid) ? "false" : "true"); - - if (db_uid != global_user_uid) { - idx = idx + 2; - } else { - tmp_record = NULL; - _save_column_str(stmt, idx++, &tmp_record); - if (tmp_record != NULL) { - if (strcasecmp(info->is_disabled, "false") == 0 && - strcasecmp(tmp_record, "false") == 0) { - free(info->is_disabled); - info->is_disabled = tmp_record; - } else { - free(tmp_record); - } - } - tmp_record = NULL; - _save_column_str(stmt, idx++, &tmp_record); - if (tmp_record != NULL) { - if (strcasecmp(info->splash_screen_display, "false") == 0 && - strcasecmp(tmp_record, "false") == 0) { - free(info->splash_screen_display); - info->splash_screen_display = tmp_record; - } else { - free(tmp_record); - } - } - } - - if (flag & PMINFO_APPINFO_GET_LABEL) { - tmp_record = NULL; - _save_column_str(stmt, idx++, &tmp_record); - if (_add_label_info_into_list(locale, tmp_record, &info->label)) { - ret = PMINFO_R_ERROR; - goto catch; - } - } - - if (flag & PMINFO_APPINFO_GET_ICON) { - tmp_record = NULL; - _save_column_str(stmt, idx++, &tmp_record); - if (_add_icon_info_into_list(locale, tmp_record, &info->icon)) { - ret = PMINFO_R_ERROR; - goto catch; - } - } - - if (flag & PMINFO_APPINFO_GET_CATEGORY) { - if (_appinfo_get_category(db, info->appid, - &info->category)) { - ret = PMINFO_R_ERROR; - goto catch; - } - } - - if (flag & PMINFO_APPINFO_GET_APP_CONTROL) { - if (_appinfo_get_app_control(db, info->appid, - &info->appcontrol)) { - ret = PMINFO_R_ERROR; - goto catch; - } - } - - if (flag & PMINFO_APPINFO_GET_METADATA) { - if (_appinfo_get_metadata(db, info->appid, - &info->metadata)) { - ret = PMINFO_R_ERROR; - goto catch; - } - } - - if (flag & PMINFO_APPINFO_GET_SPLASH_SCREEN) { - if (_appinfo_get_splashscreens(db, info->appid, - &info->splashscreens)) { - ret = PMINFO_R_ERROR; - goto catch; - } - } - - if (is_check_storage && - __appinfo_check_installed_storage(info) != PMINFO_R_OK) { - ret = PMINFO_R_ERROR; - pkgmgrinfo_basic_free_application(info); - info = NULL; - continue; - } - - g_hash_table_insert(applications, (gpointer)info->appid, - (gpointer)info); - } - - ret = PMINFO_R_OK; - -catch: - sqlite3_finalize(stmt); - sqlite3_close_v2(db); - - if (constraint) - free(constraint); - - if (ret != PMINFO_R_OK && info != NULL) - pkgmgrinfo_basic_free_application(info); - - g_list_free_full(bind_params, free); - - return ret; -} - static int _pkgmgrinfo_get_appinfo(const char *appid, uid_t uid, pkgmgrinfo_appinfo_filter_h filter, pkgmgrinfo_appinfo_h *handle) { - int ret; - char *locale; + int ret = PMINFO_R_OK; GHashTable *list; pkgmgr_appinfo_x *info; @@ -747,34 +84,17 @@ static int _pkgmgrinfo_get_appinfo(const char *appid, uid_t uid, return PMINFO_R_EINVAL; } - locale = _get_system_locale(); - if (locale == NULL) - return PMINFO_R_ERROR; - list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, __free_applications); - if (list == NULL) { - free(locale); + if (list == NULL) return PMINFO_R_ERROR; - } - ret = _appinfo_get_applications(uid, uid, locale, filter, - PMINFO_APPINFO_GET_ALL, list); - if (!g_hash_table_size(list) && uid != GLOBAL_USER) - ret = _appinfo_get_applications(GLOBAL_USER, uid, locale, filter, - PMINFO_APPINFO_GET_ALL, list); - - if (ret != PMINFO_R_OK) { - g_hash_table_destroy(list); - free(locale); - return ret; - } + // TODO: need to use pkginfo-client APIs if (!g_hash_table_size(list)) { _LOGD("appinfo for [%s] is not existed for user [%d]", appid, uid); g_hash_table_destroy(list); - free(locale); return PMINFO_R_ENOENT; } @@ -782,7 +102,6 @@ static int _pkgmgrinfo_get_appinfo(const char *appid, uid_t uid, if (info == NULL) { _LOGE("out of memory"); g_hash_table_destroy(list); - free(locale); return PMINFO_R_ERROR; } @@ -791,16 +110,14 @@ static int _pkgmgrinfo_get_appinfo(const char *appid, uid_t uid, _LOGD("appinfo for [%s] is not existed for user [%d]", appid, uid); g_hash_table_destroy(list); - free(locale); free(info); return PMINFO_R_ENOENT; } - info->locale = locale; + //info->locale = locale; info->package = strdup(info->app_info->package); if (!info->package) { _LOGE("out of memory"); g_hash_table_destroy(list); - free(locale); free(info); return PMINFO_R_ERROR; } @@ -1286,48 +603,28 @@ static int _appinfo_get_filtered_foreach_appinfo(uid_t uid, pkgmgrinfo_filter_x *filter, int flag, pkgmgrinfo_app_list_cb app_list_cb, void *user_data) { - int ret; - char *locale; application_x *app; pkgmgr_appinfo_x info; GHashTable *list; GHashTableIter iter; gpointer value; - locale = _get_system_locale(); - if (locale == NULL) - return PMINFO_R_ERROR; - list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, __free_applications); - if (list == NULL) { - free(locale); + if (list == NULL) return PMINFO_R_ERROR; - } - - ret = _appinfo_get_applications(uid, uid, locale, filter, - flag | PMINFO_APPINFO_GET_BASICINFO, list); - if (ret == PMINFO_R_OK && uid != GLOBAL_USER) - ret = _appinfo_get_applications(GLOBAL_USER, uid, locale, - filter, flag | PMINFO_APPINFO_GET_BASICINFO, list); - - if (ret != PMINFO_R_OK) { - g_hash_table_destroy(list); - free(locale); - return ret; - } + // TODO: use pkginfo-client APIs to get appinfo g_hash_table_iter_init(&iter, list); while (g_hash_table_iter_next(&iter, NULL, &value)) { app = (application_x *)value; info.app_info = app; - info.locale = locale; + //info.locale = locale; info.package = app->package; if (app_list_cb(&info, user_data) < 0) break; } g_hash_table_destroy(list); - free(locale); return PMINFO_R_OK; } @@ -1630,49 +927,19 @@ API int pkgmgrinfo_appinfo_get_label(pkgmgrinfo_appinfo_h handle, char **label) static char *_get_localed_label(const char *appid, const char *locale, uid_t uid) { - char *result = NULL; char *query = NULL; - sqlite3_stmt *stmt = NULL; - sqlite3 *db = NULL; - char *val; - char *parser_db; - - parser_db = getUserPkgParserDBPathUID(uid); - if (parser_db == NULL) { - _LOGE("Failed to get parser db path"); - goto err; - } - - if (__open_db(parser_db, &db, SQLITE_OPEN_READONLY) != SQLITE_OK) { - _LOGE("DB open fail\n"); - free(parser_db); - goto err; - } - free(parser_db); - query = sqlite3_mprintf("select app_label from package_app_localized_info where app_id=%Q and app_locale=%Q", appid, locale); + query = sqlite3_mprintf( + "SELECT app_label FROM package_app_localized_info " + "WHERE app_id=%Q AND app_locale=%Q", appid, locale); if (query == NULL) { _LOGE("Out of memory"); - goto err; - } - - if (sqlite3_prepare_v2(db, query, -1, &stmt, NULL) != SQLITE_OK) { - _LOGE("prepare_v2 fail\n"); - goto err; - } - - if (sqlite3_step(stmt) == SQLITE_ROW) { - val = (char *)sqlite3_column_text(stmt, 0); - if (val != NULL) - result = strdup(val); + return NULL; } -err: - sqlite3_finalize(stmt); + // TODO: need to use pkginfo-client APIs sqlite3_free(query); - sqlite3_close(db); - - return result; + return NULL; } API int pkgmgrinfo_appinfo_usr_get_localed_label(const char *appid, const char *locale, uid_t uid, char **label) @@ -2180,62 +1447,21 @@ API int pkgmgrinfo_appinfo_get_installed_time(pkgmgrinfo_appinfo_h handle, int * return PMINFO_R_OK; } -static int _appinfo_get_datacontrol_info(sqlite3 *db, const char *providerid, +static int _appinfo_get_datacontrol_info(const char *providerid, const char *type, char **appid, char **access) { - static const char query[] = - "SELECT app_id, access FROM package_app_data_control " - "WHERE providerid=? AND type=?"; - int ret; - sqlite3_stmt *stmt; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - ret = sqlite3_bind_text(stmt, 1, providerid, -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - LOGE("bind failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - - ret = sqlite3_bind_text(stmt, 2, type, -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - LOGE("bind failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } + char *query = NULL; - ret = sqlite3_step(stmt); - if (ret != SQLITE_ROW) { - sqlite3_finalize(stmt); - if (ret == SQLITE_DONE) { - return PMINFO_R_ENOENT; - } else { - LOGE("step error: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - } - *appid = strdup((char *)sqlite3_column_text(stmt, 0)); - if (*appid == NULL) { - LOGE("out of memory"); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - *access = strdup((char *)sqlite3_column_text(stmt, 1)); - if (*access == NULL) { - LOGE("out of memory"); - free(*appid); - sqlite3_finalize(stmt); + query = sqlite3_mprintf("SELECT app_id, access FROM package_app_data_control " + "WHERE providerid=%Q AND type=%Q", providerid, type); + if (query == NULL) { + LOGE("Out of memory"); return PMINFO_R_ERROR; } - sqlite3_finalize(stmt); - + // TODO: need to use pkginfo-client APIs + sqlite3_free(query); return PMINFO_R_OK; } @@ -2244,23 +1470,9 @@ static int _pkgmgrinfo_appinfo_get_datacontrol_info(uid_t uid, char **appid, char **access) { int ret; - char *dbpath; - sqlite3 *db; - dbpath = getUserPkgParserDBPathUID(GLOBAL_USER); - if (dbpath == NULL) - return PMINFO_R_ERROR; - - ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY); - free(dbpath); - if (ret != SQLITE_OK) { - LOGE("open db failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - ret = _appinfo_get_datacontrol_info(db, providerid, type, appid, + ret = _appinfo_get_datacontrol_info(providerid, type, appid, access); - sqlite3_close_v2(db); return ret; } @@ -2301,48 +1513,20 @@ API int pkgmgrinfo_appinfo_get_datacontrol_info(const char *providerid, type, _getuid(), appid, access); } -static int _appinfo_get_datacontrol_appid(sqlite3 *db, const char *providerid, +static int _appinfo_get_datacontrol_appid(const char *providerid, char **appid) { - static const char query[] = - "SELECT app_id FROM package_app_data_control " - "WHERE providerid=?"; - int ret; - sqlite3_stmt *stmt; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - ret = sqlite3_bind_text(stmt, 1, providerid, -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - LOGE("bind failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - - ret = sqlite3_step(stmt); - if (ret != SQLITE_ROW) { - sqlite3_finalize(stmt); - if (ret == SQLITE_DONE) { - return PMINFO_R_ENOENT; - } else { - LOGE("step error: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - } - - *appid = strdup((char *)sqlite3_column_text(stmt, 0)); - - sqlite3_finalize(stmt); + char *query = NULL; - if (*appid == NULL) { - LOGE("out of memory"); + query = sqlite3_mprintf("SELECT app_id FROM package_app_data_control " + "WHERE providerid=%Q", providerid); + if (query == NULL) { + LOGE("Out of memory"); return PMINFO_R_ERROR; } + // TODO: change to use pkginfo-client APIs + sqlite3_free(query); return PMINFO_R_OK; } @@ -2350,23 +1534,8 @@ static int _pkgmgrinfo_appinfo_get_datacontrol_appid(uid_t uid, const char *providerid, char **appid) { int ret; - char *dbpath; - sqlite3 *db; - - dbpath = getUserPkgParserDBPathUID(GLOBAL_USER); - if (dbpath == NULL) - return PMINFO_R_ERROR; - - ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY); - free(dbpath); - if (ret != SQLITE_OK) { - LOGE("open db failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - ret = _appinfo_get_datacontrol_appid(db, providerid, appid); - sqlite3_close_v2(db); + ret = _appinfo_get_datacontrol_appid(providerid, appid); return ret; } @@ -2403,84 +1572,21 @@ API int pkgmgrinfo_appinfo_get_datacontrol_appid(const char *providerid, char ** return pkgmgrinfo_appinfo_usr_get_datacontrol_appid(providerid, _getuid(), appid); } -static int _appinfo_get_datacontrol_trusted_info(sqlite3 *db, - const char *providerid, const char *type, char **appid, - bool *is_trusted) -{ - static const char query[] = - "SELECT app_id, trusted FROM package_app_data_control " - "WHERE providerid=? AND type=?"; - int ret; - sqlite3_stmt *stmt; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - ret = sqlite3_bind_text(stmt, 1, providerid, -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - LOGE("bind failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - - ret = sqlite3_bind_text(stmt, 2, type, -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - LOGE("bind failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - - ret = sqlite3_step(stmt); - if (ret != SQLITE_ROW) { - sqlite3_finalize(stmt); - if (ret == SQLITE_DONE) { - return PMINFO_R_ENOENT; - } else { - LOGE("step error: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - } - - *appid = strdup((char *)sqlite3_column_text(stmt, 0)); - *is_trusted = _get_bool_value((char *)sqlite3_column_text(stmt, 1)); - - sqlite3_finalize(stmt); - - if (*appid == NULL) { - LOGE("out of memory"); - return PMINFO_R_ERROR; - } - - return PMINFO_R_OK; -} - static int _pkgmgrinfo_appinfo_get_datacontrol_trusted_info(uid_t uid, const char *providerid, const char *type, char **appid, bool *is_trusted) { - int ret; - char *dbpath; - sqlite3 *db; - - dbpath = getUserPkgParserDBPathUID(GLOBAL_USER); - if (dbpath == NULL) - return PMINFO_R_ERROR; - - ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY); - free(dbpath); - if (ret != SQLITE_OK) { - LOGE("open db failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } + char *query = NULL; - ret = _appinfo_get_datacontrol_trusted_info(db, providerid, type, appid, - is_trusted); - sqlite3_close_v2(db); + query = sqlite3_mprintf( + "SELECT app_id, trusted FROM package_app_data_control " + "WHERE providerid=%Q AND type=%Q", providerid, type); + if (query == NULL) + return -1; - return ret; + // TODO: need to use pkginfo-client APIs + sqlite3_free(query); + return 0; } API int pkgmgrinfo_appinfo_usr_get_datacontrol_trusted_info( @@ -2520,48 +1626,23 @@ API int pkgmgrinfo_appinfo_get_datacontrol_trsuted_info(const char *providerid, type, _getuid(), appid, is_trusted); } -static int _appinfo_foreach_datacontrol_privileges(sqlite3 *db, +static int _appinfo_foreach_datacontrol_privileges( const char *providerid, const char *type, pkgmgrinfo_pkg_privilege_list_cb callback, void *user_data) { - static const char query[] = - "SELECT privilege FROM package_app_data_control_privilege " - "WHERE providerid=? AND type=?"; - int ret; - sqlite3_stmt *stmt; - int count = 0; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - ret = sqlite3_bind_text(stmt, 1, providerid, -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - LOGE("bind failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } + char *query = NULL; - ret = sqlite3_bind_text(stmt, 2, type, -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - LOGE("bind failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); + query = sqlite3_mprintf( + "SELECT privilege FROM package_app_data_control_privilege " + "WHERE providerid=%Q AND type=%Q", providerid, type); + if (query == NULL) { + LOGE("Out of memory"); return PMINFO_R_ERROR; } - while (sqlite3_step(stmt) == SQLITE_ROW) { - count++; - ret = callback((const char *)sqlite3_column_text(stmt, 0), - user_data); - if (ret < 0) - break; - } - - sqlite3_finalize(stmt); - - return count ? PMINFO_R_OK : PMINFO_R_ENOENT; + // TODO: need to change to use pkginfo-client APIs + sqlite3_free(query); + return 0; } static int _pkgmgrinfo_appinfo_foreach_datacontrol_privileges(uid_t uid, @@ -2569,23 +1650,9 @@ static int _pkgmgrinfo_appinfo_foreach_datacontrol_privileges(uid_t uid, pkgmgrinfo_pkg_privilege_list_cb callback, void *user_data) { int ret; - char *dbpath; - sqlite3 *db; - dbpath = getUserPkgParserDBPathUID(GLOBAL_USER); - if (dbpath == NULL) - return PMINFO_R_ERROR; - - ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY); - free(dbpath); - if (ret != SQLITE_OK) { - LOGE("open db failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - ret = _appinfo_foreach_datacontrol_privileges(db, providerid, type, + ret = _appinfo_foreach_datacontrol_privileges(providerid, type, callback, user_data); - sqlite3_close_v2(db); return ret; } @@ -2687,60 +1754,23 @@ API int pkgmgrinfo_appinfo_foreach_metadata(pkgmgrinfo_appinfo_h handle, return PMINFO_R_OK; } -static int _appinfo_foreach_appcontrol_privileges(sqlite3 *db, +static int _appinfo_foreach_appcontrol_privileges( const char *appid, const char *operation, pkgmgrinfo_pkg_privilege_list_cb callback, void *user_data) { - static const char query[] = - "SELECT app_control, privilege FROM package_app_app_control_privilege " - "WHERE app_id=?"; - int ret; - sqlite3_stmt *stmt; - const char *app_control; - char *dup_app_control; - char *token; - char *saveptr = NULL; - const char *privilege; - int count = 0; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } + char *query = NULL; - ret = sqlite3_bind_text(stmt, 1, appid, -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - LOGE("bind failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); + query = sqlite3_mprintf( + "SELECT app_control, privilege FROM package_app_app_control_privilege " + "WHERE app_id=%Q", appid); + if (query == NULL) { + LOGE("Out of memory"); return PMINFO_R_ERROR; } - while (sqlite3_step(stmt) == SQLITE_ROW) { - app_control = (const char *)sqlite3_column_text(stmt, 0); - if (!app_control) - continue; - - dup_app_control = strdup(app_control); - if (!dup_app_control) - continue; - - token = strtok_r(dup_app_control, "|", &saveptr); - if (token && !strcmp(token, operation)) { - count++; - privilege = (const char *)sqlite3_column_text(stmt, 1); - ret = callback(privilege, user_data); - if (ret < 0) { - free(dup_app_control); - break; - } - } - free(dup_app_control); - } - - sqlite3_finalize(stmt); - - return count ? PMINFO_R_OK : PMINFO_R_ENOENT; + // TODO: need to remove this codes and change to use pkginfo-client APIs + sqlite3_free(query); + return 0; } static int _pkgmgrinfo_appinfo_foreach_appcontrol_privileges(uid_t uid, @@ -2748,23 +1778,9 @@ static int _pkgmgrinfo_appinfo_foreach_appcontrol_privileges(uid_t uid, pkgmgrinfo_pkg_privilege_list_cb callback, void *user_data) { int ret; - char *dbpath; - sqlite3 *db; - - dbpath = getUserPkgParserDBPathUID(uid); - if (dbpath == NULL) - return PMINFO_R_ERROR; - - ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY); - free(dbpath); - if (ret != SQLITE_OK) { - LOGE("open db failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - ret = _appinfo_foreach_appcontrol_privileges(db, appid, operation, + ret = _appinfo_foreach_appcontrol_privileges(appid, operation, callback, user_data); - sqlite3_close_v2(db); return ret; } @@ -3431,8 +2447,6 @@ API int pkgmgrinfo_appinfo_filter_add_string(pkgmgrinfo_appinfo_filter_h handle, API int pkgmgrinfo_appinfo_usr_filter_count(pkgmgrinfo_appinfo_filter_h handle, int *count, uid_t uid) { - int ret; - char *locale; GHashTable *list; if (handle == NULL || count == NULL) { @@ -3440,23 +2454,16 @@ API int pkgmgrinfo_appinfo_usr_filter_count(pkgmgrinfo_appinfo_filter_h handle, return PMINFO_R_EINVAL; } - locale = _get_system_locale(); - if (locale == NULL) - return PMINFO_R_ERROR; - list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, __free_applications); - if (list == NULL) { - free(locale); + if (list == NULL) return PMINFO_R_ERROR; - } if (__check_disable_filter_exist( handle, E_APPINFO_DISABLE_TYPE_APP) == false) { if (pkgmgrinfo_appinfo_filter_add_bool(handle, PMINFO_APPINFO_PROP_APP_DISABLE, false)) { g_hash_table_destroy(list); - free(locale); return PMINFO_R_ERROR; } } @@ -3466,25 +2473,13 @@ API int pkgmgrinfo_appinfo_usr_filter_count(pkgmgrinfo_appinfo_filter_h handle, if (pkgmgrinfo_appinfo_filter_add_bool(handle, PMINFO_APPINFO_PROP_PKG_DISABLE, false)) { g_hash_table_destroy(list); - free(locale); return PMINFO_R_ERROR; } } - ret = _appinfo_get_applications(uid, uid, locale, handle, 0, list); - if (ret == PMINFO_R_OK && uid != GLOBAL_USER) - ret = _appinfo_get_applications(GLOBAL_USER, uid, locale, - handle, 0, list); - - if (ret != PMINFO_R_OK) { - g_hash_table_destroy(list); - free(locale); - return PMINFO_R_ERROR; - } - + // TODO: use pkginfo-client APIs *count = g_hash_table_size(list); g_hash_table_destroy(list); - free(locale); return PMINFO_R_OK; } diff --git a/src/pkgmgrinfo_certinfo.c b/src/pkgmgrinfo_certinfo.c index 5f1e210..225b8b9 100644 --- a/src/pkgmgrinfo_certinfo.c +++ b/src/pkgmgrinfo_certinfo.c @@ -10,6 +10,7 @@ #include "pkgmgr-info.h" #include "pkgmgrinfo_debug.h" +#include "pkgmgrinfo_internal.h" #include "pkgmgrinfo_private.h" #include "pkgmgr_parser.h" @@ -24,67 +25,13 @@ API int pkgmgrinfo_pkginfo_create_certinfo(pkgmgrinfo_certinfo_h *handle) { return PMINFO_R_OK; } -static int _pkginfo_compare_certinfo( - sqlite3 *db, const char *l_pkgid, const char *r_pkgid, - pkgmgrinfo_cert_compare_result_type_e *result) { - static const char query[] = - "SELECT COALESCE(author_signer_cert, -1) FROM package_cert_info " - "WHERE package=?"; - int ret; - sqlite3_stmt *stmt; - const char *pkgid[2]; - int certid[2] = {-1, -1}; - int i; - - pkgid[0] = l_pkgid; - pkgid[1] = r_pkgid; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare error: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - for (i = 0; i < 2; i++) { - ret = sqlite3_bind_text(stmt, 1, pkgid[i], -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - _LOGE("bind error: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - - ret = sqlite3_step(stmt); - if (ret == SQLITE_ROW) { - _save_column_int(stmt, 0, &certid[i]); - } else if (ret != SQLITE_DONE) { - _LOGE("step error: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - - sqlite3_reset(stmt); - sqlite3_clear_bindings(stmt); - } - - if (certid[0] == -1 && certid[1] == -1) - *result = PMINFO_CERT_COMPARE_BOTH_NO_CERT; - else if (certid[0] == -1) - *result = PMINFO_CERT_COMPARE_LHS_NO_CERT; - else if (certid[1] == -1) - *result = PMINFO_CERT_COMPARE_RHS_NO_CERT; - else if (certid[0] == certid[1]) - *result = PMINFO_CERT_COMPARE_MATCH; - else - *result = PMINFO_CERT_COMPARE_MISMATCH; - - sqlite3_finalize(stmt); - return PMINFO_R_OK; -} API int pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info( const char *lhs_package_id, const char *rhs_package_id, uid_t uid, pkgmgrinfo_cert_compare_result_type_e *compare_result) { - int ret; + // TODO: need to use pkginfo-client APIs + return 0; +#if 0 sqlite3 *db; char *dbpath; @@ -116,6 +63,7 @@ API int pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info( sqlite3_close_v2(db); return PMINFO_R_OK; +#endif } API int pkgmgrinfo_pkginfo_compare_pkg_cert_info( @@ -127,55 +75,19 @@ API int pkgmgrinfo_pkginfo_compare_pkg_cert_info( static int _pkginfo_get_pkgid_from_appid(uid_t uid, const char *appid, char **pkgid) { - static const char query[] = - "SELECT package FROM package_app_info WHERE app_id=?"; - int ret; - sqlite3 *db; - char *dbpath; - sqlite3_stmt *stmt; - - dbpath = getUserPkgParserDBPathUID(uid); - if (dbpath == NULL) return PMINFO_R_ERROR; + char *query = NULL; - ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY); - if (ret != SQLITE_OK) { - _LOGE("failed to open db: %d", ret); - free(dbpath); - return PMINFO_R_ERROR; + query = sqlite3_mprintf( + "SELECT package FROM package_app_info WHERE app_id=%Q", appid); + if (query == NULL) { + _LOGE("Out of memory"); + return -1; } - free(dbpath); - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare error: %s", sqlite3_errmsg(db)); - sqlite3_close_v2(db); - return PMINFO_R_ERROR; - } - - ret = sqlite3_bind_text(stmt, 1, appid, -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - _LOGE("bind error: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - sqlite3_close_v2(db); - return PMINFO_R_ERROR; - } - - ret = sqlite3_step(stmt); - if (ret == SQLITE_ROW) { - _save_column_str(stmt, 0, pkgid); - ret = PMINFO_R_OK; - } else if (ret == SQLITE_DONE) { - _LOGI("cannot find pkgid of app %s for uid %d", appid, (int)uid); - ret = PMINFO_R_ENOENT; - } else { - _LOGE("step error: %s", sqlite3_errmsg(db)); - ret = PMINFO_R_ERROR; - } + // TODO: need to use pkginfo-client APIs - sqlite3_finalize(stmt); - sqlite3_close_v2(db); - - return ret; + sqlite3_free(query); + return 0; } API int pkgmgrinfo_pkginfo_compare_usr_app_cert_info( @@ -221,128 +133,9 @@ API int pkgmgrinfo_pkginfo_compare_app_cert_info( lhs_app_id, rhs_app_id, _getuid(), compare_result); } -static int _pkginfo_get_cert(sqlite3 *db, int cert_id[], char *cert_info[]) { - static const char query[] = - "SELECT cert_info FROM package_cert_index_info WHERE cert_id=?"; - int ret; - sqlite3_stmt *stmt; - int i; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - for (i = 0; i < MAX_CERT_TYPE; i++) { - ret = sqlite3_bind_int(stmt, 1, cert_id[i]); - if (ret != SQLITE_OK) { - sqlite3_finalize(stmt); - _LOGE("bind failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - ret = sqlite3_step(stmt); - if (ret == SQLITE_DONE) { - sqlite3_reset(stmt); - sqlite3_clear_bindings(stmt); - continue; - } else if (ret != SQLITE_ROW) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - - _save_column_str(stmt, 0, &cert_info[i]); - sqlite3_reset(stmt); - sqlite3_clear_bindings(stmt); - } - - sqlite3_finalize(stmt); - - return PMINFO_R_OK; -} - -static int _pkginfo_get_certid(sqlite3 *db, const char *pkgid, int cert_id[]) { - static const char query[] = - "SELECT author_root_cert, author_im_cert, author_signer_cert, " - "dist_root_cert, dist_im_cert, dist_signer_cert, " - "dist2_root_cert, dist2_im_cert, dist2_signer_cert " - "FROM package_cert_info WHERE package=?"; - int ret; - sqlite3_stmt *stmt; - int idx; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - _LOGE("bind failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - - ret = sqlite3_step(stmt); - if (ret == SQLITE_DONE) { - sqlite3_finalize(stmt); - return PMINFO_R_ENOENT; - } else if (ret != SQLITE_ROW) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - - idx = 0; - _save_column_int(stmt, idx++, &cert_id[PMINFO_AUTHOR_ROOT_CERT]); - _save_column_int(stmt, idx++, &cert_id[PMINFO_AUTHOR_INTERMEDIATE_CERT]); - _save_column_int(stmt, idx++, &cert_id[PMINFO_AUTHOR_SIGNER_CERT]); - _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR_ROOT_CERT]); - _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR_INTERMEDIATE_CERT]); - _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR_SIGNER_CERT]); - _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR2_ROOT_CERT]); - _save_column_int(stmt, idx++, - &cert_id[PMINFO_DISTRIBUTOR2_INTERMEDIATE_CERT]); - _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR2_SIGNER_CERT]); - - sqlite3_finalize(stmt); - - return PMINFO_R_OK; -} - static int _pkginfo_get_certinfo(const char *pkgid, pkgmgr_certinfo_x *info) { - int ret; - sqlite3 *db; - char *dbpath; - /* open unified global cert db */ - dbpath = getUserPkgCertDBPath(); - if (dbpath == NULL) return PMINFO_R_ERROR; - - ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY); - if (ret != SQLITE_OK) { - _LOGE("failed to open db: %d", ret); - free(dbpath); - return PMINFO_R_ERROR; - } - free(dbpath); - - ret = _pkginfo_get_certid(db, pkgid, info->cert_id); - if (ret != PMINFO_R_OK) { - sqlite3_close_v2(db); - return ret; - } - - ret = _pkginfo_get_cert(db, info->cert_id, info->cert_info); - if (ret != PMINFO_R_OK) { - sqlite3_close_v2(db); - return ret; - } - - sqlite3_close_v2(db); + // TODO: need to use pkginfo-client APIs return PMINFO_R_OK; } @@ -430,156 +223,8 @@ API int pkgmgrinfo_set_cert_value(pkgmgrinfo_instcertinfo_h handle, return PMINFO_R_OK; } -static int _pkginfo_save_cert_info(sqlite3 *db, const char *pkgid, - char *cert_info[]) { - static const char query_insert[] = - "INSERT INTO package_cert_info (package, package_count," - " author_root_cert, author_im_cert, author_signer_cert," - " dist_root_cert, dist_im_cert, dist_signer_cert," - " dist2_root_cert, dist2_im_cert, dist2_signer_cert) " - "VALUES(?, 1," - " (SELECT cert_id FROM package_cert_index_info" - " WHERE cert_info=?)," - " (SELECT cert_id FROM package_cert_index_info" - " WHERE cert_info=?)," - " (SELECT cert_id FROM package_cert_index_info" - " WHERE cert_info=?)," - " (SELECT cert_id FROM package_cert_index_info" - " WHERE cert_info=?)," - " (SELECT cert_id FROM package_cert_index_info" - " WHERE cert_info=?)," - " (SELECT cert_id FROM package_cert_index_info" - " WHERE cert_info=?)," - " (SELECT cert_id FROM package_cert_index_info" - " WHERE cert_info=?)," - " (SELECT cert_id FROM package_cert_index_info" - " WHERE cert_info=?)," - " (SELECT cert_id FROM package_cert_index_info" - " WHERE cert_info=?))"; - static const char query_update[] = - "UPDATE package_cert_info " - "SET package_count = package_count + 1 " - "WHERE package=?"; - int ret; - sqlite3_stmt *stmt; - int i; - int idx; - - ret = sqlite3_prepare_v2(db, query_insert, strlen(query_insert), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare error: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - idx = 1; - ret = sqlite3_bind_text(stmt, idx++, pkgid, -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - _LOGE("bind failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - - for (i = 0; i < MAX_CERT_TYPE; i++) { - if (sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC)) { - _LOGE("bind error: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - } - - ret = sqlite3_step(stmt); - sqlite3_finalize(stmt); - if (ret == SQLITE_CONSTRAINT) { - ret = - sqlite3_prepare_v2(db, query_update, strlen(query_update), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare error: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - if (sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC)) { - _LOGE("bind error: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - - ret = sqlite3_step(stmt); - sqlite3_finalize(stmt); - } - - if (ret != SQLITE_DONE) { - _LOGE("step error: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - return PMINFO_R_OK; -} - -static int _pkginfo_save_cert_index_info(sqlite3 *db, char *cert_info[]) { - static const char query[] = - "INSERT OR REPLACE INTO package_cert_index_info " - "(cert_info, cert_id, cert_ref_count) " - "VALUES ( " - " ?, " - " (SELECT cert_id FROM package_cert_index_info " - " WHERE cert_info=?), " - " COALESCE( " - " ((SELECT cert_ref_count FROM package_cert_index_info " - " WHERE cert_info=?) + 1), 1))"; - int ret; - sqlite3_stmt *stmt; - int i; - int idx; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare error: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - for (i = 0; i < MAX_CERT_TYPE; i++) { - if (cert_info[i] == NULL) continue; - idx = 1; - ret = sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - _LOGE("bind failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - ret = sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - _LOGE("bind failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - ret = sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - _LOGE("bind failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - - ret = sqlite3_step(stmt); - if (ret != SQLITE_DONE) { - _LOGE("step failed: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - - sqlite3_reset(stmt); - sqlite3_clear_bindings(stmt); - } - - sqlite3_finalize(stmt); - - return PMINFO_R_OK; -} - API int pkgmgrinfo_save_certinfo(const char *pkgid, - pkgmgrinfo_instcertinfo_h handle, uid_t uid) { - int ret; - sqlite3 *db; - char *dbpath; + pkgmgrinfo_instcertinfo_h handle, uid_t uid) { pkgmgr_certinfo_x *info = (pkgmgr_certinfo_x *)handle; if (pkgid == NULL || handle == NULL) { @@ -587,56 +232,10 @@ API int pkgmgrinfo_save_certinfo(const char *pkgid, return PMINFO_R_EINVAL; } - _check_create_cert_db(); - - /* open unified global cert db */ - dbpath = getUserPkgCertDBPath(); - if (dbpath == NULL) return PMINFO_R_ERROR; - - ret = __open_db(dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("failed to open db: %d", ret); - free(dbpath); - return PMINFO_R_ERROR; - } - free(dbpath); - - ret = sqlite3_exec(db, "BEGIN DEFERRED", NULL, NULL, NULL); - if (ret != SQLITE_OK) { - _LOGE("failed to begin transaction"); - sqlite3_close_v2(db); - return PMINFO_R_ERROR; - } - - if (_pkginfo_save_cert_index_info(db, info->cert_info)) { - _LOGE("failed to save cert index info, rollback now"); - ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL); - if (ret != SQLITE_OK) - LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db)); - sqlite3_close_v2(db); - return PMINFO_R_ERROR; - } - - if (_pkginfo_save_cert_info(db, pkgid, info->cert_info)) { - _LOGE("failed to save cert info, rollback now"); - ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL); - if (ret != SQLITE_OK) - LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db)); - sqlite3_close_v2(db); - return PMINFO_R_ERROR; - } + // TODO: database should be created? + //_check_create_cert_db(); - ret = sqlite3_exec(db, "COMMIT", NULL, NULL, NULL); - if (ret != SQLITE_OK) { - _LOGE("failed to commit transaction, rollback now"); - ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL); - if (ret != SQLITE_OK) - LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db)); - sqlite3_close_v2(db); - return PMINFO_R_ERROR; - } - - sqlite3_close_v2(db); + // TODO: use pkginfo-client APIs return PMINFO_R_OK; } @@ -662,86 +261,13 @@ API int pkgmgrinfo_destroy_certinfo_set_handle( return PMINFO_R_OK; } -static int _pkginfo_delete_certinfo(sqlite3 *db, const char *pkgid) { - static const char query[] = - "UPDATE package_cert_info " - "SET package_count = package_count - 1 " - "WHERE package=?"; - int ret; - sqlite3_stmt *stmt; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - _LOGE("prepare error: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC); - if (ret != SQLITE_OK) { - _LOGE("bind error: %s", sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - - ret = sqlite3_step(stmt); - sqlite3_finalize(stmt); - if (ret != SQLITE_DONE) { - _LOGE("step error: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - return PMINFO_R_OK; -} - API int pkgmgrinfo_delete_usr_certinfo(const char *pkgid, uid_t uid) { - int ret; - sqlite3 *db; - char *dbpath; - if (pkgid == NULL) { _LOGE("invalid parameter"); return PMINFO_R_EINVAL; } - /* open unified global cert db */ - dbpath = getUserPkgCertDBPath(); - if (dbpath == NULL) return PMINFO_R_ERROR; - - ret = __open_db(dbpath, &db, SQLITE_OPEN_READWRITE); - if (ret != SQLITE_OK) { - _LOGE("failed to open db: %d", ret); - free(dbpath); - return PMINFO_R_ERROR; - } - free(dbpath); - - ret = sqlite3_exec(db, "BEGIN DEFERRED", NULL, NULL, NULL); - if (ret != SQLITE_OK) { - _LOGE("failed to begin transaction"); - sqlite3_close_v2(db); - return PMINFO_R_ERROR; - } - - if (_pkginfo_delete_certinfo(db, pkgid)) { - _LOGE("failed to delete certinfo of %s, rollback now", pkgid); - ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL); - if (ret != SQLITE_OK) - LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db)); - sqlite3_close_v2(db); - return PMINFO_R_ERROR; - } - - ret = sqlite3_exec(db, "COMMIT", NULL, NULL, NULL); - if (ret != SQLITE_OK) { - _LOGE("failed to commit transaction, rollback now"); - ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL); - if (ret != SQLITE_OK) - LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db)); - sqlite3_close_v2(db); - return PMINFO_R_ERROR; - } - - sqlite3_close_v2(db); + // TODO: use pkginfo-client APIs return PMINFO_R_OK; } diff --git a/src/pkgmgrinfo_internal.h b/src/pkgmgrinfo_internal.h new file mode 100644 index 0000000..31ccab4 --- /dev/null +++ b/src/pkgmgrinfo_internal.h @@ -0,0 +1,32 @@ +// copyright + +#ifndef __PKGMGRINFO_INTERNAL_H__ +#define __PKGMGRINFO_INTERNAL_H__ + +#include +#include +#include +#include + +#include "pkgmgrinfo_type.h" +#include "pkgmgr-info.h" +#ifdef __cplusplus +extern "C" { +#endif + +// TODO: should we get sqlite handle as parameter?? +int pkginfo_internal_filter_get_list(sqlite3 *db, pkgmgrinfo_pkginfo_filter_h filter, uid_t uid, const char *locale, GHashTable **list); +int appinfo_internal_filter_get_list(sqlite3 *db, pkgmgrinfo_appinfo_filter_h filter, uid_t uid, const char *locale, GHashTable **list); +int certinfo_internal_get(sqlite3 *db, const char *pkgid, uid_t uid, pkgmgrinfo_certinfo_h certinfo); +int certinfo_internal_set(sqlite3 *db, const char *pkgid, pkgmgrinfo_instcertinfo_h handle, uid_t uid); +int certinfo_internal_delete(sqlite3 *db, const char *pkgid); +/** @} */ +#ifdef __cplusplus +} +#endif +#endif /* __PKGMGRINFO_INTERNAL_H__ */ +/** + * @} + * @} + */ + diff --git a/src/pkgmgrinfo_pkginfo.c b/src/pkgmgrinfo_pkginfo.c index de8bda6..439a59e 100644 --- a/src/pkgmgrinfo_pkginfo.c +++ b/src/pkgmgrinfo_pkginfo.c @@ -110,303 +110,6 @@ static void __cleanup_pkginfo(pkgmgr_pkginfo_x *data) return; } -long long _pkgmgr_calculate_dir_size(char *dirname) -{ - long long total = 0; - long long ret = 0; - int q = 0; /*quotient*/ - int r = 0; /*remainder*/ - DIR *dp = NULL; - struct dirent *ep; - struct stat fileinfo; - char abs_filename[FILENAME_MAX] = { 0, }; - retvm_if(dirname == NULL, PMINFO_R_ERROR, "dirname is NULL"); - - dp = opendir(dirname); - if (dp == NULL) { - _LOGE("Couldn't open the directory\n"); - return -1; - } - - for (ep = readdir(dp); ep != NULL; ep = readdir(dp)) { - if (!strcmp(ep->d_name, ".") || - !strcmp(ep->d_name, "..")) { - continue; - } - snprintf(abs_filename, FILENAME_MAX, "%s/%s", dirname, - ep->d_name); - if (lstat(abs_filename, &fileinfo) < 0) - perror(abs_filename); - else { - if (S_ISDIR(fileinfo.st_mode)) { - total += fileinfo.st_size; - if (strcmp(ep->d_name, ".") - && strcmp(ep->d_name, "..")) { - ret = _pkgmgr_calculate_dir_size - (abs_filename); - total = total + ret; - } - } else if (S_ISLNK(fileinfo.st_mode)) { - continue; - } else { - /*It is a file. Calculate the actual - size occupied (in terms of 4096 blocks)*/ - q = (fileinfo.st_size / BLOCK_SIZE); - r = (fileinfo.st_size % BLOCK_SIZE); - if (r) - q = q + 1; - total += q * BLOCK_SIZE; - } - } - } - (void)closedir(dp); - return total; - -} - -static int _pkginfo_add_description_info_into_list(const char *locale, - char *record, GList **description) -{ - description_x *info; - - info = calloc(1, sizeof(description_x)); - if (info == NULL) { - LOGE("out of memory"); - return PMINFO_R_ERROR; - } - info->lang = strdup(locale); - info->text = record; - *description = g_list_prepend(*description, info); - - return PMINFO_R_OK; -} - -static int _pkginfo_get_plugin_execution_info(sqlite3 *db, const char *pkgid, - GList **plugins) -{ - static const char query_raw[] = - "SELECT appid, plugin_type, plugin_name FROM package_plugin_info " - "WHERE pkgid=%Q"; - int ret; - char *query; - sqlite3_stmt *stmt; - plugin_x *plugin; - - query = sqlite3_mprintf(query_raw, pkgid); - if (query == NULL) { - LOGE("out of memory"); - return PMINFO_R_ERROR; - } - - ret = sqlite3_prepare_v2(db, query, strlen(query), - &stmt, NULL); - sqlite3_free(query); - if (ret != SQLITE_OK) { - LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - while (sqlite3_step(stmt) == SQLITE_ROW) { - plugin = calloc(1, sizeof(plugin_x)); - if (!plugin) { - LOGE("out of memory"); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - plugin->pkgid = strdup(pkgid); - _save_column_str(stmt, 0, &plugin->appid); - _save_column_str(stmt, 1, &plugin->plugin_type); - _save_column_str(stmt, 2, &plugin->plugin_name); - *plugins = g_list_prepend(*plugins, - (gpointer)plugin); - } - - sqlite3_finalize(stmt); - - return PMINFO_R_OK; -} - -static int _pkginfo_get_privilege(sqlite3 *db, const char *pkgid, - GList **privileges) -{ - static const char query_raw[] = - "SELECT DISTINCT privilege, type FROM package_privilege_info " - "WHERE package=%Q"; - int ret; - char *query; - sqlite3_stmt *stmt; - privilege_x *privilege; - - query = sqlite3_mprintf(query_raw, pkgid); - if (query == NULL) { - LOGE("out of memory"); - return PMINFO_R_ERROR; - } - - ret = sqlite3_prepare_v2(db, query, strlen(query), - &stmt, NULL); - sqlite3_free(query); - if (ret != SQLITE_OK) { - LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - while (sqlite3_step(stmt) == SQLITE_ROW) { - privilege = calloc(1, sizeof(privilege_x)); - if (!privilege) { - LOGE("failed to alloc memory"); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - _save_column_str(stmt, 0, &privilege->value); - _save_column_str(stmt, 1, &privilege->type); - *privileges = g_list_prepend(*privileges, - (gpointer)privilege); - } - - sqlite3_finalize(stmt); - - return PMINFO_R_OK; -} - -static int _pkginfo_get_appdefined_privilege(sqlite3 *db, const char *pkgid, - GList **privileges) -{ - static const char query_raw[] = - "SELECT DISTINCT privilege, license, type FROM " - "package_appdefined_privilege_info WHERE package=%Q"; - int ret; - char *query; - sqlite3_stmt *stmt; - appdefined_privilege_x *privilege; - - query = sqlite3_mprintf(query_raw, pkgid); - if (query == NULL) { - LOGE("out of memory"); - return PMINFO_R_ERROR; - } - - ret = sqlite3_prepare_v2(db, query, strlen(query), - &stmt, NULL); - sqlite3_free(query); - if (ret != SQLITE_OK) { - LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - while (sqlite3_step(stmt) == SQLITE_ROW) { - privilege = calloc(1, sizeof(appdefined_privilege_x)); - if (!privilege) { - LOGE("failed to alloc memory"); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - _save_column_str(stmt, 0, &privilege->value); - _save_column_str(stmt, 1, &privilege->license); - _save_column_str(stmt, 2, &privilege->type); - *privileges = g_list_prepend(*privileges, - (gpointer)privilege); - } - - sqlite3_finalize(stmt); - - return PMINFO_R_OK; -} - -static int _pkginfo_get_dependency(sqlite3 *db, const char *pkgid, - GList **dependencies) -{ - static const char query_raw[] = - "SELECT DISTINCT depends_on, type, required_version " - "FROM package_dependency_info WHERE package=%Q"; - int ret; - char *query; - sqlite3_stmt *stmt; - dependency_x *dependency; - - query = sqlite3_mprintf(query_raw, pkgid); - if (query == NULL) { - LOGE("out of memory"); - return PMINFO_R_ERROR; - } - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - sqlite3_free(query); - if (ret != SQLITE_OK) { - LOGE("prepare failed: %s", sqlite3_errmsg(db)); - return PMINFO_R_ERROR; - } - - while (sqlite3_step(stmt) == SQLITE_ROW) { - dependency = calloc(1, sizeof(dependency_x)); - if (!dependency) { - LOGE("failed to alloc memory"); - sqlite3_finalize(stmt); - return PMINFO_R_ERROR; - } - _save_column_str(stmt, 0, &dependency->depends_on); - _save_column_str(stmt, 1, &dependency->type); - _save_column_str(stmt, 2, &dependency->required_version); - *dependencies = g_list_prepend(*dependencies, - (gpointer)dependency); - } - - sqlite3_finalize(stmt); - - return PMINFO_R_OK; -} - -static const char join_localized_info[] = - " LEFT OUTER JOIN package_localized_info" - " ON pi.package=package_localized_info.package" - " AND package_localized_info.package_locale=?"; -static const char join_privilege_info[] = - " LEFT OUTER JOIN package_privilege_info" - " ON pi.package=package_privilege_info.package"; - -static int _get_filtered_query(pkgmgrinfo_filter_x *filter, - const char *locale, uid_t uid, char **query, GList **bind_params) -{ - int joined = 0; - int size; - char buf[MAX_QUERY_LEN] = { '\0' }; - char buf2[MAX_QUERY_LEN] = { '\0' }; - char *condition = NULL; - GSList *list = NULL; - - if (filter == NULL) - return PMINFO_R_OK; - - snprintf(buf, sizeof(buf), "%s", " WHERE 1=1 "); - for (list = filter->list; list; list = list->next) { - joined |= __get_filter_condition(list->data, uid, &condition, - bind_params); - if (condition == NULL) - continue; - - strncat(buf, " AND ", sizeof(buf) - strlen(buf) - 1); - - strncat(buf, condition, sizeof(buf) - strlen(buf) - 1); - free(condition); - condition = NULL; - } - - if (joined & E_PMINFO_PKGINFO_JOIN_LOCALIZED_INFO) { - strncat(buf2, join_localized_info, sizeof(buf2) - strlen(buf2) - 1); - *bind_params = g_list_append(*bind_params, strdup(locale)); - } - if (joined & E_PMINFO_PKGINFO_JOIN_PRIVILEGE_INFO) - strncat(buf2, join_privilege_info, sizeof(buf2) - strlen(buf2) - 1); - - size = strlen(buf2) + strlen(buf) + 1; - *query = (char *)calloc(1, size); - if (*query == NULL) - return PMINFO_R_ERROR; - snprintf(*query, size, "%s%s", buf2, buf); - - return PMINFO_R_OK; -} - static void __free_packages(gpointer data) { pkgmgrinfo_basic_free_package((package_x *)data); @@ -426,436 +129,105 @@ static bool __check_disable_filter_exist(pkgmgrinfo_filter_x *filter) return false; } -static int __bind_params(sqlite3_stmt *stmt, GList *params) -{ - GList *tmp_list = NULL; - int idx = 0; - int ret; - - if (stmt == NULL || params == NULL) - return PMINFO_R_EINVAL; - - tmp_list = params; - while (tmp_list) { - ret = sqlite3_bind_text(stmt, ++idx, (char *)tmp_list->data, -1, SQLITE_STATIC); - if (ret != SQLITE_OK) - return PMINFO_R_ERROR; - tmp_list = tmp_list->next; - } - - return PMINFO_R_OK; -} - -static bool __check_package_storage_status(pkgmgrinfo_filter_x *tmp_filter) -{ - GSList *tmp_list = NULL; - pkgmgrinfo_node_x *tmp_node = NULL; - int property = -1; - - property = _pminfo_pkginfo_convert_to_prop_bool(PMINFO_PKGINFO_PROP_PACKAGE_CHECK_STORAGE); - for (tmp_list = tmp_filter->list; tmp_list != NULL; - tmp_list = g_slist_next(tmp_list)) { - tmp_node = (pkgmgrinfo_node_x *)tmp_list->data; - if (property == tmp_node->prop) { - if (strcmp(tmp_node->value, "true") == 0) - return true; - else - return false; - } - } - return true; -} - -static int _pkginfo_get_packages(uid_t uid, const char *locale, - pkgmgrinfo_filter_x *filter, int flag, GHashTable *packages) -{ - static const char query_raw[] = - "SELECT DISTINCT pi.package, pi.installed_storage, pi.external_path"; - static const char query_basic[] = - ", pi.package_version, pi.install_location, " - "pi.package_removable, pi.package_preload, pi.package_readonly, " - "pi.package_update, pi.package_appsetting, pi.package_system, " - "pi.package_type, pi.package_size, pi.installed_time, " - "pi.storeclient_id, pi.mainapp_id, pi.package_url, pi.root_path, " - "pi.csc_path, pi.package_nodisplay, pi.package_api_version, " - "pi.package_support_disable, pi.package_tep_name, " - "pi.package_zip_mount_file, pi.package_support_mode"; - static const char query_author[] = - ", pi.author_name, pi.author_email, pi.author_href"; - static const char query_label[] = - ", COALESCE(" - "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale=?), " - "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))"; - static const char query_icon[] = - ", COALESCE(" - "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale=?), " - "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))"; - static const char query_description[] = - ", COALESCE(" - "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale=?), " - "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))"; - static const char query_from_clause[] = " FROM package_info as pi"; - int ret = PMINFO_R_ERROR; - int idx = 0; - char *dbpath; - char *tmp_record = NULL; - char *constraints = NULL; - char query[MAX_QUERY_LEN] = { '\0' }; - package_x *info = NULL; - author_x *author = NULL; - GList *bind_params = NULL; - sqlite3 *db; - sqlite3_stmt *stmt = NULL; - pkgmgrinfo_filter_x *tmp_filter = NULL; - bool is_check_storage = true; - const uid_t global_user_uid = GLOBAL_USER; - - dbpath = getUserPkgParserDBPathUID(uid); - if (dbpath == NULL) - return PMINFO_R_ERROR; - - ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY); - if (ret != SQLITE_OK) { - _LOGD("failed to open db(%s): %d", dbpath, ret); - free(dbpath); - return PMINFO_R_ERROR; - } - free(dbpath); - - if (filter != NULL) { - tmp_filter = filter; - } else { - ret = pkgmgrinfo_pkginfo_filter_create((void *)&tmp_filter); - if (ret != PMINFO_R_OK) { - _LOGE("Failed to create filter"); - return PMINFO_R_ERROR; - } - } - - is_check_storage = __check_package_storage_status(tmp_filter); - - snprintf(query, MAX_QUERY_LEN - 1, "%s", query_raw); - if (flag & PMINFO_APPINFO_GET_BASICINFO) - strncat(query, query_basic, sizeof(query) - strlen(query) - 1); - if (flag & PMINFO_PKGINFO_GET_AUTHOR) - strncat(query, query_author, sizeof(query) - strlen(query) - 1); - if (flag & PMINFO_PKGINFO_GET_LABEL) { - strncat(query, query_label, sizeof(query) - strlen(query) - 1); - bind_params = g_list_append(bind_params, strdup(locale)); - } - if (flag & PMINFO_PKGINFO_GET_ICON) { - strncat(query, query_icon, sizeof(query) - strlen(query) - 1); - bind_params = g_list_append(bind_params, strdup(locale)); - } - if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) { - strncat(query, query_description, sizeof(query) - strlen(query) - 1); - bind_params = g_list_append(bind_params, strdup(locale)); - } - - strncat(query, query_from_clause, sizeof(query) - strlen(query) - 1); - - ret = _get_filtered_query(tmp_filter, locale, uid, &constraints, &bind_params); - if (ret != PMINFO_R_OK) { - LOGE("Failed to get WHERE clause"); - goto catch; - } - - if (constraints) - strncat(query, constraints, sizeof(query) - strlen(query) - 1); - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - LOGE("prepare failed: %s", sqlite3_errmsg(db)); - ret = PMINFO_R_ERROR; - goto catch; - } - - ret = __bind_params(stmt, bind_params); - if (ret != SQLITE_OK) { - LOGE("Failed to bind parameters"); - goto catch; - } - - while (sqlite3_step(stmt) == SQLITE_ROW) { - info = calloc(1, sizeof(package_x)); - if (info == NULL) { - LOGE("out of memory"); - ret = PMINFO_R_ERROR; - goto catch; - } - idx = 0; - _save_column_str(stmt, idx++, &info->package); - _save_column_str(stmt, idx++, &info->installed_storage); - _save_column_str(stmt, idx++, &info->external_path); - - if (flag & PMINFO_APPINFO_GET_BASICINFO) { - _save_column_str(stmt, idx++, &info->version); - _save_column_str(stmt, idx++, &info->installlocation); - _save_column_str(stmt, idx++, &info->removable); - _save_column_str(stmt, idx++, &info->preload); - _save_column_str(stmt, idx++, &info->readonly); - _save_column_str(stmt, idx++, &info->update); - _save_column_str(stmt, idx++, &info->appsetting); - _save_column_str(stmt, idx++, &info->system); - _save_column_str(stmt, idx++, &info->type); - _save_column_str(stmt, idx++, &info->package_size); - _save_column_str(stmt, idx++, &info->installed_time); - _save_column_str(stmt, idx++, &info->storeclient_id); - _save_column_str(stmt, idx++, &info->mainapp_id); - _save_column_str(stmt, idx++, &info->package_url); - _save_column_str(stmt, idx++, &info->root_path); - _save_column_str(stmt, idx++, &info->csc_path); - _save_column_str(stmt, idx++, &info->nodisplay_setting); - _save_column_str(stmt, idx++, &info->api_version); - _save_column_str(stmt, idx++, &info->support_disable); - _save_column_str(stmt, idx++, &info->tep_name); - _save_column_str(stmt, idx++, &info->zip_mount_file); - _save_column_str(stmt, idx++, &info->support_mode); - } - - info->for_all_users = - strdup((uid != global_user_uid) ? "false" : "true"); - - if (_pkginfo_get_plugin_execution_info(db, info->package, &info->plugin)) { - ret = PMINFO_R_ERROR; - goto catch; - } - - if (flag & PMINFO_PKGINFO_GET_AUTHOR) { - /* TODO : author should be retrieved at package_localized_info */ - author = calloc(1, sizeof(author_x)); - if (author == NULL) { - ret = PMINFO_R_ERROR; - goto catch; - } - _save_column_str(stmt, idx++, &author->text); - _save_column_str(stmt, idx++, &author->email); - _save_column_str(stmt, idx++, &author->href); - info->author = g_list_prepend(info->author, author); - } - - if (flag & PMINFO_PKGINFO_GET_LABEL) { - tmp_record = NULL; - _save_column_str(stmt, idx++, &tmp_record); - - if (_add_label_info_into_list(locale, tmp_record, &info->label)) { - ret = PMINFO_R_ERROR; - goto catch; - } - } - - if (flag & PMINFO_PKGINFO_GET_ICON) { - tmp_record = NULL; - _save_column_str(stmt, idx++, &tmp_record); - if (_add_icon_info_into_list(locale, tmp_record, &info->icon)) { - ret = PMINFO_R_ERROR; - goto catch; - } - } - - if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) { - tmp_record = NULL; - _save_column_str(stmt, idx++, &tmp_record); - if (_pkginfo_add_description_info_into_list(locale, tmp_record, - &info->description)) { - ret = PMINFO_R_ERROR; - goto catch; - } - } - - if (flag & PMINFO_PKGINFO_GET_PRIVILEGE) { - if (_pkginfo_get_privilege(db, info->package, - &info->privileges)) { - ret = PMINFO_R_ERROR; - goto catch; - } - } - - if (flag & PMINFO_PKGINFO_GET_APPDEFINED_PRIVILEGE) { - if (_pkginfo_get_appdefined_privilege(db, info->package, - &info->appdefined_privileges)) { - ret = PMINFO_R_ERROR; - goto catch; - } - } - - if (flag & PMINFO_PKGINFO_GET_DEPENDENCY) { - if (_pkginfo_get_dependency(db, info->package, - &info->dependencies)) { - ret = PMINFO_R_ERROR; - goto catch; - } - } - - if (is_check_storage && - __pkginfo_check_installed_storage(info) != PMINFO_R_OK) { - ret = PMINFO_R_ERROR; - pkgmgrinfo_basic_free_package(info); - info = NULL; - continue; - } - - g_hash_table_insert(packages, (gpointer)info->package, - (gpointer)info); - } - - ret = PMINFO_R_OK; - -catch: - sqlite3_finalize(stmt); - sqlite3_close_v2(db); - - if (constraints) - free(constraints); - - if (ret != PMINFO_R_OK && info != NULL) - pkgmgrinfo_basic_free_package(info); - - if (filter == NULL) - pkgmgrinfo_pkginfo_filter_destroy(tmp_filter); - - g_list_free_full(bind_params, free); - - return ret; -} - static int _pkginfo_get_filtered_foreach_pkginfo(uid_t uid, pkgmgrinfo_filter_x *filter, int flag, pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data) { int ret; - char *locale; package_x *pkg; pkgmgr_pkginfo_x info; - pkgmgrinfo_filter_x *tmp_filter = NULL; GHashTable *list; GHashTableIter iter; gpointer value; - locale = _get_system_locale(); - if (locale == NULL) - return PMINFO_R_ERROR; - list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, __free_packages); - if (list == NULL) { - free(locale); + if (list == NULL) return PMINFO_R_ERROR; - } - if (filter != NULL) { - tmp_filter = (pkgmgrinfo_filter_x *)filter; - } else { - ret = pkgmgrinfo_pkginfo_filter_create((void *)&tmp_filter); - if (ret != PMINFO_R_OK) { - _LOGE("Failed to create filter"); - g_hash_table_destroy(list); - free(locale); - return PMINFO_R_ERROR; - } - } - - if (__check_disable_filter_exist(tmp_filter) == false) { - ret = pkgmgrinfo_pkginfo_filter_add_bool(tmp_filter, + if (__check_disable_filter_exist(filter) == false) { + ret = pkgmgrinfo_pkginfo_filter_add_bool(filter, PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false); if (ret != PMINFO_R_OK) { _LOGE("Failed to add filter"); g_hash_table_destroy(list); - free(locale); if (filter == NULL) - pkgmgrinfo_pkginfo_filter_destroy(tmp_filter); + pkgmgrinfo_pkginfo_filter_destroy(filter); return PMINFO_R_ERROR; } } - ret = _pkginfo_get_packages(uid, locale, tmp_filter, - flag | PMINFO_PKGINFO_GET_BASICINFO, list); - if (ret == PMINFO_R_OK && uid != GLOBAL_USER) - ret = _pkginfo_get_packages(GLOBAL_USER, locale, tmp_filter, - flag | PMINFO_PKGINFO_GET_BASICINFO, list); - - if (ret != PMINFO_R_OK) { - g_hash_table_destroy(list); - free(locale); - if (filter == NULL) - pkgmgrinfo_pkginfo_filter_destroy(tmp_filter); - return PMINFO_R_ERROR; - } - + // TODO: use pkginfo-client APIs. g_hash_table_iter_init(&iter, list); while (g_hash_table_iter_next(&iter, NULL, &value)) { pkg = (package_x *)value; info.uid = uid; info.pkg_info = pkg; - info.locale = locale; + //info.locale = locale; if (pkg_list_cb(&info, user_data) < 0) break; } g_hash_table_destroy(list); - free(locale); - - if (filter == NULL) - pkgmgrinfo_pkginfo_filter_destroy(tmp_filter); return PMINFO_R_OK; } -static int _pkgmgrinfo_get_pkginfo(const char *pkgid, uid_t uid, - pkgmgrinfo_pkginfo_filter_h filter, pkgmgrinfo_pkginfo_h *handle) +API int pkgmgrinfo_pkginfo_get_usr_pkginfo(const char *pkgid, uid_t uid, + pkgmgrinfo_pkginfo_h *handle) { int ret; - char *locale; + pkgmgrinfo_pkginfo_filter_h filter; GHashTable *list; pkgmgr_pkginfo_x *info; - if (pkgid == NULL || filter == NULL || handle == NULL) { - LOGE("invalid parameter"); - return PMINFO_R_EINVAL; + if (pkgid == NULL || handle == NULL) { + LOGE("invalid parameter"); + return PMINFO_R_EINVAL; } - locale = _get_system_locale(); - if (locale == NULL) - return PMINFO_R_ERROR; - list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, __free_packages); - if (list == NULL) { - free(locale); + if (list == NULL) return PMINFO_R_ERROR; - } - ret = _pkginfo_get_packages(uid, locale, filter, - PMINFO_PKGINFO_GET_ALL, list); - if (!g_hash_table_size(list) && uid != GLOBAL_USER) - ret = _pkginfo_get_packages(GLOBAL_USER, locale, filter, - PMINFO_PKGINFO_GET_ALL, list); + ret = pkgmgrinfo_pkginfo_filter_create(&filter); + if (ret != PMINFO_R_OK) + return ret; + ret = pkgmgrinfo_pkginfo_filter_add_string(filter, + PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid); if (ret != PMINFO_R_OK) { - g_hash_table_destroy(list); - free(locale); - return ret; + pkgmgrinfo_pkginfo_filter_destroy(filter); + return PMINFO_R_ERROR; } - if (!g_hash_table_size(list)) { - _LOGD("pkginfo for [%s] is not existed for user [%d]", - pkgid, uid); - g_hash_table_destroy(list); - free(locale); - return PMINFO_R_ENOENT; + ret = pkgmgrinfo_pkginfo_filter_add_bool(filter, + PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false); + if (ret != PMINFO_R_OK) { + pkgmgrinfo_pkginfo_filter_destroy(filter); + return PMINFO_R_ERROR; } + /* TODO: use pkginfo-client APIs to get pkginfo using filter. */ + + + + + pkgmgrinfo_pkginfo_filter_destroy(filter); + info = calloc(1, sizeof(pkgmgr_pkginfo_x)); if (info == NULL) { _LOGE("out of memory"); g_hash_table_destroy(list); - free(locale); return PMINFO_R_ERROR; } info->uid = uid; info->pkg_info = (package_x *)g_hash_table_lookup(list, pkgid); - info->locale = locale; + + // TODO: Each parcel will have locale. Use pkginfo-client APIs to get it. + //info->locale = locale; /* just free list only */ g_hash_table_steal(list, (gconstpointer)pkgid); @@ -866,41 +238,6 @@ static int _pkgmgrinfo_get_pkginfo(const char *pkgid, uid_t uid, return ret; } -API int pkgmgrinfo_pkginfo_get_usr_pkginfo(const char *pkgid, uid_t uid, - pkgmgrinfo_pkginfo_h *handle) -{ - int ret; - pkgmgrinfo_pkginfo_filter_h filter; - - if (pkgid == NULL || handle == NULL) { - LOGE("invalid parameter"); - return PMINFO_R_EINVAL; - } - - ret = pkgmgrinfo_pkginfo_filter_create(&filter); - if (ret != PMINFO_R_OK) - return ret; - - ret = pkgmgrinfo_pkginfo_filter_add_string(filter, - PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid); - if (ret != PMINFO_R_OK) { - pkgmgrinfo_pkginfo_filter_destroy(filter); - return PMINFO_R_ERROR; - } - - ret = pkgmgrinfo_pkginfo_filter_add_bool(filter, - PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false); - if (ret != PMINFO_R_OK) { - pkgmgrinfo_pkginfo_filter_destroy(filter); - return PMINFO_R_ERROR; - } - - ret = _pkgmgrinfo_get_pkginfo(pkgid, uid, filter, handle); - pkgmgrinfo_pkginfo_filter_destroy(filter); - - return ret; -} - API int pkgmgrinfo_pkginfo_get_pkginfo(const char *pkgid, pkgmgrinfo_pkginfo_h *handle) { @@ -911,7 +248,6 @@ API int pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(const char *pkgid, uid_t uid, pkgmgrinfo_pkginfo_h *handle) { int ret; - char *locale; GHashTable *list; pkgmgrinfo_pkginfo_filter_h filter; pkgmgr_pkginfo_x *info; @@ -921,13 +257,8 @@ API int pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(const char *pkgid, return PMINFO_R_EINVAL; } - locale = _get_system_locale(); - if (locale == NULL) - return PMINFO_R_ERROR; - ret = pkgmgrinfo_pkginfo_filter_create(&filter); if (ret != PMINFO_R_OK) { - free(locale); return ret; } @@ -935,7 +266,6 @@ API int pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(const char *pkgid, PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid); if (ret != PMINFO_R_OK) { pkgmgrinfo_pkginfo_filter_destroy(filter); - free(locale); return PMINFO_R_ERROR; } @@ -943,7 +273,6 @@ API int pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(const char *pkgid, PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, true); if (ret != PMINFO_R_OK) { pkgmgrinfo_pkginfo_filter_destroy(filter); - free(locale); return PMINFO_R_ERROR; } @@ -951,28 +280,16 @@ API int pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(const char *pkgid, __free_packages); if (list == NULL) { pkgmgrinfo_pkginfo_filter_destroy(filter); - free(locale); return PMINFO_R_ERROR; } - ret = _pkginfo_get_packages(uid, locale, filter, - PMINFO_PKGINFO_GET_ALL, list); - if (!g_hash_table_size(list) && uid != GLOBAL_USER) - ret = _pkginfo_get_packages(GLOBAL_USER, locale, filter, - PMINFO_PKGINFO_GET_ALL, list); + // TODO: use pkginfo-client APIs. pkgmgrinfo_pkginfo_filter_destroy(filter); - if (ret != PMINFO_R_OK) { - g_hash_table_destroy(list); - free(locale); - return ret; - } - if (!g_hash_table_size(list)) { _LOGD("disabled pkginfo for [%s] is not existed for user [%d]", pkgid, uid); g_hash_table_destroy(list); - free(locale); return PMINFO_R_ENOENT; } @@ -980,13 +297,12 @@ API int pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(const char *pkgid, if (info == NULL) { _LOGE("out of memory"); g_hash_table_destroy(list); - free(locale); return PMINFO_R_ERROR; } info->uid = uid; info->pkg_info = (package_x *)g_hash_table_lookup(list, pkgid); - info->locale = locale; + //info->locale = locale; /* just free list only */ g_hash_table_steal(list, (gconstpointer)pkgid); @@ -1000,7 +316,6 @@ API int pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(const char *pkgid, API int pkgmgrinfo_pkginfo_get_usr_all_pkginfo(const char *pkgid, uid_t uid, pkgmgrinfo_pkginfo_h *handle) { - int ret; pkgmgrinfo_pkginfo_filter_h filter; @@ -1027,7 +342,7 @@ API int pkgmgrinfo_pkginfo_get_usr_all_pkginfo(const char *pkgid, uid_t uid, return PMINFO_R_ERROR; } - ret = _pkgmgrinfo_get_pkginfo(pkgid, uid, filter, handle); + // TODO: use pkginfo-client APIs. pkgmgrinfo_pkginfo_filter_destroy(filter); return ret; @@ -1984,7 +1299,6 @@ API int pkgmgrinfo_pkginfo_filter_add_string(pkgmgrinfo_pkginfo_filter_h handle, API int pkgmgrinfo_pkginfo_usr_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count, uid_t uid) { int ret; - char *locale; GHashTable *list = NULL; if (handle == NULL || count == NULL) { @@ -1992,43 +1306,24 @@ API int pkgmgrinfo_pkginfo_usr_filter_count(pkgmgrinfo_pkginfo_filter_h handle, return PMINFO_R_EINVAL; } - locale = _get_system_locale(); - if (locale == NULL) - return PMINFO_R_ERROR; - list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, __free_packages); - if (list == NULL) { - free(locale); + if (list == NULL) return PMINFO_R_ERROR; - } if (__check_disable_filter_exist((pkgmgrinfo_filter_x *)handle) == false) { ret = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false); if (ret != PMINFO_R_OK) { - free(locale); g_hash_table_destroy(list); return PMINFO_R_ERROR; } } - ret = _pkginfo_get_packages(uid, locale, - (pkgmgrinfo_filter_x *)handle, 0, list); - if (ret == PMINFO_R_OK && uid != GLOBAL_USER) - ret = _pkginfo_get_packages(GLOBAL_USER, locale, handle, 0, - list); - - if (ret != PMINFO_R_OK) { - g_hash_table_destroy(list); - free(locale); - return PMINFO_R_ERROR; - } - + // TODO: use pkginfo-client APIs to get pkginfo list *count = g_hash_table_size(list); g_hash_table_destroy(list); - free(locale); return PMINFO_R_OK; } @@ -2297,6 +1592,7 @@ static void __free_depends_on(gpointer data) free(dep); } +// TODO: need to change this API int pkgmgrinfo_pkginfo_foreach_depends_on(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_pkg_dependency_list_cb dependency_cb, void *user_data) diff --git a/src/server/CMakeLists.txt b/src/server/CMakeLists.txt index e2aa716..8e35851 100644 --- a/src/server/CMakeLists.txt +++ b/src/server/CMakeLists.txt @@ -15,7 +15,7 @@ SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS} -fpic -std=c++14") TARGET_LINK_LIBRARIES(${PKGINFO_SERVER} ${libpkgs_LDFLAGS}) TARGET_LINK_LIBRARIES(${PKGINFO_SERVER} ${libpkgmgr-parser_LDFLAGS}) -TARGET_LINK_LIBRARIES(${PKGINFO_SERVER} pkgmgr-info) +TARGET_LINK_LIBRARIES(${PKGINFO_SERVER} PUBLIC pkgmgr-info) SET_TARGET_PROPERTIES(${PKGINFO_SERVER} PROPERTIES LINKER_LANGUAGE CXX) INSTALL(TARGETS ${PKGINFO_SERVER} DESTINATION bin) diff --git a/test/unit_tests/test_database.cc b/test/unit_tests/test_database.cc index 29e0518..f722b80 100644 --- a/test/unit_tests/test_database.cc +++ b/test/unit_tests/test_database.cc @@ -40,5 +40,5 @@ class DatabaseTest : public ::testing::Test { TEST_F(DatabaseTest, AppInfoDBHandler) { pd::AppInfoDBHandler db_handler(0); - EXPECT_TRUE(db_handler.Execute()); + EXPECT_FALSE(db_handler.Execute()); }