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                 "  image) "
 222                 "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)";
 223         int r;
 224         sqlite3_stmt *stmt;
 225         int idx = 1;
 226
 227         r = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 228         if (r != SQLITE_OK) {
 229                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 230                 return -1;
 231         }
 232
 233         __BIND_TEXT(db, stmt, idx++, rec->pkg_name);
 234         __BIND_TEXT(db, stmt, idx++, rec->app_path);
 235         __BIND_TEXT(db, stmt, idx++, rec->arg ? rec->arg : "");
 236         __BIND_INT(db, stmt, idx++, (int)rec->launch_time);
 237         __BIND_TEXT(db, stmt, idx++, rec->instance_id ? rec->instance_id : "");
 238         __BIND_TEXT(db, stmt, idx++,
 239                         rec->instance_name ? rec->instance_name : "");
 240         __BIND_TEXT(db, stmt, idx++, rec->icon ? rec->icon : "");
 241         __BIND_TEXT(db, stmt, idx++, rec->uri ? rec->uri : "");
 242         __BIND_TEXT(db, stmt, idx++, rec->image ? rec->image : "");
 243
 244         r = sqlite3_step(stmt);
 245         if (r != SQLITE_DONE) {
 246                 LOGE("step failed: %s", sqlite3_errmsg(db));
 247                 sqlite3_finalize(stmt);
 248                 return -1;
 249         }
 250
 251         sqlite3_finalize(stmt);
 252
 253         return 0;
 254 }
 255
 256 static int __update_history(sqlite3 *db, struct rua_rec *rec)
 257 {
 258         static const char query[] =
 259                 "UPDATE rua_history SET launch_time=? "
 260                 "WHERE pkg_name=? AND instance_id=?";
 261         int r;
 262         sqlite3_stmt *stmt;
 263         int idx = 1;
 264
 265         r = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 266         if (r != SQLITE_OK) {
 267                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 268                 return -1;
 269         }
 270
 271         __BIND_INT(db, stmt, idx++, (int)rec->launch_time);
 272         __BIND_TEXT(db, stmt, idx++, rec->pkg_name);
 273         __BIND_TEXT(db, stmt, idx++, rec->instance_id);
 274
 275         r = sqlite3_step(stmt);
 276         if (r != SQLITE_DONE) {
 277                 LOGE("step failed: %s", sqlite3_errmsg(db));
 278                 sqlite3_finalize(stmt);
 279                 return -1;
 280         }
 281
 282         sqlite3_finalize(stmt);
 283
 284         return 0;
 285 }
 286
 287 API int rua_usr_db_add_history(struct rua_rec *rec, uid_t uid)
 288 {
 289         int r;
 290         sqlite3 *db;
 291
 292         if (rec == NULL || rec->pkg_name == NULL || rec->app_path == NULL) {
 293                 LOGE("Invalid parameter");
 294                 return -1;
 295         }
 296
 297         db = __db_init(uid);
 298         if (db == NULL) {
 299                 LOGE("Error db null");
 300                 return -1;
 301         }
 302
 303         if (rec->instance_id &&
 304                         (rec->instance_name == NULL || rec->icon == NULL ||
 305                          rec->uri == NULL))
 306                 r = __update_history(db, rec);
 307         else
 308                 r = __insert_history(db, rec);
 309
 310         r = rua_dbus_send_update_signal(ADD);
 311         if (r == -1) {
 312                 LOGE("[RUA SEND SIGNAL ERROR] \n");
 313                 sqlite3_close_v2(db);
 314                 return -1;
 315         }
 316
 317         sqlite3_close_v2(db);
 318         return r;
 319 }
 320
 321 API int rua_db_add_history(struct rua_rec *rec)
 322 {
 323         return rua_usr_db_add_history(rec, getuid());
 324 }
 325
 326 static int __update_image(sqlite3 *db, const char *pkg_name,
 327                 const char *instance_id, const char *image)
 328 {
 329         static const char query[] =
 330                 "UPDATE rua_history SET image=? "
 331                 "WHERE pkg_name=? AND instance_id=?";
 332         sqlite3_stmt *stmt;
 333         int idx = 1;
 334         int r;
 335
 336         r = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 337         if (r != SQLITE_OK) {
 338                 LOGE("Prepare failed: %s", sqlite3_errmsg(db));
 339                 return -1;
 340         }
 341
 342         __BIND_TEXT(db, stmt, idx++, image);
 343         __BIND_TEXT(db, stmt, idx++, pkg_name);
 344         __BIND_TEXT(db, stmt, idx++, instance_id ? instance_id : "");
 345
 346         r = sqlite3_step(stmt);
 347         if (r != SQLITE_DONE) {
 348                 LOGE("Step failed: %s", sqlite3_errmsg(db));
 349                 sqlite3_finalize(stmt);
 350                 return -1;
 351         }
 352         sqlite3_finalize(stmt);
 353
 354         return 0;
 355 }
 356
 357 API int rua_usr_db_update_image(const char *pkg_name, const char *instance_id,
 358                 const char *image, uid_t uid)
 359 {
 360         int r;
 361         sqlite3 *db;
 362
 363         if (pkg_name == NULL || image == NULL) {
 364                 LOGE("Invalid parameter");
 365                 return -1;
 366         }
 367
 368         db = __db_init(uid);
 369         if (db == NULL) {
 370                 LOGE("Error db null");
 371                 return -1;
 372         }
 373
 374         r = __update_image(db, pkg_name, instance_id, image);
 375         if (r < 0) {
 376                 LOGE("Failed to update image - appid(%s)", pkg_name);
 377                 sqlite3_close_v2(db);
 378                 return -1;
 379         }
 380         sqlite3_close_v2(db);
 381
 382         r = rua_dbus_send_update_signal(UPDATE);
 383         if (r < 0) {
 384                 LOGE("[RUA SEND SIGNAL ERROR]");
 385                 return -1;
 386         }
 387
 388         return r;
 389 }
 390
 391 API int rua_db_update_image(const char *pkg_name, const char *instance_id,
 392                 const char *image)
 393 {
 394         return rua_usr_db_update_image(pkg_name, instance_id, image, getuid());
 395 }