src/rua_stat_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 #include <unistd.h>
  17 #include <sys/types.h>
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21
  22 #include <db-util.h>
  23
  24 #include "db-schema.h"
  25 #include "rua_stat_internal.h"
  26 #include "rua_util.h"
  27
  28 int __rua_stat_insert(sqlite3 *db, char *caller, char *rua_stat_tag)
  29 {
  30         int r;
  31         char query[QUERY_MAXLEN];
  32         sqlite3_stmt *stmt = NULL;
  33
  34         sqlite3_snprintf(QUERY_MAXLEN, query,
  35                 "INSERT INTO rua_panel_stat (caller_panel, rua_stat_tag, score) VALUES (?,?,?)");
  36
  37         r = sqlite3_prepare(db, query, sizeof(query), &stmt, NULL);
  38         if (r != SQLITE_OK) {
  39                 LOGE("sqlite3_prepare error(%d , %d, %s)", r, sqlite3_extended_errcode(db), sqlite3_errmsg(db));
  40                 goto out;
  41         }
  42
  43         r = sqlite3_bind_text(stmt, 1, caller, strlen(caller), SQLITE_STATIC);
  44         if (r != SQLITE_OK) {
  45                 LOGE("caller bind error(%d) \n", r);
  46                 goto out;
  47         }
  48
  49         r = sqlite3_bind_text(stmt, 2, rua_stat_tag, strlen(rua_stat_tag), SQLITE_STATIC);
  50         if (r != SQLITE_OK) {
  51                 LOGE("rua_stat_tag bind error(%d) \n", r);
  52                 goto out;
  53         }
  54
  55         r = sqlite3_bind_int(stmt, 3, WIN_SCORE);
  56         if (r != SQLITE_OK) {
  57                 LOGE("arg bind error(%d) \n", r);
  58                 goto out;
  59         }
  60
  61         r = sqlite3_step(stmt);
  62         if (r != SQLITE_DONE) {
  63                 LOGE("step error(%d) \n", r);
  64                 goto out;
  65         }
  66
  67 out:
  68         if (stmt)
  69                 sqlite3_finalize(stmt);
  70
  71         return r;
  72 }
  73
  74 int __rua_stat_lose_score_update(sqlite3 *db, char *caller, char *rua_stat_tag)
  75 {
  76         int r;
  77         char query[QUERY_MAXLEN];
  78         sqlite3_stmt *stmt = NULL;
  79
  80         sqlite3_snprintf(QUERY_MAXLEN, query,
  81                 "UPDATE rua_panel_stat SET score = score * %f WHERE caller_panel = ? AND rua_stat_tag != ?",
  82                 LOSE_SCORE_RATE);
  83
  84         LOGD("lose score update sql : %s", query);
  85         r = sqlite3_prepare(db, query, sizeof(query), &stmt, NULL);
  86         if (r != SQLITE_OK) {
  87                 LOGE("sqlite3_prepare error(%d , %d, %s)", r, sqlite3_extended_errcode(db), sqlite3_errmsg(db));
  88                 goto out;
  89         }
  90
  91         r = sqlite3_bind_text(stmt, 1, caller, strlen(caller), SQLITE_STATIC);
  92         if (r != SQLITE_OK) {
  93                 LOGE("caller bind error(%d) \n", r);
  94                 goto out;
  95         }
  96
  97         r = sqlite3_bind_text(stmt, 2, rua_stat_tag, strlen(rua_stat_tag), SQLITE_STATIC);
  98         if (r != SQLITE_OK) {
  99                 LOGE("rua_stat_tag bind error(%d) \n", r);
 100                 goto out;
 101         }
 102
 103         r = sqlite3_step(stmt);
 104         if (r != SQLITE_DONE) {
 105                 LOGE("step error(%d) \n", r);
 106                 goto out;
 107         }
 108
 109 out:
 110         if (stmt)
 111                 sqlite3_finalize(stmt);
 112
 113         return r;
 114 }
 115
 116 int __rua_stat_win_score_update(sqlite3 *db, char *caller, char *rua_stat_tag)
 117 {
 118         int r;
 119         char query[QUERY_MAXLEN];
 120         sqlite3_stmt *stmt = NULL;
 121
 122         sqlite3_snprintf(QUERY_MAXLEN, query,
 123                 "UPDATE rua_panel_stat SET score = score + %d WHERE caller_panel = ? AND rua_stat_tag = ?",
 124                 WIN_SCORE);
 125
 126         LOGD("win score update sql : %s", query);
 127
 128         r = sqlite3_prepare(db, query, sizeof(query), &stmt, NULL);
 129         if (r != SQLITE_OK) {
 130                 LOGE("sqlite3_prepare error(%d , %d, %s)", r, sqlite3_extended_errcode(db), sqlite3_errmsg(db));
 131                 goto out;
 132         }
 133
 134         r = sqlite3_bind_text(stmt, 1, caller, strlen(caller), SQLITE_STATIC);
 135         if (r != SQLITE_OK) {
 136                 LOGE("caller bind error(%d) \n", r);
 137                 goto out;
 138         }
 139
 140         r = sqlite3_bind_text(stmt, 2, rua_stat_tag, strlen(rua_stat_tag), SQLITE_STATIC);
 141         if (r != SQLITE_OK) {
 142                 LOGE("rua_stat_tag bind error(%d) \n", r);
 143                 goto out;
 144         }
 145
 146         r = sqlite3_step(stmt);
 147         if (r != SQLITE_DONE) {
 148                 LOGE("step error(%d) \n", r);
 149                 goto out;
 150         }
 151
 152 out:
 153         if (stmt)
 154                 sqlite3_finalize(stmt);
 155
 156         return r;
 157 }
 158
 159 static int __exec(sqlite3 *db, char *query)
 160 {
 161         int r;
 162         char *errmsg = NULL;
 163
 164         if (db == NULL)
 165                 return -1;
 166
 167         r = sqlite3_exec(db, query, NULL, NULL, &errmsg);
 168         if (r != SQLITE_OK) {
 169                 SECURE_LOGE("query(%s) exec error(%s)", query, errmsg);
 170                 sqlite3_free(errmsg);
 171                 return -1;
 172         }
 173
 174         return 0;
 175 }
 176
 177 static int __create_table(sqlite3 *db)
 178 {
 179         int r;
 180
 181         r = __exec(db, CREATE_RUA_STAT_TABLE);
 182         if (r == -1) {
 183                 LOGE("create table error");
 184                 return -1;
 185         }
 186
 187         return 0;
 188 }
 189
 190 int _rua_stat_init(sqlite3 **db, char *db_name, int flags, uid_t uid)
 191 {
 192         int r;
 193         r = _rua_util_open_db(db, flags, uid, db_name);
 194         r = __create_table(*db);
 195         if (r) {
 196                 db_util_close(*db);
 197                 return -1;
 198         }
 199
 200         if (*db == NULL) {
 201                 LOGE("__rua_stat_init error");
 202                 return -1;
 203         }
 204         return 0;
 205 }
 206
 207 int rua_stat_db_update(char *caller, char *rua_stat_tag)
 208 {
 209         int r;
 210         int affected_rows = 0;
 211         sqlite3 *db = NULL;
 212
 213         LOGD("rua_stat_update start");
 214
 215         r = _rua_stat_init(&db, RUA_STAT_DB_NAME, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, getuid());
 216         if (r == -1) {
 217                 LOGE("__rua_stat_init fail");
 218                 return -1;
 219         }
 220
 221         if (db == NULL) {
 222                 LOGE("rua_stat is not initialized");
 223                 return -1;
 224         }
 225
 226         if (caller == NULL) {
 227                 LOGE("caller is null");
 228                 return -1;
 229         }
 230
 231         if (rua_stat_tag == NULL) {
 232                 LOGE("rua_stat_tag is null");
 233                 return -1;
 234         }
 235
 236         r = __rua_stat_lose_score_update(db, caller, rua_stat_tag);
 237         if (r != SQLITE_DONE) {
 238                 LOGE("__rua_stat_lose_score_insert fail.");
 239                 return -1;
 240         }
 241
 242         r = __rua_stat_win_score_update(db, caller, rua_stat_tag);
 243         affected_rows = sqlite3_changes(db);
 244         if ((r != SQLITE_DONE) || (affected_rows == 0)) {
 245                 r = __rua_stat_insert(db, caller, rua_stat_tag);
 246
 247                 if (r != SQLITE_DONE) {
 248                         LOGE("__rua_stat_insert fail.");
 249                         return -1;
 250                 }
 251         }
 252         if (db)
 253                 db_util_close(db);
 254         LOGD("rua_stat_update done");
 255         return r;
 256 }
 257