src/badge_internal.c

   1 /*
   2  * Copyright (c) 2000 - 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
  18 #include <string.h>
  19 #include <stdlib.h>
  20 #include <stdarg.h>
  21 #include <fcntl.h>
  22 #include <unistd.h>
  23 #include <glib.h>
  24 #include <gio/gio.h>
  25 #include <dbus/dbus.h>
  26 #include <dbus/dbus-glib-lowlevel.h>
  27 #include <aul.h>
  28 #include <sqlite3.h>
  29 #include <db-util.h>
  30 #include <package_manager.h>
  31 #include <tzplatform_config.h>
  32
  33 #include "badge_log.h"
  34 #include "badge_error.h"
  35 #include "badge_internal.h"
  36 #include "badge_ipc.h"
  37 #include "badge_db.h"
  38
  39 #define BADGE_PKGNAME_LEN 512
  40 #define BADGE_TABLE_NAME "badge_data"
  41 #define BADGE_OPTION_TABLE_NAME "badge_option"
  42
  43 #define BADGE_CHANGED_NOTI      "badge_changed"
  44
  45 struct _badge_h {
  46         char *pkgname;
  47         char *writable_pkgs;
  48 };
  49
  50 struct _badge_cb_data {
  51         badge_change_cb callback;
  52         void *data;
  53 };
  54
  55 static GHashTable *_badge_cb_hash = NULL;
  56
  57 static inline long _get_max_len(void)
  58 {
  59         long max = 0;
  60         long path_max_len = 4096;
  61
  62 #ifdef _PC_PATH_MAX
  63         max = (pathconf("/", _PC_PATH_MAX) < 1 ? path_max_len
  64                                 : pathconf("/", _PC_PATH_MAX));
  65 #else /* _PC_PATH_MAX */
  66         max = path_max_len;
  67 #endif /* _PC_PATH_MAX */
  68         return max;
  69 }
  70
  71 char *_badge_get_pkgname_by_pid(void)
  72 {
  73         char *pkgname = NULL;
  74         int pid = 0;
  75         int ret = AUL_R_OK;
  76         int fd = 0;
  77         long max = 0;
  78
  79         pid = getpid();
  80         max = _get_max_len();
  81         pkgname = malloc(max);
  82         if (!pkgname) {
  83                 /* LCOV_EXCL_START */
  84                 ERR("fail to alloc memory");
  85                 return NULL;
  86                 /* LCOV_EXCL_STOP */
  87         }
  88         memset(pkgname, 0x00, max);
  89
  90         ret = aul_app_get_pkgname_bypid(pid, pkgname, max);
  91         if (ret != AUL_R_OK) {
  92                 fd = open("/proc/self/cmdline", O_RDONLY);
  93                 if (fd < 0) {
  94                         /* LCOV_EXCL_START */
  95                         free(pkgname);
  96                         return NULL;
  97                         /* LCOV_EXCL_STOP */
  98                 }
  99
 100                 ret = read(fd, pkgname, max - 1);
 101                 if (ret <= 0) {
 102                         /* LCOV_EXCL_START */
 103                         close(fd);
 104                         free(pkgname);
 105                         return NULL;
 106                         /* LCOV_EXCL_STOP */
 107                 }
 108
 109                 close(fd);
 110         }
 111
 112         if (pkgname[0] == '\0') {
 113                 /* LCOV_EXCL_START */
 114                 free(pkgname);
 115                 return NULL;
 116                 /* LCOV_EXCL_STOP */
 117         } else {
 118                 return pkgname;
 119         }
 120 }
 121
 122 static int _badge_check_data_inserted(const char *pkgname,
 123                                         sqlite3 *db, uid_t uid)
 124 {
 125         sqlite3_stmt *stmt = NULL;
 126         int count = 0;
 127         int result = BADGE_ERROR_NONE;
 128         char *sqlbuf = NULL;
 129         int sqlret;
 130
 131         if (!pkgname)
 132                 return BADGE_ERROR_INVALID_PARAMETER;
 133
 134         if (!db)
 135                 return BADGE_ERROR_INVALID_PARAMETER;
 136
 137         sqlbuf = sqlite3_mprintf("SELECT count(*) FROM %q WHERE " \
 138                          "pkgname = %Q AND uid = %d",
 139                          BADGE_TABLE_NAME, pkgname, uid);
 140
 141         if (!sqlbuf) {
 142                 /* LCOV_EXCL_START */
 143                 ERR("fail to alloc sql query");
 144                 return BADGE_ERROR_OUT_OF_MEMORY;
 145                 /* LCOV_EXCL_STOP */
 146         }
 147
 148         sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL);
 149         if (sqlret != SQLITE_OK) {
 150                 /* LCOV_EXCL_START */
 151                 ERR("DB err [%s]", sqlite3_errmsg(db));
 152                 ERR("query[%s]", sqlbuf);
 153                 result = BADGE_ERROR_FROM_DB;
 154                 goto free_and_return;
 155                 /* LCOV_EXCL_STOP */
 156         }
 157
 158         sqlret = sqlite3_step(stmt);
 159         if (sqlret == SQLITE_ROW)
 160                 count = sqlite3_column_int(stmt, 0);
 161         else
 162                 count = 0;
 163
 164         DBG("[%s], DB search result[%d]", sqlbuf, count);
 165
 166         if (count > 0)
 167                 result = BADGE_ERROR_ALREADY_EXIST;
 168         else
 169                 result = BADGE_ERROR_NOT_EXIST;
 170
 171 free_and_return:
 172         if (sqlbuf)
 173                 sqlite3_free(sqlbuf);
 174
 175         if (stmt)
 176                 sqlite3_finalize(stmt);
 177
 178         return result;
 179 }
 180
 181 static int _badge_check_option_inserted(const char *pkgname,
 182                                         sqlite3 *db, uid_t uid)
 183 {
 184         sqlite3_stmt *stmt = NULL;
 185         int count = 0;
 186         int result = BADGE_ERROR_NONE;
 187         char *sqlbuf = NULL;
 188         int sqlret;
 189
 190         if (!pkgname)
 191                 return BADGE_ERROR_INVALID_PARAMETER;
 192
 193         if (!db)
 194                 return BADGE_ERROR_INVALID_PARAMETER;
 195
 196         sqlbuf = sqlite3_mprintf("SELECT count(*) FROM %q WHERE " \
 197                          "pkgname = %Q AND uid = %d",
 198                          BADGE_OPTION_TABLE_NAME, pkgname, uid);
 199
 200         if (!sqlbuf) {
 201                 /* LCOV_EXCL_START */
 202                 ERR("fail to alloc sql query");
 203                 return BADGE_ERROR_OUT_OF_MEMORY;
 204                 /* LCOV_EXCL_STOP */
 205         }
 206
 207         sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL);
 208         if (sqlret != SQLITE_OK) {
 209                 /* LCOV_EXCL_START */
 210                 ERR("DB err [%s]", sqlite3_errmsg(db));
 211                 ERR("query[%s]", sqlbuf);
 212                 result = BADGE_ERROR_FROM_DB;
 213                 goto free_and_return;
 214                 /* LCOV_EXCL_STOP */
 215         }
 216
 217         sqlret = sqlite3_step(stmt);
 218         if (sqlret == SQLITE_ROW)
 219                 count = sqlite3_column_int(stmt, 0);
 220         else
 221                 count = 0;
 222
 223         DBG("[%s], DB search result[%d]", sqlbuf, count);
 224
 225         if (count > 0)
 226                 result = BADGE_ERROR_ALREADY_EXIST;
 227         else
 228                 result = BADGE_ERROR_NOT_EXIST;
 229
 230 free_and_return:
 231         if (sqlbuf)
 232                 sqlite3_free(sqlbuf);
 233
 234         if (stmt)
 235                 sqlite3_finalize(stmt);
 236
 237         return result;
 238 }
 239
 240 static int _is_same_certinfo(const char *caller, const char *pkgname)
 241 {
 242         int ret = PACKAGE_MANAGER_ERROR_NONE;
 243         package_manager_compare_result_type_e compare_result = PACKAGE_MANAGER_COMPARE_MISMATCH;
 244
 245         if (!caller)
 246                 return 0;
 247
 248         if (!pkgname)
 249                 return 0;
 250
 251         ret = package_manager_compare_package_cert_info(pkgname, caller, &compare_result);
 252         if (ret == PACKAGE_MANAGER_ERROR_NONE &&
 253                 compare_result == PACKAGE_MANAGER_COMPARE_MATCH)
 254                 return 1;
 255
 256         return 0;
 257 }
 258
 259 static int _badge_check_writable(const char *caller,
 260                         const char *pkgname, sqlite3 *db, uid_t uid)
 261 {
 262         sqlite3_stmt *stmt = NULL;
 263         int count = 0;
 264         int result = BADGE_ERROR_NONE;
 265         char *sqlbuf = NULL;
 266         int sqlret;
 267
 268         if (!db)
 269                 return BADGE_ERROR_INVALID_PARAMETER;
 270
 271         if (!caller)
 272                 return BADGE_ERROR_INVALID_PARAMETER;
 273
 274         if (!pkgname)
 275                 return BADGE_ERROR_INVALID_PARAMETER;
 276
 277         if (g_strcmp0(caller, pkgname) == 0)
 278                 return BADGE_ERROR_NONE;
 279
 280         /* LCOV_EXCL_START */
 281         if (_is_same_certinfo(caller, pkgname) == 1)
 282                 return BADGE_ERROR_NONE;
 283
 284         sqlbuf = sqlite3_mprintf("SELECT COUNT(*) FROM %q WHERE " \
 285                          "pkgname = %Q AND writable_pkgs LIKE '%%%q%%'" \
 286                          "AND uid = %d",
 287                          BADGE_TABLE_NAME,
 288                          pkgname, caller, uid);
 289         if (!sqlbuf) {
 290                 ERR("fail to alloc sql query");
 291                 return BADGE_ERROR_OUT_OF_MEMORY;
 292         }
 293
 294         sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL);
 295         if (sqlret != SQLITE_OK) {
 296                 ERR("DB err [%s]", sqlite3_errmsg(db));
 297                 ERR("query[%s]", sqlbuf);
 298                 result = BADGE_ERROR_FROM_DB;
 299                 goto free_and_return;
 300         }
 301
 302         sqlret = sqlite3_step(stmt);
 303         if (sqlret == SQLITE_ROW)
 304                 count = sqlite3_column_int(stmt, 0);
 305         else
 306                 count = 0;
 307
 308         DBG("[%s], DB search result[%d]", sqlbuf, count);
 309
 310         if (count <= 0)
 311                 result = BADGE_ERROR_PERMISSION_DENIED;
 312
 313 free_and_return:
 314         if (sqlbuf)
 315                 sqlite3_free(sqlbuf);
 316
 317         if (stmt)
 318                 sqlite3_finalize(stmt);
 319
 320         return result;
 321         /* LCOV_EXCL_STOP */
 322 }
 323
 324 int _badge_is_existing(const char *pkgname, bool *existing, uid_t uid)
 325 {
 326         sqlite3 *db = NULL;
 327         int sqlret;
 328         int result = BADGE_ERROR_NONE;
 329
 330         if (!pkgname || !existing) {
 331                 /* LCOV_EXCL_START */
 332                 ERR("pkgname : %s, existing : %p", pkgname, existing);
 333                 return BADGE_ERROR_INVALID_PARAMETER;
 334                 /* LCOV_EXCL_STOP */
 335         }
 336
 337         sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
 338         if (sqlret != SQLITE_OK || !db) {
 339                 /* LCOV_EXCL_START */
 340                 ERR("fail to db_util_open - [%d]", sqlret);
 341                 if (sqlret == SQLITE_PERM)
 342                         return BADGE_ERROR_PERMISSION_DENIED;
 343                 return BADGE_ERROR_FROM_DB;
 344                 /* LCOV_EXCL_STOP */
 345         }
 346
 347         result = _badge_check_data_inserted(pkgname, db, uid);
 348         if (result == BADGE_ERROR_ALREADY_EXIST) {
 349                 *existing = TRUE;
 350                 result = BADGE_ERROR_NONE;
 351         } else if (result == BADGE_ERROR_NOT_EXIST) {
 352                 *existing = FALSE;
 353                 result = BADGE_ERROR_NONE;
 354         }
 355
 356         sqlret = db_util_close(db);
 357         if (sqlret != SQLITE_OK)
 358                 WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 359
 360         return result;
 361 }
 362
 363 int _badge_get_list(GList **badge_list, uid_t uid)
 364 {
 365         sqlite3 *db = NULL;
 366         int result = BADGE_ERROR_NONE;
 367         char *sqlbuf = NULL;
 368         sqlite3_stmt *stmt = NULL;
 369         int sqlret;
 370         const char *pkg;
 371         unsigned int badge_count;
 372         badge_info_s *badge_info;
 373
 374         sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
 375         if (sqlret != SQLITE_OK || !db) {
 376                 /* LCOV_EXCL_START */
 377                 ERR("fail to db_util_open - [%d]", sqlret);
 378                 return BADGE_ERROR_FROM_DB;
 379                 /* LCOV_EXCL_STOP */
 380         }
 381
 382         sqlbuf = sqlite3_mprintf("SELECT pkgname, badge FROM %q WHERE uid = %d",
 383                                 BADGE_TABLE_NAME, uid);
 384         if (!sqlbuf) {
 385                 /* LCOV_EXCL_START */
 386                 ERR("fail to alloc sql query");
 387                 result = BADGE_ERROR_OUT_OF_MEMORY;
 388                 goto free_and_return;
 389                 /* LCOV_EXCL_STOP */
 390         }
 391
 392         sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL);
 393         if (sqlret != SQLITE_OK) {
 394                 /* LCOV_EXCL_START */
 395                 ERR("fail to sqlite3_prepare_v2 - [%s]", sqlite3_errmsg(db));
 396                 ERR("query[%s]", sqlbuf);
 397                 result = BADGE_ERROR_FROM_DB;
 398                 goto free_and_return;
 399                 /* LCOV_EXCL_STOP */
 400         }
 401
 402         sqlret = sqlite3_step(stmt);
 403         if (sqlret == SQLITE_DONE) {
 404                 INFO("badge db has no data");
 405                 result = BADGE_ERROR_NOT_EXIST;
 406                 goto free_and_return;
 407         } else if (sqlret != SQLITE_ROW) {
 408                 ERR("fail to sqlite3_step : %d", sqlret);
 409                 result = BADGE_ERROR_FROM_DB;
 410                 goto free_and_return;
 411         }
 412
 413         do {
 414                 pkg = (const char *)sqlite3_column_text(stmt, 0);
 415                 badge_count = (unsigned int)sqlite3_column_int(stmt, 1);
 416                 if (pkg) {
 417                         badge_info = (badge_info_s *)calloc(sizeof(badge_info_s), 1);
 418                         if (badge_info == NULL) {
 419                                 /* LCOV_EXCL_START */
 420                                 ERR("alloc badge_info fail");
 421                                 result = BADGE_ERROR_OUT_OF_MEMORY;
 422                                 break;
 423                                 /* LCOV_EXCL_STOP */
 424                         }
 425                         badge_info->pkg = strdup(pkg);
 426                         badge_info->badge_count = badge_count;
 427                         *badge_list = g_list_append(*badge_list, badge_info);
 428                 } else {
 429                         /* LCOV_EXCL_START */
 430                         ERR("db has invaild data");
 431                         result = BADGE_ERROR_FROM_DB;
 432                         /* LCOV_EXCL_STOP */
 433                 }
 434         } while (sqlite3_step(stmt) == SQLITE_ROW);
 435
 436 free_and_return:
 437         if (sqlbuf)
 438                 sqlite3_free(sqlbuf);
 439
 440         if (stmt)
 441                 sqlite3_finalize(stmt);
 442
 443         sqlret = db_util_close(db);
 444         if (sqlret != SQLITE_OK)
 445                 WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 446
 447         return result;
 448 }
 449
 450 int _badge_insert(badge_h *badge, uid_t uid)
 451 {
 452         sqlite3 *db = NULL;
 453         int sqlret;
 454         int ret = BADGE_ERROR_NONE;
 455         int result = BADGE_ERROR_NONE;
 456         char *sqlbuf = NULL;
 457
 458         if (!badge || !badge->pkgname || !badge->writable_pkgs)
 459                 return BADGE_ERROR_INVALID_PARAMETER;
 460
 461         sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
 462         if (sqlret != SQLITE_OK || !db) {
 463                 /* LCOV_EXCL_START */
 464                 ERR("fail to db_util_open - [%s][%d]", BADGE_DB_PATH, sqlret);
 465                 return BADGE_ERROR_FROM_DB;
 466                 /* LCOV_EXCL_STOP */
 467         }
 468
 469         /* Check pkgname & id */
 470         ret = _badge_check_data_inserted(badge->pkgname, db, uid);
 471         if (ret != BADGE_ERROR_NOT_EXIST) {
 472                 /* LCOV_EXCL_START */
 473                 result = ret;
 474                 goto return_close_db;
 475                 /* LCOV_EXCL_STOP */
 476         }
 477
 478         sqlbuf = sqlite3_mprintf("INSERT INTO %q " \
 479                         "(pkgname, " \
 480                         "writable_pkgs, " \
 481                         "uid) "\
 482                         "VALUES " \
 483                         "(%Q, %Q, %d);",
 484                          BADGE_TABLE_NAME,
 485                          badge->pkgname, badge->writable_pkgs, uid);
 486         if (!sqlbuf) {
 487                 /* LCOV_EXCL_START */
 488                 ERR("fail to alloc query");
 489                 result = BADGE_ERROR_OUT_OF_MEMORY;
 490                 goto return_close_db;
 491                 /* LCOV_EXCL_STOP */
 492         }
 493
 494         ret = badge_db_exec(db, sqlbuf, NULL);
 495         if (ret != BADGE_ERROR_NONE) {
 496                 /* LCOV_EXCL_START */
 497                 ERR("failed to insert badge[%s], err[%d]",
 498                                         badge->pkgname, ret);
 499                 result = ret;
 500                 goto return_close_db;
 501                 /* LCOV_EXCL_STOP */
 502         }
 503
 504         /* inserting badge options */
 505         ret = _badge_check_option_inserted(badge->pkgname, db, uid);
 506         if (ret != BADGE_ERROR_NOT_EXIST) {
 507                 result = ret;
 508                 goto return_close_db;
 509         }
 510
 511         sqlbuf = sqlite3_mprintf("INSERT INTO %q " \
 512                         "(pkgname, " \
 513                         "uid) " \
 514                         "VALUES "
 515                         "(%Q, %d);",
 516                         BADGE_OPTION_TABLE_NAME,
 517                          badge->pkgname, uid);
 518         if (!sqlbuf) {
 519                 /* LCOV_EXCL_START */
 520                 ERR("fail to alloc query");
 521                 result = BADGE_ERROR_OUT_OF_MEMORY;
 522                 goto return_close_db;
 523                 /* LCOV_EXCL_STOP */
 524         }
 525
 526         ret = badge_db_exec(db, sqlbuf, NULL);
 527         if (ret != BADGE_ERROR_NONE) {
 528                 /* LCOV_EXCL_START */
 529                 ERR("failed to insert badge option[%s], err[%d]",
 530                                         badge->pkgname, sqlret);
 531                 result = ret;
 532                 goto return_close_db;
 533                 /* LCOV_EXCL_STOP */
 534         }
 535
 536 return_close_db:
 537         if (sqlbuf)
 538                 sqlite3_free(sqlbuf);
 539
 540         sqlret = db_util_close(db);
 541         if (sqlret != SQLITE_OK)
 542                 WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 543
 544         return result;
 545 }
 546
 547 int _badge_remove(const char *caller, const char *pkgname, uid_t uid)
 548 {
 549         int ret = BADGE_ERROR_NONE;
 550         int result = BADGE_ERROR_NONE;
 551         sqlite3 *db = NULL;
 552         int sqlret;
 553         char *sqlbuf = NULL;
 554
 555         if (!caller)
 556                 return BADGE_ERROR_INVALID_PARAMETER;
 557
 558         if (!pkgname)
 559                 return BADGE_ERROR_INVALID_PARAMETER;
 560
 561         sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
 562         if (sqlret != SQLITE_OK || !db) {
 563                 /* LCOV_EXCL_START */
 564                 ERR("fail to db_util_open - [%d]", sqlret);
 565                 return BADGE_ERROR_FROM_DB;
 566                 /* LCOV_EXCL_STOP */
 567         }
 568
 569         ret = _badge_check_data_inserted(pkgname, db, uid);
 570         if (ret != BADGE_ERROR_ALREADY_EXIST) {
 571                 result = ret;
 572                 goto return_close_db;
 573         }
 574
 575         ret = _badge_check_writable(caller, pkgname, db, uid);
 576         if (ret != BADGE_ERROR_NONE) {
 577                 result = ret;
 578                 goto return_close_db;
 579         }
 580
 581         sqlbuf = sqlite3_mprintf("DELETE FROM %q WHERE pkgname = %Q AND uid = %d",
 582                          BADGE_TABLE_NAME, pkgname, uid);
 583         if (!sqlbuf) {
 584                 /* LCOV_EXCL_START */
 585                 ERR("fail to alloc query");
 586                 result = BADGE_ERROR_OUT_OF_MEMORY;
 587                 goto return_close_db;
 588                 /* LCOV_EXCL_STOP */
 589         }
 590
 591         ret = badge_db_exec(db, sqlbuf, NULL);
 592         if (ret != BADGE_ERROR_NONE) {
 593                 ERR("failed to remove badge[%s], err[%d]",
 594                                 pkgname, ret);
 595                 result = ret;
 596                 goto return_close_db;
 597         }
 598
 599         /* treating option table */
 600         ret = _badge_check_option_inserted(pkgname, db, uid);
 601         if (ret != BADGE_ERROR_ALREADY_EXIST) {
 602                 result = ret;
 603                 goto return_close_db;
 604         }
 605
 606         sqlbuf = sqlite3_mprintf("DELETE FROM %q WHERE pkgname = %Q AND uid = %d",
 607                         BADGE_OPTION_TABLE_NAME, pkgname, uid);
 608         if (!sqlbuf) {
 609                 /* LCOV_EXCL_START */
 610                 ERR("fail to alloc query");
 611                 result = BADGE_ERROR_OUT_OF_MEMORY;
 612                 goto return_close_db;
 613                 /* LCOV_EXCL_STOP */
 614         }
 615
 616         ret = badge_db_exec(db, sqlbuf, NULL);
 617         if (ret != BADGE_ERROR_NONE) {
 618                 /* LCOV_EXCL_START */
 619                 ERR("failed to remove badge option[%s], err[%d]",
 620                                 pkgname, ret);
 621                 result = ret;
 622                 goto return_close_db;
 623                 /* LCOV_EXCL_STOP */
 624         }
 625
 626 return_close_db:
 627         if (sqlbuf)
 628                 sqlite3_free(sqlbuf);
 629
 630         sqlret = db_util_close(db);
 631         if (sqlret != SQLITE_OK)
 632                 WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 633
 634         return result;
 635 }
 636
 637 int _badge_set_count(const char *caller, const char *pkgname,
 638                         unsigned int count, uid_t uid)
 639 {
 640         int ret = BADGE_ERROR_NONE;
 641         int result = BADGE_ERROR_NONE;
 642         sqlite3 *db = NULL;
 643         char *sqlbuf = NULL;
 644         int sqlret;
 645
 646         if (!caller)
 647                 return BADGE_ERROR_INVALID_PARAMETER;
 648
 649         if (!pkgname)
 650                 return BADGE_ERROR_INVALID_PARAMETER;
 651
 652         sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
 653         if (sqlret != SQLITE_OK || !db) {
 654                 /* LCOV_EXCL_START */
 655                 ERR("fail to db_util_open - [%d]", sqlret);
 656                 return BADGE_ERROR_FROM_DB;
 657                 /* LCOV_EXCL_STOP */
 658         }
 659
 660         ret = _badge_check_data_inserted(pkgname, db, uid);
 661         if (ret != BADGE_ERROR_ALREADY_EXIST) {
 662                 result = ret;
 663                 goto return_close_db;
 664         }
 665
 666         ret = _badge_check_writable(caller, pkgname, db, uid);
 667         if (ret != BADGE_ERROR_NONE) {
 668                 result = ret;
 669                 goto return_close_db;
 670         }
 671
 672         sqlbuf = sqlite3_mprintf("UPDATE %q SET badge = %d " \
 673                         "WHERE pkgname = %Q AND uid = %d",
 674                          BADGE_TABLE_NAME, count, pkgname, uid);
 675         if (!sqlbuf) {
 676                 /* LCOV_EXCL_START */
 677                 ERR("fail to alloc query");
 678                 result = BADGE_ERROR_OUT_OF_MEMORY;
 679                 goto return_close_db;
 680                 /* LCOV_EXCL_STOP */
 681         }
 682
 683         ret = badge_db_exec(db, sqlbuf, NULL);
 684         if (ret != BADGE_ERROR_NONE) {
 685                 /* LCOV_EXCL_START */
 686                 ERR("failed to set badge[%s] count[%d], err[%d]",
 687                                 pkgname, count, ret);
 688                 result = ret;
 689                 goto return_close_db;
 690                 /* LCOV_EXCL_STOP */
 691         }
 692
 693 return_close_db:
 694         if (sqlbuf)
 695                 sqlite3_free(sqlbuf);
 696
 697         sqlret = db_util_close(db);
 698         if (sqlret != SQLITE_OK)
 699                 WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 700
 701         return result;
 702 }
 703
 704 int _badge_get_count(const char *pkgname, unsigned int *count, uid_t uid)
 705 {
 706         int ret = BADGE_ERROR_NONE;
 707         int result = BADGE_ERROR_NONE;
 708         sqlite3 *db = NULL;
 709         char *sqlbuf = NULL;
 710         sqlite3_stmt *stmt = NULL;
 711         int sqlret;
 712
 713         if (!pkgname)
 714                 return BADGE_ERROR_INVALID_PARAMETER;
 715
 716         if (!count)
 717                 return BADGE_ERROR_INVALID_PARAMETER;
 718
 719         sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
 720         if (sqlret != SQLITE_OK || !db) {
 721                 /* LCOV_EXCL_START */
 722                 ERR("fail to db_util_open - [%d]", sqlret);
 723                 if (sqlret == SQLITE_PERM)
 724                         return BADGE_ERROR_PERMISSION_DENIED;
 725                 else
 726                         return BADGE_ERROR_FROM_DB;
 727                 /* LCOV_EXCL_STOP */
 728         }
 729
 730         ret = _badge_check_data_inserted(pkgname, db, uid);
 731         if (ret != BADGE_ERROR_ALREADY_EXIST) {
 732                 result = ret;
 733                 goto return_close_db;
 734         }
 735
 736         sqlbuf = sqlite3_mprintf("SELECT badge FROM %q " \
 737                         "WHERE pkgname = %Q AND uid = %d",
 738                          BADGE_TABLE_NAME, pkgname, uid);
 739         if (!sqlbuf) {
 740                 /* LCOV_EXCL_START */
 741                 ERR("fail to alloc query");
 742                 result = BADGE_ERROR_OUT_OF_MEMORY;
 743                 goto return_close_db;
 744                 /* LCOV_EXCL_STOP */
 745         }
 746
 747         sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL);
 748         if (sqlret != SQLITE_OK) {
 749                 /* LCOV_EXCL_START */
 750                 ERR("fail to prepare %s - [%s]",
 751                                 sqlbuf, sqlite3_errmsg(db));
 752                 result = BADGE_ERROR_FROM_DB;
 753                 goto return_close_db;
 754                 /* LCOV_EXCL_STOP */
 755         }
 756
 757         sqlret = sqlite3_step(stmt);
 758         if (sqlret == SQLITE_ROW)
 759                 *count = (unsigned int)sqlite3_column_int(stmt, 0);
 760         else
 761                 *count = (unsigned int)0;
 762
 763 return_close_db:
 764         if (sqlbuf)
 765                 sqlite3_free(sqlbuf);
 766
 767         if (stmt)
 768                 sqlite3_finalize(stmt);
 769
 770         sqlret = db_util_close(db);
 771         if (sqlret != SQLITE_OK)
 772                 WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 773
 774         return result;
 775 }
 776
 777 int _badge_set_display(const char *pkgname, unsigned int is_display, uid_t uid)
 778 {
 779         int ret = BADGE_ERROR_NONE;
 780         int result = BADGE_ERROR_NONE;
 781         sqlite3 *db = NULL;
 782         char *sqlbuf = NULL;
 783         int sqlret;
 784
 785         if (!pkgname)
 786                 return BADGE_ERROR_INVALID_PARAMETER;
 787
 788         if (is_display != 0 && is_display != 1)
 789                 return BADGE_ERROR_INVALID_PARAMETER;
 790
 791         sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
 792         if (sqlret != SQLITE_OK || !db) {
 793                 /* LCOV_EXCL_START */
 794                 ERR("fail to db_util_open - [%d]", sqlret);
 795                 return BADGE_ERROR_FROM_DB;
 796                 /* LCOV_EXCL_STOP */
 797         }
 798
 799 #if 0 /* Temporary */
 800         ret = _badge_check_data_inserted(pkgname, db, uid);
 801         if (ret != BADGE_ERROR_ALREADY_EXIST) {
 802                 result = ret;
 803                 goto return_close_db;
 804         }
 805 #endif
 806         ret = _badge_check_option_inserted(pkgname, db, uid);
 807         if (ret == BADGE_ERROR_ALREADY_EXIST) {
 808                 sqlbuf = sqlite3_mprintf("UPDATE %q SET display = %d " \
 809                                 "WHERE pkgname = %Q AND uid = %d",
 810                                 BADGE_OPTION_TABLE_NAME, is_display, pkgname, uid);
 811                 if (!sqlbuf) {
 812                         /* LCOV_EXCL_START */
 813                         ERR("fail to alloc query");
 814                         result = BADGE_ERROR_OUT_OF_MEMORY;
 815                         goto return_close_db;
 816                         /* LCOV_EXCL_STOP */
 817                 }
 818
 819                 ret = badge_db_exec(db, sqlbuf, NULL);
 820                 if (ret != BADGE_ERROR_NONE) {
 821                         /* LCOV_EXCL_START */
 822                         ERR("failed to set badge[%s] option[%d], err[%d]",
 823                                         pkgname, is_display, ret);
 824                         result = ret;
 825                         goto return_close_db;
 826                         /* LCOV_EXCL_STOP */
 827                 }
 828
 829         } else if (ret == BADGE_ERROR_NOT_EXIST) {
 830                 sqlbuf = sqlite3_mprintf("INSERT INTO %q " \
 831                                 "(pkgname, " \
 832                                 "display, " \
 833                                 "uid) " \
 834                                 "VALUES "
 835                                 "(%Q, %d, %d);",
 836                                 BADGE_OPTION_TABLE_NAME,
 837                                 pkgname, is_display, uid);
 838                 if (!sqlbuf) {
 839                         /* LCOV_EXCL_START */
 840                         ERR("fail to alloc query");
 841                         result = BADGE_ERROR_OUT_OF_MEMORY;
 842                         goto return_close_db;
 843                         /* LCOV_EXCL_STOP */
 844                 }
 845
 846                 ret = badge_db_exec(db, sqlbuf, NULL);
 847                 if (ret != BADGE_ERROR_NONE) {
 848                         /* LCOV_EXCL_START */
 849                         ERR("failed to set badge[%s] option[%d], err[%d]",
 850                                         pkgname, is_display, ret);
 851                         result = ret;
 852                         goto return_close_db;
 853                         /* LCOV_EXCL_STOP */
 854                 }
 855         } else {
 856                 result = ret;
 857                 goto return_close_db;
 858         }
 859
 860 return_close_db:
 861         if (sqlbuf)
 862                 sqlite3_free(sqlbuf);
 863
 864         sqlret = db_util_close(db);
 865         if (sqlret != SQLITE_OK)
 866                 WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 867
 868         return result;
 869 }
 870
 871 int _badge_get_display(const char *pkgname, unsigned int *is_display, uid_t uid)
 872 {
 873         int ret = BADGE_ERROR_NONE;
 874         int result = BADGE_ERROR_NONE;
 875         sqlite3 *db = NULL;
 876         char *sqlbuf = NULL;
 877         sqlite3_stmt *stmt = NULL;
 878         int sqlret;
 879
 880         if (!pkgname)
 881                 return BADGE_ERROR_INVALID_PARAMETER;
 882
 883         if (!is_display)
 884                 return BADGE_ERROR_INVALID_PARAMETER;
 885
 886         sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
 887         if (sqlret != SQLITE_OK || !db) {
 888                 /* LCOV_EXCL_START */
 889                 ERR("fail to db_util_open - [%d]", sqlret);
 890                 if (sqlret == SQLITE_PERM)
 891                         return BADGE_ERROR_PERMISSION_DENIED;
 892                 else
 893                         return BADGE_ERROR_FROM_DB;
 894                 /* LCOV_EXCL_STOP */
 895         }
 896
 897         ret = _badge_check_option_inserted(pkgname, db, uid);
 898         if (ret != BADGE_ERROR_ALREADY_EXIST) {
 899                 if (ret == BADGE_ERROR_NOT_EXIST)
 900                         *is_display = 1;
 901
 902                 result = ret;
 903                 goto return_close_db;
 904         }
 905
 906         sqlbuf = sqlite3_mprintf("SELECT display FROM %q " \
 907                         "WHERE pkgname = %Q AND uid = %d",
 908                         BADGE_OPTION_TABLE_NAME, pkgname, uid);
 909         if (!sqlbuf) {
 910                 /* LCOV_EXCL_START */
 911                 ERR("fail to alloc query");
 912                 result = BADGE_ERROR_OUT_OF_MEMORY;
 913                 goto return_close_db;
 914                 /* LCOV_EXCL_STOP */
 915         }
 916
 917         sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL);
 918         if (sqlret != SQLITE_OK) {
 919                 /* LCOV_EXCL_START */
 920                 ERR("fail to prepare %s - [%s]",
 921                                 sqlbuf, sqlite3_errmsg(db));
 922                 result = BADGE_ERROR_FROM_DB;
 923                 goto return_close_db;
 924                 /* LCOV_EXCL_STOP */
 925         }
 926
 927         sqlret = sqlite3_step(stmt);
 928         if (sqlret == SQLITE_ROW)
 929                 *is_display = (unsigned int)sqlite3_column_int(stmt, 0);
 930         else
 931                 *is_display = (unsigned int)1;
 932
 933 return_close_db:
 934         if (sqlbuf)
 935                 sqlite3_free(sqlbuf);
 936
 937         if (stmt)
 938                 sqlite3_finalize(stmt);
 939
 940         sqlret = db_util_close(db);
 941         if (sqlret != SQLITE_OK)
 942                 WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 943
 944         return result;
 945 }
 946
 947 void badge_changed_cb_call(unsigned int action, const char *pkgname,
 948                         unsigned int count, uid_t uid)
 949 {
 950         GList *badge_cb_list = NULL;
 951         struct _badge_cb_data *bd = NULL;
 952
 953         DBG("call badge_change_cb");
 954
 955         if (_badge_cb_hash == NULL)
 956                 return;
 957
 958         badge_cb_list = (GList *)g_hash_table_lookup(_badge_cb_hash, GUINT_TO_POINTER(uid));
 959
 960         if (badge_cb_list == NULL) {
 961                 ERR("invalid data");
 962                 return;
 963         }
 964
 965         badge_cb_list = g_list_first(badge_cb_list);
 966
 967         for (; badge_cb_list != NULL; badge_cb_list = badge_cb_list->next) {
 968                 bd = badge_cb_list->data;
 969
 970                 if (bd != NULL && bd->callback != NULL) {
 971                         DBG("call badge_change_cb : action %d, pkgname %s, count %d",
 972                             action, pkgname, count);
 973                         bd->callback(action, pkgname, count, bd->data);
 974                 }
 975         }
 976 }
 977
 978 static int _badge_changed_monitor_init(uid_t uid)
 979 {
 980         return badge_ipc_monitor_init(uid);
 981 }
 982
 983 static void _badge_chanaged_monitor_fini()
 984 {
 985         badge_ipc_monitor_fini();
 986 }
 987
 988 static gint _badge_data_compare(gconstpointer a, gconstpointer b)
 989 {
 990         const struct _badge_cb_data *bd = NULL;
 991
 992         if (!a)
 993                 return -1;
 994         bd = (struct _badge_cb_data *)a;
 995
 996         if (bd->callback == b)
 997                 return 0;
 998
 999         return 1;
1000 }
1001
1002 static struct _badge_cb_data *__malloc_badge_cb_data(badge_change_cb callback, void *data)
1003 {
1004         struct _badge_cb_data *bd = NULL;
1005         bd = (struct _badge_cb_data *)malloc(sizeof(struct _badge_cb_data));
1006         if (bd == NULL) {
1007                 ERR("failed malloc badge_cb_data");
1008                 return NULL;
1009         }
1010
1011         bd->callback = callback;
1012         bd->data = data;
1013
1014         return bd;
1015 }
1016
1017 int _badge_register_changed_cb(badge_change_cb callback, void *data, uid_t uid)
1018 {
1019         struct _badge_cb_data *bd = NULL;
1020         GList *badge_cb_list = NULL;
1021         GList *badge_found_list = NULL;
1022         int ret;
1023
1024         if (callback == NULL)
1025                 return BADGE_ERROR_INVALID_PARAMETER;
1026
1027         if (_badge_cb_hash == NULL)
1028                 _badge_cb_hash = g_hash_table_new(g_direct_hash, g_direct_equal);
1029
1030         badge_cb_list = (GList *)g_hash_table_lookup(_badge_cb_hash, GUINT_TO_POINTER(uid));
1031
1032         if (badge_cb_list == NULL) {
1033                 bd = __malloc_badge_cb_data(callback, data);
1034                 if (!bd)
1035                         return BADGE_ERROR_OUT_OF_MEMORY;
1036
1037                 badge_cb_list = g_list_append(badge_cb_list, bd);
1038                 g_hash_table_insert(_badge_cb_hash, GUINT_TO_POINTER(uid), badge_cb_list);
1039         } else {
1040                 badge_found_list = g_list_find_custom(g_list_first(badge_cb_list), (gconstpointer)callback,
1041                                                       (GCompareFunc)_badge_data_compare);
1042                 if (badge_found_list) {
1043                         bd = g_list_nth_data(badge_found_list, 0);
1044                         bd->data = data;
1045                 } else {
1046                         bd = __malloc_badge_cb_data(callback, data);
1047                         if (!bd)
1048                                 return BADGE_ERROR_OUT_OF_MEMORY;
1049                         badge_cb_list = g_list_append(badge_cb_list, bd);
1050                 }
1051         }
1052
1053         ret = _badge_changed_monitor_init(uid);
1054         if (ret == BADGE_ERROR_NONE) {
1055                 ret = badge_ipc_init_badge(uid);
1056                 if (ret != BADGE_ERROR_NONE && ret != BADGE_ERROR_NOT_EXIST)
1057                         return ret;
1058         } else {
1059                 /* LCOV_EXCL_START */
1060                 ERR("badge_ipc_monitor_init err : %d", ret);
1061                 _badge_unregister_changed_cb(callback, uid);
1062                 return ret;
1063                 /* LCOV_EXCL_STOP */
1064         }
1065         return BADGE_ERROR_NONE;
1066 }
1067
1068 int _badge_unregister_changed_cb(badge_change_cb callback, uid_t uid)
1069 {
1070         GList *badge_cb_list = NULL;
1071         GList *badge_delete_list = NULL;
1072         struct _badge_cb_data *bd = NULL;
1073
1074         if (callback == NULL)
1075                 return BADGE_ERROR_INVALID_PARAMETER;
1076
1077         if (_badge_cb_hash == NULL)
1078                 return BADGE_ERROR_INVALID_PARAMETER;
1079
1080         badge_cb_list = (GList *)g_hash_table_lookup(_badge_cb_hash, GUINT_TO_POINTER(uid));
1081
1082         if (badge_cb_list == NULL)
1083                 return BADGE_ERROR_INVALID_PARAMETER;
1084
1085         badge_delete_list = g_list_find_custom(g_list_first(badge_cb_list), (gconstpointer)callback,
1086                                                (GCompareFunc)_badge_data_compare);
1087
1088         if (badge_delete_list) {
1089                 bd = g_list_nth_data(badge_delete_list, 0);
1090                 badge_cb_list = g_list_delete_link(badge_cb_list, badge_delete_list);
1091                 free(bd);
1092         } else {
1093                 return BADGE_ERROR_INVALID_PARAMETER;
1094         }
1095
1096         if (badge_cb_list == NULL)
1097                 g_hash_table_steal(_badge_cb_hash, GUINT_TO_POINTER(uid));
1098         else
1099                 g_hash_table_replace(_badge_cb_hash, GUINT_TO_POINTER(uid), badge_cb_list);
1100
1101         if (g_hash_table_size(_badge_cb_hash) == 0)
1102                 _badge_chanaged_monitor_fini();
1103
1104         return BADGE_ERROR_NONE;
1105 }
1106
1107 int _badge_free(badge_h *badge)
1108 {
1109         if (!badge)
1110                 return BADGE_ERROR_INVALID_PARAMETER;
1111
1112         if (badge->pkgname)
1113                 free(badge->pkgname);
1114
1115         if (badge->writable_pkgs)
1116                 free(badge->writable_pkgs);
1117
1118         free(badge);
1119
1120         return BADGE_ERROR_NONE;
1121 }
1122
1123 badge_h *_badge_new(const char *pkgname, const char *writable_pkgs,
1124                 int *err)
1125 {
1126         badge_h *badge = NULL;
1127
1128         if (!pkgname) {
1129                 ERR("PKGNAME is NULL");
1130                 if (err)
1131                         *err = BADGE_ERROR_INVALID_PARAMETER;
1132                 return NULL;
1133         }
1134
1135         if (!writable_pkgs) {
1136                 ERR("writable_pkgs is NULL");
1137                 if (err)
1138                         *err = BADGE_ERROR_INVALID_PARAMETER;
1139                 return NULL;
1140         }
1141
1142
1143         badge = (badge_h *)malloc(sizeof(struct _badge_h));
1144         if (!badge) {
1145                 ERR("fail to alloc handle");
1146                 if (err)
1147                         *err = BADGE_ERROR_OUT_OF_MEMORY;
1148                 return NULL;
1149         }
1150
1151         badge->pkgname = strdup(pkgname);
1152         badge->writable_pkgs = strdup(writable_pkgs);
1153         if (err)
1154                 *err = BADGE_ERROR_NONE;
1155
1156         return badge;
1157 }
1158
1159 char *_badge_pkgs_new(int *err, const char *pkg1, ...)
1160 {
1161         char *caller_pkgname = NULL;
1162         char *s = NULL;
1163         char *result = NULL;
1164         char *ptr = NULL;
1165         gsize length;
1166         va_list args;
1167         char *new_pkgs = NULL;
1168
1169         if (err)
1170                 *err = BADGE_ERROR_NONE;
1171
1172         caller_pkgname = _badge_get_pkgname_by_pid();
1173         if (!caller_pkgname) {
1174                 ERR("fail to get caller pkgname");
1175                 if (err)
1176                         *err = BADGE_ERROR_PERMISSION_DENIED;
1177                 return NULL;
1178         }
1179
1180         if (!pkg1) {
1181                 WARN("pkg1 is NULL");
1182                 return caller_pkgname;
1183         }
1184
1185         length = strlen(pkg1);
1186         va_start(args, pkg1);
1187         s = va_arg(args, char *);
1188         while (s) {
1189                 length += strlen(s) ;
1190                 s = va_arg(args, char *);
1191         }
1192         va_end(args);
1193
1194         if (length <= 0) {
1195                 WARN("length is %d", length);
1196                 return caller_pkgname;
1197         }
1198
1199         result = g_new0(char, length + 1); /* 1 for null terminate */
1200         if (!result) {
1201                 /* LCOV_EXCL_START */
1202                 ERR("fail to alloc memory");
1203                 if (err)
1204                         *err = BADGE_ERROR_OUT_OF_MEMORY;
1205                 free(caller_pkgname);
1206                 return NULL;
1207                 /* LCOV_EXCL_STOP */
1208         }
1209
1210         ptr = result;
1211         ptr = g_stpcpy(ptr, pkg1);
1212         va_start(args, pkg1);
1213         s = va_arg(args, char *);
1214         while (s) {
1215                 ptr = g_stpcpy(ptr, s);
1216                 s = va_arg(args, char *);
1217         }
1218         va_end(args);
1219
1220         if (g_strstr_len(result, -1, caller_pkgname) == NULL) {
1221                 new_pkgs = g_strdup_printf("%s%s", caller_pkgname, result);
1222                 if (!new_pkgs) {
1223                         ERR("fail to alloc memory");
1224                         if (err)
1225                                 *err = BADGE_ERROR_OUT_OF_MEMORY;
1226
1227                         free(result);
1228                         free(caller_pkgname);
1229                         return NULL;
1230                 }
1231                 free(result);
1232                 result = new_pkgs;
1233         }
1234
1235         free(caller_pkgname);
1236
1237         return result;
1238 }
1239
1240 EXPORT_API
1241 int badge_create_for_uid(const char *pkgname, const char *writable_pkg, uid_t uid)
1242 {
1243         char *caller = NULL;
1244         int err = BADGE_ERROR_NONE;
1245
1246         if (pkgname == NULL)
1247                 return BADGE_ERROR_INVALID_PARAMETER;
1248
1249
1250         caller = _badge_get_pkgname_by_pid();
1251         if (!caller) {
1252                 ERR("fail to get caller pkgname");
1253                 return BADGE_ERROR_PERMISSION_DENIED;
1254         }
1255
1256         err = badge_ipc_request_insert(pkgname, writable_pkg, caller, uid);
1257
1258         free(caller);
1259         return err;
1260 }
1261
1262 EXPORT_API
1263 int badge_new_for_uid(const char *writable_app_id, uid_t uid)
1264 {
1265         char *caller = NULL;
1266         int err = BADGE_ERROR_NONE;
1267
1268         caller = _badge_get_pkgname_by_pid();
1269         if (!caller) {
1270                 ERR("fail to get caller pkgname");
1271                 return BADGE_ERROR_PERMISSION_DENIED;
1272         }
1273
1274         err = badge_ipc_request_insert(caller, writable_app_id, caller, uid);
1275
1276         free(caller);
1277         return err;
1278 }
1279
1280 EXPORT_API
1281 int badge_add_for_uid(const char *badge_app_id, uid_t uid)
1282 {
1283         char *caller = NULL;
1284         int err = BADGE_ERROR_NONE;
1285
1286         caller = _badge_get_pkgname_by_pid();
1287         if (!caller) {
1288                 ERR("fail to get caller pkgname");
1289                 return BADGE_ERROR_PERMISSION_DENIED;
1290         }
1291
1292         if (badge_app_id == NULL) {
1293                 badge_app_id = caller;
1294         } else {
1295                 int pkgmgr_ret  = PACKAGE_MANAGER_ERROR_NONE;
1296                 package_manager_compare_result_type_e compare_result = PACKAGE_MANAGER_COMPARE_MISMATCH;
1297
1298                 pkgmgr_ret = package_manager_compare_app_cert_info(badge_app_id, caller, &compare_result);
1299
1300                 if (pkgmgr_ret != PACKAGE_MANAGER_ERROR_NONE || compare_result != PACKAGE_MANAGER_COMPARE_MATCH) {
1301                         err = BADGE_ERROR_INVALID_PACKAGE;
1302                         goto out;
1303                 }
1304         }
1305
1306         err = badge_ipc_request_insert(badge_app_id, caller, caller, uid);
1307
1308 out:
1309         if (caller)
1310                 free(caller);
1311         return err;
1312 }
1313
1314 EXPORT_API
1315 int badge_remove_for_uid(const char *app_id, uid_t uid)
1316 {
1317         char *caller = NULL;
1318         int result = BADGE_ERROR_NONE;
1319
1320         if (app_id == NULL)
1321                 return BADGE_ERROR_INVALID_PARAMETER;
1322
1323         caller = _badge_get_pkgname_by_pid();
1324         if (!caller) {
1325                 ERR("fail to get caller pkgname");
1326                 result = BADGE_ERROR_PERMISSION_DENIED;
1327                 goto out;
1328         }
1329
1330         result = badge_ipc_request_delete(app_id, caller, uid);
1331
1332 out:
1333         if (caller)
1334                 free(caller);
1335         return result;
1336 }
1337
1338 EXPORT_API
1339 int badge_is_existing_for_uid(const char *app_id, bool *existing, uid_t uid)
1340 {
1341         return badge_ipc_request_is_existing(app_id, existing, uid);
1342 }
1343
1344 EXPORT_API
1345 int badge_foreach_for_uid(badge_foreach_cb callback, void *user_data, uid_t uid)
1346 {
1347         int result = BADGE_ERROR_NONE;
1348         result = badge_ipc_request_get_list(callback, user_data, uid);
1349         if (result == BADGE_ERROR_IO_ERROR)
1350                 result = BADGE_ERROR_FROM_DB;
1351         return result;
1352 }
1353
1354 EXPORT_API
1355 int badge_set_count_for_uid(const char *app_id, unsigned int count, uid_t uid)
1356 {
1357         char *caller = NULL;
1358         int result = BADGE_ERROR_NONE;
1359
1360         if (app_id == NULL)
1361                 return BADGE_ERROR_INVALID_PARAMETER;
1362
1363         DBG("app_id %s, count %d", app_id, count);
1364
1365         caller = _badge_get_pkgname_by_pid();
1366         if (!caller) {
1367                 ERR("fail to get caller pkgname");
1368                 result = BADGE_ERROR_PERMISSION_DENIED;
1369                 goto out;
1370         }
1371
1372         result = badge_ipc_request_set_count(app_id, caller, count, uid);
1373 out:
1374         if (caller)
1375                 free(caller);
1376         return result;
1377 }
1378
1379 EXPORT_API
1380 int badge_get_count_for_uid(const char *app_id, unsigned int *count, uid_t uid)
1381 {
1382         int result = BADGE_ERROR_NONE;
1383         if (app_id == NULL || count == NULL)
1384                 return BADGE_ERROR_INVALID_PARAMETER;
1385
1386         result = badge_ipc_request_get_count(app_id, count, uid);
1387         if (result == BADGE_ERROR_IO_ERROR)
1388                 result = BADGE_ERROR_FROM_DB;
1389
1390         return result;
1391 }
1392
1393 EXPORT_API
1394 int badge_set_display_for_uid(const char *app_id, unsigned int is_display, uid_t uid)
1395 {
1396         char *caller = NULL;
1397         int result = BADGE_ERROR_NONE;
1398
1399         if (app_id == NULL)
1400                 return BADGE_ERROR_INVALID_PARAMETER;
1401
1402         caller = _badge_get_pkgname_by_pid();
1403         if (!caller) {
1404                 ERR("fail to get caller pkgname");
1405                 result = BADGE_ERROR_PERMISSION_DENIED;
1406                 goto out;
1407         }
1408
1409         result = badge_ipc_request_set_display(app_id, caller, is_display, uid);
1410
1411 out:
1412         if (caller)
1413                 free(caller);
1414         return result;
1415 }
1416
1417 EXPORT_API
1418 int badge_get_display_for_uid(const char *app_id, unsigned int *is_display, uid_t uid)
1419 {
1420         int result = BADGE_ERROR_NONE;
1421         if (app_id == NULL || is_display == NULL)
1422                 return BADGE_ERROR_INVALID_PARAMETER;
1423
1424         result = badge_ipc_request_get_display(app_id, is_display, uid);
1425         if (result == BADGE_ERROR_IO_ERROR)
1426                 result = BADGE_ERROR_FROM_DB;
1427
1428         return result;
1429 }
1430
1431 EXPORT_API
1432 int badge_register_changed_cb_for_uid(badge_change_cb callback, void *data, uid_t uid)
1433 {
1434         if (callback == NULL)
1435                 return BADGE_ERROR_INVALID_PARAMETER;
1436
1437         return _badge_register_changed_cb(callback, data, uid);
1438 }
1439
1440 EXPORT_API
1441 int badge_unregister_changed_cb_for_uid(badge_change_cb callback, uid_t uid)
1442 {
1443         if (callback == NULL)
1444                 return BADGE_ERROR_INVALID_PARAMETER;
1445
1446         return _badge_unregister_changed_cb(callback, uid);
1447 }