src/badge_internal.c

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