src/rua.c

   1 /*
   2  *  RUA
   3  *
   4  * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 /*
  23  * @file    rua.c
  24  * @version 0.1
  25  */
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include <db-util.h>
  32
  33 /* For multi-user support */
  34 #include <tzplatform_config.h>
  35
  36 #include "rua.h"
  37 #include "db-schema.h"
  38 #include "perf-measure.h"
  39
  40 #define RUA_DB_NAME     ".rua.db"
  41 #define RUA_HISTORY     "rua_history"
  42 #define QUERY_MAXLEN    4096
  43 #define Q_LATEST \
  44         "select pkg_name from rua_history " \
  45         "order by launch_time desc limit 1 "
  46
  47 static sqlite3 *_db = NULL;
  48
  49 static int __exec(sqlite3 *db, char *query);
  50 static int __create_table(sqlite3 *db);
  51 static sqlite3 *__db_init(char *root);
  52
  53 int rua_clear_history(void)
  54 {
  55         int r;
  56         char query[QUERY_MAXLEN];
  57
  58         if (_db == NULL)
  59                 return -1;
  60
  61         snprintf(query, QUERY_MAXLEN, "delete from %s;", RUA_HISTORY);
  62
  63         r = __exec(_db, query);
  64
  65         return r;
  66 }
  67
  68 int rua_delete_history_with_pkgname(char *pkg_name)
  69 {
  70         int r;
  71         char query[QUERY_MAXLEN];
  72
  73         if (_db == NULL)
  74                 return -1;
  75
  76         if (pkg_name == NULL)
  77                 return -1;
  78
  79         snprintf(query, QUERY_MAXLEN, "delete from %s where pkg_name = '%s';",
  80                 RUA_HISTORY, pkg_name);
  81
  82         r = __exec(_db, query);
  83
  84         return r;
  85 }
  86
  87 int rua_delete_history_with_apppath(char *app_path)
  88 {
  89         int r;
  90         char query[QUERY_MAXLEN];
  91
  92         if (_db == NULL)
  93                 return -1;
  94
  95         if (app_path == NULL)
  96                 return -1;
  97
  98         snprintf(query, QUERY_MAXLEN, "delete from %s where app_path = '%s';",
  99                 RUA_HISTORY, app_path);
 100
 101         r = __exec(_db, query);
 102
 103         return r;
 104 }
 105
 106 int rua_add_history(struct rua_rec *rec)
 107 {
 108         int r;
 109         int cnt = 0;
 110         char query[QUERY_MAXLEN];
 111         sqlite3_stmt *stmt;
 112
 113         unsigned int timestamp;
 114         timestamp = PERF_MEASURE_START("RUA");
 115
 116         if (_db == NULL)
 117                 return -1;
 118
 119         if (rec == NULL)
 120                 return -1;
 121
 122         snprintf(query, QUERY_MAXLEN,
 123                 "select count(*) from %s where pkg_name = '%s';", RUA_HISTORY,
 124                 rec->pkg_name);
 125
 126         r = sqlite3_prepare(_db, query, sizeof(query), &stmt, NULL);
 127         if (r != SQLITE_OK) {
 128                 return -1;
 129         }
 130
 131         r = sqlite3_step(stmt);
 132         if (r == SQLITE_ROW) {
 133                 cnt = sqlite3_column_int(stmt, 0);
 134         }
 135         sqlite3_finalize(stmt);
 136
 137         if (cnt == 0)
 138                 /* insert */
 139                 snprintf(query, QUERY_MAXLEN,
 140                         "insert into %s ( pkg_name, app_path, arg, launch_time ) "
 141                         " values ( \"%s\", \"%s\", \"%s\", %d ) ",
 142                         RUA_HISTORY,
 143                         rec->pkg_name ? rec->pkg_name : "",
 144                         rec->app_path ? rec->app_path : "",
 145                         rec->arg ? rec->arg : "", time(NULL));
 146         else
 147                 /* update */
 148                 snprintf(query, QUERY_MAXLEN,
 149                         "update %s set arg='%s', launch_time='%d' where pkg_name = '%s';",
 150                         RUA_HISTORY,
 151                         rec->arg ? rec->arg : "", time(NULL), rec->pkg_name);
 152
 153         r = __exec(_db, query);
 154         if (r == -1) {
 155                 printf("[RUA ADD HISTORY ERROR] %s\n", query);
 156                 return -1;
 157         }
 158
 159         PERF_MEASURE_END("RUA", timestamp);
 160
 161         return r;
 162 }
 163
 164 int rua_history_load_db(char ***table, int *nrows, int *ncols)
 165 {
 166         int r;
 167         char query[QUERY_MAXLEN];
 168         char *db_err = NULL;
 169         char **db_result = NULL;
 170
 171         if (table == NULL)
 172                 return -1;
 173         if (nrows == NULL)
 174                 return -1;
 175         if (ncols == NULL)
 176                 return -1;
 177
 178         snprintf(query, QUERY_MAXLEN,
 179                  "select * from %s order by launch_time desc;", RUA_HISTORY);
 180
 181         r = sqlite3_get_table(_db, query, &db_result, nrows, ncols, &db_err);
 182
 183         if (r == SQLITE_OK)
 184                 *table = db_result;
 185         else
 186                 sqlite3_free_table(db_result);
 187
 188         return r;
 189 }
 190
 191 int rua_history_unload_db(char ***table)
 192 {
 193         if (*table) {
 194                 sqlite3_free_table(*table);
 195                 *table = NULL;
 196                 return 0;
 197         }
 198         return -1;
 199 }
 200
 201 int rua_history_get_rec(struct rua_rec *rec, char **table, int nrows, int ncols,
 202                         int row)
 203 {
 204         char **db_result = NULL;
 205         char *tmp = NULL;
 206
 207         if (rec == NULL)
 208                 return -1;
 209         if (table == NULL)
 210                 return -1;
 211         if (row >= nrows)
 212                 return -1;
 213
 214         db_result = table + ((row + 1) * ncols);
 215
 216         tmp = db_result[RUA_COL_ID];
 217         if (tmp) {
 218                 rec->id = atoi(tmp);
 219         }
 220
 221         tmp = db_result[RUA_COL_PKGNAME];
 222         if (tmp) {
 223                 rec->pkg_name = tmp;
 224         }
 225
 226         tmp = db_result[RUA_COL_APPPATH];
 227         if (tmp) {
 228                 rec->app_path = tmp;
 229         }
 230
 231         tmp = db_result[RUA_COL_ARG];
 232         if (tmp) {
 233                 rec->arg = tmp;
 234         }
 235
 236         tmp = db_result[RUA_COL_LAUNCHTIME];
 237         if (tmp) {
 238                 rec->launch_time = atoi(tmp);
 239         }
 240
 241         return 0;
 242 }
 243
 244 int rua_is_latest_app(const char *pkg_name)
 245 {
 246         int r;
 247         sqlite3_stmt *stmt;
 248         const unsigned char *ct;
 249
 250         if (!pkg_name || !_db)
 251                 return -1;
 252
 253         r = sqlite3_prepare(_db, Q_LATEST, sizeof(Q_LATEST), &stmt, NULL);
 254         if (r != SQLITE_OK) {
 255                 return -1;
 256         }
 257
 258         r = sqlite3_step(stmt);
 259         if (r == SQLITE_ROW) {
 260                 ct = sqlite3_column_text(stmt, 0);
 261                 if (ct == NULL || ct[0] == '\0') {
 262                         sqlite3_finalize(stmt);
 263                         return -1;
 264                 }
 265
 266                 if (strncmp(pkg_name, ct, strlen(pkg_name)) == 0) {
 267                         sqlite3_finalize(stmt);
 268                         return 0;
 269                 }
 270         }
 271
 272         sqlite3_finalize(stmt);
 273         return -1;
 274 }
 275
 276 int rua_init(void)
 277 {
 278         unsigned int timestamp;
 279         timestamp = PERF_MEASURE_START("RUA");
 280
 281         if (_db) {
 282                 return 0;
 283         }
 284
 285         char defname[FILENAME_MAX];
 286         const char *rua_db_path = tzplatform_getenv(TZ_USER_DB);
 287         snprintf(defname, sizeof(defname), "%s/%s", rua_db_path, RUA_DB_NAME);
 288         _db = __db_init(defname);
 289
 290         if (_db == NULL)
 291                 return -1;
 292
 293         PERF_MEASURE_END("RUA", timestamp);
 294
 295         return 0;
 296 }
 297
 298 int rua_fini(void)
 299 {
 300         unsigned int timestamp;
 301         timestamp = PERF_MEASURE_START("RUA");
 302
 303         if (_db) {
 304                 db_util_close(_db);
 305                 _db = NULL;
 306         }
 307
 308         PERF_MEASURE_END("RUA", timestamp);
 309         return 0;
 310 }
 311
 312 static int __exec(sqlite3 *db, char *query)
 313 {
 314         int r;
 315         char *errmsg = NULL;
 316
 317         if (db == NULL)
 318                 return -1;
 319
 320         r = sqlite3_exec(db, query, NULL, NULL, &errmsg);
 321
 322         if (r != SQLITE_OK) {
 323                 sqlite3_free(errmsg);
 324                 return -1;
 325         }
 326
 327         return 0;
 328 }
 329
 330 static int __create_table(sqlite3 *db)
 331 {
 332         int r;
 333
 334         r = __exec(db, CREATE_RUA_HISTORY_TABLE);
 335         if (r == -1)
 336                 return -1;
 337
 338         return 0;
 339 }
 340
 341 static sqlite3 *__db_init(char *root)
 342 {
 343         int r;
 344         sqlite3 *db = NULL;
 345
 346         r = db_util_open_with_options(root, &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL);
 347         if (r) {
 348                 db_util_close(db);
 349                 return NULL;
 350         }
 351
 352         r = __create_table(db);
 353         if (r) {
 354                 db_util_close(db);
 355                 return NULL;
 356         }
 357
 358         return db;
 359 }