capi/src/privilege_db_manager.c

   1 /*
   2  * Copyright(c) 2013-2020 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 #include "privilege_db_manager.h"
  18 #include "privilege_private.h"
  19 #include "privilege_manager_types.h"
  20 #include <sqlite3.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <errno.h>
  26 #include <stdbool.h>
  27
  28 #ifdef __TIZEN__
  29 #include <dlog.h>
  30 #include <tzplatform_config.h>
  31 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
  32 #ifdef LOG_TAG
  33 #undef LOG_TAG
  34 #define LOG_TAG "PRIVILEGE_DB_MANAGER"
  35 #define _LOGE(fmt, arg...) LOGE(fmt, ##arg)
  36 #define _LOGD(fmt, arg...) LOGD(fmt, ##arg)
  37 #define _LOGW(fmt, arg...) LOGW(fmt, ##arg)
  38 #define _LOGI(fmt, arg...) LOGI(fmt, ##arg)
  39 #endif
  40 #else
  41 #define _LOGE(fmt, arg...)
  42 #define _LOGD(fmt, arg...)
  43 #define _LOGW(fmt, arg...)
  44 #define _LOGI(fmt, arg...)
  45 #define GLOBAL_USER 0
  46 #endif
  47
  48 #define STORAGE_PRIVACY "http://tizen.org/privacy/storage"
  49
  50 #define MAX_RETRY_CNT 10 // max 0.5s
  51 #define USLEEP_TIME (50 * 1000) // 0.05s
  52
  53 #include <iniparser.h>
  54 privilege_profile_type_e get_priv_profile()
  55 {
  56         static privilege_profile_type_e saved = 0xff;
  57
  58         if (__builtin_expect(saved == 0xff, 0)) {
  59                 dictionary *dic = iniparser_load(INI_PATH);
  60
  61                 if (dic == NULL) {
  62                         /* if there is no .ini file, let's assume it's mobile (the default as recommended by Yunjin Lee) */
  63                         saved = PRIVILEGE_PROFILE_TYPE_MOBILE;
  64                         return saved;
  65                 }
  66
  67                 const char* val = iniparser_getstring(dic, INI_KEYWORD_PROFILE, NULL);
  68
  69                 if (val != NULL) {
  70                         switch (*val) {
  71                         case 'm':
  72                         case 'M':
  73                                 saved = PRIVILEGE_PROFILE_TYPE_MOBILE;
  74                                 break;
  75                         case 'w':
  76                         case 'W':
  77                                 saved = PRIVILEGE_PROFILE_TYPE_WEARABLE;
  78                                 break;
  79                         case 't':
  80                         case 'T':
  81                                 saved = PRIVILEGE_PROFILE_TYPE_TV;
  82                                 break;
  83                         case 'i':
  84                         case 'I':
  85                                 saved = PRIVILEGE_PROFILE_TYPE_IOT;
  86                                 break;
  87                         default: // common or ivi or unknown ==> Mobile as the default recommended by Yunjin Lee
  88                                 saved = PRIVILEGE_PROFILE_TYPE_MOBILE;
  89                         }
  90                 } else {
  91                         saved = PRIVILEGE_PROFILE_TYPE_MOBILE;
  92                 }
  93                 iniparser_freedict(dic);
  94         }
  95         return saved;
  96 }
  97
  98 #define TryReturn(condition, expr, returnValue, ...)    \
  99         if (!(condition)) { \
 100                 _LOGE(__VA_ARGS__); \
 101                 expr; \
 102                 return returnValue; \
 103         }
 104
 105 #define TRY_INIT_DB(type, db) { \
 106         int ret = __initialize_db(type, db); \
 107         if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE) { \
 108                 return ret; \
 109         } \
 110 }
 111
 112 #define TRY_PREPARE_STMT(db, sql, stmt) { \
 113         int ret = __prepare_stmt(db, sql, stmt); \
 114         if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE) { \
 115                 __finalize_db(db, *stmt, sql); \
 116                 return ret; \
 117         } \
 118 }
 119
 120 #define TRY_BEGIN_TRANSACTION(db) { \
 121         if (__begin_transaction(db) != PRIVILEGE_DB_MANAGER_ERR_NONE) { \
 122                 __finalize_db(db, NULL, NULL); \
 123                 return PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL; \
 124         } \
 125 }
 126
 127 #define TRY_FINISH_TRANSACTION(result, db, stmt, sql) { \
 128         int ret_val = __finish_transaction(result, db); \
 129         __finalize_db(db, stmt, sql); \
 130         return ret_val; \
 131 }
 132
 133 #define SAFE_FREE(var) { if ((var) != NULL) {free(var); var = NULL; } }
 134 #define SAFE_SQLITE_FREE(sql) { if ((sql) != NULL) {sqlite3_free(sql); sql = NULL; } }
 135 #define SAFE_SQLITE_FINALIZE(stmt) { if ((stmt) != NULL) {sqlite3_finalize(stmt); stmt = NULL; } }
 136 #define SAFE_G_LIST_FREE_FULL(list, func) { if ((list) != NULL) {g_list_free_full(list, func); list = NULL; } }
 137
 138 static const char* __get_policy_table(privilege_manager_policy_type_e policy_type)
 139 {
 140         switch (policy_type) {
 141         case (PRVMGR_POLICY_TYPE_PREVENT):
 142                 return "prevent_list";
 143         case (PRVMGR_POLICY_TYPE_DISABLE):
 144         default:
 145                 return "disable_list";
 146         }
 147 }
 148
 149 static int __initialize_db(privilege_db_type_e type, sqlite3 ** db)
 150 {
 151         char *db_path = NULL;
 152         int db_mode = SQLITE_OPEN_READONLY;
 153
 154         switch (type) {
 155         case PRIVILEGE_DB_TYPE_INFO:
 156                 db_path = PRIVILEGE_DB_PATH;
 157                 break;
 158         case PRIVILEGE_DB_TYPE_POLICY_RW:
 159                 db_mode = SQLITE_OPEN_READWRITE;
 160                 __attribute__ ((fallthrough));
 161         case PRIVILEGE_DB_TYPE_POLICY_RO:
 162                 db_path = PRIVILEGE_POLICY_DB_PATH;
 163                 break;
 164         case PRIVILEGE_DB_TYPE_PRIVACY_RW:
 165                 db_mode = SQLITE_OPEN_READWRITE;
 166                 __attribute__ ((fallthrough));
 167         case PRIVILEGE_DB_TYPE_PRIVACY_RO:
 168                 db_path = PRIVILEGE_PRIVACY_DB_PATH;
 169                 break;
 170         default:
 171                 _LOGE("Undefined db initialize mode!");
 172                 return PRIVILEGE_DB_MANAGER_ERR_INVALID_TYPE;
 173         }
 174
 175         if (access(db_path, F_OK) == -1 && errno == ENOENT)
 176                 return PRIVILEGE_DB_MANAGER_ERR_DB_NOENTRY;
 177
 178         int ret = sqlite3_open_v2(db_path, db, db_mode, NULL);
 179         if (ret != SQLITE_OK) {
 180                 _LOGE("[DB_FAIL] Can't open database %s : %s", db_path, sqlite3_errmsg(*db));
 181                 sqlite3_close(*db);
 182                 return PRIVILEGE_DB_MANAGER_ERR_CONNECTION_FAIL;
 183         }
 184         if (*db == NULL) {
 185                 _LOGE("[DB_FAIL] Can't open database %s : db handle is NULL", db_path);
 186                 return PRIVILEGE_DB_MANAGER_ERR_CONNECTION_FAIL;
 187         }
 188
 189         return PRIVILEGE_DB_MANAGER_ERR_NONE;
 190 }
 191
 192 static void __finalize_db(sqlite3 *db, sqlite3_stmt *stmt, char* sql)
 193 {
 194         SAFE_SQLITE_FINALIZE(stmt);
 195         SAFE_SQLITE_FREE(sql);
 196
 197         if (db != NULL)
 198                 sqlite3_close_v2(db);
 199 }
 200
 201 static int __prepare_stmt(sqlite3 *db, char* sql, sqlite3_stmt **stmt)
 202 {
 203         TryReturn(sql != NULL, , PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "query is NULL");
 204
 205         if (sqlite3_prepare_v2(db, sql, strlen(sql), stmt, NULL) != SQLITE_OK) {
 206                 _LOGE("sqlite3_prepare_v2() failed. ret %d[%s]", sqlite3_errcode(db), sqlite3_errmsg(db));
 207                 return PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY;
 208         }
 209
 210         return PRIVILEGE_DB_MANAGER_ERR_NONE;
 211 }
 212
 213 static int __finish_transaction(int result, sqlite3 *db)
 214 {
 215         if (result != PRIVILEGE_DB_MANAGER_ERR_NONE) {
 216                 _LOGE("DB update failed. Try ROLLBACK TRANSACTION.");
 217                 if (sqlite3_exec(db, "ROLLBACK TRANSACTION", NULL, NULL, NULL) != SQLITE_OK) {
 218                         _LOGE("[DB_FAIL] sqlite3_exec for 'ROLLBACK TRANSACTION' failed. ret %d[%s]", sqlite3_errcode(db), sqlite3_errmsg(db));
 219                 }
 220         } else {
 221                 if (sqlite3_exec(db, "COMMIT TRANSACTION", NULL, NULL, NULL) != SQLITE_OK) {
 222                         _LOGE("[DB_FAIL] sqlite3_exec for 'COMMIT TRANSACTION' failed. ret %d[%s]", sqlite3_errcode(db), sqlite3_errmsg(db));
 223                         return PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL;
 224                 }
 225         }
 226         return result;
 227 }
 228
 229 static int __begin_transaction(sqlite3 *db)
 230 {
 231         int ret = -1;
 232         int retry_cnt = 0;
 233
 234         while (ret != SQLITE_OK) {
 235                 ret = sqlite3_exec(db, "BEGIN IMMEDIATE TRANSACTION", NULL, NULL, NULL);
 236                 if (ret != SQLITE_OK) {
 237                         _LOGE("sqlite3_exec() for BEGIN IMMEDIATE TRANSACTION failed. ret %d[%s]", sqlite3_errcode(db), sqlite3_errmsg(db));
 238                         if (ret == SQLITE_BUSY || ret == SQLITE_LOCKED) {
 239                                 if (retry_cnt < MAX_RETRY_CNT) {
 240                                         retry_cnt++;
 241                                         usleep(USLEEP_TIME);
 242                                 } else {
 243                                         _LOGE("Exceed MAX_RETRY_CNT. BEGIN IMMEDIATE TRANSACTION failed.");
 244                                         return PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL;
 245                                 }
 246                         } else {
 247                                 return PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL;
 248                         }
 249                 }
 250         }
 251     return PRIVILEGE_DB_MANAGER_ERR_NONE;
 252 }
 253
 254 static int __make_privilege_list_str(GList *privilege_list, char** privilege_list_str)
 255 {
 256         char* temp_privilege_list_str = NULL;
 257         for (GList* l = privilege_list; l != NULL; l = l->next) {
 258                 char *privilege_name = (char *)l->data;
 259                 if (temp_privilege_list_str == NULL) {
 260                         temp_privilege_list_str = sqlite3_mprintf("'%q'", privilege_name);
 261                 } else {
 262                         char* temp = sqlite3_mprintf("%s, '%q'", temp_privilege_list_str, privilege_name);
 263                         SAFE_SQLITE_FREE(temp_privilege_list_str);
 264                         temp_privilege_list_str = temp;
 265                 }
 266                 if (temp_privilege_list_str == NULL)
 267                         return -1;
 268         }
 269         *privilege_list_str = temp_privilege_list_str;
 270         return 0;
 271 }
 272
 273 static void __get_db_error(int *ret)
 274 {
 275         _LOGE("[PRIVILEGE_DB_MANAGER_ERR_DB_FAIL] %s", sqlite3_errstr(*ret));
 276         switch (*ret) {
 277         case SQLITE_BUSY:
 278                 *ret = PRIVILEGE_DB_MANAGER_ERR_DB_BUSY_FAIL;
 279                 break;
 280         case SQLITE_CONSTRAINT:
 281                 *ret = PRIVILEGE_DB_MANAGER_ERR_DB_CONSTRAINT_FAIL;
 282                 break;
 283         case SQLITE_FULL:
 284                 *ret = PRIVILEGE_DB_MANAGER_ERR_DB_FULL_FAIL;
 285                 break;
 286         default:
 287                 *ret = PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL;
 288         }
 289 }
 290
 291 void privilege_db_manager_list_free(GList* list)
 292 {
 293         SAFE_G_LIST_FREE_FULL(list, free);
 294 }
 295
 296 int privilege_db_manager_check_black_list(uid_t uid, privilege_manager_package_type_e package_type, GList* privilege_list)
 297 {
 298         sqlite3 *db = NULL;
 299         sqlite3_stmt *stmt = NULL;
 300
 301         int count = 0;
 302
 303         TRY_INIT_DB(PRIVILEGE_DB_TYPE_POLICY_RO, &db);
 304
 305         char *privilege_list_str = NULL;
 306         TryReturn(__make_privilege_list_str(privilege_list, &privilege_list_str) == 0 && privilege_list_str != NULL, sqlite3_close(db), PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY, "[PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY] making privilege_list_str for where in query is failed.");
 307
 308         char *sql = sqlite3_mprintf("select count(distinct privilege_name) from prevent_list where privilege_name in(%s)and (uid=%d or uid=%d) and package_type=%d", privilege_list_str, uid, GLOBAL_USER, package_type);
 309         SAFE_SQLITE_FREE(privilege_list_str);
 310
 311         TRY_PREPARE_STMT(db, sql, &stmt);
 312
 313         if (sqlite3_step(stmt) == SQLITE_ROW)
 314                 count = sqlite3_column_int(stmt, 0);
 315
 316         __finalize_db(db, stmt, sql);
 317
 318         return count;
 319 }
 320
 321 static void __free_privilege_level_info(privilege_level_info_s* p)
 322 {
 323         SAFE_FREE(p->privilege_name);
 324         SAFE_FREE(p);
 325 }
 326
 327 static void __free_privilege_level_info_list(gpointer privilege_level_info_list)
 328 {
 329         __free_privilege_level_info((privilege_level_info_s*)privilege_level_info_list);
 330 }
 331
 332 void free_privilege_level_info_list(GList* row_list)
 333 {
 334         SAFE_G_LIST_FREE_FULL(row_list, __free_privilege_level_info_list);
 335 }
 336
 337 static privilege_level_info_s* __new_privilege_level_info(const char* privilege, int privilege_level_id)
 338 {
 339         privilege_level_info_s *p = (privilege_level_info_s*)malloc(sizeof(privilege_level_info_s));
 340         TryReturn(p != NULL, , NULL, "malloc() of privilege_level_info_s failed.");
 341
 342         p->privilege_name = g_strdup(privilege);
 343         p->privilege_level_id = privilege_level_id;
 344
 345         return p;
 346 }
 347
 348 int privilege_db_manager_get_privilege_level_info_list(privilege_manager_package_type_e package_type, GList ** privilege_list)
 349 {
 350         sqlite3 *db = NULL;
 351         sqlite3_stmt *stmt = NULL;
 352
 353         TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 354
 355         char *sql = sqlite3_mprintf("select privilege_name, privilege_level_id from privilege_info where package_type_id=%d", package_type);
 356
 357         TRY_PREPARE_STMT(db, sql, &stmt);
 358
 359         GList *temp_privilege_list = NULL;
 360         while (sqlite3_step(stmt) == SQLITE_ROW) {
 361                 privilege_level_info_s *p = __new_privilege_level_info((const char*)sqlite3_column_text(stmt, 0), sqlite3_column_int(stmt, 1));
 362                 TryReturn(p != NULL, free_privilege_level_info_list(temp_privilege_list); __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY, "[PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY] __new_privilege_level_info() failed.");
 363                 temp_privilege_list = g_list_append(temp_privilege_list, p);
 364         }
 365
 366         *privilege_list = temp_privilege_list;
 367
 368         __finalize_db(db, stmt, sql);
 369
 370         return PRIVILEGE_DB_MANAGER_ERR_NONE;
 371 }
 372
 373 int privilege_db_manager_get_mapped_privilege_list(const char *api_version, privilege_manager_package_type_e package_type, GList * privilege_list, GList ** mapped_privilege_list)
 374 {
 375         sqlite3 *db = NULL;
 376         sqlite3_stmt *stmt = NULL;
 377
 378         TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 379
 380         char *privilege_list_str = NULL;
 381         TryReturn(__make_privilege_list_str(privilege_list, &privilege_list_str) == 0 && privilege_list_str != NULL, sqlite3_close(db), PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY, "[PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY] making privilege_list_str for where in query is failed.");
 382
 383         char *sql =  sqlite3_mprintf("select distinct mapped_privilege_name from privilege_mapping where package_type_id=%d and privilege_name in(%s) and from_api_version<=%Q and to_api_version>%Q", package_type, privilege_list_str, api_version, api_version, package_type);
 384         SAFE_SQLITE_FREE(privilege_list_str);
 385
 386         TRY_PREPARE_STMT(db, sql, &stmt);
 387
 388         GList *temp_privilege_list = NULL;
 389         while (sqlite3_step(stmt) == SQLITE_ROW) {
 390                 char *privilege_name = g_strdup((char *)sqlite3_column_text(stmt, 0));
 391                 temp_privilege_list = g_list_append(temp_privilege_list, privilege_name);
 392         }
 393
 394         *mapped_privilege_list = temp_privilege_list;
 395
 396         __finalize_db(db, stmt, sql);
 397
 398         return PRIVILEGE_DB_MANAGER_ERR_NONE;
 399 }
 400
 401 int privilege_db_manager_get_privacy_display(const char *privacy_name, char **privacy_display)
 402 {
 403         sqlite3 *db = NULL;
 404         sqlite3_stmt *stmt = NULL;
 405         int ret = PRIVILEGE_DB_MANAGER_ERR_NONE;
 406
 407         TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 408
 409         char *sql = sqlite3_mprintf("select privacy_display from privacy_info where privacy_name=%Q", privacy_name);
 410
 411         TRY_PREPARE_STMT(db, sql, &stmt);
 412
 413         if (sqlite3_step(stmt) == SQLITE_ROW) {
 414                 *privacy_display = g_strdup((char*)sqlite3_column_text(stmt, 0));
 415         } else {
 416                 ret = PRIVILEGE_DB_MANAGER_ERR_NO_EXIST_RESULT;
 417         }
 418
 419         __finalize_db(db, stmt, sql);
 420
 421         return ret;
 422 }
 423
 424 int privilege_db_manager_get_privilege_display(privilege_manager_package_type_e package_type, const char *privilege_name, __attribute__((unused)) const char *api_version, char **privilege_display)
 425 {
 426         sqlite3 *db = NULL;
 427         sqlite3_stmt *stmt = NULL;
 428         int ret = PRIVILEGE_DB_MANAGER_ERR_NONE;
 429
 430         TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 431
 432         char *sql = sqlite3_mprintf("select privilege_display from privilege_info where package_type_id=%d and privilege_name=%Q", package_type, privilege_name);
 433
 434         TRY_PREPARE_STMT(db, sql, &stmt);
 435
 436         if (sqlite3_step(stmt) == SQLITE_ROW) {
 437                 *privilege_display = g_strdup((char *)sqlite3_column_text(stmt, 0));
 438         } else {
 439                 ret = PRIVILEGE_DB_MANAGER_ERR_NO_EXIST_RESULT;
 440         }
 441
 442         __finalize_db(db, stmt, sql);
 443
 444         return ret;
 445 }
 446
 447 int privilege_db_manager_get_privilege_description(privilege_manager_package_type_e package_type, const char *privilege_name, __attribute__((unused)) const char *api_version, char **privilege_description)
 448 {
 449         sqlite3 *db = NULL;
 450         sqlite3_stmt *stmt = NULL;
 451         int ret = PRIVILEGE_DB_MANAGER_ERR_NONE;
 452
 453         TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 454
 455         char *sql = sqlite3_mprintf("select privilege_description from privilege_info where package_type_id=%d and privilege_name=%Q", package_type, privilege_name);
 456
 457         TRY_PREPARE_STMT(db, sql, &stmt);
 458
 459         if (sqlite3_step(stmt) == SQLITE_ROW) {
 460                 *privilege_description = g_strdup((char *)sqlite3_column_text(stmt, 0));
 461         } else {
 462                 ret = PRIVILEGE_DB_MANAGER_ERR_NO_EXIST_RESULT;
 463         }
 464
 465         __finalize_db(db, stmt, sql);
 466
 467         return ret;
 468 }
 469
 470 int privilege_db_manager_get_privilege_group_id(privilege_manager_package_type_e package_type, const char *privilege_name, __attribute__((unused)) const char *api_version, int *privilege_group_id)
 471 {
 472         sqlite3 *db = NULL;
 473         sqlite3_stmt *stmt = NULL;
 474         int ret = PRIVILEGE_DB_MANAGER_ERR_NONE;
 475
 476         TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 477
 478         char *sql = sqlite3_mprintf("select privilege_group_id from privilege_info where package_type_id=%d and privilege_name=%Q",
 479                                                                 package_type, privilege_name);
 480
 481         TRY_PREPARE_STMT(db, sql, &stmt);
 482
 483         if (sqlite3_step(stmt) == SQLITE_ROW) {
 484                 *privilege_group_id = (int)sqlite3_column_int(stmt, 0);
 485         } else {
 486                 ret = PRIVILEGE_DB_MANAGER_ERR_NO_EXIST_RESULT;
 487         }
 488
 489         __finalize_db(db, stmt, sql);
 490
 491         return ret;
 492 }
 493
 494 int privilege_db_manager_is(char type, const char* privilege)
 495 {
 496         sqlite3 *db = NULL;
 497         sqlite3_stmt *stmt = NULL;
 498
 499         TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 500
 501         char *sql = NULL;
 502         switch (type) {
 503         case 'v':
 504                 sql = sqlite3_mprintf("select privilege_name from privilege_mapping where mapped_privilege_name=%Q", privilege);
 505                 break;
 506         case 'p':
 507                 sql = sqlite3_mprintf("select is_privacy from privilege_info where privilege_name=%Q and package_type='core'", privilege);
 508                 break;
 509         case 'i':
 510                 sql = sqlite3_mprintf("select distinct (case when exists(select * from privilege_info where privilege_name=%Q) then 0 else 1 end) from privilege_mapping where mapped_privilege_name=%Q", privilege, privilege);
 511                 break;
 512         default:
 513                 _LOGE("Undefined type for privilege_db_manager_is()");
 514                 __finalize_db(db, stmt, sql);
 515                 return PRIVILEGE_DB_MANAGER_ERR_INVALID_TYPE;
 516         }
 517
 518         TRY_PREPARE_STMT(db, sql, &stmt);
 519
 520         int ret = sqlite3_step(stmt);
 521         if (ret == SQLITE_ROW) {
 522                 switch (type) {
 523                 case 'v':
 524                         ret = 1;
 525                         break;
 526                 case 'p':
 527                 case 'i':
 528                         ret = sqlite3_column_int(stmt, 0);
 529                         break;
 530                 }
 531         } else if (ret == SQLITE_DONE) {
 532                 _LOGD("[PRIVILEGE_DB_MANAGER] NO DATA TO READ. %s is invalid privilege.", privilege);
 533                 ret = 0;
 534         } else {
 535                 ret = -1;
 536         }
 537
 538         __finalize_db(db, stmt, sql);
 539
 540         return ret;
 541 }
 542
 543 // TODO: change it to get package's privacy option only.
 544 int privilege_db_manager_is_privacy_white_list(const char* pkgid, const char* privilege)
 545 {
 546         sqlite3 *db = NULL;
 547         sqlite3_stmt *stmt = NULL;
 548
 549         int privacy_id = 0;
 550         int ret = privilege_db_manager_get_privacy_id_by_privilege(privilege, &privacy_id);
 551         TryReturn(ret == PRIVILEGE_DB_MANAGER_ERR_NONE, , ret, "[PRIVILEGE_DB_MANAGER] privilege_db_manager_get_privacy_id_by_privilege failed");
 552
 553         TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 554
 555         char *sql = sqlite3_mprintf("select privacy_option from privacy_whitelist where pkg_id=%Q", pkgid);
 556
 557         TRY_PREPARE_STMT(db, sql, &stmt);
 558
 559         ret = 0;
 560         while (sqlite3_step(stmt) == SQLITE_ROW) {
 561                 char* privacy_option = (char *)sqlite3_column_text(stmt, 0);
 562                 if (privacy_option[privacy_id] == '1') {
 563                         ret = 1;
 564                         break;
 565                 }
 566         }
 567
 568         __finalize_db(db, stmt, sql);
 569
 570         return ret;
 571 }
 572
 573 // TODO: make it to get package's privacy option and settable info only.
 574 int privilege_db_manager_is_user_settable(const char* pkgid, const char* privacy_name)
 575 {
 576         sqlite3 *db = NULL;
 577         sqlite3_stmt *stmt = NULL;
 578
 579         int privacy_id = 0;
 580         int ret = privilege_db_manager_get_privacy_id(privacy_name, &privacy_id);
 581         TryReturn(ret == PRIVILEGE_DB_MANAGER_ERR_NONE, , ret, "[PRIVILEGE_DB_MANAGER] privilege_db_manager_get_privacy_id failed");
 582
 583         TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 584
 585         char *sql = sqlite3_mprintf("select privacy_option, settable from privacy_whitelist where pkg_id=%Q", pkgid);
 586
 587         TRY_PREPARE_STMT(db, sql, &stmt);
 588
 589         ret = 1;
 590         while (sqlite3_step(stmt) == SQLITE_ROW) {
 591                 char* privacy_option = (char *)sqlite3_column_text(stmt, 0);
 592                 int settable_flag = (int)sqlite3_column_int(stmt, 1);
 593                 if (privacy_option[privacy_id] == '1' && settable_flag == 1) {
 594                         break;
 595                 } else if (privacy_option[privacy_id] == '1' && settable_flag == 0) {
 596                         ret = 0;
 597                         break;
 598                 }
 599         }
 600
 601         __finalize_db(db, stmt, sql);
 602
 603         return ret;
 604 }
 605
 606 int privilege_db_manager_is_disabled_privilege(uid_t uid, const char* privilege)
 607 {
 608         sqlite3 *db = NULL;
 609         sqlite3_stmt *stmt = NULL;
 610
 611         TRY_INIT_DB(PRIVILEGE_DB_TYPE_POLICY_RO, &db);
 612
 613         char *sql = sqlite3_mprintf("select * from disable_list where privilege_name=%Q and (uid=%d or uid=%d)", privilege, uid, GLOBAL_USER);
 614
 615         TRY_PREPARE_STMT(db, sql, &stmt);
 616
 617         int ret = 0;
 618         if (sqlite3_step(stmt) == SQLITE_ROW)
 619                 ret = 1;
 620
 621         __finalize_db(db, stmt, sql);
 622         return ret;
 623 }
 624
 625 int privilege_db_manager_get_privacy_list(GList **privacy_list)
 626 {
 627         sqlite3 *db = NULL;
 628         sqlite3_stmt *stmt = NULL;
 629
 630         TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 631
 632         char *sql = sqlite3_mprintf("select DISTINCT privacy_name from privilege_info where is_privacy=1 and package_type='core' order by privacy_name");
 633
 634         TRY_PREPARE_STMT(db, sql, &stmt);
 635
 636         GList* temp_privacy_list = NULL;
 637         while (sqlite3_step(stmt) == SQLITE_ROW) {
 638                 char *privacy_name = g_strdup((char *)sqlite3_column_text(stmt, 0));
 639                 temp_privacy_list = g_list_append(temp_privacy_list, privacy_name);
 640         }
 641
 642         *privacy_list = temp_privacy_list;
 643
 644         __finalize_db(db, stmt, sql);
 645
 646         return PRIVILEGE_DB_MANAGER_ERR_NONE;
 647 }
 648
 649 int privilege_db_manager_get_privilege_list_by_privacy(const char* privacy, GList **privilege_list)
 650 {
 651         sqlite3 *db = NULL;
 652         sqlite3_stmt *stmt = NULL;
 653
 654         TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 655
 656         char *sql = sqlite3_mprintf("select distinct privilege_name from privilege_info where is_privacy=1 and privacy_name=%Q", privacy);
 657
 658         TRY_PREPARE_STMT(db, sql, &stmt);
 659
 660         GList* temp_privilege_list = NULL;
 661         while (sqlite3_step(stmt) == SQLITE_ROW) {
 662                 char *privilege_name = g_strdup((char *)sqlite3_column_text(stmt, 0));
 663                 temp_privilege_list = g_list_append(temp_privilege_list, privilege_name);
 664         }
 665
 666         __finalize_db(db, stmt, sql);
 667
 668         *privilege_list = temp_privilege_list;
 669
 670         return PRIVILEGE_DB_MANAGER_ERR_NONE;
 671 }
 672
 673 int privilege_db_manager_get_privacy_by_privilege(const char* privilege, char** privacy_name)
 674 {
 675         sqlite3 *db = NULL;
 676         sqlite3_stmt *stmt = NULL;
 677         int ret = PRIVILEGE_DB_MANAGER_ERR_NONE;
 678
 679         TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 680
 681         char *sql = sqlite3_mprintf("select privacy_name from privilege_info where privilege_name=%Q and package_type='core'", privilege);
 682
 683         TRY_PREPARE_STMT(db, sql, &stmt);
 684
 685         if (sqlite3_step(stmt) == SQLITE_ROW) {
 686                 *privacy_name = g_strdup((char*)sqlite3_column_text(stmt, 0));
 687         } else {
 688                 ret = PRIVILEGE_DB_MANAGER_ERR_NO_EXIST_RESULT;
 689         }
 690
 691         __finalize_db(db, stmt, sql);
 692
 693         return ret;
 694 }
 695
 696 int privilege_db_manager_get_same_privacy_grouped_privileges(const char* privilege, GList** privilege_list)
 697 {
 698         sqlite3 *db = NULL;
 699         sqlite3_stmt *stmt = NULL;
 700
 701         TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 702
 703         char *sql = sqlite3_mprintf("select distinct privilege_name from privilege_info where privacy_name=(select distinct privacy_name from privilege_info where privilege_name=%Q and is_privacy=1)", privilege);
 704
 705         TRY_PREPARE_STMT(db, sql, &stmt);
 706
 707         GList* temp_privilege_list = NULL;
 708         while (sqlite3_step(stmt) == SQLITE_ROW) {
 709                 char *privilege_name = g_strdup((char *)sqlite3_column_text(stmt, 0));
 710                 temp_privilege_list = g_list_append(temp_privilege_list, privilege_name);
 711         }
 712
 713         __finalize_db(db, stmt, sql);
 714
 715         if (temp_privilege_list == NULL)
 716                 return PRIVILEGE_DB_MANAGER_ERR_NO_EXIST_RESULT;
 717
 718         *privilege_list = temp_privilege_list;
 719
 720         return PRIVILEGE_DB_MANAGER_ERR_NONE;
 721 }
 722
 723 int privilege_db_manager_get_privacy_id_by_privilege(const char* privilege, int *privacy_id)
 724 {
 725         sqlite3 *db = NULL;
 726         sqlite3_stmt *stmt = NULL;
 727
 728         TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 729
 730         char *sql = sqlite3_mprintf("select privacy_id from privacy_info where privacy_name=(select privacy_name from privilege_info where privilege_name=%Q and package_type='core')", privilege);
 731
 732         TRY_PREPARE_STMT(db, sql, &stmt);
 733
 734         int ret = sqlite3_step(stmt);
 735         if (ret == SQLITE_ROW) {
 736                 *privacy_id = (int)sqlite3_column_int(stmt, 0);
 737                 ret = PRIVILEGE_DB_MANAGER_ERR_NONE;
 738         } else {
 739                 ret = PRIVILEGE_DB_MANAGER_ERR_NO_EXIST_RESULT;
 740         }
 741
 742         __finalize_db(db, stmt, sql);
 743
 744         return ret;
 745 }
 746
 747 int privilege_db_manager_get_privacy_id(const char* privacy, int *privacy_id)
 748 {
 749         sqlite3 *db = NULL;
 750         sqlite3_stmt *stmt = NULL;
 751
 752
 753         TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 754
 755         char *sql = sqlite3_mprintf("select privacy_id from privacy_info where privacy_name=%Q", privacy);
 756
 757
 758         TRY_PREPARE_STMT(db, sql, &stmt);
 759
 760         int ret = sqlite3_step(stmt);
 761         if (ret == SQLITE_ROW) {
 762                 *privacy_id = (int)sqlite3_column_int(stmt, 0);
 763                 ret = PRIVILEGE_DB_MANAGER_ERR_NONE;
 764         } else {
 765                 _LOGD("privacy %s not exist", privacy);
 766                 ret = PRIVILEGE_DB_MANAGER_ERR_NO_EXIST_RESULT;
 767         }
 768
 769         __finalize_db(db, stmt, sql);
 770
 771         return ret;
 772 }
 773
 774 int privilege_db_manager_get_black_list(privilege_manager_policy_type_e policy_type, int uid, privilege_manager_package_type_e package_type, GList **privilege_list)
 775 {
 776         sqlite3 *db = NULL;
 777         sqlite3_stmt *stmt = NULL;
 778
 779         TRY_INIT_DB(PRIVILEGE_DB_TYPE_POLICY_RO, &db);
 780
 781         char* sql = NULL;
 782         if (policy_type == PRVMGR_POLICY_TYPE_DISABLE)
 783                 sql = sqlite3_mprintf("select privilege_name from %Q where (uid=%d or uid=%d)", __get_policy_table(policy_type), uid, GLOBAL_USER);
 784         else if (policy_type == PRVMGR_POLICY_TYPE_PREVENT)
 785                 sql = sqlite3_mprintf("select privilege_name from %Q where uid=%d and package_type=%d", __get_policy_table(policy_type), uid, package_type);
 786
 787         TRY_PREPARE_STMT(db, sql, &stmt);
 788
 789         GList *temp_privilege_list = NULL;
 790         while (sqlite3_step(stmt) == SQLITE_ROW) {
 791                 char *privilege_name = g_strdup((char *)sqlite3_column_text(stmt, 0));
 792                 temp_privilege_list = g_list_append(temp_privilege_list, privilege_name);
 793         }
 794
 795         *privilege_list = temp_privilege_list;
 796
 797         __finalize_db(db, stmt, sql);
 798
 799         return PRIVILEGE_DB_MANAGER_ERR_NONE;
 800 }
 801
 802 int privilege_db_manager_set_black_list(int uid, privilege_manager_package_type_e package_type, GList *privilege_list)
 803 {
 804         sqlite3 *db = NULL;
 805         sqlite3_stmt *stmt = NULL;
 806         char* sql = NULL;
 807
 808         int ret = PRIVILEGE_DB_MANAGER_ERR_NONE;
 809
 810         TRY_INIT_DB(PRIVILEGE_DB_TYPE_POLICY_RW, &db);
 811
 812         TRY_BEGIN_TRANSACTION(db);
 813
 814         for (GList *l = privilege_list; l != NULL; l = l->next) {
 815                 char *privilege_name = (char *)l->data;
 816                 sql = sqlite3_mprintf("insert or ignore into prevent_list (uid, package_type, privilege_name) values (%d, %d, %Q)", uid, package_type, privilege_name);
 817
 818                 if (__prepare_stmt(db, sql, &stmt) != PRIVILEGE_DB_MANAGER_ERR_NONE) {
 819                         ret = PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL;
 820                         break;
 821                 }
 822
 823                 if (sqlite3_step(stmt) != SQLITE_DONE) {
 824                         _LOGE("sqlite3_step() failed. [%s]", sqlite3_errmsg(db));
 825                         ret = PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL;
 826                         break;
 827                 }
 828                 SAFE_SQLITE_FINALIZE(stmt);
 829                 SAFE_SQLITE_FREE(sql);
 830         }
 831
 832         TRY_FINISH_TRANSACTION(ret, db, stmt, sql);
 833 }
 834
 835 int privilege_db_manager_unset_black_list(int uid, privilege_manager_package_type_e package_type, GList *privilege_list)
 836 {
 837         sqlite3 *db = NULL;
 838         sqlite3_stmt *stmt = NULL;
 839         int ret = PRIVILEGE_DB_MANAGER_ERR_NONE;
 840         char* sql = NULL;
 841
 842         TRY_INIT_DB(PRIVILEGE_DB_TYPE_POLICY_RW, &db);
 843
 844         TRY_BEGIN_TRANSACTION(db);
 845
 846         for (GList *l = privilege_list; l != NULL; l = l->next) {
 847                 char *privilege_name = (char *)l->data;
 848                 sql = sqlite3_mprintf("delete from prevent_list where uid=%d and package_type=%d and privilege_name=%Q", uid, package_type, privilege_name);
 849
 850                 if (__prepare_stmt(db, sql, &stmt) != PRIVILEGE_DB_MANAGER_ERR_NONE) {
 851                         ret = PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL;
 852                         break;
 853                 }
 854
 855                 if (sqlite3_step(stmt) != SQLITE_DONE) {
 856                         _LOGE("sqlite3_step() failed. [%s]", sqlite3_errmsg(db));
 857                         ret = PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL;
 858                         break;
 859                 }
 860
 861                 SAFE_SQLITE_FINALIZE(stmt);
 862                 SAFE_SQLITE_FREE(sql);
 863         }
 864
 865         TRY_FINISH_TRANSACTION(ret, db, stmt, sql);
 866 }
 867
 868 //TODO: Do insert only. DO NOT determine whether to insert or not in here.
 869 int privilege_db_manager_set_package_privacy_privilege_info(const uid_t uid, const char* pkgid, privilege_manager_package_type_e package_type, const char* api_version, GList* privilege_list)
 870 {
 871         sqlite3 *db = NULL;
 872         sqlite3_stmt *stmt = NULL;
 873         char* sql = NULL;
 874
 875         int ret = PRIVILEGE_DB_MANAGER_ERR_NONE;
 876
 877         TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RW, &db);
 878
 879         GList* mapped_privilege_list = NULL;
 880         ret = privilege_db_manager_get_mapped_privilege_list(api_version, package_type, privilege_list, &mapped_privilege_list);
 881         TryReturn(ret == PRIVILEGE_DB_MANAGER_ERR_NONE && mapped_privilege_list != NULL, __finalize_db(db, stmt, NULL), PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL, "[DB_FAIL] privilege_db_manager_get_mapped_privilege_list failed");
 882
 883         TRY_BEGIN_TRANSACTION(db);
 884
 885         GList *l = NULL;
 886         for (l = mapped_privilege_list; l != NULL; l = l->next) {
 887                 char *privilege_name = (char *)l->data;
 888                 if (strstr(privilege_name, "/internal/") == NULL) {
 889                         char * privacy_name = NULL;
 890                         ret = privilege_db_manager_get_privacy_by_privilege(privilege_name, &privacy_name);
 891                         if (ret == PRIVILEGE_DB_MANAGER_ERR_NONE && strstr(privacy_name, "N/A") == NULL && privilege_db_manager_is_user_settable(pkgid, privacy_name) == 1) {
 892                                 sql = sqlite3_mprintf("insert or ignore into privacy_package (uid, pkg_id, privacy_name, privilege_name, api_version, is_critical) values (%d, %Q, %Q, %Q, %Q, 0)", uid, pkgid, privacy_name, privilege_name, api_version);
 893
 894                                 if (__prepare_stmt(db, sql, &stmt) != PRIVILEGE_DB_MANAGER_ERR_NONE) {
 895                                         ret = PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL;
 896                                         break;
 897                                 }
 898
 899                                 if (sqlite3_step(stmt) != SQLITE_DONE) {
 900                                         _LOGE("sqlite3_step() failed. [%s]", sqlite3_errmsg(db));
 901                                         ret = PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL;
 902                                         break;
 903                                 }
 904
 905                                 SAFE_SQLITE_FREE(sql);
 906                                 SAFE_SQLITE_FINALIZE(stmt);
 907                         }
 908                         SAFE_FREE(privacy_name);
 909                 }
 910         }
 911         SAFE_G_LIST_FREE_FULL(mapped_privilege_list, free);
 912
 913         TRY_FINISH_TRANSACTION(ret, db, stmt, sql);
 914 }
 915
 916 int privilege_db_manager_unset_package_privilege_info(const uid_t uid, const char* pkgid)
 917 {
 918         sqlite3 *db = NULL;
 919         sqlite3_stmt *stmt = NULL;
 920
 921         TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RW, &db);
 922
 923         char* sql = sql = sqlite3_mprintf("delete from privacy_package where pkg_id = %Q and uid = %d", pkgid, uid);
 924
 925         TRY_PREPARE_STMT(db, sql, &stmt);
 926
 927
 928         int ret = sqlite3_step(stmt);
 929         if (ret != SQLITE_DONE)
 930                 __get_db_error(&ret);
 931         else
 932                 ret = PRIVILEGE_DB_MANAGER_ERR_NONE;
 933
 934         __finalize_db(db, stmt, sql);
 935
 936         return ret;
 937 }
 938
 939 int privilege_db_manager_is_privacy_requestable(const uid_t uid, const char* pkgid, const char* privilege, privilege_manager_package_type_e pkg_type, bool* is_privacy_requestable)
 940 {
 941         sqlite3 *db = NULL;
 942         sqlite3_stmt *stmt = NULL;
 943         int ret;
 944
 945         TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
 946
 947         char* sql = NULL;
 948         if (g_privilege_profile_type == PRIVILEGE_PROFILE_TYPE_WEARABLE || pkg_type == PRVMGR_PACKAGE_TYPE_CORE) {
 949                 sql = sqlite3_mprintf("select (case when api_version < 4 then 0 else 1 end) from privacy_package where (uid=%d or uid=%d) and pkg_id=%Q and privilege_name=%Q", uid, GLOBAL_USER, pkgid, privilege);
 950         } else {
 951                 sql = sqlite3_mprintf("select (case when api_version < 4 or (api_version < 5 and privacy_name=%Q) then 0 else 1 end) from privacy_package where (uid=%d or uid=%d) and pkg_id=%Q and privilege_name=%Q", STORAGE_PRIVACY, uid, GLOBAL_USER, pkgid, privilege);
 952         }
 953
 954         TRY_PREPARE_STMT(db, sql, &stmt);
 955
 956         ret = sqlite3_step(stmt);
 957         if (ret == SQLITE_ROW) {
 958                 if (sqlite3_column_int(stmt, 0))
 959                         *is_privacy_requestable = true;
 960                 else
 961                         *is_privacy_requestable = false;
 962                 ret = PRIVILEGE_DB_MANAGER_ERR_NONE;
 963         } else if (ret == SQLITE_DONE) {
 964                 ret = PRIVILEGE_DB_MANAGER_ERR_NO_EXIST_RESULT;
 965         } else {
 966                 _LOGE("sqlite3_step() failed. et %d[%s]", ret, sqlite3_errmsg(db));
 967                 //TODO: add error value for internal error
 968         }
 969
 970         __finalize_db(db, stmt, sql);
 971
 972         return ret;
 973 }
 974
 975 int privilege_db_manager_get_all_privacy_package_list(const uid_t uid, GList** package_list)
 976 {
 977         sqlite3 *db = NULL;
 978         sqlite3_stmt *stmt = NULL;
 979
 980         TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
 981         char *sql = sqlite3_mprintf("select distinct pkg_id from privacy_package where (uid=%d or uid=%d)", uid, GLOBAL_USER);
 982
 983         TRY_PREPARE_STMT(db, sql, &stmt);
 984
 985         GList* temp_package_list = NULL;
 986         while (sqlite3_step(stmt) == SQLITE_ROW) {
 987                 char *pkgid = g_strdup((char *)sqlite3_column_text(stmt, 0));
 988                 temp_package_list = g_list_append(temp_package_list, pkgid);
 989         }
 990
 991         __finalize_db(db, stmt, sql);
 992
 993         *package_list = temp_package_list;
 994         if (temp_package_list == NULL)
 995                 return PRIVILEGE_DB_MANAGER_ERR_NO_EXIST_RESULT;
 996
 997         return PRIVILEGE_DB_MANAGER_ERR_NONE;
 998 }
 999
1000 int privilege_db_manager_get_privacy_list_by_pkgid(const uid_t uid, const char* pkgid, GList** privacy_list)
1001 {
1002         sqlite3 *db = NULL;
1003         sqlite3_stmt *stmt = NULL;
1004
1005         TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
1006
1007         char *sql = sqlite3_mprintf("select distinct privacy_name from privacy_package where (uid=%d or uid=%d) and pkg_id=%Q", uid, GLOBAL_USER, pkgid);
1008
1009         TRY_PREPARE_STMT(db, sql, &stmt);
1010
1011         GList* temp_privacy_list = NULL;
1012         while (sqlite3_step(stmt) == SQLITE_ROW) {
1013                 char *privacy_name = g_strdup((char *)sqlite3_column_text(stmt, 0));
1014                 temp_privacy_list = g_list_append(temp_privacy_list, privacy_name);
1015         }
1016
1017         __finalize_db(db, stmt, sql);
1018
1019         *privacy_list = temp_privacy_list;
1020         if (temp_privacy_list == NULL)
1021                 return PRIVILEGE_DB_MANAGER_ERR_NO_EXIST_RESULT;
1022
1023         return PRIVILEGE_DB_MANAGER_ERR_NONE;
1024 }
1025
1026 int privilege_db_manager_get_package_list_by_privacy(const uid_t uid, const char* privacy, GList** package_list)
1027 {
1028         sqlite3 *db = NULL;
1029         sqlite3_stmt *stmt = NULL;
1030
1031         TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
1032
1033         char *sql = sqlite3_mprintf("select distinct pkg_id from privacy_package where (uid=%d or uid=%d) and privacy_name=%Q", uid, GLOBAL_USER, privacy);
1034
1035         TRY_PREPARE_STMT(db, sql, &stmt);
1036
1037         GList* temp_package_list = NULL;
1038         while (sqlite3_step(stmt) == SQLITE_ROW) {
1039                 char *pkgid = g_strdup((char *)sqlite3_column_text(stmt, 0));
1040                 temp_package_list = g_list_append(temp_package_list, pkgid);
1041         }
1042
1043         __finalize_db(db, stmt, sql);
1044
1045         *package_list = temp_package_list;
1046         if (temp_package_list == NULL)
1047                 return PRIVILEGE_DB_MANAGER_ERR_NO_EXIST_RESULT;
1048
1049         return PRIVILEGE_DB_MANAGER_ERR_NONE;
1050 }
1051
1052 int privilege_db_manager_get_privilege_list_by_pkgid_and_privacy(const uid_t uid, const char* pkgid, const char* privacy, GList** privilege_list)
1053 {
1054         sqlite3 *db = NULL;
1055         sqlite3_stmt *stmt = NULL;
1056
1057         TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
1058
1059         char *sql = sqlite3_mprintf("select distinct privilege_name from privacy_package where (uid=%d or uid=%d) and pkg_id=%Q and privacy_name=%Q", uid, GLOBAL_USER, pkgid, privacy);
1060
1061         TRY_PREPARE_STMT(db, sql, &stmt);
1062
1063         GList* temp_privilege_list = NULL;
1064         while (sqlite3_step(stmt) == SQLITE_ROW) {
1065                 char *privilege_name = g_strdup((char *)sqlite3_column_text(stmt, 0));
1066                 temp_privilege_list = g_list_append(temp_privilege_list, privilege_name);
1067         }
1068
1069         __finalize_db(db, stmt, sql);
1070
1071         *privilege_list = temp_privilege_list;
1072         if (temp_privilege_list == NULL)
1073                 return PRIVILEGE_DB_MANAGER_ERR_NO_EXIST_RESULT;
1074
1075         return PRIVILEGE_DB_MANAGER_ERR_NONE;
1076 }