src/badge_db.c

   1 /*
   2  * Copyright (c) 2000 - 2017 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <stdarg.h>
  21 #include <sqlite3.h>
  22 #include <db-util.h>
  23
  24 #include "badge.h"
  25 #include "badge_db.h"
  26 #include "badge_log.h"
  27 #include "badge_error.h"
  28 #include "badge_internal.h"
  29
  30 #define CREATE_BADGE_TABLE " \
  31 PRAGMA journal_mode = PERSIST; \
  32 PRAGMA synchronous = FULL; \
  33 CREATE TABLE IF NOT EXISTS badge_data ( \
  34         uid INTEGER, \
  35         pkgname TEXT NOT NULL, \
  36         writable_pkgs TEXT, \
  37         badge INTEGER DEFAULT 0, \
  38         rowid INTEGER PRIMARY KEY AUTOINCREMENT, \
  39         UNIQUE (uid, pkgname) \
  40 ); \
  41 CREATE TABLE IF NOT EXISTS badge_option ( \
  42         uid INTEGER, \
  43         pkgname TEXT NOT NULL, \
  44         display INTEGER DEFAULT 1, \
  45         UNIQUE (uid, pkgname) \
  46 ); \
  47 CREATE TABLE IF NOT EXISTS badge_setting ( \
  48         uid INTEGER, \
  49         pkgname TEXT NOT NULL, \
  50         appid TEXT NOT NULL, \
  51         allow_to_display INTEGER DEFAULT 1, \
  52         UNIQUE (uid, pkgname, appid) \
  53 ); "
  54
  55 EXPORT_API
  56 int badge_db_init()
  57 {
  58         int ret = BADGE_ERROR_NONE;
  59         int sql_ret;
  60         sqlite3 *db = NULL;
  61         char *errmsg = NULL;
  62
  63         sql_ret = sqlite3_open_v2(BADGE_DB_PATH, &db,
  64                         SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL);
  65         if (sql_ret != SQLITE_OK) {
  66                 ERR("Failed to open badge db[%d]", sql_ret);
  67
  68                 if (sqlite3_errcode(db) == SQLITE_CORRUPT) {
  69                         if (db)
  70                                 sqlite3_close(db);
  71                         unlink(BADGE_DB_PATH);
  72
  73                         sql_ret = sqlite3_open_v2(BADGE_DB_PATH, &db,
  74                                 SQLITE_OPEN_CREATE |SQLITE_OPEN_READWRITE,
  75                                 NULL);
  76                         if (sql_ret != SQLITE_OK) {
  77                                 ERR("Failed to open badge db[%d]", sql_ret);
  78                                 unlink(BADGE_DB_PATH);
  79                                 ret = BADGE_ERROR_FROM_DB;
  80                                 goto out;
  81                         }
  82                 } else {
  83                         ret = BADGE_ERROR_FROM_DB;
  84                         goto out;
  85                 }
  86         }
  87
  88         sql_ret = sqlite3_exec(db, CREATE_BADGE_TABLE, NULL, NULL, &errmsg);
  89         if (sql_ret != SQLITE_OK) {
  90                 ERR("Failed to exec query[%d][%s]", sql_ret, errmsg);
  91
  92                 if (sql_ret == SQLITE_CORRUPT || sql_ret == SQLITE_NOTADB) {
  93                         sqlite3_close(db);
  94                         unlink(BADGE_DB_PATH);
  95
  96                         sql_ret = sqlite3_open_v2(BADGE_DB_PATH, &db,
  97                                         SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE,
  98                                         NULL);
  99                         if (sql_ret != SQLITE_OK) {
 100                                 ERR("Failed to open db[%d]", sql_ret);
 101                                 unlink(BADGE_DB_PATH);
 102                                 ret = BADGE_ERROR_FROM_DB;
 103                                 goto out;
 104                         }
 105
 106                         sqlite3_free(errmsg);
 107                         sql_ret = sqlite3_exec(db, CREATE_BADGE_TABLE, NULL,
 108                                                 NULL, &errmsg);
 109                         if (sql_ret != SQLITE_OK) {
 110                                 ERR("Failed to exec sqlite, again[%d][%s]",
 111                                         sql_ret, errmsg);
 112                                 unlink(BADGE_DB_PATH);
 113                                 ret = BADGE_ERROR_FROM_DB;
 114                                 goto out;
 115                         }
 116                 } else {
 117                         ret = BADGE_ERROR_FROM_DB;
 118                         goto out;
 119                 }
 120         }
 121
 122 out:
 123         if (errmsg)
 124                 sqlite3_free(errmsg);
 125
 126         if (db)
 127                 db_util_close(db);
 128
 129         return ret;
 130 }
 131
 132 EXPORT_API
 133 int badge_db_is_existing(const char *pkgname, bool *existing, uid_t uid)
 134 {
 135         return _badge_is_existing(pkgname, existing, uid);
 136 }
 137
 138 EXPORT_API
 139 int badge_db_get_list(GList **badge_list, uid_t uid)
 140 {
 141         return _badge_get_list(badge_list, uid);
 142 }
 143
 144 EXPORT_API
 145 int badge_db_insert(const char *pkgname, const char *writable_pkg, const char *caller, uid_t uid)
 146 {
 147         int err = BADGE_ERROR_NONE;
 148         badge_h *badge = NULL;
 149         char *pkgs = NULL;
 150
 151         if (!pkgname) {
 152                 ERR("package name is NULL");
 153                 return BADGE_ERROR_INVALID_PARAMETER;
 154         }
 155
 156         pkgs = _badge_pkgs_new(&err, writable_pkg, caller, NULL);
 157         if (!pkgs) {
 158                 ERR("Failed to _badge_pkgs_new [%d]", err);
 159                 return err;
 160         }
 161
 162         INFO("pkgs : %s", pkgs);
 163
 164         badge = _badge_new(pkgname, pkgs, &err);
 165         if (!badge) {
 166                 ERR("Failed to _badge_new [%d]", err);
 167                 free(pkgs);
 168                 return err;
 169         }
 170         free(pkgs);
 171
 172         err = _badge_insert(badge, uid);
 173         if (err != BADGE_ERROR_NONE) {
 174                 ERR("Failed to _badge_insert [%d]", err);
 175                 _badge_free(badge);
 176                 return err;
 177         }
 178
 179         _badge_free(badge);
 180
 181         return BADGE_ERROR_NONE;
 182 }
 183
 184 EXPORT_API
 185 int badge_db_delete(const char *pkgname, const char *caller, uid_t uid, pid_t pid)
 186 {
 187         return _badge_remove(caller, pkgname, uid, pid);
 188 }
 189
 190 EXPORT_API
 191 int badge_db_delete_by_pkgname(const char *pkgname, uid_t uid)
 192 {
 193         return _badge_remove_by_pkgname(pkgname, uid);
 194 }
 195
 196 EXPORT_API
 197 int badge_db_set_count(const char *pkgname, const char *caller, unsigned int count, uid_t uid, pid_t pid)
 198 {
 199         return _badge_set_count(caller, pkgname, count, uid, pid);
 200 }
 201
 202 EXPORT_API
 203 int badge_db_get_count(const char *pkgname, unsigned int *count, uid_t uid)
 204 {
 205         return _badge_get_count(pkgname, count, uid);
 206 }
 207
 208 EXPORT_API
 209 int badge_db_set_display_option(const char *pkgname, unsigned int is_display, uid_t uid)
 210 {
 211         return _badge_set_display(pkgname, is_display, uid);
 212 }
 213
 214 EXPORT_API
 215 int badge_db_get_display_option(const char *pkgname, unsigned int *is_display, uid_t uid)
 216 {
 217         return _badge_get_display(pkgname, is_display, uid);
 218 }
 219
 220 EXPORT_API
 221 int badge_db_exec(sqlite3 *db, const char *query, int *num_changes)
 222 {
 223         int ret;
 224         sqlite3_stmt *stmt = NULL;
 225
 226         if (db == NULL || query == NULL)
 227                 return BADGE_ERROR_INVALID_PARAMETER;
 228
 229         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 230         if (ret != SQLITE_OK) {
 231                 ERR("sqlite3_prepare_v2 failed [%d][%s]", ret,
 232                                         sqlite3_errmsg(db));
 233                 return BADGE_ERROR_FROM_DB;
 234         }
 235
 236         if (stmt != NULL) {
 237                 ret = sqlite3_step(stmt);
 238                 if (ret == SQLITE_OK || ret == SQLITE_DONE) {
 239                         if (num_changes != NULL)
 240                                 *num_changes = sqlite3_changes(db);
 241
 242                         sqlite3_finalize(stmt);
 243                 } else {
 244                         ERR("sqlite3_step failed [%d][%s]", ret,
 245                                         sqlite3_errmsg(db));
 246                         sqlite3_finalize(stmt);
 247                         return BADGE_ERROR_FROM_DB;
 248                 }
 249         } else {
 250                         return BADGE_ERROR_FROM_DB;
 251         }
 252
 253         return BADGE_ERROR_NONE;
 254 }