src/rua_internal.c

   1 /*
   2  * Copyright (c) 2016 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 #include <stdio.h>
  18 #include <sys/types.h>
  19 #include <unistd.h>
  20
  21 #include <aul.h>
  22 #include <dlog.h>
  23 #include <sqlite3.h>
  24
  25 #include "rua_internal.h"
  26 #include "db-schema.h"
  27 #include "rua_util.h"
  28 #include "rua_dbus.h"
  29 #include "rua_private.h"
  30
  31 static int __exec(sqlite3 *db, char *query)
  32 {
  33         int r;
  34         char *errmsg = NULL;
  35
  36         if (db == NULL)
  37                 return -1;
  38
  39         r = sqlite3_exec(db, query, NULL, NULL, &errmsg);
  40
  41         if (r != SQLITE_OK) {
  42                 sqlite3_free(errmsg);
  43                 return -1;
  44         }
  45
  46         return 0;
  47 }
  48
  49 static int __create_table(sqlite3 *db)
  50 {
  51         int r;
  52
  53         r = __exec(db, CREATE_RUA_HISTORY_TABLE);
  54         if (r == -1)
  55                 return -1;
  56
  57         return 0;
  58 }
  59
  60 static sqlite3 *__db_init(uid_t uid)
  61 {
  62         int r;
  63         sqlite3 *db = NULL;
  64
  65         r = _rua_util_open_db(&db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE,
  66                         uid, RUA_DB_NAME);
  67         if (r != SQLITE_OK)
  68                 return NULL;
  69
  70         r = __create_table(db);
  71         if (r) {
  72                 sqlite3_close_v2(db);
  73                 return NULL;
  74         }
  75
  76         return db;
  77 }
  78
  79 static int __delete_history_with_pkg_name(sqlite3 *db, const char *pkg_name,
  80                 const char *instance_id)
  81 {
  82         static const char query[] =
  83                 "DELETE FROM rua_history WHERE pkg_name=? AND instance_id=?";
  84         sqlite3_stmt *stmt;
  85         int r;
  86         int idx = 1;
  87
  88         r = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
  89         if (r != SQLITE_OK) {
  90                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
  91                 return -1;
  92         }
  93
  94         __BIND_TEXT(db, stmt, idx++, pkg_name);
  95         __BIND_TEXT(db, stmt, idx++, instance_id ? instance_id : "");
  96
  97         r = sqlite3_step(stmt);
  98         if (r != SQLITE_DONE) {
  99                 LOGE("step failed: %s", sqlite3_errmsg(db));
 100                 sqlite3_finalize(stmt);
 101                 return -1;
 102         }
 103
 104         sqlite3_finalize(stmt);
 105
 106         return 0;
 107 }
 108
 109 static int __delete_history_with_app_path(sqlite3 *db, const char *app_path,
 110                 const char *instance_id)
 111 {
 112         static const char query[] =
 113                 "DELETE FROM rua_history WHERE app_path=? AND instance_id=?";
 114         sqlite3_stmt *stmt;
 115         int r;
 116         int idx = 1;
 117
 118         r = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 119         if (r != SQLITE_OK) {
 120                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 121                 return -1;
 122         }
 123
 124         __BIND_TEXT(db, stmt, idx++, app_path);
 125         __BIND_TEXT(db, stmt, idx++, instance_id ? instance_id : "");
 126
 127         r = sqlite3_step(stmt);
 128         if (r != SQLITE_DONE) {
 129                 LOGE("step failed: %s", sqlite3_errmsg(db));
 130                 sqlite3_finalize(stmt);
 131                 return -1;
 132         }
 133
 134         sqlite3_finalize(stmt);
 135
 136         return 0;
 137 }
 138
 139 static int __clear_history(sqlite3 *db)
 140 {
 141         static const char query[] = "DELETE FROM rua_history";
 142         sqlite3_stmt *stmt;
 143         int r;
 144
 145         r = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 146         if (r != SQLITE_OK) {
 147                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 148                 return -1;
 149         }
 150
 151         r = sqlite3_step(stmt);
 152         if (r != SQLITE_DONE) {
 153                 LOGE("step failed: %s", sqlite3_errmsg(db));
 154                 sqlite3_finalize(stmt);
 155                 return -1;
 156         }
 157
 158         sqlite3_finalize(stmt);
 159
 160         return 0;
 161 }
 162
 163 API int rua_usr_db_delete_history(bundle *b, uid_t uid)
 164 {
 165         int r;
 166         sqlite3 *db;
 167         char *pkg_name = NULL;
 168         char *app_path = NULL;
 169         char *instance_id = NULL;
 170
 171         db = __db_init(uid);
 172         if (db == NULL) {
 173                 LOGE("Error db null");
 174                 return -1;
 175         }
 176
 177         if (b != NULL) {
 178                 bundle_get_str(b, AUL_K_RUA_PKGNAME, &pkg_name);
 179                 bundle_get_str(b, AUL_K_RUA_APPPATH, &app_path);
 180                 bundle_get_str(b, AUL_K_RUA_INSTANCE_ID, &instance_id);
 181         }
 182
 183         if (pkg_name) {
 184                 LOGI("rua_delete_history_from_db : %s", pkg_name);
 185                 r = __delete_history_with_pkg_name(db, pkg_name, instance_id);
 186         } else if (app_path) {
 187                 LOGI("rua_delete_history_from_db : %s", app_path);
 188                 r = __delete_history_with_app_path(db, app_path, instance_id);
 189         } else {
 190                 LOGI("rua clear history");
 191                 r = __clear_history(db);
 192         }
 193
 194         sqlite3_close_v2(db);
 195
 196         if (r == -1) {
 197                 LOGE("Failed to delete history");
 198                 return -1;
 199         }
 200
 201         r = rua_dbus_send_update_signal(DELETE);
 202         if (r == -1) {
 203                 LOGE("[RUA SEND SIGNAL ERROR] \n");
 204                 return -1;
 205         }
 206
 207         return 0;
 208 }
 209
 210 API int rua_db_delete_history(bundle *b)
 211 {
 212         return rua_usr_db_delete_history(b, getuid());
 213 }
 214
 215 static int __insert_history(sqlite3 *db, struct rua_rec *rec)
 216 {
 217         static const char query[] =
 218                 "INSERT OR REPLACE INTO rua_history ("
 219                 "  pkg_name, app_path, arg, launch_time,"
 220                 "  instance_id, instance_name, icon, uri) "
 221                 "VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
 222         int r;
 223         sqlite3_stmt *stmt;
 224         int idx = 1;
 225
 226         r = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 227         if (r != SQLITE_OK) {
 228                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 229                 return -1;
 230         }
 231
 232         __BIND_TEXT(db, stmt, idx++, rec->pkg_name);
 233         __BIND_TEXT(db, stmt, idx++, rec->app_path);
 234         __BIND_TEXT(db, stmt, idx++, rec->arg ? rec->arg : "");
 235         __BIND_INT(db, stmt, idx++, (int)rec->launch_time);
 236         __BIND_TEXT(db, stmt, idx++, rec->instance_id ? rec->instance_id : "");
 237         __BIND_TEXT(db, stmt, idx++,
 238                         rec->instance_name ? rec->instance_name : "");
 239         __BIND_TEXT(db, stmt, idx++, rec->icon ? rec->icon : "");
 240         __BIND_TEXT(db, stmt, idx++, rec->uri ? rec->uri : "");
 241
 242         r = sqlite3_step(stmt);
 243         if (r != SQLITE_DONE) {
 244                 LOGE("step failed: %s", sqlite3_errmsg(db));
 245                 sqlite3_finalize(stmt);
 246                 return -1;
 247         }
 248
 249         sqlite3_finalize(stmt);
 250
 251         return 0;
 252 }
 253
 254 static int __update_history(sqlite3 *db, struct rua_rec *rec)
 255 {
 256         static const char query[] =
 257                 "UPDATE rua_history SET launch_time=? "
 258                 "WHERE pkg_name=? AND instance_id=?";
 259         int r;
 260         sqlite3_stmt *stmt;
 261         int idx = 1;
 262
 263         r = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 264         if (r != SQLITE_OK) {
 265                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 266                 return -1;
 267         }
 268
 269         __BIND_INT(db, stmt, idx++, (int)rec->launch_time);
 270         __BIND_TEXT(db, stmt, idx++, rec->pkg_name);
 271         __BIND_TEXT(db, stmt, idx++, rec->instance_id);
 272
 273         r = sqlite3_step(stmt);
 274         if (r != SQLITE_DONE) {
 275                 LOGE("step failed: %s", sqlite3_errmsg(db));
 276                 sqlite3_finalize(stmt);
 277                 return -1;
 278         }
 279
 280         sqlite3_finalize(stmt);
 281
 282         return 0;
 283 }
 284
 285 API int rua_usr_db_add_history(struct rua_rec *rec, uid_t uid)
 286 {
 287         int r;
 288         sqlite3 *db;
 289
 290         if (rec == NULL || rec->pkg_name == NULL || rec->app_path == NULL) {
 291                 LOGE("Invalid parameter");
 292                 return -1;
 293         }
 294
 295         db = __db_init(uid);
 296         if (db == NULL) {
 297                 LOGE("Error db null");
 298                 return -1;
 299         }
 300
 301         if (rec->instance_id &&
 302                         (rec->instance_name == NULL || rec->icon == NULL ||
 303                          rec->uri == NULL))
 304                 r = __update_history(db, rec);
 305         else
 306                 r = __insert_history(db, rec);
 307
 308         r = rua_dbus_send_update_signal(ADD);
 309         if (r == -1) {
 310                 LOGE("[RUA SEND SIGNAL ERROR] \n");
 311                 sqlite3_close_v2(db);
 312                 return -1;
 313         }
 314
 315         sqlite3_close_v2(db);
 316         return r;
 317 }
 318
 319 API int rua_db_add_history(struct rua_rec *rec)
 320 {
 321         return rua_usr_db_add_history(rec, getuid());
 322 }