src/badge_setting_service.c

   1 /*
   2  * Copyright (c) 2016 - 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 <sqlite3.h>
  19 #include <db-util.h>
  20 #include <gio/gio.h>
  21 #include <string.h>
  22 #include <pkgmgr-info.h>
  23 #include <package_manager.h>
  24
  25 #include "badge_setting.h"
  26 #include "badge_setting_service.h"
  27 #include "badge_db.h"
  28 #include "badge_error.h"
  29 #include "badge_log.h"
  30
  31 #define BADGE_PRIVILEGE "http://tizen.org/privilege/notification"
  32
  33 typedef struct {
  34         uid_t uid;
  35         sqlite3 *db;
  36 } badge_setting_info;
  37
  38 static bool _get_table_field_data_int(char **table, int *buf, int index)
  39 {
  40         if (table == NULL || buf == NULL || index < 0) {
  41                 /* LCOV_EXCL_START */
  42                 ERR("table[%p], buf[%p], index[%d]", table, buf, index);
  43                 return false;
  44                 /* LCOV_EXCL_STOP */
  45         }
  46
  47         if (table[index] != NULL) {
  48                 *buf = atoi(table[index]);
  49                 return true;
  50         }
  51
  52         /* LCOV_EXCL_START */
  53         *buf = 0;
  54         return false;
  55         /* LCOV_EXCL_STOP */
  56 }
  57
  58 static bool _get_table_field_data_string(char **table, char **buf, int ucs2, int index)
  59 {
  60         bool ret = false;
  61         int sLen = 0;
  62         char *pTemp;
  63
  64         if (table == NULL || buf == NULL || index < 0) {
  65                 /* LCOV_EXCL_START */
  66                 ERR("table[%p], buf[%p], index[%d]", table, buf, index);
  67                 return false;
  68                 /* LCOV_EXCL_STOP */
  69         }
  70
  71         pTemp = table[index];
  72         if (pTemp == NULL) {
  73                 *buf = NULL; /* LCOV_EXCL_LINE */
  74         } else {
  75                 sLen = strlen(pTemp);
  76                 if (sLen) {
  77                         *buf = (char *)malloc(sLen + 1);
  78                         if (*buf == NULL) {
  79                                 ERR("malloc is failed"); /* LCOV_EXCL_LINE */
  80                                 goto out;
  81                         }
  82                         memset(*buf, 0, sLen + 1);
  83                         strncpy(*buf, pTemp, sLen);
  84                 } else {
  85                         *buf = NULL; /* LCOV_EXCL_LINE */
  86                 }
  87         }
  88
  89         ret = true;
  90
  91 out:
  92         return ret;
  93 }
  94
  95 EXPORT_API int badge_db_get_setting_by_appid(const char *appid, badge_setting_h *setting, uid_t uid)
  96 {
  97         int ret = BADGE_ERROR_NONE;
  98         int sql_ret;
  99         int row_count;
 100         int col_count;
 101         int col_index;
 102         char *sql_query = NULL;
 103         char **query_result = NULL;
 104         badge_setting_h result_setting;
 105         sqlite3 *db = NULL;
 106
 107         if (appid == NULL)
 108                 return BADGE_ERROR_INVALID_PARAMETER;
 109
 110         sql_ret = db_util_open(BADGE_DB_PATH, &db, 0);
 111         if (sql_ret != SQLITE_OK || db == NULL) {
 112                 ERR("Failed db util open [%s][%d]", BADGE_DB_PATH, sql_ret);
 113                 return BADGE_ERROR_FROM_DB;
 114         }
 115
 116         sql_query = sqlite3_mprintf("SELECT pkgname, appid, allow_to_display FROM %s " \
 117                                 "WHERE appid = %Q AND (uid = %d OR uid = %d) " \
 118                                 "ORDER BY uid DESC;",
 119                                 BADGE_SETTING_DB_TABLE, appid, uid, tzplatform_getuid(TZ_SYS_GLOBALAPP_USER));
 120         if (!sql_query) {
 121                 ERR("Failed to alloc query");
 122                 ret = BADGE_ERROR_FROM_DB;
 123                 goto out;
 124         }
 125
 126         sql_ret = sqlite3_get_table(db, sql_query, &query_result, &row_count, &col_count, NULL);
 127         if (sql_ret != SQLITE_OK && sql_ret != -1) {
 128                 ERR("sqlite3_get_table failed [%d][%s]", sql_ret,
 129                                         sqlite3_errmsg(db));
 130                 ret = BADGE_ERROR_FROM_DB;
 131                 goto out;
 132         }
 133
 134         if (!row_count) {
 135                 DBG("No setting found for [%s]", appid);
 136                 ret = BADGE_ERROR_NOT_EXIST;
 137                 goto out;
 138         }
 139
 140         result_setting = (struct badge_setting *)malloc(sizeof(struct badge_setting));
 141         if (result_setting == NULL) {
 142                 ERR("Failed to alloc setting");
 143                 ret = BADGE_ERROR_OUT_OF_MEMORY;
 144                 goto out;
 145         }
 146
 147         col_index = col_count;
 148
 149         _get_table_field_data_string(query_result, &(result_setting[0].pkgname), 1, col_index++);
 150         _get_table_field_data_string(query_result, &(result_setting[0].appid), 1, col_index++);
 151         _get_table_field_data_int(query_result, (int *)&(result_setting[0].allow_to_display), col_index++);
 152
 153         *setting = result_setting;
 154
 155 out:
 156         if (query_result)
 157                 sqlite3_free_table(query_result);
 158         if (sql_query)
 159                 sqlite3_free(sql_query);
 160         if (db) {
 161                 sql_ret = db_util_close(db);
 162                 if (sql_ret != SQLITE_OK)
 163                         WARN("Failed to db_util_close");
 164         }
 165
 166         return ret;
 167 }
 168
 169 EXPORT_API int badge_db_update_setting(char *pkgname, char *appid, int allow_to_display, uid_t uid)
 170 {
 171         int ret = BADGE_ERROR_NONE;
 172         sqlite3 *db = NULL;
 173         char *sqlbuf = NULL;
 174         int sql_ret;
 175
 176         if (pkgname == NULL || appid == NULL) {
 177                 ERR("Invalid package name or app id");
 178                 return BADGE_ERROR_INVALID_PARAMETER;
 179         }
 180
 181         sql_ret = db_util_open(BADGE_DB_PATH, &db, 0);
 182         if (sql_ret != SQLITE_OK || db == NULL) {
 183                 ERR("db_util_open failed [%s][%d]", BADGE_DB_PATH, sql_ret);
 184                 return BADGE_ERROR_FROM_DB;
 185         }
 186
 187         sqlbuf = sqlite3_mprintf("UPDATE %s SET allow_to_display = %d " \
 188                                 "WHERE pkgname = %Q AND appid = %Q " \
 189                                 "AND uid = %d;",
 190                                 BADGE_SETTING_DB_TABLE, allow_to_display,
 191                                 pkgname, appid, uid);
 192
 193         if (!sqlbuf) {
 194                 ERR("Failed to alloc query");
 195                 ret = BADGE_ERROR_FROM_DB;
 196                 goto out;
 197         }
 198
 199         ret = badge_db_exec(db, sqlbuf, NULL);
 200
 201 out:
 202         if (sqlbuf)
 203                 sqlite3_free(sqlbuf);
 204         if (db) {
 205                 sql_ret = db_util_close(db);
 206                 if (sql_ret != SQLITE_OK)
 207                         WARN("Failed to db_util_close");
 208         }
 209
 210         return ret;
 211 }
 212
 213 EXPORT_API int badge_db_get_allow_to_display_by_appid(char *appid, int *allow_to_display, uid_t uid)
 214 {
 215         int ret = BADGE_ERROR_NONE;
 216         int sql_ret;
 217         int row_count;
 218         int col_count;
 219         int col_index;
 220         char *sql_query = NULL;
 221         char **query_result = NULL;
 222         sqlite3 *db = NULL;
 223
 224         if (appid == NULL)
 225                 return BADGE_ERROR_INVALID_PARAMETER;
 226
 227         sql_ret = db_util_open(BADGE_DB_PATH, &db, 0);
 228         if (sql_ret != SQLITE_OK || db == NULL) {
 229                 ERR("Failed db util open [%s][%d]", BADGE_DB_PATH, sql_ret);
 230                 return BADGE_ERROR_FROM_DB;
 231         }
 232
 233         sql_query = sqlite3_mprintf("SELECT allow_to_display FROM %s WHERE appid = %Q " \
 234                                 "AND (uid = %d OR uid = %d) ORDER BY uid DESC;",
 235                                 BADGE_SETTING_DB_TABLE, appid, uid,
 236                                 tzplatform_getuid(TZ_SYS_GLOBALAPP_USER));
 237         if (!sql_query) {
 238                 ERR("Failed to alloc query");
 239                 ret = BADGE_ERROR_FROM_DB;
 240                 goto out;
 241         }
 242
 243         sql_ret = sqlite3_get_table(db, sql_query, &query_result, &row_count, &col_count, NULL);
 244         if (sql_ret != SQLITE_OK && sql_ret != -1) {
 245                 ERR("sqlite3_get_table failed [%d][%s]", sql_ret,
 246                                         sqlite3_errmsg(db));
 247                 ret = BADGE_ERROR_FROM_DB;
 248                 goto out;
 249         }
 250
 251         if (!row_count) {
 252                 DBG("No setting found for [%s]", appid);
 253                 ret = BADGE_ERROR_NOT_EXIST;
 254                 goto out;
 255         }
 256
 257         col_index = col_count;
 258
 259         _get_table_field_data_int(query_result, (int *)allow_to_display, col_index++);
 260
 261 out:
 262         if (query_result)
 263                 sqlite3_free_table(query_result);
 264         if (sql_query)
 265                 sqlite3_free(sql_query);
 266         if (db) {
 267                 sql_ret = db_util_close(db);
 268                 if (sql_ret != SQLITE_OK)
 269                         WARN("Failed to db_util_close");
 270         }
 271
 272         return ret;
 273 }
 274
 275 EXPORT_API int badge_setting_is_existed_appid(const char *appid, bool *is_existed, uid_t uid)
 276 {
 277         int ret = BADGE_ERROR_NONE;
 278         int sqlret;
 279         sqlite3 *db = NULL;
 280         sqlite3_stmt *stmt = NULL;
 281         char *sqlbuf = NULL;
 282         int count = 0;
 283
 284         if (appid == NULL || is_existed == NULL) {
 285                 ERR("Invalid parameter");
 286                 return BADGE_ERROR_INVALID_PARAMETER;
 287         }
 288
 289         sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
 290         if (sqlret != SQLITE_OK || !db) {
 291                 ERR("Failed to db_util_open [%d]", sqlret);
 292                 if (sqlret == SQLITE_PERM)
 293                         return BADGE_ERROR_PERMISSION_DENIED;
 294                 return BADGE_ERROR_FROM_DB;
 295         }
 296
 297         sqlbuf = sqlite3_mprintf("SELECT count(*) FROM %q WHERE " \
 298                                 "appid = %Q AND uid = %d",
 299                                 BADGE_SETTING_DB_TABLE, appid, uid);
 300         if (!sqlbuf) {
 301                 ERR("Failed to alloc query");
 302                 ret = BADGE_ERROR_OUT_OF_MEMORY;
 303                 goto out;
 304         }
 305
 306         sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL);
 307         if (sqlret != SQLITE_OK) {
 308                 ERR("sqlite3_prepare_v2 failed [%d][%s]", sqlret,
 309                                         sqlite3_errmsg(db));
 310                 ret = BADGE_ERROR_FROM_DB;
 311                 goto out;
 312         }
 313
 314         sqlret = sqlite3_step(stmt);
 315         if (sqlret == SQLITE_ROW)
 316                 count = sqlite3_column_int(stmt, 0);
 317
 318         if (count > 0)
 319                 *is_existed = true;
 320         else
 321                 *is_existed = false;
 322
 323 out:
 324         if (sqlbuf)
 325                 sqlite3_free(sqlbuf);
 326         if (stmt)
 327                 sqlite3_finalize(stmt);
 328         if (db) {
 329                 sqlret = db_util_close(db);
 330                 if (sqlret != SQLITE_OK)
 331                         WARN("Failed to db_util_close [%d]", sqlret);
 332         }
 333
 334         return ret;
 335 }
 336
 337 static bool _is_package_in_setting_table(sqlite3 *db, const char *pkgname, const char* appid, uid_t uid)
 338 {
 339         sqlite3_stmt *db_statement = NULL;
 340         int sqlite3_ret = SQLITE_OK;
 341         bool err = true;
 342         int field_index = 1;
 343
 344         if (appid != NULL)
 345                 sqlite3_ret = sqlite3_prepare_v2(db, "SELECT appid FROM badge_setting WHERE uid = ? AND pkgname = ? AND appid = ?", -1, &db_statement, NULL);
 346         else
 347                 sqlite3_ret = sqlite3_prepare_v2(db, "SELECT pkgname FROM badge_setting WHERE uid = ? AND pkgname = ?", -1, &db_statement, NULL);
 348
 349         if (sqlite3_ret != SQLITE_OK) {
 350                 ERR("sqlite3_prepare_v2 failed [%d][%s]", sqlite3_ret,
 351                                         sqlite3_errmsg(db));
 352                 err = false;
 353                 goto out;
 354         }
 355
 356         sqlite3_bind_int(db_statement, field_index++, uid);
 357         sqlite3_bind_text(db_statement, field_index++, pkgname, -1, SQLITE_TRANSIENT);
 358         if (appid != NULL)
 359                 sqlite3_bind_text(db_statement, field_index++, appid, -1, SQLITE_TRANSIENT);
 360
 361         sqlite3_ret = sqlite3_step(db_statement);
 362         if (sqlite3_ret == SQLITE_DONE) {
 363                 INFO("no matched appid from pkgname found[%s][%s][%d]", pkgname, appid, sqlite3_ret);
 364                 err = false;
 365                 goto out;
 366         }
 367
 368         if (sqlite3_ret != SQLITE_OK && sqlite3_ret != SQLITE_ROW) {
 369                 ERR("sqlite3_step failed [%d][%s]", sqlite3_ret,
 370                                         sqlite3_errmsg(db));
 371                 err = false;
 372                 goto out;
 373         }
 374
 375 out:
 376         if (db_statement)
 377                 sqlite3_finalize(db_statement);
 378
 379         return err;
 380 }
 381
 382 static int app_info_callback(const pkgmgrinfo_appinfo_h handle, void *user_data)
 383 {
 384         badge_setting_info *info = (badge_setting_info *)user_data;
 385         sqlite3 *db = info->db;
 386         sqlite3_stmt *db_statement = NULL;
 387         int pkgmgr_ret = PACKAGE_MANAGER_ERROR_NONE;
 388         int field_index = 1;
 389         int sqlite3_ret = SQLITE_OK;
 390         char *appid = NULL;
 391         char *pkgname = NULL;
 392
 393         pkgmgr_ret = pkgmgrinfo_appinfo_get_appid(handle, &appid);
 394         if (pkgmgr_ret != PACKAGE_MANAGER_ERROR_NONE) {
 395                 ERR("pkgmgrinfo_appinfo_get_appid failed [%d]", pkgmgr_ret);
 396                 goto out;
 397         }
 398
 399         pkgmgr_ret = pkgmgrinfo_appinfo_get_pkgname(handle, &pkgname);
 400         if (pkgmgr_ret != PACKAGE_MANAGER_ERROR_NONE) {
 401                 ERR("pkgmgrinfo_appinfo_get_pkgname failed [%d]", pkgmgr_ret);
 402                 goto out;
 403         }
 404
 405         if (_is_package_in_setting_table(db, pkgname, appid, info->uid) == true) {
 406                 INFO("uid %d [%s] is exist", info->uid, appid);
 407                 goto out;
 408         }
 409
 410         INFO("uid %d pkgname %s [%s] will be inserted", info->uid, pkgname, appid);
 411         sqlite3_ret = sqlite3_prepare_v2(db, "INSERT INTO badge_setting (uid, pkgname, appid) "
 412                                          "VALUES (?, ?, ?) ", -1, &db_statement, NULL);
 413
 414         if (sqlite3_ret != SQLITE_OK) {
 415                 ERR("sqlite3_prepare_v2 failed [%d][%s]", sqlite3_ret,
 416                                         sqlite3_errmsg(db));
 417                 goto out;
 418         }
 419
 420         sqlite3_bind_int(db_statement, field_index++, info->uid);
 421         sqlite3_bind_text(db_statement, field_index++, pkgname, -1, SQLITE_TRANSIENT);
 422         sqlite3_bind_text(db_statement, field_index++, appid, -1, SQLITE_TRANSIENT);
 423
 424         sqlite3_ret = sqlite3_step(db_statement);
 425
 426         INFO("sqlite3_step returns[%d]", sqlite3_ret);
 427
 428         if (sqlite3_ret != SQLITE_OK && sqlite3_ret != SQLITE_DONE)
 429                 ERR("sqlite3_step failed [%d][%s]", sqlite3_ret,
 430                                         sqlite3_errmsg(db));
 431
 432 out:
 433         if (db_statement)
 434                 sqlite3_finalize(db_statement);
 435
 436         return 0;
 437 }
 438
 439 static int package_info_callback(const pkgmgrinfo_pkginfo_h package_info, void *user_data)
 440 {
 441         char *pkgname = NULL;
 442         int pkgmgr_ret = PACKAGE_MANAGER_ERROR_NONE;
 443         pkgmgrinfo_appinfo_filter_h handle = NULL;
 444         badge_setting_info *info = (badge_setting_info *)user_data;
 445
 446         pkgmgr_ret = pkgmgrinfo_pkginfo_get_pkgname(package_info, &pkgname);
 447         if (pkgmgr_ret != PACKAGE_MANAGER_ERROR_NONE) {
 448                 ERR("package_info_get_package failed [%d]", pkgmgr_ret);
 449                 goto out;
 450         }
 451
 452         pkgmgr_ret = pkgmgrinfo_appinfo_filter_create(&handle);
 453         if (pkgmgr_ret != PMINFO_R_OK) {
 454                 ERR("pkgmgrinfo_appinfo_filter_create failed [%d]", pkgmgr_ret);
 455                 goto out;
 456         }
 457
 458         pkgmgr_ret = pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_PACKAGE, pkgname);
 459         if (pkgmgr_ret != PMINFO_R_OK) {
 460                 ERR("pkgmgrinfo_appinfo_filter_add_string failed [%d]",
 461                                         pkgmgr_ret);
 462                 goto out;
 463         }
 464
 465         pkgmgr_ret = pkgmgrinfo_appinfo_filter_add_bool(handle, PMINFO_APPINFO_PROP_APP_NODISPLAY, false);
 466         if (pkgmgr_ret != PMINFO_R_OK) {
 467                 ERR("pkgmgrinfo_appinfo_filter_add_bool failed [%d]",
 468                                         pkgmgr_ret);
 469                 goto out;
 470         }
 471
 472         pkgmgr_ret = pkgmgrinfo_appinfo_usr_filter_foreach_appinfo(handle, app_info_callback, info, info->uid);
 473         if (pkgmgr_ret != PMINFO_R_OK) {
 474                 ERR("pkgmgrinfo_pkginfo_filter_foreach_appinfo failed [%d]",
 475                                         pkgmgr_ret);
 476                 goto out;
 477         }
 478
 479 out:
 480         if (handle)
 481                 pkgmgrinfo_appinfo_filter_destroy(handle);
 482
 483         return 0;
 484 }
 485
 486 EXPORT_API int badge_setting_insert_package_for_uid(const char *pkgname, uid_t uid)
 487 {
 488         sqlite3 *db;
 489         int ret = BADGE_ERROR_NONE;
 490         int sqlite3_ret = SQLITE_OK;
 491         int pkgmgr_ret = PACKAGE_MANAGER_ERROR_NONE;
 492         badge_setting_info info;
 493         pkgmgrinfo_pkginfo_filter_h handle = NULL;
 494
 495         sqlite3_ret = sqlite3_open_v2(BADGE_DB_PATH, &db, SQLITE_OPEN_READWRITE, NULL);
 496         if (sqlite3_ret != SQLITE_OK || db == NULL) {
 497                 ERR("db_util_open failed [%s][%d]", BADGE_DB_PATH, sqlite3_ret);
 498                 ret = BADGE_ERROR_FROM_DB;
 499                 goto out;
 500         }
 501
 502         sqlite3_exec(db, "BEGIN immediate;", NULL, NULL, NULL);
 503
 504         pkgmgr_ret = pkgmgrinfo_pkginfo_filter_create(&handle);
 505         if (pkgmgr_ret != PMINFO_R_OK) {
 506                 ERR("pkgmgrinfo_pkginfo_filter_create failed [%d]", pkgmgr_ret);
 507                 ret = BADGE_ERROR_FROM_DB;
 508                 goto out;
 509         }
 510
 511         pkgmgr_ret = pkgmgrinfo_pkginfo_filter_add_string(handle, PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgname);
 512         if (pkgmgr_ret != PMINFO_R_OK) {
 513                 ERR("pkgmgrinfo_pkginfo_filter_add_string failed [%d]",
 514                                         pkgmgr_ret);
 515                 ret = BADGE_ERROR_FROM_DB;
 516                 goto out;
 517         }
 518
 519         info.db = db;
 520         info.uid = uid;
 521         pkgmgr_ret = pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(handle, package_info_callback, &info, uid);
 522         if (pkgmgr_ret != PMINFO_R_OK) {
 523                 ERR("pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo failed [%d]",
 524                                         pkgmgr_ret);
 525                 ret = BADGE_ERROR_FROM_DB;
 526                 goto out;
 527         }
 528
 529 out:
 530         if (handle)
 531                 pkgmgrinfo_pkginfo_filter_destroy(handle);
 532         if (db) {
 533                 if (ret == BADGE_ERROR_NONE)
 534                         sqlite3_exec(db, "END;", NULL, NULL, NULL);
 535                 else
 536                         sqlite3_exec(db, "ROLLBACK;", NULL, NULL, NULL);
 537
 538                 if ((sqlite3_ret = db_util_close(db)) != SQLITE_OK)
 539                         WARN("db_util_close failed [%d]", sqlite3_ret);
 540         }
 541
 542         return ret;
 543 }
 544
 545 EXPORT_API int badge_setting_delete_package_for_uid(const char *pkgname, uid_t uid)
 546 {
 547         sqlite3 *db = NULL;
 548         sqlite3_stmt *db_statement = NULL;
 549         int ret = BADGE_ERROR_NONE;
 550         int sqlite3_ret = SQLITE_OK;
 551         int field_index = 1;
 552         bool is_package_in_setting_table = false;
 553
 554         sqlite3_ret = sqlite3_open_v2(BADGE_DB_PATH, &db, SQLITE_OPEN_READWRITE, NULL);
 555         if (sqlite3_ret != SQLITE_OK || db == NULL) {
 556                 ERR("db_util_open failed [%s][%d]", BADGE_DB_PATH, sqlite3_ret);
 557                 ret = BADGE_ERROR_FROM_DB;
 558                 goto out;
 559         }
 560
 561         is_package_in_setting_table = _is_package_in_setting_table(db, pkgname, NULL, uid);
 562         if (is_package_in_setting_table == false) {
 563                 INFO("[%s] is not exist", pkgname);
 564                 goto out;
 565         }
 566
 567         sqlite3_exec(db, "BEGIN immediate;", NULL, NULL, NULL);
 568
 569         sqlite3_ret = sqlite3_prepare_v2(db, "DELETE FROM badge_setting WHERE uid = ? AND pkgname = ? ", -1, &db_statement, NULL);
 570         if (sqlite3_ret != SQLITE_OK) {
 571                 ERR("sqlite3_prepare_v2 failed [%d][%s]", sqlite3_ret,
 572                                         sqlite3_errmsg(db));
 573                 ret = BADGE_ERROR_FROM_DB;
 574                 goto out;
 575         }
 576
 577         sqlite3_bind_int(db_statement, field_index++, uid);
 578         sqlite3_bind_text(db_statement, field_index++, pkgname, -1, SQLITE_TRANSIENT);
 579
 580         sqlite3_ret = sqlite3_step(db_statement);
 581         if (sqlite3_ret != SQLITE_OK && sqlite3_ret != SQLITE_DONE) {
 582                 ERR("sqlite3_step failed [%d][%s]", sqlite3_ret,
 583                                         sqlite3_errmsg(db));
 584                 ret = BADGE_ERROR_FROM_DB;
 585         }
 586
 587 out:
 588         if (db_statement)
 589                 sqlite3_finalize(db_statement);
 590         if (db) {
 591                 if (ret == BADGE_ERROR_NONE)
 592                         sqlite3_exec(db, "END;", NULL, NULL, NULL);
 593                 else
 594                         sqlite3_exec(db, "ROLLBACK;", NULL, NULL, NULL);
 595
 596                 if ((sqlite3_ret = db_util_close(db)) != SQLITE_OK)
 597                         WARN("db_util_close failed [%d]", sqlite3_ret);
 598         }
 599
 600         return ret;
 601 }
 602
 603 EXPORT_API int badge_setting_refresh_setting_table(uid_t uid)
 604 {
 605         int ret = BADGE_ERROR_NONE;
 606         int sql_ret;
 607         int pkgmgr_ret;
 608         sqlite3 *db = NULL;
 609         badge_setting_info info;
 610         pkgmgrinfo_pkginfo_filter_h filter;
 611
 612         sql_ret = sqlite3_open_v2(BADGE_DB_PATH, &db, SQLITE_OPEN_READWRITE, NULL);
 613         if (sql_ret != SQLITE_OK || db == NULL) {
 614                 ERR("sqlite3_open_v2 fail [%s][%d]", BADGE_DB_PATH, sql_ret);
 615                 return BADGE_ERROR_FROM_DB;
 616         }
 617
 618         sqlite3_exec(db, "BEGIN immediate;", NULL, NULL, NULL);
 619
 620         pkgmgr_ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 621         if (pkgmgr_ret != PMINFO_R_OK) {
 622                 ERR("pkgmgrinfo_pkginfo_filter_create failed [%d]", pkgmgr_ret);
 623                 ret = BADGE_ERROR_FROM_DB;
 624                 goto out;
 625         }
 626
 627         info.db = db;
 628         info.uid = uid;
 629         pkgmgr_ret = pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(filter, package_info_callback, &info, uid);
 630         if (pkgmgr_ret != PMINFO_R_OK) {
 631                 ERR("pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo failed [%d]",
 632                                         pkgmgr_ret);
 633                 ret = BADGE_ERROR_FROM_DB;
 634                 goto out;
 635         }
 636
 637 out:
 638         if (filter)
 639                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 640         if (db) {
 641                 if (ret == BADGE_ERROR_NONE)
 642                         sqlite3_exec(db, "END;", NULL, NULL, NULL);
 643                 else
 644                         sqlite3_exec(db, "ROLLBACK;", NULL, NULL, NULL);
 645                 if ((sql_ret = db_util_close(db)) != SQLITE_OK)
 646                         WARN("fail to db_util_close [%d]", sql_ret);
 647         }
 648
 649         return ret;
 650 }
 651