separate db access codes from pkgmgr-info internal APIs and add codes at db handlers to use it.
#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)
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) \
SQLITE_OK) \
_LOGE("roll back transaction failed: %s", \
sqlite3_errmsg(db)); \
- sqlite3_close_v2(db); \
return PM_PARSER_R_ERROR; \
} \
} while (0) \
SQLITE_OK) \
_LOGE("roll back transaction failed: %s", \
sqlite3_errmsg(db)); \
- sqlite3_close_v2(db); \
return PM_PARSER_R_ERROR; \
} \
} while (0) \
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;
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,
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)
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;
__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);
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;
}
}
__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;
}
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;
}
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;
}
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;
}
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(
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");
}
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(
__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");
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)
__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;
}
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)
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;
}
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)
-/*
- * pkgmgr-info
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
- *
- * 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
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <dlfcn.h>
+
+#include <sqlite3.h>
+#include <glib.h>
+
+#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;
+}
--- /dev/null
+// copyright
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <sys/smack.h>
+#include <linux/limits.h>
+#include <libgen.h>
+#include <sys/stat.h>
+
+#include <sqlite3.h>
+#include <glib.h>
+
+#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
#include "abstract_db_handler.hh"
+#include <stdlib.h>
+#include <tzplatform_config.h>
+
+#include <string>
+
+#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; }
#ifndef ABSTRACT_DB_HANDLER_HH_
#define ABSTRACT_DB_HANDLER_HH_
+#include <string>
+
#include <sys/types.h>
#include <sqlite3.h>
DB_TYPE_FILE_PKGDB,
DB_TYPE_FILE_CERTDB,
DB_TYPE_MEMORY_PKGDB,
- DB_TYPE_MEMORY_CERTDB,
};
enum OperationType {
OPERATION_TYPE_NONE,
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;
};
#include "appinfo_db_handler.hh"
+#include "pkgmgrinfo_internal.h"
+
#include <list>
+namespace {
+
+void _move(gpointer key, gpointer value, gpointer user_data) {
+ application_x* appinfo = static_cast<application_x*>(value);
+ std::list<application_x*>* app_list = static_cast<std::list<application_x*>*>(user_data);
+ app_list->emplace_back(appinfo);
+}
+
+} // namespace
+
namespace pkgmgr_common {
namespace database {
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;
}
#include "cert_get_db_handler.hh"
+#include "pkgmgrinfo_internal.h"
+
namespace pkgmgr_common {
namespace database {
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<pkgmgr_certinfo_x*>(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;
}
#include "cert_set_db_handler.hh"
+#include "pkgmgrinfo_internal.h"
+
namespace pkgmgr_common {
namespace database {
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;
}
#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<package_x*>(value);
+ std::list<package_x*>* app_list = static_cast<std::list<package_x*>*>(user_data);
+ app_list->emplace_back(appinfo);
+}
+
+} // namespace
+
namespace pkgmgr_common {
namespace database {
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;
}
#include "pkg_set_db_handler.hh"
+#include "pkgmgr_parser_db.h"
+
namespace pkgmgr_common {
namespace database {
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;
}
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; }
bool QueryHandler::Execute() {
SetOpType(OPERATION_TYPE_READ);
SetDBType(DB_TYPE_FILE_PKGDB);
+
return true;
}
--- /dev/null
+// copyright
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <sys/smack.h>
+#include <linux/limits.h>
+#include <libgen.h>
+#include <sys/stat.h>
+
+#include <sqlite3.h>
+#include <glib.h>
+
+#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;
+}
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);
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;
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;
}
if (info == NULL) {
_LOGE("out of memory");
g_hash_table_destroy(list);
- free(locale);
return PMINFO_R_ERROR;
}
_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;
}
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;
}
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)
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;
}
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;
}
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;
}
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;
}
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(
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,
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;
}
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,
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;
}
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) {
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;
}
}
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;
}
#include "pkgmgr-info.h"
#include "pkgmgrinfo_debug.h"
+#include "pkgmgrinfo_internal.h"
#include "pkgmgrinfo_private.h"
#include "pkgmgr_parser.h"
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;
sqlite3_close_v2(db);
return PMINFO_R_OK;
+#endif
}
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(
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;
}
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) {
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;
}
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;
}
--- /dev/null
+// copyright
+
+#ifndef __PKGMGRINFO_INTERNAL_H__
+#define __PKGMGRINFO_INTERNAL_H__
+
+#include <errno.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+#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__ */
+/**
+ * @}
+ * @}
+ */
+
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);
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);
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)
{
uid_t uid, pkgmgrinfo_pkginfo_h *handle)
{
int ret;
- char *locale;
GHashTable *list;
pkgmgrinfo_pkginfo_filter_h filter;
pkgmgr_pkginfo_x *info;
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;
}
PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid);
if (ret != PMINFO_R_OK) {
pkgmgrinfo_pkginfo_filter_destroy(filter);
- free(locale);
return PMINFO_R_ERROR;
}
PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, true);
if (ret != PMINFO_R_OK) {
pkgmgrinfo_pkginfo_filter_destroy(filter);
- free(locale);
return PMINFO_R_ERROR;
}
__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;
}
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);
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;
return PMINFO_R_ERROR;
}
- ret = _pkgmgrinfo_get_pkginfo(pkgid, uid, filter, handle);
+ // TODO: use pkginfo-client APIs.
pkgmgrinfo_pkginfo_filter_destroy(filter);
return ret;
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) {
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;
}
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)
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)
TEST_F(DatabaseTest, AppInfoDBHandler) {
pd::AppInfoDBHandler db_handler(0);
- EXPECT_TRUE(db_handler.Execute());
+ EXPECT_FALSE(db_handler.Execute());
}
projects / platform / core / appfw / pkgmgr-info.git / commitdiff