path: root/src/badge_db.c

/*
 * Copyright (c) 2000 - 2017 Samsung Electronics Co., Ltd. All rights reserved.
 *
 * 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.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <sqlite3.h>
#include <db-util.h>

#include "badge.h"
#include "badge_db.h"
#include "badge_log.h"
#include "badge_error.h"
#include "badge_internal.h"

#define CREATE_BADGE_TABLE " \
PRAGMA journal_mode = PERSIST; \
PRAGMA synchronous = FULL; \
CREATE TABLE IF NOT EXISTS badge_data ( \
	uid INTEGER, \
	pkgname TEXT NOT NULL, \
	writable_pkgs TEXT, \
	badge INTEGER DEFAULT 0, \
	rowid INTEGER PRIMARY KEY AUTOINCREMENT, \
	UNIQUE (uid, pkgname) \
); \
CREATE TABLE IF NOT EXISTS badge_option ( \
	uid INTEGER, \
	pkgname TEXT NOT NULL, \
	display INTEGER DEFAULT 1, \
	UNIQUE (uid, pkgname) \
); \
CREATE TABLE IF NOT EXISTS badge_setting ( \
	uid INTEGER, \
	pkgname TEXT NOT NULL, \
	appid TEXT NOT NULL, \
	allow_to_display INTEGER DEFAULT 1, \
	UNIQUE (uid, pkgname, appid) \
); "

static bool is_db_corrupted = false;

static int __check_integrity_cb(void *pid, int argc, char **argv, char **notUsed)
{
	if (strcmp(argv[0], "ok") != 0) {
		ERR("db integrity result : %s" , argv[0]);
		is_db_corrupted = true;
		return -1;
	}

	INFO("db integrity result : %s" , argv[0]);
	return 0;
}

static int __recover_corrupted_db(sqlite3 *db)
{
	int ret = BADGE_ERROR_NONE;
	int sql_ret;
	char *errmsg = NULL;

	INFO("DB is corrupted, start to recover corrupted db");
	if (db)
		sqlite3_close(db);
	unlink(BADGE_DB_PATH);

	sql_ret = sqlite3_open_v2(BADGE_DB_PATH, &db,
				  SQLITE_OPEN_CREATE |SQLITE_OPEN_READWRITE,
				  NULL);
	if (sql_ret != SQLITE_OK) {
		ERR("Failed to open badge db[%d]", sql_ret);
		unlink(BADGE_DB_PATH);
		ret = BADGE_ERROR_FROM_DB;
		goto out;
	}

	sql_ret = sqlite3_exec(db, CREATE_BADGE_TABLE, NULL, NULL, &errmsg);
	if (sql_ret != SQLITE_OK) {
		ERR("Failed to exec query[%d][%s]", sql_ret, errmsg);
		ret = BADGE_ERROR_FROM_DB;
	}

out:
	if (errmsg)
		sqlite3_free(errmsg);

	return ret;
}

EXPORT_API
int badge_db_init()
{
	int ret = BADGE_ERROR_NONE;
	int sql_ret;
	sqlite3 *db = NULL;
	char *errmsg = NULL;

	sql_ret = sqlite3_open_v2(BADGE_DB_PATH, &db,
			SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL);
	if (sql_ret != SQLITE_OK) {
		ERR("Failed to open badge db[%d]", sql_ret);
		ret = BADGE_ERROR_FROM_DB;
		goto out;
	}

	sql_ret = sqlite3_exec(db, CREATE_BADGE_TABLE, NULL, NULL, &errmsg);
	if (sql_ret != SQLITE_OK) {
		ERR("Failed to exec query[%d][%s]", sql_ret, errmsg);
		ret = BADGE_ERROR_FROM_DB;
		goto out;
	}

	sql_ret = sqlite3_exec(db, "PRAGMA integrity_check",
				__check_integrity_cb, NULL, &errmsg);
	if (sql_ret != SQLITE_OK || is_db_corrupted) {
		ERR("Failed to exec query[%d][%s]", sql_ret, errmsg);
		ret = BADGE_ERROR_FROM_DB;
	}

out:
	if (sql_ret == SQLITE_CORRUPT || sql_ret == SQLITE_NOTADB || is_db_corrupted)
		ret = __recover_corrupted_db(db);
	if (errmsg)
		sqlite3_free(errmsg);
	if (db)
		db_util_close(db);

	return ret;
}

EXPORT_API
int badge_db_is_existing(const char *pkgname, bool *existing, uid_t uid)
{
	return _badge_is_existing(pkgname, existing, uid);
}

EXPORT_API
int badge_db_get_list(GList **badge_list, uid_t uid)
{
	return _badge_get_list(badge_list, uid);
}

EXPORT_API
int badge_db_insert(const char *pkgname, const char *writable_pkg, const char *caller, uid_t uid)
{
	int err = BADGE_ERROR_NONE;
	badge_h *badge = NULL;
	char *pkgs = NULL;

	if (!pkgname) {
		ERR("package name is NULL");
		return BADGE_ERROR_INVALID_PARAMETER;
	}

	pkgs = _badge_pkgs_new(&err, writable_pkg, caller, NULL);
	if (!pkgs) {
		ERR("Failed to _badge_pkgs_new [%d]", err);
		return err;
	}

	INFO("pkgs : %s", pkgs);

	badge = _badge_new(pkgname, pkgs, &err);
	if (!badge) {
		ERR("Failed to _badge_new [%d]", err);
		free(pkgs);
		return err;
	}
	free(pkgs);

	err = _badge_insert(badge, uid);
	if (err != BADGE_ERROR_NONE) {
		ERR("Failed to _badge_insert [%d]", err);
		_badge_free(badge);
		return err;
	}

	_badge_free(badge);

	return BADGE_ERROR_NONE;
}

EXPORT_API
int badge_db_delete(const char *pkgname, const char *caller, uid_t uid, pid_t pid)
{
	return _badge_remove(caller, pkgname, uid, pid);
}

EXPORT_API
int badge_db_delete_by_pkgname(const char *pkgname, uid_t uid)
{
	return _badge_remove_by_pkgname(pkgname, uid);
}

EXPORT_API
int badge_db_set_count(const char *pkgname, const char *caller, unsigned int count, uid_t uid, pid_t pid)
{
	return _badge_set_count(caller, pkgname, count, uid, pid);
}

EXPORT_API
int badge_db_get_count(const char *pkgname, unsigned int *count, uid_t uid)
{
	return _badge_get_count(pkgname, count, uid);
}

EXPORT_API
int badge_db_set_display_option(const char *pkgname, unsigned int is_display, uid_t uid)
{
	return _badge_set_display(pkgname, is_display, uid);
}

EXPORT_API
int badge_db_get_display_option(const char *pkgname, unsigned int *is_display, uid_t uid)
{
	return _badge_get_display(pkgname, is_display, uid);
}

EXPORT_API
int badge_db_exec(sqlite3 *db, const char *query, int *num_changes)
{
	int ret;
	sqlite3_stmt *stmt = NULL;

	if (db == NULL || query == NULL)
		return BADGE_ERROR_INVALID_PARAMETER;

	ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
	if (ret != SQLITE_OK) {
		ERR("sqlite3_prepare_v2 failed [%d][%s]", ret,
					sqlite3_errmsg(db));
		return BADGE_ERROR_FROM_DB;
	}

	if (stmt != NULL) {
		ret = sqlite3_step(stmt);
		if (ret == SQLITE_OK || ret == SQLITE_DONE) {
			if (num_changes != NULL)
				*num_changes = sqlite3_changes(db);

			sqlite3_finalize(stmt);
		} else {
			ERR("sqlite3_step failed [%d][%s]", ret,
					sqlite3_errmsg(db));
			sqlite3_finalize(stmt);
			return BADGE_ERROR_FROM_DB;
		}
	} else {
			return BADGE_ERROR_FROM_DB;
	}

	return BADGE_ERROR_NONE;
}