#include <pwd.h>
#include <glib.h>
+#include <gio/gio.h>
#include <sqlite3.h>
#include <tzplatform_config.h>
#define __BEGIN_TRANSACTION(db) \
do { \
- if (sqlite3_exec(db, "BEGIN EXCLUSIVE", NULL, NULL, NULL) != \
+ if (sqlite3_exec(db, "BEGIN DEFERRED", NULL, NULL, NULL) != \
SQLITE_OK) { \
_LOGE("begin transaction failed: %s", sqlite3_errmsg(db)); \
sqlite3_close_v2(db); \
return tzplatform_mkpath(TZ_SYS_DB, ".pkgmgr_cert.db");
}
+#define DB_VERSION_PATH SYSCONFDIR "/package-manager/pkg_db_version.txt"
static int __set_db_version(sqlite3 *db)
{
- static const char query_raw[] = "PRAGMA user_version=";
- char query[BUFSIZE];
int ret;
- int version;
+ FILE *fp = NULL;
+ char version[PKG_STRING_LEN_MAX] = { 0 };
+ char *query = NULL;
+
+ fp = fopen(DB_VERSION_PATH, "r");
+ retvm_if(fp == NULL, -1, "Failed to open db version file");
+ if (fgets(version, sizeof(version), fp) == NULL) {
+ _LOGE("Failed to get version information");
+ fclose(fp);
+ return -1;
+ }
+ fclose(fp);
- version = atoi(TIZEN_MAJOR_VER) * 10000 + atoi(TIZEN_MINOR_VER) * 100 +
- atoi(TIZEN_PATCH_VER);
- snprintf(query, sizeof(query), "%s%d", query_raw, version);
+ query = sqlite3_mprintf("PRAGMA user_version=%Q", version);
+ if (!query) {
+ _LOGE("Out of memory");
+ return -1;
+ }
ret = sqlite3_exec(db, query, NULL, NULL, NULL);
if (ret != SQLITE_OK) {
_LOGE("exec failed: %s", sqlite3_errmsg(db));
+ sqlite3_free(query);
return -1;
}
+ sqlite3_free(query);
return 0;
}
QUERY_CREATE_TABLE_PACKAGE_INFO,
QUERY_CREATE_TABLE_PACKAGE_LOCALIZED_INFO,
QUERY_CREATE_TABLE_PACKAGE_PRIVILEGE_INFO,
+ QUERY_CREATE_TABLE_PACKAGE_APPDEFINED_PRIVILEGE_INFO,
+ QUERY_CREATE_TABLE_PACKAGE_UPDATE_INFO,
QUERY_CREATE_TABLE_PACKAGE_APP_INFO,
QUERY_CREATE_TABLE_PACKAGE_APP_LOCALIZED_INFO,
- QUERY_CREATE_TABLE_PACKAGE_APP_ICON_SECTION_INFO, /* ? */
- QUERY_CREATE_TABLE_PACKAGE_APP_IMAGE_INFO, /* ? */
QUERY_CREATE_TABLE_PACKAGE_APP_APP_CONTROL,
+ QUERY_CREATE_TABLE_PACKAGE_APP_APP_CONTROL_PRIVILEGE,
QUERY_CREATE_TABLE_PACKAGE_APP_APP_CATEGORY,
QUERY_CREATE_TABLE_PACKAGE_APP_APP_METADATA,
- QUERY_CREATE_TABLE_PACKAGE_APP_APP_PERMISSION, /* ? */
- QUERY_CREATE_TABLE_PACKAGE_APP_SHARE_ALLOWED, /* ? */
- QUERY_CREATE_TABLE_PACKAGE_APP_SHARE_REQUEST, /* ? */
QUERY_CREATE_TABLE_PACKAGE_APP_DATA_CONTROL,
+ QUERY_CREATE_TABLE_PACKAGE_APP_DATA_CONTROL_PRIVILEGE,
QUERY_CREATE_TABLE_PACKAGE_APP_INFO_FOR_UID,
QUERY_CREATE_TRIGGER_UPDATE_PACKAGE_APP_INFO_FOR_UID,
QUERY_CREATE_TABLE_PACKAGE_APP_SPLASH_SCREEN,
+ QUERY_CREATE_TABLE_PACKAGE_DEPENDENCY_INFO,
+ QUERY_CREATE_TABLE_PACKAGE_PLUGIN_INFO,
NULL,
};
NULL
};
-static int __initialize_db(sqlite3 *db, const char *dbpath, uid_t uid)
+static int __create_tables(sqlite3 *db, const char **queries)
{
int ret;
- const char **queries;
int i;
+ for (i = 0; queries[i] != NULL; i++) {
+ ret = sqlite3_exec(db, queries[i], NULL, NULL, NULL);
+ if (ret != SQLITE_OK) {
+ _LOGE("exec failed: %s", sqlite3_errmsg(db));
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int __initialize_db(sqlite3 *db, const char *dbpath, uid_t uid)
+{
+ const char **queries;
if (__set_db_version(db))
return -1;
return -1;
}
- for (i = 0; queries[i] != NULL; i++) {
- ret = sqlite3_exec(db, queries[i], NULL, NULL, NULL);
- if (ret != SQLITE_OK) {
- _LOGE("exec failed: %s", sqlite3_errmsg(db));
- return -1;
- }
- }
+ __BEGIN_TRANSACTION(db);
+ __DO_TRANSACTION(db, __create_tables(db, queries));
+ __END_TRANSACTION(db);
if (__set_db_permission(dbpath, uid))
_LOGE("failed to set db permission");
return 0;
}
+#define RESOURCED_BUS_NAME "org.tizen.resourced"
+#define RESOURCED_PROC_PATH "/Org/Tizen/ResourceD/Process"
+#define RESOURCED_PROC_INTERFACE "org.tizen.resourced.process"
+#define RESOURCED_PROC_METHOD "ProcExclude"
+static void __send_wakeup_signal_to_resourced(pid_t pid)
+{
+ GError *error = NULL;
+ GDBusConnection *conn;
+ GDBusProxy *proxy;
+ GVariant *reply;
+
+ conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+ if (conn == NULL) {
+ _LOGE("Failed to connect to dbus: %s", error->message);
+ g_error_free(error);
+ return;
+ }
+
+ proxy = g_dbus_proxy_new_sync(conn,
+ G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
+ NULL, RESOURCED_BUS_NAME,
+ RESOURCED_PROC_PATH, RESOURCED_PROC_INTERFACE,
+ NULL, &error);
+ if (proxy == NULL) {
+ _LOGE("failed to get proxy object: %s", error->message);
+ g_error_free(error);
+ g_object_unref(conn);
+ return;
+ }
+
+ reply = g_dbus_proxy_call_sync(proxy, RESOURCED_PROC_METHOD,
+ g_variant_new("(si)", "wakeup", pid),
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (reply == NULL)
+ _LOGE("failed to get reply from resourced");
+ if (error) {
+ _LOGE("failed to send request: %s", error->message);
+ g_error_free(error);
+ }
+
+ g_object_unref(proxy);
+ g_object_unref(conn);
+}
+
+static void __check_db_lock(const char *dbpath)
+{
+ FILE *fp;
+ FILE *fp_cmdline;
+ struct stat sb;
+ int pid;
+ unsigned int maj;
+ unsigned int min;
+ ino_t ino;
+ char cmdline[BUFSIZE];
+ char name[BUFSIZE];
+ size_t len;
+
+ if (stat(dbpath, &sb) == -1) {
+ _LOGE("get db file(%s) status failed: %d", dbpath, errno);
+ return;
+ }
+
+ fp = fopen("/proc/locks", "r");
+ if (fp == NULL) {
+ _LOGE("Failed to open lock info: %d", errno);
+ return;
+ }
+
+ while (fscanf(fp, "%*s %*s %*s %*s %d %x:%x:%lu %*s %*s",
+ &pid, &maj, &min, &ino) != EOF) {
+ if (maj != major(sb.st_dev) || min != minor(sb.st_dev) ||
+ ino != sb.st_ino || pid == getpid())
+ continue;
+
+ snprintf(cmdline, sizeof(cmdline), "/proc/%d/cmdline", pid);
+ fp_cmdline = fopen(cmdline, "r");
+ name[0] = '\0';
+ if (fp_cmdline != NULL) {
+ len = fread(name, sizeof(char), sizeof(name) - 1,
+ fp_cmdline);
+ if (len > 0) {
+ if (name[len - 1] == '\n')
+ name[len - 1] = '\0';
+ else
+ name[len] = '\0';
+ }
+ fclose(fp_cmdline);
+ }
+
+ _LOGE("%s (%d) has lock on pkgmgr db(%s)!", name, pid, dbpath);
+ __send_wakeup_signal_to_resourced(pid);
+ }
+
+ fclose(fp);
+}
+
+#define BUSY_WAITING_USEC (1000000 / 10 / 2) /* 0.05 sec */
+#define BUSY_WAITING_MAX 40 /* wait for max 2 sec */
+static int __db_busy_handler(void *data, int count)
+{
+ if (count < (BUSY_WAITING_MAX / 2)) {
+ usleep(BUSY_WAITING_USEC);
+ return 1;
+ } else if (count == (BUSY_WAITING_MAX / 2)) {
+ __check_db_lock((const char *)data);
+ usleep(BUSY_WAITING_USEC);
+ return 1;
+ } else if (count < BUSY_WAITING_MAX) {
+ usleep(BUSY_WAITING_USEC);
+ return 1;
+ } else {
+ /* sqlite3_prepare_v2 will return SQLITE_BUSY */
+ return 0;
+ }
+}
+
API int pkgmgr_parser_initialize_parser_db(uid_t uid)
{
int ret;
return PM_PARSER_R_ERROR;
}
+ ret = sqlite3_busy_handler(db, __db_busy_handler, NULL);
+ if (ret != SQLITE_OK) {
+ _LOGE("failed to register busy handler: %s",
+ sqlite3_errmsg(db));
+ sqlite3_close_v2(db);
+ return ret;
+ }
+
if (__initialize_db(db, dbpath, uid)) {
sqlite3_close_v2(db);
return PM_PARSER_R_ERROR;
return PM_PARSER_R_ERROR;
}
+ ret = sqlite3_busy_handler(db, __db_busy_handler, NULL);
+ if (ret != SQLITE_OK) {
+ _LOGE("failed to register busy handler: %s",
+ sqlite3_errmsg(db));
+ sqlite3_close_v2(db);
+ return ret;
+ }
+
if (__initialize_db(db, dbpath, GLOBAL_USER)) {
sqlite3_close_v2(db);
return PM_PARSER_R_ERROR;
if (pkgmgr_parser_initialize_parser_db(uid))
return PM_PARSER_R_ERROR;
- if (pkgmgr_parser_initialize_cert_db())
- return PM_PARSER_R_ERROR;
+ if (uid == OWNER_ROOT || uid == GLOBAL_USER)
+ if (pkgmgr_parser_initialize_cert_db())
+ return PM_PARSER_R_ERROR;
return PM_PARSER_R_OK;
}
-#define BUSY_WAITING_USEC (1000000 / 10 / 2) /* 0.05 sec */
-#define BUSY_WAITING_MAX 20 /* wait for max 1 sec */
-static int __db_busy_handler(void *data, int count)
-{
- if (count < BUSY_WAITING_MAX) {
- usleep(BUSY_WAITING_USEC);
- return 1;
- } else {
- /* sqlite3_prepare_v2 will return SQLITE_BUSY */
- return 0;
- }
-}
-
static int __open_db(uid_t uid, const char *path, sqlite3 **db, int flags)
{
int ret;
if (ret != SQLITE_OK)
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\n");
+ _LOGE("failed to initialize db: %s", path);
sqlite3_close_v2(*db);
return -1;
}
return ret;
}
- ret = sqlite3_busy_handler(*db, __db_busy_handler, NULL);
- if (ret != SQLITE_OK) {
- _LOGE("failed to register busy handler: %s",
- sqlite3_errmsg(*db));
- sqlite3_close_v2(*db);
- return ret;
- }
-
return ret;
}
return NULL;
}
+static int __insert_appcontrol_privilege_info(sqlite3 *db, const char *appid,
+ appcontrol_x *ac)
+{
+ static const char query[] =
+ "INSERT INTO package_app_app_control_privilege (app_id,"
+ " app_control, privilege) VALUES (?, ?, ?)";
+ int ret;
+ sqlite3_stmt *stmt;
+ int idx;
+ char app_control[BUFSIZE];
+ GList *tmp;
+ char *privilege;
+
+ if (ac == NULL)
+ 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;
+ }
+
+ for (tmp = ac->privileges; tmp; tmp = tmp->next) {
+ privilege = (char *)tmp->data;
+ if (privilege == NULL || !strlen(privilege))
+ continue;
+
+ idx = 1;
+ snprintf(app_control, sizeof(app_control), "%s|%s|%s",
+ ac->operation ? (strlen(ac->operation) > 0 ?
+ ac->operation : "NULL") : "NULL",
+ ac->uri ? (strlen(ac->uri) > 0 ?
+ ac->uri : "NULL") : "NULL",
+ ac->mime ? (strlen(ac->mime) > 0 ?
+ ac->mime : "NULL") : "NULL");
+ __BIND_TEXT(db, stmt, idx++, appid);
+ __BIND_TEXT(db, stmt, idx++, app_control);
+ __BIND_TEXT(db, stmt, idx++, privilege);
+
+ ret = sqlite3_step(stmt);
+ if (ret != SQLITE_DONE) {
+ _LOGE("step failed: %s", sqlite3_errmsg(db));
+ sqlite3_finalize(stmt);
+ return -1;
+ }
+
+ sqlite3_reset(stmt);
+ }
+
+ sqlite3_finalize(stmt);
+
+ return 0;
+}
+
static int __insert_appcontrol_info(sqlite3 *db, application_x *app)
{
static const char query[] =
- "INSERT INTO package_app_app_control (app_id, app_control) "
- "VALUES (?, ?)";
+ "INSERT INTO package_app_app_control (app_id, app_control,"
+ " visibility, app_control_id) "
+ "VALUES (?, ?, ?, ?)";
int ret;
sqlite3_stmt *stmt;
int idx;
ac->mime : "NULL") : "NULL");
__BIND_TEXT(db, stmt, idx++, app->appid);
__BIND_TEXT(db, stmt, idx++, app_control);
+ __BIND_TEXT(db, stmt, idx++, ac->visibility);
+ __BIND_TEXT(db, stmt, idx++, ac->id);
ret = sqlite3_step(stmt);
if (ret != SQLITE_DONE) {
return -1;
}
+ if (__insert_appcontrol_privilege_info(db, app->appid, ac)) {
+ sqlite3_finalize(stmt);
+ return -1;
+ }
+
sqlite3_reset(stmt);
}
return 0;
}
+static int __insert_app_data_control_privilege_info(sqlite3 *db,
+ datacontrol_x *datacontrol)
+{
+ static const char query[] =
+ "INSERT INTO package_app_data_control_privilege (providerid,"
+ " privilege, type) VALUES (?, ?, ?)";
+
+ int ret;
+ sqlite3_stmt *stmt;
+ int idx;
+ GList *privileges;
+ char *priv;
+
+ if (datacontrol == NULL)
+ 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;
+ }
+
+ for (privileges = datacontrol->privileges; privileges;
+ privileges = privileges->next) {
+ priv = (char *)privileges->data;
+ if (priv == NULL)
+ continue;
+
+ idx = 1;
+ __BIND_TEXT(db, stmt, idx++, datacontrol->providerid);
+ __BIND_TEXT(db, stmt, idx++, priv);
+ __BIND_TEXT(db, stmt, idx++, datacontrol->type);
+
+ ret = sqlite3_step(stmt);
+ if (ret != SQLITE_DONE) {
+ _LOGE("step failed: %s", sqlite3_errmsg(db));
+ sqlite3_finalize(stmt);
+ return -1;
+ }
+
+ sqlite3_reset(stmt);
+ }
+
+ sqlite3_finalize(stmt);
+ return 0;
+}
+
static int __insert_datacontrol_info(sqlite3 *db, application_x *app)
{
static const char query[] =
return -1;
}
+ if (dc->privileges &&
+ __insert_app_data_control_privilege_info(db, dc)) {
+ sqlite3_finalize(stmt);
+ return -1;
+ }
+
sqlite3_reset(stmt);
}
GList *list = NULL;
splashscreen_x *ss;
+ if (splashscreens == NULL)
+ return NULL;
+
g_list_foreach(splashscreens,
__find_appcontrol_splashscreen_with_dpi, &list);
g_list_foreach(splashscreens,
return list;
}
-static int __insert_splashscreen_info(sqlite3 *db, application_x *app)
+static int __insert_splashscreen_info(sqlite3 *db, application_x *app,
+ GList *ss_list)
{
static const char query[] =
"INSERT INTO package_app_splash_screen (app_id, src, type,"
int idx;
GList *tmp;
splashscreen_x *ss;
- GList *ss_list;
if (app->splashscreens == NULL)
return 0;
- ss_list = __find_splashscreens(app->splashscreens);
if (ss_list == NULL)
return 0;
sqlite3_reset(stmt);
- if (strcasecmp(app->mainapp, "true")) {
+ if (strcasecmp(app->mainapp, "true") == 0) {
if (__insert_mainapp_localized_info(db, app, locale,
label, icon))
_LOGE("insert mainapp localized info failed");
return 0;
}
+static int __insert_package_plugin_execution_info(sqlite3 *db,
+ manifest_x *mfx)
+{
+ static const char query[] =
+ "INSERT INTO package_plugin_info "
+ "(pkgid, appid, plugin_type, plugin_name) "
+ "VALUES (?, ?, ?, ?)";
+ int ret;
+ sqlite3_stmt *stmt;
+ int idx;
+ 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;
+ }
+
+ 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;
+ }
+ sqlite3_reset(stmt);
+ }
+
+ sqlite3_finalize(stmt);
+
+ return 0;
+}
+
+static int __delete_package_plugin_execution_info(sqlite3 *db,
+ const char *pkgid)
+{
+ 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);
+
+ 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;
+}
+
+static int __insert_package_appdefined_privilege_info(sqlite3 *db,
+ manifest_x *mfx)
+{
+ static const char query[] =
+ "INSERT INTO package_appdefined_privilege_info "
+ "(package, privilege, license, type) "
+ "VALUES (?, ?, ?, ?)";
+ int ret;
+ sqlite3_stmt *stmt;
+ int idx;
+ GList *tmp;
+ appdefined_privilege_x *priv;
+
+ ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
+ if (ret != SQLITE_OK) {
+ _LOGE("prepare failed: %s", sqlite3_errmsg(db));
+ return -1;
+ }
+
+ for (tmp = mfx->appdefined_privileges; tmp; tmp = tmp->next) {
+ priv = (appdefined_privilege_x *)tmp->data;
+ if (priv == NULL)
+ continue;
+
+ idx = 1;
+ __BIND_TEXT(db, stmt, idx++, mfx->package);
+ __BIND_TEXT(db, stmt, idx++, priv->value);
+ __BIND_TEXT(db, stmt, idx++, priv->license);
+ __BIND_TEXT(db, stmt, idx++, priv->type);
+
+ ret = sqlite3_step(stmt);
+ if (ret != SQLITE_DONE) {
+ _LOGE("step failed: %s", sqlite3_errmsg(db));
+ sqlite3_finalize(stmt);
+ return -1;
+ }
+ sqlite3_reset(stmt);
+ }
+
+ sqlite3_finalize(stmt);
+
+ return 0;
+}
+
+static int __insert_package_dependency_info(sqlite3 *db, manifest_x *mfx)
+{
+ static const char query[] =
+ "INSERT INTO package_dependency_info"
+ " (package, depends_on, type, required_version) "
+ "VALUES (?, ?, ?, ?)";
+ int ret;
+ sqlite3_stmt *stmt;
+ int idx;
+ GList *tmp;
+ dependency_x *dep;
+
+ ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
+ if (ret != SQLITE_OK) {
+ _LOGE("prepare failed: %s", sqlite3_errmsg(db));
+ return -1;
+ }
+
+ for (tmp = mfx->dependencies; tmp; tmp = tmp->next) {
+ dep = (dependency_x *)tmp->data;
+ if (dep == NULL)
+ continue;
+
+ idx = 1;
+ __BIND_TEXT(db, stmt, idx++, mfx->package);
+ __BIND_TEXT(db, stmt, idx++, dep->depends_on);
+ __BIND_TEXT(db, stmt, idx++, dep->type);
+ __BIND_TEXT(db, stmt, idx++, dep->required_version);
+
+ ret = sqlite3_step(stmt);
+ if (ret != SQLITE_DONE) {
+ _LOGE("step failed: %s", sqlite3_errmsg(db));
+ sqlite3_finalize(stmt);
+ return -1;
+ }
+ sqlite3_reset(stmt);
+ }
+
+ sqlite3_finalize(stmt);
+
+ return 0;
+}
+
/* _PRODUCT_LAUNCHING_ENHANCED_
* app->indicatordisplay, app->portraitimg, app->landscapeimg,
* app->guestmode_appstatus
" app_effective_appid, app_splash_screen_display,"
" app_package_system, app_removable,"
" app_package_installed_time, app_support_ambient,"
- " app_setup_appid) "
+ " app_external_path, app_setup_appid) "
"VALUES (?, ?, "
" ?, LOWER(?), ?, LOWER(?), LOWER(?),"
" LOWER(?), LOWER(?), ?,"
" ?, LOWER(?),"
" ?, LOWER(?), LOWER(?),"
" ?, ?, LOWER(?),"
- " ?, LOWER(?), ?,"
+ " COALESCE(?, 'single'), LOWER(?), ?,"
" LOWER(?), ?, ?, ?,"
" ?, ?,"
" ?, ?, ?,"
" ?, LOWER(?),"
" LOWER(?), LOWER(?),"
" ?, LOWER(?),"
- " ?)";
+ " ?, ?)";
int ret;
sqlite3_stmt *stmt;
int idx;
application_x *app;
int bg_category;
const char *effective_appid;
+ GList *ss_list;
ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
if (ret != SQLITE_OK) {
__BIND_TEXT(db, stmt, idx++, mfx->api_version);
__BIND_TEXT(db, stmt, idx++, effective_appid);
__BIND_TEXT(db, stmt, idx++,
- __get_bool(app->splash_screen_display, false));
+ __get_bool(app->splash_screen_display, true));
__BIND_TEXT(db, stmt, idx++, __get_bool(mfx->system, false));
__BIND_TEXT(db, stmt, idx++, __get_bool(mfx->removable, false));
__BIND_TEXT(db, stmt, idx++, mfx->installed_time);
__BIND_TEXT(db, stmt, idx++,
__get_bool(app->support_ambient, false));
+ __BIND_TEXT(db, stmt, idx++, mfx->external_path);
__BIND_TEXT(db, stmt, idx++, app->setup_appid);
ret = sqlite3_step(stmt);
sqlite3_finalize(stmt);
return -1;
}
- if (__insert_splashscreen_info(db, app)) {
+ ss_list = __find_splashscreens(app->splashscreens);
+ if (__insert_splashscreen_info(db, app, ss_list)) {
+ g_list_free(ss_list);
sqlite3_finalize(stmt);
return -1;
}
+ g_list_free(ss_list);
if (__insert_app_localized_info(db, app)) {
sqlite3_finalize(stmt);
return -1;
return 0;
}
+static int __insert_package_update_info(sqlite3 *db, manifest_x *mfx)
+{
+ static const char query[] =
+ "INSERT INTO package_update_info (package, update_version) "
+ "VALUES (?, ?)";
+ int ret;
+ int idx;
+ 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;
+ }
+
+ idx = 1;
+ __BIND_TEXT(db, stmt, idx++, mfx->package);
+ __BIND_TEXT(db, stmt, idx, mfx->version);
+ 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;
+}
+
static int __insert_package_localized_info(sqlite3 *db, manifest_x *mfx)
{
static const char query[] =
sqlite3_finalize(stmt);
+ if (__insert_package_update_info(db, mfx))
+ return -1;
if (__insert_package_localized_info(db, mfx))
return -1;
if (__insert_application_info(db, mfx))
return -1;
if (__insert_package_privilege_info(db, mfx))
return -1;
+ if (__insert_package_appdefined_privilege_info(db, mfx))
+ return -1;
+ if (__insert_package_dependency_info(db, mfx))
+ return -1;
return 0;
}
return PM_PARSER_R_EINVAL;
}
- dbpath = __get_parser_db_path(uid);
+ dbpath = __get_parser_db_path(GLOBAL_USER);
- ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
+ ret = __open_db(GLOBAL_USER, dbpath, &db, SQLITE_OPEN_READWRITE);
if (ret != SQLITE_OK) {
_LOGE("open db failed: %d", ret);
return PM_PARSER_R_ERROR;
return PM_PARSER_R_EINVAL;
}
- dbpath = __get_parser_db_path(uid);
+ dbpath = __get_parser_db_path(GLOBAL_USER);
- ret = __open_db(uid, dbpath, &db, SQLITE_OPEN_READWRITE);
+ ret = __open_db(GLOBAL_USER, dbpath, &db, SQLITE_OPEN_READWRITE);
if (ret != SQLITE_OK) {
_LOGE("open db failed: %d", ret);
return PM_PARSER_R_ERROR;
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);
+
+ 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_app_icon(db, appid, icon_path));
+ __END_TRANSACTION(db);
+
+ sqlite3_close_v2(db);
+
+ return PM_PARSER_R_OK;
+}
+
+API int pkgmgr_parser_update_app_icon_info_in_db(const char *appid,
+ const char *icon_path)
+{
+ return pkgmgr_parser_update_app_icon_info_in_usr_db(appid, __getuid(),
+ icon_path);
+}
+
static int __set_tep_path(sqlite3 *db, const char *pkgid, const char *tep_path)
{
static const char query[] =
return pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(
__getuid());
}
+
+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;
+}
+
+API int pkgmgr_parser_register_pkg_plugin_info_in_db(manifest_x *mfx)
+{
+ return pkgmgr_parser_register_pkg_plugin_info_in_usr_db(mfx, __getuid());
+}
+
+API int pkgmgr_parser_update_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, __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);
+
+ return PM_PARSER_R_OK;
+}
+
+API int pkgmgr_parser_update_pkg_plugin_info_in_db(manifest_x *mfx)
+{
+ return pkgmgr_parser_update_pkg_plugin_info_in_usr_db(mfx, __getuid());
+}
+
+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;
+}
+
+API int pkgmgr_parser_unregister_pkg_plugin_info_in_db(const char *pkgid)
+{
+ return pkgmgr_parser_unregister_pkg_plugin_info_in_usr_db(pkgid, __getuid());
+}
\ No newline at end of file
projects / platform / core / appfw / pkgmgr-info.git / blobdiff