server/src/account-server-db.c

   1 /*
   2  *
   3  * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  * http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <fcntl.h>
  23 #include <unistd.h>
  24 #include <sys/stat.h>
  25 #include <pthread.h>
  26 #include <glib.h>
  27 #include <db-util.h>
  28 #include <pthread.h>
  29 #include <vconf.h>
  30
  31 #include <pkgmgr-info.h>
  32 //#include <tzplatform_config.h>
  33
  34 #include <dbg.h>
  35 #include <account_ipc_marshal.h>
  36 #include <account_free.h>
  37 #include <account-private.h>
  38 #include <account_db_helper.h>
  39 #include <account_crypto_service.h>
  40 #include <account_err.h>
  41 #include "account_type.h"
  42 #include "account-server-db.h"
  43
  44 #define EMAIL_SERVICE_CMDLINE "/usr/bin/email-service"
  45
  46 #define EMAIL_APPID "email-setting-efl"
  47
  48 #define ACCOUNT_DB_OPEN_READONLY 0
  49 #define ACCOUNT_DB_OPEN_READWRITE 1
  50
  51 #define MAX_TEXT 4096
  52
  53 #define _TIZEN_PUBLIC_
  54 #ifndef _TIZEN_PUBLIC_
  55
  56 #endif
  57
  58 static sqlite3* g_hAccountDB = NULL;
  59 static sqlite3* g_hAccountDB2 = NULL;
  60 static sqlite3* g_hAccountGlobalDB = NULL;
  61 static sqlite3* g_hAccountGlobalDB2 = NULL;
  62 pthread_mutex_t account_mutex = PTHREAD_MUTEX_INITIALIZER;
  63 pthread_mutex_t account_global_mutex = PTHREAD_MUTEX_INITIALIZER;
  64
  65 //static char *_account_dup_text(const char *text_data);
  66 static int _account_insert_custom(account_s *account, int account_id);
  67 static int _account_update_custom(account_s *account, int account_id);
  68 static int _account_type_update_provider_feature(sqlite3 * account_db_handle, account_type_s *account_type, const char* app_id);
  69
  70 static void _account_insert_delete_update_notification_send(char *noti_name)
  71 {
  72         if (!noti_name) {
  73                 _ERR("Noti Name is NULL!!!!!!\n");
  74                 return;
  75         }
  76
  77         _INFO("noti_type = %s", noti_name);
  78
  79         if (vconf_set_str(VCONFKEY_ACCOUNT_MSG_STR, noti_name) != 0) {
  80                 _ERR("Vconf MSG Str set FAILED !!!!!!\n");;
  81         }
  82 }
  83
  84 int _account_get_current_appid_cb(const pkgmgrinfo_appinfo_h handle, void *user_data)
  85 {
  86         char* appid = NULL;
  87         char* item = NULL;
  88         GSList** appid_list = (GSList**)user_data;
  89         int pkgmgr_ret = -1;
  90
  91         pkgmgr_ret = pkgmgrinfo_appinfo_get_appid(handle, &appid);
  92
  93         if (pkgmgr_ret != PMINFO_R_OK)
  94                 ACCOUNT_DEBUG("pkgmgrinfo_appinfo_get_appid(%d)", pkgmgr_ret);
  95
  96         item = _account_dup_text(appid);
  97         *appid_list = g_slist_append(*appid_list, item);
  98
  99         return 0;
 100 }
 101
 102 static inline int __read_proc(const char *path, char *buf, int size)
 103 {
 104         int fd = 0, ret = 0;
 105
 106         if (buf == NULL || path == NULL) {
 107                 ACCOUNT_ERROR("path and buffer is mandatory\n");
 108                 return -1;
 109         }
 110
 111         fd = open(path, O_RDONLY);
 112         if (fd < 0) {
 113                 ACCOUNT_ERROR("fd open error(%d)\n", fd);
 114                 return -1;
 115         }
 116
 117         ret = read(fd, buf, size - 1);
 118         if (ret <= 0) {
 119                 ACCOUNT_ERROR("fd read error(%d)\n", fd);
 120                 close(fd);
 121                 return -1;
 122         } else {
 123                 buf[ret] = 0;
 124         }
 125
 126         close(fd);
 127
 128         return ret;
 129 }
 130
 131 char *_account_get_proc_cmdline_bypid(int pid)
 132 {
 133         char buf[128];
 134         int ret = 0;
 135
 136         ACCOUNT_SNPRINTF(buf, sizeof(buf), "/proc/%d/cmdline", pid);
 137         ret = __read_proc(buf, buf, sizeof(buf));
 138         if (ret <= 0) {
 139                 ACCOUNT_DEBUG("No proc directory (%d)\n", pid);
 140                 return NULL;
 141         }
 142
 143         return strdup(buf);
 144 }
 145
 146 /*
 147 static int _account_execute_query_from_global_db(const char *query)
 148 {
 149         int rc = -1;
 150         char* pszErrorMsg = NULL;
 151
 152         if (!query) {
 153                 ACCOUNT_ERROR("NULL query\n");
 154                 return _ACCOUNT_ERROR_QUERY_SYNTAX_ERROR;
 155         }
 156
 157         if (!g_hAccountGlobalDB) {
 158                 ACCOUNT_ERROR("Global DB is not opened\n");
 159                 return _ACCOUNT_ERROR_DB_NOT_OPENED;
 160         }
 161
 162         rc = sqlite3_exec(g_hAccountGlobalDB, query, NULL, NULL, &pszErrorMsg);
 163         if (SQLITE_OK != rc) {
 164                 ACCOUNT_ERROR("sqlite3_exec rc(%d) query(%s) failed(%s).", rc, query, pszErrorMsg);
 165                 sqlite3_free(pszErrorMsg);
 166         }
 167
 168         return rc;
 169 }
 170 */
 171
 172 /*
 173 static int _account_begin_transaction_from_global_db(void)
 174 {
 175         ACCOUNT_DEBUG("_account_begin_transaction start");
 176         int ret = -1;
 177
 178         ret = _account_execute_query_from_global_db("BEGIN IMMEDIATE TRANSACTION");
 179
 180         if (ret == SQLITE_BUSY) {
 181                 ACCOUNT_ERROR(" sqlite3 busy = %d", ret);
 182                 return _ACCOUNT_ERROR_DATABASE_BUSY;
 183         } else if (ret != SQLITE_OK) {
 184                 ACCOUNT_ERROR("_account_svc_begin_transaction_in_global_db fail :: %d", ret);
 185                 return _ACCOUNT_ERROR_DB_FAILED;
 186         }
 187
 188         ACCOUNT_DEBUG("_account_begin_transaction_in_global_db end");
 189         return _ACCOUNT_ERROR_NONE;
 190 }
 191
 192 static int _account_end_transaction_from_global_db(bool is_success)
 193 {
 194         ACCOUNT_DEBUG("_account_end_transaction_in_global_db start");
 195
 196         int ret = -1;
 197
 198         if (is_success == true) {
 199                 ret = _account_execute_query_from_global_db("COMMIT TRANSACTION");
 200                 ACCOUNT_DEBUG("_account_end_transaction_in_global_db COMMIT");
 201         } else {
 202                 ret = _account_execute_query_from_global_db("ROLLBACK TRANSACTION");
 203                 ACCOUNT_DEBUG("_account_end_transaction ROLLBACK");
 204         }
 205
 206         if (ret == SQLITE_PERM) {
 207                 ACCOUNT_ERROR("Account permission denied :: %d", ret);
 208                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
 209         }
 210
 211         if (ret == SQLITE_BUSY) {
 212                 ACCOUNT_DEBUG(" sqlite3 busy = %d", ret);
 213                 return _ACCOUNT_ERROR_DATABASE_BUSY;
 214         }
 215
 216         if (ret != SQLITE_OK) {
 217                 ACCOUNT_ERROR("_account_svc_end_transaction_in_global_db fail :: %d", ret);
 218                 return _ACCOUNT_ERROR_DB_FAILED;
 219         }
 220
 221         ACCOUNT_DEBUG("_account_end_transaction_in_global_db end");
 222         return _ACCOUNT_ERROR_NONE;
 223 }
 224 */
 225
 226 int _account_global_db_open(void)
 227 {
 228         int rc = 0;
 229         int ret = -1;
 230         char account_db_path[256] = {0, };
 231
 232         _INFO("start _account_global_db_open()");
 233
 234         ACCOUNT_MEMSET(account_db_path, 0x00, sizeof(account_db_path));
 235         ACCOUNT_GET_GLOBAL_DB_PATH(account_db_path, sizeof(account_db_path));
 236
 237         if (g_hAccountGlobalDB) {
 238                 _ERR("Account database is using in another app. %x", g_hAccountDB);
 239                 return _ACCOUNT_ERROR_DATABASE_BUSY;
 240         }
 241
 242         ret = _account_db_handle_close(g_hAccountGlobalDB2);
 243         if (ret != _ACCOUNT_ERROR_NONE)
 244                 ACCOUNT_DEBUG("db_util_close(g_hAccountGlobalDB2) fail ret = %d", ret);
 245
 246         ACCOUNT_DEBUG("before _account_global_db_open()");
 247 //      if (mode == ACCOUNT_DB_OPEN_READWRITE)
 248 //              rc = db_util_open(account_db_path, &g_hAccountDB, DB_UTIL_REGISTER_HOOK_METHOD);
 249 //      else if (mode == ACCOUNT_DB_OPEN_READONLY)
 250         rc = db_util_open_with_options(account_db_path, &g_hAccountGlobalDB, SQLITE_OPEN_READONLY, NULL);
 251 //      else
 252 //              return _ACCOUNT_ERROR_DB_NOT_OPENED;
 253         ACCOUNT_DEBUG("after _account_global_db_open() sqlite_rc = %d", rc);
 254
 255         if (rc == SQLITE_PERM || _account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
 256                 ACCOUNT_ERROR("Account permission denied");
 257                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
 258         }
 259
 260         if (rc == SQLITE_BUSY) {
 261                 ACCOUNT_ERROR("busy handler fail.");
 262                 return _ACCOUNT_ERROR_DATABASE_BUSY;
 263         }
 264
 265         if (rc != SQLITE_OK) {
 266                 ACCOUNT_ERROR("The database isn't connected.");
 267                 return _ACCOUNT_ERROR_DB_NOT_OPENED;
 268         }
 269
 270         _INFO("end _account_global_db_open()");
 271         return _ACCOUNT_ERROR_NONE;
 272 }
 273
 274 int _account_global_db_close(void)
 275 {
 276         ACCOUNT_DEBUG("start account_global_db_close()");
 277         int ret = -1;
 278 /*
 279         ret = _account_db_handle_close(g_hAccountGlobalDB2);
 280         if (ret != _ACCOUNT_ERROR_NONE)
 281                 ACCOUNT_DEBUG("db_util_close(g_hAccountGlobalDB2) fail ret = %d", ret);
 282 */
 283         ret = _account_db_handle_close(g_hAccountGlobalDB);
 284         if (ret != _ACCOUNT_ERROR_NONE) {
 285                 ACCOUNT_ERROR("db_util_close(g_hAccountGlobalDB) fail ret = %d", ret);
 286                 g_hAccountGlobalDB2 = g_hAccountGlobalDB;
 287         }
 288         g_hAccountGlobalDB = NULL;
 289
 290         return ret;
 291 }
 292
 293 static bool _account_check_add_more_account(const char* app_id)
 294 {
 295         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
 296         int                             rc = 0;
 297
 298         ACCOUNT_RETURN_VAL((app_id != 0), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
 299         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
 300
 301         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
 302
 303         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE AppId = '%s' and MultipleAccountSupport = 1", ACCOUNT_TYPE_TABLE, app_id);
 304         rc = _account_get_record_count(g_hAccountDB, query);
 305
 306         /* multiple account support case (User DB & global DB) */
 307         if (rc > 0 || _account_get_record_count(g_hAccountGlobalDB, query) > 0) {
 308                 ACCOUNT_SLOGD("app id (%s) supports multiple account. rc(%d)\n", app_id, rc);
 309                 return TRUE;
 310         }
 311
 312         /* multiple account not support case */
 313         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
 314         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE package_name = '%s'", ACCOUNT_TABLE, app_id);
 315         rc = _account_get_record_count(g_hAccountDB, query);
 316
 317         if (rc <= 0) {
 318                 ACCOUNT_SLOGD("app id (%s) supports single account. and there is no account of the app id\n", app_id);
 319                 return TRUE;
 320         }
 321
 322         return FALSE;
 323 }
 324
 325
 326 int _account_db_open(int mode, int pid, uid_t uid)
 327 {
 328         int rc = 0;
 329         int ret = -1;
 330         char account_db_dir[256] = {0, };
 331         char account_db_path[256] = {0, };
 332
 333         _INFO("start _account_db_open() pid [%d]. uid [%d]", pid, uid);
 334
 335         ACCOUNT_MEMSET(account_db_dir, 0x00, sizeof(account_db_dir));
 336         ACCOUNT_MEMSET(account_db_path, 0x00, sizeof(account_db_path));
 337
 338         ACCOUNT_GET_USER_DB_PATH(account_db_path, sizeof(account_db_path), uid);
 339
 340         if (g_hAccountDB) {
 341                 _ERR("Account database is using in another app. %x", g_hAccountDB);
 342                 return _ACCOUNT_ERROR_DATABASE_BUSY;
 343         }
 344
 345         ret = _account_db_handle_close(g_hAccountDB2);
 346         if (ret != _ACCOUNT_ERROR_NONE)
 347                 ACCOUNT_DEBUG("db_util_close(g_hAccountDB2) fail ret = %d", ret);
 348
 349         ACCOUNT_GET_USER_DB_DIR(account_db_dir, sizeof(account_db_dir), uid);
 350
 351         if (mkdir(account_db_dir, 0777) != 0)
 352                 ACCOUNT_DEBUG("\"%s\" is already exist directory", account_db_dir);
 353
 354         ACCOUNT_DEBUG("before db_util_open()");
 355 //      if (mode == ACCOUNT_DB_OPEN_READWRITE)
 356                 rc = db_util_open(account_db_path, &g_hAccountDB, DB_UTIL_REGISTER_HOOK_METHOD);
 357 //      else if (mode == ACCOUNT_DB_OPEN_READONLY)
 358 //              rc = db_util_open_with_options(account_db_path, &g_hAccountDB, SQLITE_OPEN_READONLY, NULL);
 359 //      else
 360 //              return _ACCOUNT_ERROR_DB_NOT_OPENED;
 361         ACCOUNT_DEBUG("after db_util_open() sqlite_rc = %d", rc);
 362
 363         if (rc == SQLITE_PERM || _account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
 364                 ACCOUNT_ERROR("Account permission denied");
 365                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
 366         }
 367
 368         if (rc == SQLITE_BUSY) {
 369                 ACCOUNT_ERROR("busy handler fail.");
 370                 return _ACCOUNT_ERROR_DATABASE_BUSY;
 371         }
 372
 373         if (rc != SQLITE_OK) {
 374                 ACCOUNT_ERROR("The database isn't connected.");
 375                 return _ACCOUNT_ERROR_DB_NOT_OPENED;
 376         }
 377
 378         rc = _account_check_is_all_table_exists(g_hAccountDB);
 379
 380         if (rc < 0) {
 381                 _ERR("_account_check_is_all_table_exists rc=[%d]", rc);
 382                 return rc;
 383         } else if (rc == ACCOUNT_TABLE_TOTAL_COUNT) {
 384                 _INFO("Tables OK");
 385         } else {
 386                 int ret = _account_create_all_tables(g_hAccountDB);
 387                 if (ret != _ACCOUNT_ERROR_NONE) {
 388                         _ERR("_account_create_all_tables fail ret=[%d]", ret);
 389                         return ret;
 390                 }
 391         }
 392
 393         _INFO("end _account_db_open()");
 394         return _ACCOUNT_ERROR_NONE;
 395 }
 396
 397 int _account_db_close(void)
 398 {
 399         ACCOUNT_DEBUG("start db_util_close()");
 400         int ret = -1;
 401 /*
 402         ret = _account_db_handle_close(g_hAccountDB2);
 403         if (ret != _ACCOUNT_ERROR_NONE)
 404                 ACCOUNT_DEBUG("db_util_close(g_hAccountDB2) fail ret = %d", ret);
 405 */
 406         ret = _account_db_handle_close(g_hAccountDB);
 407         if (ret != _ACCOUNT_ERROR_NONE) {
 408                 ACCOUNT_ERROR("db_util_close(g_hAccountDB) fail ret = %d", ret);
 409                 g_hAccountDB2 = g_hAccountDB;
 410         }
 411         g_hAccountDB = NULL;
 412
 413         return ret;
 414 }
 415
 416 static int _account_execute_insert_query(account_s *account)
 417 {
 418         _INFO("_account_execute_insert_query start");
 419
 420         int                             rc = 0;
 421         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
 422         int                             error_code = _ACCOUNT_ERROR_NONE;
 423         account_stmt    hstmt = NULL;
 424
 425         /* check whether app id exist in account type db */
 426
 427         if (!account->user_name && !account->display_name && !account->email_address) {
 428                 _INFO("");
 429                 ACCOUNT_ERROR("Mandetory fields is NULL. At least one field is required among username, display name, email address\n");
 430                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
 431         }
 432
 433         _INFO("");
 434         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
 435         ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s (user_name, email_address , display_name , icon_path , source , package_name , "
 436                         "access_token , domain_name , auth_type , secret , sync_support , txt_custom0, txt_custom1, txt_custom2, txt_custom3, txt_custom4, "
 437                         "int_custom0, int_custom1, int_custom2, int_custom3, int_custom4, txt_custom0 ) values " // to do urusa
 438                         "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",   ACCOUNT_TABLE);
 439
 440         hstmt = _account_prepare_query(g_hAccountDB, query);
 441         ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query(g_hAccountDB, ) failed(%s).\n", _account_db_err_msg(g_hAccountDB)));
 442
 443         _INFO("");
 444         _account_convert_account_to_sql(account, hstmt, query);
 445
 446         _INFO("");
 447         rc = _account_query_step(hstmt);
 448         if (rc != SQLITE_DONE) {
 449                 _INFO("");
 450                 ACCOUNT_ERROR("account_db_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
 451
 452                 if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM)
 453                         error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
 454                 else
 455                         error_code = _ACCOUNT_ERROR_DB_FAILED;
 456         }
 457
 458         _INFO("");
 459         rc = _account_query_finalize(hstmt);
 460         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
 461         hstmt = NULL;
 462
 463         _INFO("_account_execute_insert_query end");
 464         return error_code;
 465 }
 466
 467 static int _account_insert_capability(account_s *account, int account_id)
 468 {
 469         _INFO("_account_insert_capability start");
 470         int                             rc, count = 1;
 471         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
 472         account_stmt    hstmt = NULL;
 473
 474         ACCOUNT_RETURN_VAL((account != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL"));
 475
 476         if (g_slist_length(account->capablity_list) == 0) {
 477                 ACCOUNT_DEBUG("_account_insert_capability, no capability\n");
 478                 return _ACCOUNT_ERROR_NONE;
 479         }
 480
 481         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where _id=%d", ACCOUNT_TABLE, account_id);
 482
 483         _INFO("_account_insert_capability _account_get_record_count [%s]", query);
 484         rc = _account_get_record_count(g_hAccountDB, query);
 485
 486         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
 487                 _ERR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
 488                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
 489         }
 490
 491         if (rc <= 0)
 492                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
 493
 494         /* insert query*/
 495
 496         GSList *iter;
 497
 498         for (iter = account->capablity_list; iter != NULL; iter = g_slist_next(iter)) {
 499                 int ret;
 500                 count = 1;
 501
 502                 account_capability_s* cap_data = NULL;
 503                 cap_data = (account_capability_s*)iter->data;
 504
 505                 _INFO("cap_data->type = %s, cap_data->value = %d \n", cap_data->type, cap_data->value);
 506
 507                 ACCOUNT_MEMSET(query, 0x00, sizeof(query));
 508                 ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(key, value, package_name, user_name, account_id) VALUES "
 509                                 "(?, ?, ?, ?, ?) ", CAPABILITY_TABLE);
 510                 hstmt = _account_prepare_query(g_hAccountDB, query);
 511
 512                 ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query(g_hAccountDB, ) failed(%s).\n", _account_db_err_msg(g_hAccountDB)));
 513
 514                 ret = _account_query_bind_text(hstmt, count++, cap_data->type);
 515                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
 516                 ret = _account_query_bind_int(hstmt, count++, cap_data->value);
 517                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Integer binding fail"));
 518                 ret = _account_query_bind_text(hstmt, count++, (char*)account->package_name);
 519                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
 520                 ret = _account_query_bind_text(hstmt, count++, (char*)account->user_name);
 521                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
 522                 ret = _account_query_bind_int(hstmt, count++, (int)account_id);
 523                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Integer binding fail"));
 524
 525                 rc = _account_query_step(hstmt);
 526                 _INFO("_account_insert_capability _account_query_step[%d]", rc);
 527
 528                 if (rc != SQLITE_DONE) {
 529                         _ERR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
 530                         break;
 531                 }
 532
 533                 rc = _account_query_finalize(hstmt);
 534                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
 535                 hstmt = NULL;
 536
 537         }
 538
 539         _INFO("_account_insert_capability end");
 540         return _ACCOUNT_ERROR_NONE;
 541 }
 542
 543 static int _account_update_capability(account_s *account, int account_id)
 544 {
 545         int                             rc, count = 1;
 546         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
 547         account_stmt    hstmt = NULL;
 548
 549         ACCOUNT_RETURN_VAL((account != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL"));
 550
 551         if (g_slist_length(account->capablity_list) == 0) {
 552                 ACCOUNT_ERROR("_account_update_capability, no capability\n");
 553                 return _ACCOUNT_ERROR_NONE;
 554         }
 555
 556         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where _id=%d", ACCOUNT_TABLE, account_id);
 557
 558         rc = _account_get_record_count(g_hAccountDB, query);
 559
 560         if (rc <= 0) {
 561                 ACCOUNT_SLOGI("_account_update_capability : related account item is not existed rc=%d , %s", rc, _account_db_err_msg(g_hAccountDB));
 562                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
 563         }
 564
 565         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
 566
 567         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE account_id=? ", CAPABILITY_TABLE);
 568         hstmt = _account_prepare_query(g_hAccountDB, query);
 569         count = 1;
 570         _account_query_bind_int(hstmt, count++, (int)account_id);
 571         rc = _account_query_step(hstmt);
 572
 573         if (rc != SQLITE_DONE) {
 574                 ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
 575                 return _ACCOUNT_ERROR_DB_FAILED;
 576         }
 577         rc = _account_query_finalize(hstmt);
 578         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
 579         hstmt = NULL;
 580
 581         GSList *iter;
 582
 583         for (iter = account->capablity_list; iter != NULL; iter = g_slist_next(iter)) {
 584                 int ret;
 585                 count = 1;
 586                 ACCOUNT_MEMSET(query, 0x00, sizeof(query));
 587                 ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(key, value, package_name, user_name, account_id) VALUES "
 588                                 "(?, ?, ?, ?, ?) ", CAPABILITY_TABLE);
 589
 590                 hstmt = _account_prepare_query(g_hAccountDB, query);
 591
 592                 ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query(g_hAccountDB, ) failed(%s).\n", _account_db_err_msg(g_hAccountDB)));
 593
 594                 account_capability_s* cap_data = NULL;
 595                 cap_data = (account_capability_s*)iter->data;
 596
 597                 ret = _account_query_bind_text(hstmt, count++, cap_data->type);
 598                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
 599                 ret = _account_query_bind_int(hstmt, count++, cap_data->value);
 600                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Integer binding fail"));
 601                 ret = _account_query_bind_text(hstmt, count++, (char*)account->package_name);
 602                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
 603                 ret = _account_query_bind_text(hstmt, count++, (char*)account->user_name);
 604                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
 605                 ret = _account_query_bind_int(hstmt, count++, (int)account_id);
 606                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Integer binding fail"));
 607
 608                 rc = _account_query_step(hstmt);
 609
 610                 if (rc != SQLITE_DONE) {
 611                         ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
 612                         break;
 613                 }
 614
 615                 rc = _account_query_finalize(hstmt);
 616                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
 617                 hstmt = NULL;
 618
 619         }
 620
 621         return _ACCOUNT_ERROR_NONE;
 622 }
 623
 624 static int _account_update_capability_by_user_name(account_s *account, const char *user_name, const char *package_name)
 625 {
 626         int                             rc, count = 1;
 627         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
 628         account_stmt    hstmt = NULL;
 629
 630         ACCOUNT_RETURN_VAL((account != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL"));
 631
 632         if (g_slist_length(account->capablity_list) == 0) {
 633                 ACCOUNT_ERROR("_account_update_capability_by_user_name, no capability\n");
 634                 return _ACCOUNT_ERROR_NONE;
 635         }
 636
 637         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where package_name= '%s' and user_name='%s'", ACCOUNT_TABLE, package_name, user_name);
 638
 639         rc = _account_get_record_count(g_hAccountDB, query);
 640
 641         if (rc <= 0) {
 642                 ACCOUNT_SLOGI("_account_update_capability_by_user_name : related account item is not existed rc=%d , %s ", rc, _account_db_err_msg(g_hAccountDB));
 643                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
 644         }
 645
 646         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
 647
 648         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE package_name=? and user_name=? ", CAPABILITY_TABLE);
 649         hstmt = _account_prepare_query(g_hAccountDB, query);
 650         count = 1;
 651         _account_query_bind_text(hstmt, count++, (char*)account->package_name);
 652         _account_query_bind_text(hstmt, count++, (char*)account->user_name);
 653         rc = _account_query_step(hstmt);
 654         if (rc != SQLITE_DONE) {
 655                 ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
 656                 return _ACCOUNT_ERROR_DB_FAILED;
 657         }
 658
 659         rc = _account_query_finalize(hstmt);
 660         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
 661         hstmt = NULL;
 662
 663         GSList* iter;
 664
 665         for (iter = account->capablity_list; iter != NULL; iter = g_slist_next(iter)) {
 666                 int ret;
 667                 count = 1;
 668                 ACCOUNT_MEMSET(query, 0x00, sizeof(query));
 669                 ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(key, value, package_name, user_name, account_id) VALUES "
 670                                 "(?, ?, ?, ?, ?) ", CAPABILITY_TABLE);
 671
 672                 hstmt = _account_prepare_query(g_hAccountDB, query);
 673
 674                 ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query(g_hAccountDB, ) failed(%s).\n", _account_db_err_msg(g_hAccountDB)));
 675
 676                 account_capability_s* cap_data = NULL;
 677                 cap_data = (account_capability_s*)iter->data;
 678
 679                 ret = _account_query_bind_text(hstmt, count++, cap_data->type);
 680                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
 681                 ret = _account_query_bind_int(hstmt, count++, cap_data->value);
 682                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Integer binding fail"));
 683                 ret = _account_query_bind_text(hstmt, count++, (char*)account->package_name);
 684                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
 685                 ret = _account_query_bind_text(hstmt, count++, (char*)account->user_name);
 686                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
 687                 ret = _account_query_bind_int(hstmt, count++, (int)account->id);
 688                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Integer binding fail"));
 689
 690                 rc = _account_query_step(hstmt);
 691
 692                 if (rc != SQLITE_DONE) {
 693                         ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
 694                         break;
 695                 }
 696
 697                 rc = _account_query_finalize(hstmt);
 698                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
 699                 hstmt = NULL;
 700
 701         }
 702
 703         return _ACCOUNT_ERROR_NONE;
 704 }
 705
 706
 707 bool _account_add_capability_to_account_cb(const char* capability_type, int capability_value, account_s *account)
 708 {
 709         account_capability_s *cap_data = (account_capability_s*)malloc(sizeof(account_capability_s));
 710
 711         if (cap_data == NULL)
 712                 return FALSE;
 713         ACCOUNT_MEMSET(cap_data, 0, sizeof(account_capability_s));
 714
 715         cap_data->type = _account_dup_text(capability_type);
 716         cap_data->value = capability_value;
 717         _INFO("cap_data->type = %s, cap_data->value = %d", cap_data->type, cap_data->value);
 718
 719         account->capablity_list = g_slist_append(account->capablity_list, (gpointer)cap_data);
 720
 721         return TRUE;
 722 }
 723
 724
 725 bool _account_add_custom_to_account_cb(const char* key, const char* value, account_s *account)
 726 {
 727         account_custom_s *custom_data = (account_custom_s*)malloc(sizeof(account_custom_s));
 728
 729         if (custom_data == NULL) {
 730                 ACCOUNT_DEBUG("_account_add_custom_to_account_cb :: malloc fail\n");
 731                 return FALSE;
 732         }
 733         ACCOUNT_MEMSET(custom_data, 0, sizeof(account_custom_s));
 734
 735         custom_data->account_id = account->id;
 736         custom_data->app_id = _account_dup_text(account->package_name);
 737         custom_data->key = _account_dup_text(key);
 738         custom_data->value = _account_dup_text(value);
 739         _INFO("custom_data->key = %s, custom_data->value = %s", custom_data->key, custom_data->value);
 740
 741         account->custom_list = g_slist_append(account->custom_list, (gpointer)custom_data);
 742
 743         return TRUE;
 744 }
 745
 746
 747 static int _account_compare_old_record_by_user_name(account_s *new_account, const char* user_name, const char* package_name)
 748 {
 749         int                             error_code = _ACCOUNT_ERROR_NONE;
 750         account_stmt    hstmt = NULL;
 751         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
 752         int                             rc = 0;
 753         account_s *old_account = NULL;
 754
 755         ACCOUNT_RETURN_VAL((new_account != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT IS NULL"));
 756         ACCOUNT_RETURN_VAL((user_name != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("USER NAME IS NULL"));
 757         ACCOUNT_RETURN_VAL((package_name != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("PACKAGE NAME IS NULL"));
 758         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
 759
 760         old_account = (account_s*)calloc(1, sizeof(account_s));
 761         if (!old_account) {
 762                 ACCOUNT_FATAL("Memory alloc fail\n");
 763                 return _ACCOUNT_ERROR_OUT_OF_MEMORY;
 764         }
 765
 766         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
 767
 768         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE user_name = '%s' and package_name='%s'", ACCOUNT_TABLE, user_name, package_name);
 769         hstmt = _account_prepare_query(g_hAccountDB, query);
 770
 771         rc = _account_query_step(hstmt);
 772         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
 773
 774         while (rc == SQLITE_ROW) {
 775                 _account_convert_column_to_account(hstmt, old_account);
 776                 rc = _account_query_step(hstmt);
 777         }
 778
 779         rc = _account_query_finalize(hstmt);
 780         ACCOUNT_CATCH_ERROR((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
 781         hstmt = NULL;
 782
 783         // get capability
 784         error_code = _account_query_capability_by_account_id(g_hAccountDB, _account_add_capability_to_account_cb, old_account->id, (void*)old_account);
 785         ACCOUNT_CATCH_ERROR((error_code == _ACCOUNT_ERROR_NONE), {}, error_code, ("account_query_capability_by_account_id error"));
 786
 787         // get custom text
 788         error_code = _account_query_custom_by_account_id(g_hAccountDB, _account_add_custom_to_account_cb, old_account->id, (void*)old_account);
 789         ACCOUNT_CATCH_ERROR((error_code == _ACCOUNT_ERROR_NONE), {}, error_code, ("_account_query_custom_by_account_id error"));
 790
 791         // compare
 792         new_account->id = old_account->id;
 793
 794         //user name
 795         if (!new_account->user_name) {
 796                 if (old_account->user_name)
 797                         new_account->user_name = _account_dup_text(old_account->user_name);
 798         }
 799
 800         // display name
 801         if (!new_account->display_name) {
 802                 if (old_account->display_name)
 803                         new_account->display_name = _account_dup_text(old_account->display_name);
 804         }
 805
 806         // email address
 807         if (!new_account->email_address) {
 808                 if (old_account->email_address)
 809                         new_account->email_address = _account_dup_text(old_account->email_address);
 810         }
 811
 812         // domain name
 813         if (!new_account->domain_name) {
 814                 if (old_account->domain_name)
 815                         new_account->domain_name = _account_dup_text(old_account->domain_name);
 816         }
 817
 818         // icon path
 819         if (!new_account->icon_path) {
 820                 if (old_account->icon_path)
 821                         new_account->icon_path = _account_dup_text(old_account->icon_path);
 822         }
 823
 824         // source
 825         if (!new_account->source) {
 826                 if (old_account->source)
 827                         new_account->source = _account_dup_text(old_account->source);
 828         }
 829
 830         _ACCOUNT_FREE(new_account->package_name);
 831         new_account->package_name = _account_dup_text(old_account->package_name);
 832
 833         // access token
 834         if (!new_account->access_token) {
 835                 if (old_account->access_token)
 836                         new_account->access_token = _account_dup_text(old_account->access_token);
 837         }
 838
 839         // auth type
 840         if (new_account->auth_type == _ACCOUNT_AUTH_TYPE_INVALID)
 841                 new_account->auth_type = old_account->auth_type;
 842
 843         //secret
 844         if (new_account->secret == _ACCOUNT_SECRECY_INVALID)
 845                 new_account->secret = old_account->secret;
 846
 847         // sync support
 848         if (new_account->sync_support == _ACCOUNT_SYNC_INVALID)
 849                 new_account->sync_support = old_account->sync_support;
 850
 851         // TODO user text
 852         int i;
 853         for (i = 0; i < USER_TXT_CNT; i++) {
 854                 if (!new_account->user_data_txt[i]) {
 855                         if (old_account->user_data_txt[i])
 856                                 new_account->user_data_txt[i] = _account_dup_text(old_account->user_data_txt[i]);
 857                 }
 858         }
 859
 860         // TODO user int
 861         for (i = 0; i < USER_INT_CNT; i++) {
 862                 if (new_account->user_data_int[i] == 0)
 863                                 new_account->user_data_int[i] = old_account->user_data_int[i];
 864         }
 865
 866 CATCH:
 867         if (old_account)
 868                 _account_free_account_with_items(old_account);
 869
 870         if (hstmt != NULL) {
 871                 rc = _account_query_finalize(hstmt);
 872                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
 873                 hstmt = NULL;
 874         }
 875
 876         return _ACCOUNT_ERROR_NONE;
 877 }
 878
 879 static int _account_update_account_by_user_name(int pid, uid_t uid, account_s *account, const char *user_name, const char *package_name)
 880 {
 881         int                             rc = 0, binding_count = 0, count = 0;
 882         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
 883         int                             error_code = _ACCOUNT_ERROR_NONE;
 884         account_stmt    hstmt = NULL;
 885
 886         ACCOUNT_RETURN_VAL((user_name != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("user_name is NULL.\n"));
 887         ACCOUNT_RETURN_VAL((package_name != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("package_name is NULL.\n"));
 888
 889         char* current_appid = NULL;
 890         char* verified_appid = NULL;
 891
 892         current_appid = _account_get_current_appid(pid, uid);
 893         error_code = _account_get_represented_appid_from_db(g_hAccountDB, g_hAccountGlobalDB, current_appid, uid, &verified_appid);
 894
 895         _ACCOUNT_FREE(current_appid);
 896         _ACCOUNT_FREE(verified_appid);
 897
 898         if (error_code != _ACCOUNT_ERROR_NONE) {
 899                 ACCOUNT_ERROR("No permission to update\n");
 900                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
 901         }
 902
 903         error_code = encrypt_access_token(account);
 904         if (error_code != _ACCOUNT_ERROR_NONE) {
 905                 _ERR("_encrypt_access_token error");
 906                 return error_code;
 907         }
 908
 909         _account_compare_old_record_by_user_name(account, user_name, package_name);
 910
 911         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
 912                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
 913                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
 914         }
 915
 916         if (!account->package_name) {
 917                 ACCOUNT_ERROR("Package name is mandetory field, it can not be NULL!!!!\n");
 918                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
 919         }
 920
 921         if (!account->user_name && !account->display_name && !account->email_address) {
 922                 ACCOUNT_ERROR("One field should be set among user name, display name, email address\n");
 923                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
 924         }
 925
 926         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE user_name='%s' and package_name='%s'"
 927                         , ACCOUNT_TABLE, user_name, package_name);
 928
 929         count = _account_get_record_count(g_hAccountDB, query);
 930
 931         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
 932                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
 933                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
 934         }
 935
 936         if (count <= 0) {
 937                 ACCOUNT_SLOGI("_account_update_account_by_user_name : The account not exist!, count = %d, user_name=%s, package_name=%s\n",
 938                         count, user_name, package_name);
 939                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
 940         }
 941
 942         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
 943
 944         //TODO: Is it required to update id ? As of now I can only think of falied rollback cases (between account and gSSO DB)
 945         ACCOUNT_SNPRINTF(query, sizeof(query), "UPDATE %s SET user_name=?, email_address =?, display_name =?, "
 946                         "icon_path =?, source =?, package_name =? , access_token =?, domain_name =?, auth_type =?, secret =?, sync_support =?,"
 947                         "txt_custom0=?, txt_custom1=?, txt_custom2=?, txt_custom3=?, txt_custom4=?, "
 948                         "int_custom0=?, int_custom1=?, int_custom2=?, int_custom3=?, int_custom4=? WHERE user_name=? and package_name=? ", ACCOUNT_TABLE);
 949
 950         hstmt = _account_prepare_query(g_hAccountDB, query);
 951         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
 952                 _account_end_transaction(g_hAccountDB, FALSE);
 953                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
 954                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
 955         }
 956         ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_svc_query_prepare() failed(%s).\n", _account_db_err_msg(g_hAccountDB)));
 957
 958         binding_count = _account_convert_account_to_sql(account, hstmt, query);
 959
 960         _account_query_bind_text(hstmt, binding_count++, user_name);
 961         _account_query_bind_text(hstmt, binding_count++, package_name);
 962
 963         rc = _account_query_step(hstmt);
 964         if (rc != SQLITE_DONE)
 965                 ACCOUNT_ERROR("account_db_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
 966
 967         rc = _account_query_finalize(hstmt);
 968         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
 969         hstmt = NULL;
 970
 971         /*update capability*/
 972         error_code = _account_update_capability_by_user_name(account, user_name, package_name);
 973
 974         /* update custom */
 975         error_code = _account_update_custom(account, account->id);
 976
 977         return error_code;
 978 }
 979
 980 int _account_insert_to_db(account_s* account, int pid, uid_t uid, int *account_id)
 981 {
 982         _INFO("");
 983         int             error_code = _ACCOUNT_ERROR_NONE;
 984         int             ret_transaction = 0;
 985
 986         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
 987         ACCOUNT_RETURN_VAL((account != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL"));
 988         ACCOUNT_RETURN_VAL((account_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT ID POINTER IS NULL"));
 989
 990         if (!account->user_name && !account->display_name && !account->email_address) {
 991                 ACCOUNT_ERROR("One field should be set among user name, display name, email address\n");
 992                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
 993         }
 994
 995         account_s *data = (account_s*)account;
 996         ACCOUNT_SLOGD("(%s)-(%d) account_insert_to_db: begin_transaction.\n", __FUNCTION__, __LINE__);
 997
 998         pthread_mutex_lock(&account_mutex);
 999
1000         /* transaction control required*/
1001         ret_transaction = _account_begin_transaction(g_hAccountDB);
1002
1003         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
1004                 pthread_mutex_unlock(&account_mutex);
1005                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
1006                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
1007         }
1008
1009         if (ret_transaction == _ACCOUNT_ERROR_DATABASE_BUSY) {
1010                 ACCOUNT_ERROR("account insert:_account_begin_transaction fail %d\n", ret_transaction);
1011                 pthread_mutex_unlock(&account_mutex);
1012                 return _ACCOUNT_ERROR_DATABASE_BUSY;
1013         } else if (ret_transaction != _ACCOUNT_ERROR_NONE) {
1014                 ACCOUNT_ERROR("account insert:_account_begin_transaction fail %d\n", ret_transaction);
1015                 pthread_mutex_unlock(&account_mutex);
1016                 return ret_transaction;
1017         }
1018
1019         *account_id = _account_get_next_sequence(g_hAccountDB, ACCOUNT_TABLE);
1020         data->id = *account_id;
1021
1022         char* appid = NULL;
1023         appid = _account_get_current_appid(pid, uid);
1024
1025         if (!appid) {
1026                 _INFO("");
1027                 // API caller cannot be recognized
1028                 ret_transaction = _account_end_transaction(g_hAccountDB, FALSE);
1029                 ACCOUNT_ERROR("App id is not registered in account type DB, transaction ret (%x)!!!!\n", ret_transaction);
1030                 pthread_mutex_unlock(&account_mutex);
1031                 return _ACCOUNT_ERROR_NOT_REGISTERED_PROVIDER;
1032         }
1033
1034         _INFO("");
1035         char* verified_appid = NULL;
1036         error_code  = _account_get_represented_appid_from_db(g_hAccountDB, g_hAccountGlobalDB, appid, uid, &verified_appid);//FIX
1037         _ACCOUNT_FREE(appid);
1038         if (error_code != _ACCOUNT_ERROR_NONE) {
1039                 _ERR("error_code = %d", error_code);
1040                 ret_transaction = _account_end_transaction(g_hAccountDB, FALSE);
1041                 ACCOUNT_ERROR("App id is not registered in account type DB, transaction ret (%x)!!!!\n", ret_transaction);
1042                 _ACCOUNT_FREE(verified_appid);
1043                 pthread_mutex_unlock(&account_mutex);
1044                 return error_code;
1045         }
1046
1047         if (verified_appid) {
1048                 _INFO("");
1049                 error_code = _account_check_duplicated(g_hAccountDB, data, verified_appid, uid);
1050                 if (error_code != _ACCOUNT_ERROR_NONE) {
1051                         _INFO("");
1052                         ret_transaction = _account_end_transaction(g_hAccountDB, FALSE);
1053                         ACCOUNT_DEBUG("_account_check_duplicated(), rollback insert query(%x)!!!!\n", ret_transaction);
1054                         *account_id = -1;
1055                         pthread_mutex_unlock(&account_mutex);
1056                         return error_code;
1057                 }
1058                 if (!_account_check_add_more_account(verified_appid)) {
1059                         ret_transaction = _account_end_transaction(g_hAccountDB, FALSE);
1060                         ACCOUNT_ERROR("No more account cannot be added, transaction ret (%x)!!!!\n", ret_transaction);
1061                         pthread_mutex_unlock(&account_mutex);
1062                         _ACCOUNT_FREE(verified_appid);
1063                         return _ACCOUNT_ERROR_NOT_ALLOW_MULTIPLE;
1064                 }
1065
1066                 _ACCOUNT_FREE(data->package_name);
1067                 data->package_name = _account_dup_text(verified_appid);
1068                 _ACCOUNT_FREE(verified_appid);
1069         }
1070
1071         if (!_account_check_add_more_account(data->package_name)) {
1072                 _INFO("");
1073                 ret_transaction = _account_end_transaction(g_hAccountDB, FALSE);
1074                 ACCOUNT_ERROR("No more account cannot be added, transaction ret (%x)!!!!\n", ret_transaction);
1075                 pthread_mutex_unlock(&account_mutex);
1076                 return _ACCOUNT_ERROR_NOT_ALLOW_MULTIPLE;
1077         }
1078
1079         error_code = encrypt_access_token(data);
1080         if (error_code != _ACCOUNT_ERROR_NONE) {
1081                 ret_transaction = _account_end_transaction(g_hAccountDB, FALSE);
1082                 ACCOUNT_ERROR("encrypt_access_token fail, rollback insert query(%x)!!!!\n", ret_transaction);
1083                 *account_id = -1;
1084                 pthread_mutex_unlock(&account_mutex);
1085                 return error_code;
1086         }
1087
1088         error_code = _account_execute_insert_query(data);
1089
1090         if (error_code != _ACCOUNT_ERROR_NONE) {
1091                 _INFO("");
1092                 ret_transaction = _account_end_transaction(g_hAccountDB, FALSE);
1093                 ACCOUNT_ERROR("INSERT account fail, rollback insert query(%x)!!!!\n", ret_transaction);
1094                 *account_id = -1;
1095                 pthread_mutex_unlock(&account_mutex);
1096                 return error_code;
1097         }
1098
1099         _INFO("");
1100         error_code = _account_insert_capability(data, *account_id);
1101         if (error_code != _ACCOUNT_ERROR_NONE) {
1102                 _INFO("");
1103                 ret_transaction = _account_end_transaction(g_hAccountDB, FALSE);
1104                 ACCOUNT_ERROR("INSERT capability fail, rollback insert capability query(%x)!!!!\n", ret_transaction);
1105                 *account_id = -1;
1106                 pthread_mutex_unlock(&account_mutex);
1107                 return error_code;
1108         }
1109
1110         _INFO("");
1111         error_code = _account_insert_custom(data, *account_id);
1112         if (error_code != _ACCOUNT_ERROR_NONE) {
1113                 ret_transaction = _account_end_transaction(g_hAccountDB, FALSE);
1114                 ACCOUNT_ERROR("INSERT custom fail, rollback insert capability query(%x)!!!!\n", ret_transaction);
1115                 *account_id = -1;
1116                 pthread_mutex_unlock(&account_mutex);
1117                 return error_code;
1118         }
1119
1120         _INFO("");
1121
1122         pthread_mutex_unlock(&account_mutex);
1123         _account_end_transaction(g_hAccountDB, TRUE);
1124         ACCOUNT_SLOGD("(%s)-(%d) account _end_transaction.\n", __FUNCTION__, __LINE__);
1125
1126         char buf[64] = {0,};
1127         ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", _ACCOUNT_NOTI_NAME_INSERT, *account_id);
1128         _account_insert_delete_update_notification_send(buf);
1129         _INFO("account _notification_send end.");
1130
1131         return _ACCOUNT_ERROR_NONE;
1132 }
1133
1134 GSList* _account_get_capability_list_by_account_id(int account_id, int *error_code)
1135 {
1136         *error_code = _ACCOUNT_ERROR_NONE;
1137         account_stmt    hstmt = NULL;
1138         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
1139         int                             rc = 0;
1140         GSList* capability_list = NULL;
1141
1142         ACCOUNT_RETURN_VAL((account_id > 0), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; }, NULL, ("ACCOUNT INDEX IS LESS THAN 0"));
1143         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), { *error_code = _ACCOUNT_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
1144
1145         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
1146
1147         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE account_id = %d", CAPABILITY_TABLE, account_id);
1148         hstmt = _account_prepare_query(g_hAccountDB, query);
1149
1150         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
1151                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
1152                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
1153                 return NULL;
1154         }
1155
1156         rc = _account_query_step(hstmt);
1157         ACCOUNT_CATCH_ERROR_P(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
1158
1159         account_capability_s* capability_record = NULL;
1160
1161         while (rc == SQLITE_ROW) {
1162                 capability_record = (account_capability_s*) malloc(sizeof(account_capability_s));
1163
1164                 if (capability_record == NULL) {
1165                         ACCOUNT_FATAL("malloc Failed");
1166                         break;
1167                 }
1168
1169                 ACCOUNT_MEMSET(capability_record, 0x00, sizeof(account_capability_s));
1170
1171                 _account_convert_column_to_capability(hstmt, capability_record);
1172
1173                 //cb_ret = callback(capability_record->type, capability_record->value, user_data);
1174
1175                 //_account_free_capability_items(capability_record);
1176                 //_ACCOUNT_FREE(capability_record);
1177
1178                 //ACCOUNT_CATCH_ERROR(cb_ret == TRUE, {}, _ACCOUNT_ERROR_NONE, ("Callback func returs FALSE, its iteration is stopped!!!!\n"));
1179
1180                 capability_list = g_slist_append(capability_list, capability_record);
1181                 rc = _account_query_step(hstmt);
1182         }
1183
1184         rc = _account_query_finalize(hstmt);
1185         if (rc != _ACCOUNT_ERROR_NONE) {
1186                 _ERR("finalize error");
1187                 _account_gslist_capability_free(capability_list);
1188                 *error_code = rc;
1189                 return NULL;
1190         }
1191
1192         hstmt = NULL;
1193
1194         *error_code = _ACCOUNT_ERROR_NONE;
1195
1196 CATCH:
1197         if (hstmt != NULL) {
1198                 rc = _account_query_finalize(hstmt);
1199                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), { *error_code = rc; }, NULL, ("finalize error"));
1200                 hstmt = NULL;
1201         }
1202
1203         pthread_mutex_unlock(&account_mutex);
1204
1205         return capability_list;
1206 }
1207
1208 static int _account_compare_old_record(account_s *new_account, int account_id)
1209 {
1210         int                             error_code = _ACCOUNT_ERROR_NONE;
1211         account_stmt    hstmt = NULL;
1212         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
1213         int                             rc = 0;
1214         account_s *old_account = NULL;
1215
1216         ACCOUNT_RETURN_VAL((account_id > 0), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT INDEX IS LESS THAN 0"));
1217         ACCOUNT_RETURN_VAL((new_account != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT IS NULL"));
1218         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
1219
1220         old_account = (account_s*)calloc(1, sizeof(account_s));
1221         if (old_account == NULL) {
1222                 _ERR("Out of Memory");
1223                 return _ACCOUNT_ERROR_OUT_OF_MEMORY;
1224         }
1225
1226         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
1227
1228         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE _id = %d", ACCOUNT_TABLE, account_id);
1229         hstmt = _account_prepare_query(g_hAccountDB, query);
1230
1231         rc = _account_query_step(hstmt);
1232         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
1233
1234         while (rc == SQLITE_ROW) {
1235                 _account_convert_column_to_account(hstmt, old_account);
1236                 rc = _account_query_step(hstmt);
1237         }
1238
1239         rc = _account_query_finalize(hstmt);
1240         ACCOUNT_CATCH_ERROR((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
1241         hstmt = NULL;
1242
1243         // get capability
1244         error_code = _account_query_capability_by_account_id(g_hAccountDB, _account_add_capability_to_account_cb, old_account->id, (void*)old_account);
1245         ACCOUNT_CATCH_ERROR((error_code == _ACCOUNT_ERROR_NONE), {}, error_code, ("account_query_capability_by_account_id error"));
1246
1247         // get custom text
1248         error_code = _account_query_custom_by_account_id(g_hAccountDB, _account_add_custom_to_account_cb, old_account->id, (void*)old_account);
1249         ACCOUNT_CATCH_ERROR((error_code == _ACCOUNT_ERROR_NONE), {}, error_code, ("_account_query_custom_by_account_id error"));
1250
1251         // compare
1252
1253         new_account->id = old_account->id;
1254
1255         //user name
1256         if (!new_account->user_name) {
1257                 if (old_account->user_name)
1258                         new_account->user_name = _account_dup_text(old_account->user_name);
1259         }
1260
1261         // display name
1262         if (!new_account->display_name) {
1263                 if (old_account->display_name)
1264                         new_account->display_name = _account_dup_text(old_account->display_name);
1265         }
1266
1267         // email address
1268         if (!new_account->email_address) {
1269                 if (old_account->email_address)
1270                         new_account->email_address = _account_dup_text(old_account->email_address);
1271         }
1272
1273         // domain name
1274         if (!new_account->domain_name) {
1275                 if (old_account->domain_name)
1276                         new_account->domain_name = _account_dup_text(old_account->domain_name);
1277         }
1278
1279         // icon path
1280         if (!new_account->icon_path) {
1281                 if (old_account->icon_path)
1282                         new_account->icon_path = _account_dup_text(old_account->icon_path);
1283         }
1284
1285         // source
1286         if (!new_account->source) {
1287                 if (old_account->source)
1288                         new_account->source = _account_dup_text(old_account->source);
1289         }
1290
1291         _ACCOUNT_FREE(new_account->package_name);
1292         new_account->package_name = _account_dup_text(old_account->package_name);
1293
1294         // access token
1295         if (!new_account->access_token) {
1296                 if (old_account->access_token)
1297                         new_account->access_token = _account_dup_text(old_account->access_token);
1298         }
1299
1300         // user text
1301         int i;
1302         for (i = 0; i < USER_TXT_CNT; i++) {
1303                 if (!new_account->user_data_txt[i]) {
1304                         if (old_account->user_data_txt[i])
1305                                 new_account->user_data_txt[i] = _account_dup_text(old_account->user_data_txt[i]);
1306                 }
1307         }
1308
1309         // auth type
1310         if (new_account->auth_type == _ACCOUNT_AUTH_TYPE_INVALID)
1311                 new_account->auth_type = old_account->auth_type;
1312
1313         // secret
1314         if (new_account->secret == _ACCOUNT_SECRECY_INVALID)
1315                 new_account->secret = old_account->secret;
1316
1317         // sync support
1318         if (new_account->sync_support == _ACCOUNT_SYNC_INVALID)
1319                 new_account->sync_support = old_account->sync_support;
1320
1321         // user int
1322         for (i = 0; i < USER_INT_CNT; i++) {
1323                 if (new_account->user_data_int[i] == 0)
1324                                 new_account->user_data_int[i] = old_account->user_data_int[i];
1325         }
1326
1327 CATCH:
1328         if (old_account)
1329                 _account_free_account_with_items(old_account);
1330
1331         if (hstmt != NULL) {
1332                 rc = _account_query_finalize(hstmt);
1333                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
1334                 hstmt = NULL;
1335         }
1336
1337         return _ACCOUNT_ERROR_NONE;
1338 }
1339
1340 static int _account_get_package_name_from_account_id(int account_id, char **package_name)
1341 {
1342         int                             error_code = _ACCOUNT_ERROR_NONE;
1343         account_stmt    hstmt = NULL;
1344         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
1345         int                             rc = 0;
1346         account_s *old_account = NULL;
1347
1348         ACCOUNT_RETURN_VAL((account_id > 0), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT INDEX IS LESS THAN 0"));
1349         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
1350
1351         old_account = (account_s*)calloc(1, sizeof(account_s));
1352         if (old_account == NULL) {
1353                 _ERR("Out Of memory");
1354                 return _ACCOUNT_ERROR_OUT_OF_MEMORY;
1355         }
1356
1357         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
1358
1359         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE _id = %d", ACCOUNT_TABLE, account_id);
1360         hstmt = _account_prepare_query(g_hAccountDB, query);
1361
1362         rc = _account_query_step(hstmt);
1363         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
1364
1365         while (rc == SQLITE_ROW) {
1366                 _account_convert_column_to_account(hstmt, old_account);
1367                 rc = _account_query_step(hstmt);
1368         }
1369
1370         rc = _account_query_finalize(hstmt);
1371         ACCOUNT_CATCH_ERROR((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
1372         hstmt = NULL;
1373
1374         // get package name.
1375         *package_name = _account_dup_text(old_account->package_name);
1376
1377 CATCH:
1378         if (old_account)
1379                 _account_free_account_with_items(old_account);
1380
1381         if (hstmt != NULL) {
1382                 rc = _account_query_finalize(hstmt);
1383                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
1384                 hstmt = NULL;
1385         }
1386
1387         return error_code;
1388
1389 }
1390
1391 static int _account_update_account(int pid, uid_t uid, account_s *account, int account_id)
1392 {
1393         int                             rc = 0, binding_count = 0;
1394         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
1395         int                             error_code = _ACCOUNT_ERROR_NONE, count = 0, ret_transaction = 0;
1396         account_stmt    hstmt = NULL;
1397
1398         if (!account->package_name) {
1399                 ACCOUNT_ERROR("Package name is mandetory field, it can not be NULL!!!!\n");
1400                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
1401         }
1402
1403         /* Check permission of requested appid */
1404         char* current_appid = NULL;
1405         char *package_name = NULL;
1406
1407         current_appid = _account_get_current_appid(pid, uid);
1408         error_code = _account_get_package_name_from_account_id(account_id, &package_name);
1409
1410         if (error_code != _ACCOUNT_ERROR_NONE || package_name == NULL) {
1411                 ACCOUNT_ERROR("No package name with account_id\n");
1412                 _ACCOUNT_FREE(current_appid);
1413                 _ACCOUNT_FREE(package_name);
1414                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
1415         }
1416
1417         error_code = _account_check_appid_group_with_package_name(current_appid, package_name, uid);
1418         ACCOUNT_DEBUG("UPDATE:account_id[%d],current_appid[%s]package_name[%s]", account_id, current_appid, package_name);      // TODO: remove the log later.
1419
1420         _ACCOUNT_FREE(current_appid);
1421         _ACCOUNT_FREE(package_name);
1422
1423         if (error_code != _ACCOUNT_ERROR_NONE) {
1424                 ACCOUNT_ERROR("No permission to update\n");
1425                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
1426         }
1427
1428         error_code = encrypt_access_token(account);
1429         if (error_code != _ACCOUNT_ERROR_NONE) {
1430                 _ERR("_encrypt_access_token error");
1431                 return error_code;
1432         }
1433
1434         error_code = _account_compare_old_record(account, account_id);
1435         if (error_code != _ACCOUNT_ERROR_NONE) {
1436                 ACCOUNT_ERROR("_account_compare_old_record fail\n");
1437                 return error_code;
1438         }
1439
1440         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
1441                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
1442                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
1443         } else if (_account_db_err_code(g_hAccountDB) == SQLITE_BUSY) {
1444                 ACCOUNT_ERROR("database busy(%s)", _account_db_err_msg(g_hAccountDB));
1445                 return _ACCOUNT_ERROR_DATABASE_BUSY;
1446         }
1447
1448         if (!account->user_name && !account->display_name && !account->email_address) {
1449                 ACCOUNT_ERROR("One field should be set among user name, display name, email address\n");
1450                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
1451         }
1452
1453         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
1454
1455         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE _id = %d ", ACCOUNT_TABLE, account_id);
1456
1457         count = _account_get_record_count(g_hAccountDB, query);
1458         if (count <= 0) {
1459                 ACCOUNT_DEBUG(" Account record not found, count = %d\n", count);
1460                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
1461         }
1462
1463         /* transaction control required*/
1464         ret_transaction = _account_begin_transaction(g_hAccountDB);
1465         if (ret_transaction == _ACCOUNT_ERROR_DATABASE_BUSY) {
1466                 ACCOUNT_ERROR("database busy(%s)", _account_db_err_msg(g_hAccountDB));
1467                 pthread_mutex_unlock(&account_mutex);
1468                 return _ACCOUNT_ERROR_DATABASE_BUSY;
1469         }
1470
1471         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
1472         ACCOUNT_SNPRINTF(query, sizeof(query), "UPDATE %s SET user_name=?, email_address =?, display_name =?, "
1473                         "icon_path =?, source =?, package_name =? , access_token =?, domain_name =?, auth_type =?, secret =?, sync_support =?,"
1474                         "txt_custom0=?, txt_custom1=?, txt_custom2=?, txt_custom3=?, txt_custom4=?, "
1475                         "int_custom0=?, int_custom1=?, int_custom2=?, int_custom3=?, int_custom4=? WHERE _id=? ", ACCOUNT_TABLE);
1476
1477         hstmt = _account_prepare_query(g_hAccountDB, query);
1478
1479         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
1480                 ret_transaction = _account_end_transaction(g_hAccountDB, FALSE);
1481                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
1482                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
1483         }
1484
1485         ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_svc_query_prepare() failed(%s)(%x).\n", _account_db_err_msg(g_hAccountDB), _account_end_transaction(g_hAccountDB, FALSE)));
1486
1487         binding_count = _account_convert_account_to_sql(account, hstmt, query);
1488         _account_query_bind_int(hstmt, binding_count++, account_id);
1489
1490         rc = _account_query_step(hstmt);
1491         if (rc != SQLITE_DONE)
1492                 ACCOUNT_SLOGE("account_db_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
1493
1494         rc = _account_query_finalize(hstmt);
1495         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
1496         hstmt = NULL;
1497
1498         _INFO("update query=%s", query);
1499
1500         /*update capability*/
1501         error_code = _account_update_capability(account, account_id);
1502         if (error_code != _ACCOUNT_ERROR_NONE && error_code != _ACCOUNT_ERROR_RECORD_NOT_FOUND) {
1503                 ret_transaction = _account_end_transaction(g_hAccountDB, FALSE);
1504                 ACCOUNT_ERROR("update capability Failed, trying to roll back(%x) !!!\n", ret_transaction);
1505                 return error_code;
1506         }
1507
1508         /* update custom */
1509         error_code = _account_update_custom(account, account_id);
1510         if (error_code != _ACCOUNT_ERROR_NONE && error_code != _ACCOUNT_ERROR_RECORD_NOT_FOUND) {
1511                 ret_transaction = _account_end_transaction(g_hAccountDB, FALSE);
1512                 ACCOUNT_ERROR("update capability Failed, trying to roll back(%x) !!!\n", ret_transaction);
1513                 return error_code;
1514         }
1515
1516         ret_transaction = _account_end_transaction(g_hAccountDB, TRUE);
1517
1518         _INFO("update end");
1519
1520         return error_code;
1521 }
1522
1523
1524 static int _account_update_account_ex(account_s *account, int account_id)
1525 {
1526         int                             rc = 0, binding_count = 0;
1527         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
1528         int                             error_code = _ACCOUNT_ERROR_NONE, count = 0, ret_transaction = 0;
1529         account_stmt    hstmt = NULL;
1530
1531         if (!account->package_name) {
1532                 ACCOUNT_ERROR("Package name is mandetory field, it can not be NULL!!!!\n");
1533                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
1534         }
1535
1536         error_code = encrypt_access_token(account);
1537         if (error_code != _ACCOUNT_ERROR_NONE) {
1538                 _ERR("_encrypt_access_token error");
1539                 return error_code;
1540         }
1541
1542         error_code = _account_compare_old_record(account, account_id);
1543         if (error_code != _ACCOUNT_ERROR_NONE) {
1544                 ACCOUNT_ERROR("_account_compare_old_record fail\n");
1545                 return error_code;
1546         }
1547
1548         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
1549                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
1550                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
1551         }
1552
1553         if (!account->user_name && !account->display_name && !account->email_address) {
1554                 ACCOUNT_ERROR("One field should be set among user name, display name, email address\n");
1555                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
1556         }
1557
1558         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
1559
1560         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE _id = %d ", ACCOUNT_TABLE, account_id);
1561
1562         count = _account_get_record_count(g_hAccountDB, query);
1563         if (count <= 0) {
1564                 ACCOUNT_DEBUG(" Account record not found, count = %d\n", count);
1565                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
1566         }
1567
1568         /* transaction control required*/
1569         ret_transaction = _account_begin_transaction(g_hAccountDB);
1570         if (ret_transaction == _ACCOUNT_ERROR_DATABASE_BUSY) {
1571                 ACCOUNT_ERROR("database busy(%s)", _account_db_err_msg(g_hAccountDB));
1572                 pthread_mutex_unlock(&account_mutex);
1573                 return _ACCOUNT_ERROR_DATABASE_BUSY;
1574         }
1575
1576         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
1577         ACCOUNT_SNPRINTF(query, sizeof(query), "UPDATE %s SET user_name=?, email_address =?, display_name =?, "
1578                         "icon_path =?, source =?, package_name =? , access_token =?, domain_name =?, auth_type =?, secret =?, sync_support =?,"
1579                         "txt_custom0=?, txt_custom1=?, txt_custom2=?, txt_custom3=?, txt_custom4=?, "
1580                         "int_custom0=?, int_custom1=?, int_custom2=?, int_custom3=?, int_custom4=? WHERE _id=? ", ACCOUNT_TABLE);
1581
1582         hstmt = _account_prepare_query(g_hAccountDB, query);
1583
1584         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
1585                 ret_transaction = _account_end_transaction(g_hAccountDB, FALSE);
1586                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
1587                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
1588         }
1589
1590         ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_svc_query_prepare() failed(%s)(%x).\n", _account_db_err_msg(g_hAccountDB), _account_end_transaction(g_hAccountDB, FALSE)));
1591
1592         _INFO("account_update_to_db_by_id_ex_p : before convert() : account_id[%d], user_name=%s", account->id, account->user_name);
1593         binding_count = _account_convert_account_to_sql(account, hstmt, query);
1594         _INFO("account_update_to_db_by_id_ex_p : after convert() : account_id[%d], user_name=%s", account->id, account->user_name);
1595         _INFO("account_update_to_db_by_id_ex_p : before bind()");
1596         rc = _account_query_bind_int(hstmt, binding_count++, account_id);
1597         _INFO("account_update_to_db_by_id_ex_p : after bind() : ret = %d", rc);
1598
1599         rc = _account_query_step(hstmt);
1600         if (rc != SQLITE_DONE)
1601                 ACCOUNT_SLOGE("account_db_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
1602         _INFO("account_update_to_db_by_id_ex_p : after query_step() : ret = %d", rc);
1603
1604         rc = _account_query_finalize(hstmt);
1605         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
1606         hstmt = NULL;
1607         _INFO("account_update_to_db_by_id_ex_p : after query_filnalize() : ret = %d", rc);
1608
1609         _INFO("account_update_to_db_by_id_ex_p : before update_capability()");
1610         /*update capability*/
1611         error_code = _account_update_capability(account, account_id);
1612         if (error_code != _ACCOUNT_ERROR_NONE && error_code != _ACCOUNT_ERROR_RECORD_NOT_FOUND) {
1613                 ret_transaction = _account_end_transaction(g_hAccountDB, FALSE);
1614                 ACCOUNT_ERROR("update capability Failed, trying to roll back(%x) !!!\n", ret_transaction);
1615                 return error_code;
1616         }
1617         _INFO("account_update_to_db_by_id_ex_p : after update_capability()");
1618
1619         _INFO("account_update_to_db_by_id_ex_p : before update_custom()");
1620         /* update custom */
1621         error_code = _account_update_custom(account, account_id);
1622         if (error_code != _ACCOUNT_ERROR_NONE && error_code != _ACCOUNT_ERROR_RECORD_NOT_FOUND) {
1623                 ret_transaction = _account_end_transaction(g_hAccountDB, FALSE);
1624                 ACCOUNT_ERROR("update capability Failed, trying to roll back(%x) !!!\n", ret_transaction);
1625                 return error_code;
1626         }
1627         _INFO("account_update_to_db_by_id_ex_p : after update_custom()");
1628
1629         ret_transaction = _account_end_transaction(g_hAccountDB, TRUE);
1630
1631         return error_code;
1632 }
1633
1634
1635 int _account_update_to_db_by_id(int pid, uid_t uid, account_s* account, int account_id)
1636 {
1637         ACCOUNT_RETURN_VAL((account != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("DATA IS NULL"));
1638         ACCOUNT_RETURN_VAL((account_id > 0), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Account id is not valid"));
1639         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
1640         int     error_code = _ACCOUNT_ERROR_NONE;
1641         account_s* data = (account_s*)account;
1642
1643         pthread_mutex_lock(&account_mutex);
1644
1645         error_code = _account_update_account(pid, uid, data, account_id);
1646
1647         if (error_code != _ACCOUNT_ERROR_NONE) {
1648                 pthread_mutex_unlock(&account_mutex);
1649                 return error_code;
1650         }
1651
1652         pthread_mutex_unlock(&account_mutex);
1653
1654         char buf[64] = {0,};
1655         ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", _ACCOUNT_NOTI_NAME_UPDATE, account_id);
1656         _account_insert_delete_update_notification_send(buf);
1657
1658         return _ACCOUNT_ERROR_NONE;
1659 }
1660
1661 int _account_update_to_db_by_id_ex(account_s* account, int account_id)
1662 {
1663         ACCOUNT_RETURN_VAL((account != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("DATA IS NULL"));
1664         ACCOUNT_RETURN_VAL((account_id > 0), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Account id is not valid"));
1665         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
1666         int     error_code = _ACCOUNT_ERROR_NONE;
1667         account_s* data = account;
1668
1669         pthread_mutex_lock(&account_mutex);
1670
1671         _INFO("before update_account_ex() : account_id[%d], user_name=%s", account_id, data->user_name);
1672         error_code = _account_update_account_ex(data, account_id);
1673         _INFO("after update_account_ex() : account_id[%d], user_name=%s", account_id, data->user_name);
1674
1675         if (error_code != _ACCOUNT_ERROR_NONE) {
1676                 pthread_mutex_unlock(&account_mutex);
1677                 return error_code;
1678         }
1679
1680         pthread_mutex_unlock(&account_mutex);
1681
1682         char buf[64] = {0,};
1683         ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", _ACCOUNT_NOTI_NAME_UPDATE, account_id);
1684         _account_insert_delete_update_notification_send(buf);
1685
1686         return _ACCOUNT_ERROR_NONE;
1687 }
1688
1689 int _account_update_to_db_by_user_name(int pid, uid_t uid, account_s* account, const char *user_name, const char *package_name)
1690 {
1691         ACCOUNT_RETURN_VAL((user_name != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("USER NAME IS NULL"));
1692         ACCOUNT_RETURN_VAL((package_name != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("PACKAGE NAME IS NULL"));
1693         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
1694
1695         int     error_code = _ACCOUNT_ERROR_NONE;
1696         account_s *data = (account_s*)account;
1697
1698         pthread_mutex_lock(&account_mutex);
1699
1700         error_code = _account_update_account_by_user_name(pid, uid, data, user_name, package_name);
1701
1702         pthread_mutex_unlock(&account_mutex);
1703
1704         char buf[64] = {0,};
1705         ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", _ACCOUNT_NOTI_NAME_UPDATE, data->id);
1706         _account_insert_delete_update_notification_send(buf);
1707
1708         return error_code;
1709 }
1710
1711 GSList* _account_db_query_all(int pid, uid_t uid)
1712 {
1713         //int                   error_code = _ACCOUNT_ERROR_NONE;
1714         account_stmt    hstmt = NULL;
1715         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
1716         int                             rc = 0;
1717         GSList                  *account_list = NULL;
1718
1719         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, NULL, ("The database isn't connected."));
1720
1721         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
1722
1723         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s ", ACCOUNT_TABLE);
1724         hstmt = _account_prepare_query(g_hAccountDB, query);
1725
1726         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
1727                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
1728                 return NULL;
1729         }
1730
1731         rc = _account_query_step(hstmt);
1732
1733         account_s *account_record = NULL;
1734
1735         if (rc != SQLITE_ROW) {
1736                 _ERR("The record isn't found");
1737                 goto CATCH;
1738         }
1739
1740         while (rc == SQLITE_ROW) {
1741                 account_record = (account_s*) malloc(sizeof(account_s));
1742
1743                 if (account_record == NULL) {
1744                         ACCOUNT_FATAL("malloc Failed");
1745                         break;
1746                 }
1747
1748                 ACCOUNT_MEMSET(account_record, 0x00, sizeof(account_s));
1749                 _account_convert_column_to_account(hstmt, account_record);
1750                 account_list = g_slist_append(account_list, account_record);
1751                 rc = _account_query_step(hstmt);
1752         }
1753
1754         rc = _account_query_finalize(hstmt);
1755         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {_account_gslist_account_free(account_list); }, NULL, ("finalize error"));
1756         hstmt = NULL;
1757
1758         GSList* iter;
1759
1760         for (iter = account_list; iter != NULL; iter = g_slist_next(iter)) {
1761                 account_s *account = NULL;
1762                 account = (account_s*)iter->data;
1763                 _account_query_capability_by_account_id(g_hAccountDB, _account_add_capability_to_account_cb, account->id, (void*)account);
1764                 _account_query_custom_by_account_id(g_hAccountDB, _account_add_custom_to_account_cb, account->id, (void*)account);
1765         }
1766
1767 CATCH:
1768         if (hstmt != NULL) {
1769                 rc = _account_query_finalize(hstmt);
1770                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {_account_gslist_account_free(account_list); }, NULL, ("finalize error"));
1771                 hstmt = NULL;
1772         }
1773
1774         if (account_list)
1775                 _remove_sensitive_info_from_non_owning_account_slist(account_list, pid, uid);
1776
1777         return account_list;
1778 }
1779
1780 int _account_update_sync_status_by_id(uid_t uid, int account_db_id, const int sync_status)
1781 {
1782         int                             error_code = _ACCOUNT_ERROR_NONE;
1783         account_stmt    hstmt = NULL;
1784         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
1785         int                             rc = 0;
1786         int count = 1;
1787
1788         ACCOUNT_RETURN_VAL((account_db_id > 0), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT INDEX IS LESS THAN 0"));
1789         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
1790         if ((sync_status < 0) || (sync_status >= _ACCOUNT_SYNC_MAX)) {
1791                 ACCOUNT_SLOGE("(%s)-(%d) sync_status is less than 0 or more than enum max.\n", __FUNCTION__, __LINE__);
1792                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
1793         }
1794
1795         pthread_mutex_lock(&account_mutex);
1796
1797         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
1798
1799         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where _id=%d", ACCOUNT_TABLE, account_db_id);
1800
1801         rc = _account_get_record_count(g_hAccountDB, query);
1802
1803         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
1804                 pthread_mutex_unlock(&account_mutex);
1805                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
1806                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
1807         }
1808
1809         if (rc <= 0) {
1810                 ACCOUNT_SLOGE("account_update_sync_status_by_id : related account item is not existed rc=%d , %s", rc, _account_db_err_msg(g_hAccountDB));
1811                 pthread_mutex_unlock(&account_mutex);
1812                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
1813         }
1814
1815         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
1816
1817         ACCOUNT_SNPRINTF(query, sizeof(query), "UPDATE %s SET sync_support=? WHERE _id = %d", ACCOUNT_TABLE, account_db_id);
1818         hstmt = _account_prepare_query(g_hAccountDB, query);
1819
1820         _account_query_bind_int(hstmt, count, sync_status);
1821
1822         rc = _account_query_step(hstmt);
1823
1824         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
1825                 pthread_mutex_unlock(&account_mutex);
1826                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
1827                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
1828         }
1829
1830         ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, _ACCOUNT_ERROR_DB_FAILED,
1831                                 ("account_db_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB)));
1832
1833         rc = _account_query_finalize(hstmt);
1834         if (rc != _ACCOUNT_ERROR_NONE) {
1835                 ACCOUNT_ERROR("_account_query_finalize error");
1836                 pthread_mutex_unlock(&account_mutex);
1837                 return rc;
1838         }
1839
1840         char buf[64] = {0,};
1841         ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", _ACCOUNT_NOTI_NAME_SYNC_UPDATE, account_db_id);
1842         _account_insert_delete_update_notification_send(buf);
1843
1844         hstmt = NULL;
1845         error_code = _ACCOUNT_ERROR_NONE;
1846
1847 CATCH:
1848         if (hstmt != NULL) {
1849                 rc = _account_query_finalize(hstmt);
1850                 pthread_mutex_unlock(&account_mutex);
1851                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
1852                 hstmt = NULL;
1853         }
1854
1855         pthread_mutex_unlock(&account_mutex);
1856
1857         return error_code;
1858 }
1859
1860 int account_server_empty_deleted_account_info_tables(const char* del_account_table, const char* del_capability_table,
1861                                         const char* del_account_custom_table)
1862 {
1863         _INFO("account_server_empty_deleted_account_info_tables start");
1864
1865         account_stmt hstmt = NULL;
1866         int error_code = _ACCOUNT_ERROR_NONE;
1867         int rc = 0;
1868         char query[ACCOUNT_SQL_LEN_MAX] = {0, };
1869
1870         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
1871
1872         rc = _account_begin_transaction(g_hAccountDB);
1873         _INFO("after _account_begin_trasaction");
1874
1875         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
1876                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
1877                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
1878         }
1879
1880         if (rc == _ACCOUNT_ERROR_DATABASE_BUSY) {
1881                 ACCOUNT_ERROR("database busy(%s)", _account_db_err_msg(g_hAccountDB));
1882                 return _ACCOUNT_ERROR_DATABASE_BUSY;
1883         } else if (rc != _ACCOUNT_ERROR_NONE) {
1884                 ACCOUNT_ERROR("account_delete:_account_begin_transaction fail %d\n", rc);
1885                 return rc;
1886         }
1887
1888         /*clear deleted account table*/
1889         ACCOUNT_MEMSET(query, 0, sizeof(query));
1890         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s", del_account_table);
1891
1892         _INFO("clearing deleted-account-table - query[%s]", query);
1893
1894         hstmt = _account_prepare_query(g_hAccountDB, query);
1895         if ((_account_db_err_code(g_hAccountDB) == SQLITE_PERM)) {
1896                 _account_end_transaction(g_hAccountDB, false);
1897                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
1898                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
1899         }
1900
1901         if (hstmt == NULL) {
1902                 _ERR("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg(g_hAccountDB));
1903                 error_code = _ACCOUNT_ERROR_DB_FAILED;
1904                 goto END;
1905         }
1906
1907         rc = _account_query_step(hstmt);
1908         if (rc != SQLITE_DONE) {
1909                 _ERR("The record isn't found");
1910                 error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
1911                 goto END;
1912         }
1913
1914         rc = _account_query_finalize(hstmt);
1915         if (rc != _ACCOUNT_ERROR_NONE) {
1916                 _ERR("finalize error");
1917                 error_code = rc;
1918                 goto END;
1919         }
1920
1921         /*clear deleted capability table*/
1922         ACCOUNT_MEMSET(query, 0, sizeof(query));
1923         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s", del_capability_table);
1924
1925         _INFO("clearing deleted-capability-table - query[%s]", query);
1926
1927         hstmt = _account_prepare_query(g_hAccountDB, query);
1928         if (hstmt == NULL) {
1929                 _ERR("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg(g_hAccountDB));
1930                 error_code = _ACCOUNT_ERROR_DB_FAILED;
1931                 goto END;
1932         }
1933
1934         rc = _account_query_step(hstmt);
1935         if (rc != SQLITE_DONE) {
1936                 _ERR("The record isn't found");
1937                 error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
1938                 goto END;
1939         }
1940
1941         rc = _account_query_finalize(hstmt);
1942         if (rc != _ACCOUNT_ERROR_NONE) {
1943                 _ERR("finalize error");
1944                 error_code = rc;
1945                 goto END;
1946         }
1947
1948         /*clear deleted account_custom table*/
1949         ACCOUNT_MEMSET(query, 0, sizeof(query));
1950         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s", del_account_custom_table);
1951
1952         _INFO("clearing deleted-account-custom-table - query[%s]", query);
1953
1954         hstmt = _account_prepare_query(g_hAccountDB, query);
1955         if (hstmt == NULL) {
1956                 _ERR("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg(g_hAccountDB));
1957                 error_code = _ACCOUNT_ERROR_DB_FAILED;
1958                 goto END;
1959         }
1960
1961         rc = _account_query_step(hstmt);
1962         if (rc != SQLITE_DONE) {
1963                 _ERR("The record isn't found");
1964                 error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
1965                 goto END;
1966         }
1967
1968         rc = _account_query_finalize(hstmt);
1969         if (rc != _ACCOUNT_ERROR_NONE) {
1970                 _ERR("finalize error");
1971                 error_code = rc;
1972                 goto END;
1973         }
1974
1975         rc = _account_end_transaction(g_hAccountDB, true);
1976         if (rc != _ACCOUNT_ERROR_NONE)
1977                 _ERR("clear deleted account tables - fail [%d]", rc);
1978
1979         hstmt =  NULL;
1980         _INFO("account_server_empty_deleted_account_info_tables end");
1981 END:
1982         return error_code;
1983 }
1984
1985 int _account_query_account_by_account_id(int pid, uid_t uid, int account_db_id, account_s *account_record, bool *IsDeletedAccount)
1986 {
1987         _INFO("_account_query_account_by_account_id() start, account_db_id=[%d]", account_db_id);
1988
1989         int error_code = _ACCOUNT_ERROR_NONE;
1990         account_stmt hstmt = NULL;
1991         char query[ACCOUNT_SQL_LEN_MAX] = {0, };
1992         int rc = 0;
1993
1994         ACCOUNT_RETURN_VAL((account_db_id > 0), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT INDEX IS LESS THAN 0"));
1995         ACCOUNT_RETURN_VAL(account_record != NULL, {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT IS NULL"));
1996         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
1997
1998         ACCOUNT_DEBUG("starting db operations");
1999
2000         /* prepare query for account-table */
2001         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
2002         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE _id = %d", ACCOUNT_TABLE, account_db_id);
2003
2004         _INFO("after _account_prepare_query, rc=[%d]", rc);
2005
2006         hstmt = _account_prepare_query(g_hAccountDB, query);
2007
2008         rc = _account_db_err_code(g_hAccountDB);
2009         if (rc == SQLITE_PERM) {
2010                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2011                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2012         }
2013
2014         ACCOUNT_DEBUG("before _account_query_step");
2015
2016         rc = _account_query_step(hstmt);
2017
2018         ACCOUNT_DEBUG("after _account_query_step returned [%d]", rc);
2019
2020         /*querying information from deleted_account_table*/
2021         if (rc != SQLITE_ROW) {
2022                 ACCOUNT_DEBUG("checking account info in deleted_account_table");
2023                 /* query from deleted-account-info table */
2024                 ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
2025                 ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE _id = %d", DELETED_ACCOUNT_TABLE, account_db_id);
2026
2027                 /*free previous hstmt*/
2028                 if (hstmt != NULL) {
2029                         rc = _account_query_finalize(hstmt);
2030                         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2031                         hstmt = NULL;
2032                 }
2033
2034                 hstmt = _account_prepare_query(g_hAccountDB, query);
2035
2036                 rc = _account_db_err_code(g_hAccountDB);
2037                 if (rc == SQLITE_PERM) {
2038                         ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2039                         return _ACCOUNT_ERROR_PERMISSION_DENIED;
2040                 }
2041
2042                 rc = _account_query_step(hstmt);
2043                 ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
2044
2045                 ACCOUNT_DEBUG("getting account info from deleted_account_table");
2046                 *IsDeletedAccount = true;
2047         }
2048
2049         while (rc == SQLITE_ROW) {
2050                 ACCOUNT_DEBUG("before _account_convert_column_to_account");
2051                 _account_convert_column_to_account(hstmt, account_record);
2052                 ACCOUNT_DEBUG("after _account_convert_column_to_account");
2053                 ACCOUNT_DEBUG("user_name = %s, user_txt[0] = %s, user_int[1] = %d", account_record->user_name, account_record->user_data_txt[0], account_record->user_data_int[1]);
2054                 rc = _account_query_step(hstmt);
2055         }
2056
2057         ACCOUNT_DEBUG("account_record->id=[%d]", account_record->id);
2058
2059         rc = _account_query_finalize(hstmt);
2060         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2061
2062         ACCOUNT_DEBUG("before _account_query_capability_by_account_id");
2063         _account_query_capability_by_account_id(g_hAccountDB, _account_add_capability_to_account_cb, account_record->id, (void*)account_record);
2064         ACCOUNT_DEBUG("after _account_query_capability_by_account_id");
2065
2066         ACCOUNT_DEBUG("before _account_query_custom_by_account_id");
2067         _account_query_custom_by_account_id(g_hAccountDB, _account_add_custom_to_account_cb, account_record->id, (void*)account_record);
2068         ACCOUNT_DEBUG("after _account_query_custom_by_account_id");
2069
2070         hstmt = NULL;
2071         error_code = _ACCOUNT_ERROR_NONE;
2072
2073 CATCH:
2074         if (hstmt != NULL) {
2075                 rc = _account_query_finalize(hstmt);
2076                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2077                 hstmt = NULL;
2078         }
2079
2080         if (account_record)
2081                 _remove_sensitive_info_from_non_owning_account(account_record, pid, uid);
2082
2083         pthread_mutex_unlock(&account_mutex);
2084         ACCOUNT_DEBUG("_account_query_account_by_account_id end [%d]", error_code);
2085
2086         return error_code;
2087 }
2088
2089 GList* _account_query_account_by_user_name(int pid, uid_t uid, const char *user_name, int *error_code)
2090 {
2091         *error_code = _ACCOUNT_ERROR_NONE;
2092         account_stmt    hstmt = NULL;
2093         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
2094         int                             rc = 0;
2095         account_s *account_head = NULL;
2096
2097         if (user_name == NULL) {
2098                 _ERR("USER NAME IS NULL");
2099                 *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER;
2100                 goto CATCH;
2101         }
2102
2103         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
2104
2105         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE user_name = ?", ACCOUNT_TABLE);
2106
2107         hstmt = _account_prepare_query(g_hAccountDB, query);
2108
2109         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2110                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2111                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
2112                 goto CATCH;
2113         }
2114
2115         int binding_count = 1;
2116         _account_query_bind_text(hstmt, binding_count++, user_name);
2117
2118         rc = _account_query_step(hstmt);
2119
2120         if (rc != SQLITE_ROW) {
2121                 _ERR("The record isn't found");
2122                 *error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
2123                 goto CATCH;
2124         }
2125
2126         int tmp = 0;
2127
2128         account_head = (account_s*) malloc(sizeof(account_s));
2129         if (account_head == NULL) {
2130                 ACCOUNT_FATAL("malloc Failed");
2131                 if (hstmt != NULL) {
2132                         rc = _account_query_finalize(hstmt);
2133                         if (rc != _ACCOUNT_ERROR_NONE) {
2134                                 _ERR("finalize error");
2135                                 *error_code = rc;
2136                                 goto CATCH;
2137                         }
2138                         hstmt = NULL;
2139                 }
2140                 *error_code = _ACCOUNT_ERROR_OUT_OF_MEMORY;
2141                 goto CATCH;
2142         }
2143         ACCOUNT_MEMSET(account_head, 0x00, sizeof(account_s));
2144
2145         while (rc == SQLITE_ROW) {
2146                 account_s* account_record = NULL;
2147
2148                 account_record = (account_s*) malloc(sizeof(account_s));
2149
2150                 if (account_record == NULL) {
2151                         ACCOUNT_FATAL("malloc Failed");
2152                         break;
2153                 }
2154                 ACCOUNT_MEMSET(account_record, 0x00, sizeof(account_s));
2155
2156                 _account_convert_column_to_account(hstmt, account_record);
2157
2158                 account_head->account_list = g_list_append(account_head->account_list, account_record);
2159
2160                 rc = _account_query_step(hstmt);
2161                 tmp++;
2162         }
2163
2164         rc = _account_query_finalize(hstmt);
2165
2166         if (rc != _ACCOUNT_ERROR_NONE) {
2167                 _ERR("finalize error");
2168                 *error_code = rc;
2169                 goto CATCH;
2170         }
2171
2172         hstmt = NULL;
2173
2174         GList *iter;
2175
2176         tmp = g_list_length(account_head->account_list);
2177
2178         for (iter = account_head->account_list; iter != NULL; iter = g_list_next(iter)) {
2179                 //account_h account;
2180                 //account = (account_h)iter->data;
2181
2182                 account_s *testaccount = (account_s*)iter->data;
2183
2184                 _account_query_capability_by_account_id(g_hAccountDB, _account_add_capability_to_account_cb, testaccount->id, (void*)testaccount);
2185                 _account_query_custom_by_account_id(g_hAccountDB, _account_add_custom_to_account_cb, testaccount->id, (void*)testaccount);
2186         }
2187
2188         *error_code = _ACCOUNT_ERROR_NONE;
2189
2190 CATCH:
2191         if (hstmt != NULL) {
2192                 rc = _account_query_finalize(hstmt);
2193                 if (rc != _ACCOUNT_ERROR_NONE) {
2194                         _ERR("finalize error");
2195                         *error_code = rc;
2196                 }
2197                 hstmt = NULL;
2198         }
2199
2200         pthread_mutex_unlock(&account_mutex);
2201
2202         if (account_head) {
2203                 _remove_sensitive_info_from_non_owning_account_list(account_head->account_list, pid, uid);
2204                 GList* result = account_head->account_list;
2205                 _ACCOUNT_FREE(account_head);
2206                 return result;
2207         }
2208
2209         return NULL;
2210 }
2211
2212 GList*
2213 _account_query_account_by_capability(int pid, uid_t uid, const char* capability_type, const int capability_value, int *error_code)
2214 {
2215         *error_code = _ACCOUNT_ERROR_NONE;
2216         account_stmt    hstmt = NULL;
2217         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
2218         int                             rc = 0;
2219
2220         ACCOUNT_RETURN_VAL((capability_type != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; }, NULL, ("capability_type IS NULL"));
2221
2222         if ((capability_value  < 0) || (capability_value >= _ACCOUNT_CAPABILITY_STATE_MAX)) {
2223                 ACCOUNT_SLOGE("(%s)-(%d) capability_value is not equal to 0 or 1.\n", __FUNCTION__, __LINE__);
2224                 *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER;
2225                 return NULL;
2226         }
2227
2228         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), { *error_code = _ACCOUNT_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
2229
2230         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
2231
2232         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE _id IN (SELECT account_id from %s WHERE key=? AND value=?)", ACCOUNT_TABLE, CAPABILITY_TABLE);
2233
2234         hstmt = _account_prepare_query(g_hAccountDB, query);
2235
2236         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2237                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2238                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
2239                 return NULL;
2240         }
2241
2242         int binding_count = 1;
2243         _account_query_bind_text(hstmt, binding_count++, capability_type);
2244         _account_query_bind_int(hstmt, binding_count++, capability_value);
2245
2246         rc = _account_query_step(hstmt);
2247
2248         account_s* account_head = NULL;
2249
2250         ACCOUNT_CATCH_ERROR_P(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
2251
2252         int tmp = 0;
2253
2254         account_head = (account_s*) malloc(sizeof(account_s));
2255         if (account_head == NULL) {
2256                 ACCOUNT_FATAL("malloc Failed");
2257                 if (hstmt != NULL) {
2258                         rc = _account_query_finalize(hstmt);
2259                         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), { *error_code = rc; }, NULL, ("finalize error"));
2260                         hstmt = NULL;
2261                 }
2262                 *error_code = _ACCOUNT_ERROR_OUT_OF_MEMORY;
2263                 return NULL;
2264         }
2265         ACCOUNT_MEMSET(account_head, 0x00, sizeof(account_s));
2266
2267         while (rc == SQLITE_ROW) {
2268                 account_s* account_record = NULL;
2269
2270                 account_record = (account_s*) malloc(sizeof(account_s));
2271
2272                 if (account_record == NULL) {
2273                         ACCOUNT_FATAL("malloc Failed");
2274                         break;
2275                 }
2276                 ACCOUNT_MEMSET(account_record, 0x00, sizeof(account_s));
2277
2278                 _account_convert_column_to_account(hstmt, account_record);
2279
2280                 account_head->account_list = g_list_append(account_head->account_list, account_record);
2281
2282                 rc = _account_query_step(hstmt);
2283                 tmp++;
2284         }
2285
2286         rc = _account_query_finalize(hstmt);
2287         ACCOUNT_CATCH_ERROR_P((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2288         hstmt = NULL;
2289
2290         GList *iter;
2291
2292
2293         tmp = g_list_length(account_head->account_list);
2294
2295         for (iter = account_head->account_list; iter != NULL; iter = g_list_next(iter)) {
2296                 //account_h account = NULL;
2297                 //account = (account_h)iter->data;
2298                 account_s* testaccount = (account_s*)iter->data;
2299
2300                 _account_query_capability_by_account_id(g_hAccountDB, _account_add_capability_to_account_cb, testaccount->id, (void*)testaccount);
2301                 _account_query_custom_by_account_id(g_hAccountDB, _account_add_custom_to_account_cb, testaccount->id, (void*)testaccount);
2302
2303         }
2304
2305         *error_code = _ACCOUNT_ERROR_NONE;
2306
2307 CATCH:
2308         if (hstmt != NULL) {
2309                 rc = _account_query_finalize(hstmt);
2310                 if (rc != _ACCOUNT_ERROR_NONE) {
2311                         *error_code = rc;
2312                         _ERR("finalize error");
2313                 }
2314                 hstmt = NULL;
2315         }
2316
2317         if (*error_code != _ACCOUNT_ERROR_NONE && account_head) {
2318                 _account_glist_account_free(account_head->account_list);
2319                 _ACCOUNT_FREE(account_head);
2320                 account_head = NULL;
2321         }
2322
2323         pthread_mutex_unlock(&account_mutex);
2324
2325         if (account_head) {
2326                 _remove_sensitive_info_from_non_owning_account_list(account_head->account_list, pid, uid);
2327                 GList* result = account_head->account_list;
2328                 _ACCOUNT_FREE(account_head);
2329                 return result;
2330         }
2331
2332         return NULL;
2333 }
2334
2335 GList* _account_query_account_by_capability_type(int pid, uid_t uid, const char* capability_type, int *error_code)
2336 {
2337         *error_code = _ACCOUNT_ERROR_NONE;
2338         account_stmt    hstmt = NULL;
2339         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
2340         int                             rc = 0;
2341
2342         ACCOUNT_RETURN_VAL((capability_type != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; }, NULL, ("capability_type IS NULL"));
2343         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), { *error_code = _ACCOUNT_ERROR_DB_NOT_OPENED; },
2344                                            NULL, ("The database isn't connected."));
2345
2346         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
2347
2348         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE _id IN (SELECT account_id from %s WHERE key=?)", ACCOUNT_TABLE, CAPABILITY_TABLE);
2349
2350         hstmt = _account_prepare_query(g_hAccountDB, query);
2351
2352         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2353                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2354                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
2355                 return NULL;
2356         }
2357
2358         int binding_count = 1;
2359         _account_query_bind_text(hstmt, binding_count++, capability_type);
2360
2361         rc = _account_query_step(hstmt);
2362
2363         account_s* account_head = NULL;
2364
2365         ACCOUNT_CATCH_ERROR_P(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
2366
2367         int tmp = 0;
2368
2369         account_head = (account_s*) malloc(sizeof(account_s));
2370         if (account_head == NULL) {
2371                 ACCOUNT_FATAL("malloc Failed");
2372                 if (hstmt != NULL) {
2373                         rc = _account_query_finalize(hstmt);
2374                         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), { *error_code = rc; }, NULL, ("finalize error"));
2375                         hstmt = NULL;
2376                 }
2377                 *error_code = _ACCOUNT_ERROR_OUT_OF_MEMORY;
2378                 return NULL;
2379         }
2380         ACCOUNT_MEMSET(account_head, 0x00, sizeof(account_s));
2381
2382         while (rc == SQLITE_ROW) {
2383                 account_s* account_record = NULL;
2384
2385                 account_record = (account_s*) malloc(sizeof(account_s));
2386
2387                 if (account_record == NULL) {
2388                         ACCOUNT_FATAL("malloc Failed");
2389                         break;
2390                 }
2391                 ACCOUNT_MEMSET(account_record, 0x00, sizeof(account_s));
2392
2393                 _account_convert_column_to_account(hstmt, account_record);
2394
2395                 account_head->account_list = g_list_append(account_head->account_list, account_record);
2396
2397                 rc = _account_query_step(hstmt);
2398                 tmp++;
2399         }
2400
2401         rc = _account_query_finalize(hstmt);
2402         ACCOUNT_CATCH_ERROR_P((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2403         hstmt = NULL;
2404
2405         GList *iter;
2406
2407
2408         tmp = g_list_length(account_head->account_list);
2409
2410         for (iter = account_head->account_list; iter != NULL; iter = g_list_next(iter)) {
2411                 account_s* testaccount = (account_s*)iter->data;
2412
2413                 _account_query_capability_by_account_id(g_hAccountDB, _account_add_capability_to_account_cb, testaccount->id, (void*)testaccount);
2414                 _account_query_custom_by_account_id(g_hAccountDB, _account_add_custom_to_account_cb, testaccount->id, (void*)testaccount);
2415
2416         }
2417
2418         *error_code = _ACCOUNT_ERROR_NONE;
2419
2420 CATCH:
2421         if (hstmt != NULL) {
2422                 rc = _account_query_finalize(hstmt);
2423                 if (rc != _ACCOUNT_ERROR_NONE) {
2424                         *error_code = rc;
2425                         _ERR("finalize error");
2426                 }
2427                 hstmt = NULL;
2428         }
2429
2430         if ((*error_code != _ACCOUNT_ERROR_NONE) && account_head) {
2431                 _account_glist_account_free(account_head->account_list);
2432                 _ACCOUNT_FREE(account_head);
2433                 account_head = NULL;
2434         }
2435
2436         pthread_mutex_unlock(&account_mutex);
2437
2438         if (account_head) {
2439                 _remove_sensitive_info_from_non_owning_account_list(account_head->account_list, pid, uid);
2440                 GList* result = account_head->account_list;
2441                 _ACCOUNT_FREE(account_head);
2442                 return result;
2443         }
2444
2445         return NULL;
2446 }
2447
2448 GList* account_server_query_account_by_package_name(const char* package_name, int *error_code, int pid, uid_t uid)
2449 {
2450         _INFO("account_server_query_account_by_package_name start");
2451
2452         GList * account_list = NULL;
2453         *error_code = _ACCOUNT_ERROR_NONE;
2454
2455         ACCOUNT_RETURN_VAL((package_name != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; }, NULL, ("PACKAGE NAME IS NULL"));
2456         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), { *error_code = _ACCOUNT_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
2457
2458         account_list = _account_query_account_by_package_name(g_hAccountDB, package_name, error_code, pid, uid);
2459
2460         _INFO("account_server_query_account_by_package_name end");
2461
2462         return account_list;
2463 }
2464
2465 int account_server_delete_account_by_package_name(const char* package_name, bool permission, int pid, uid_t uid)
2466 {
2467         _INFO("account_db_delete_account_by_package_name");
2468
2469         int error_code = _ACCOUNT_ERROR_NONE;
2470
2471         ACCOUNT_RETURN_VAL((package_name != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("PACKAGE NAME IS NULL"));
2472         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2473
2474         error_code = _account_delete_account_by_package_name(g_hAccountDB, package_name, permission, pid, uid);
2475
2476         _INFO("account_server_delete_account_by_package_name end");
2477
2478         return error_code;
2479 }
2480
2481 int _account_delete(int pid, uid_t uid, int account_id)
2482 {
2483         int error_code = _ACCOUNT_ERROR_NONE;
2484         account_stmt    hstmt = NULL;
2485         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
2486         int                             rc = 0;
2487         int                             ret_transaction = 0;
2488         bool                    is_success = FALSE;
2489
2490         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2491
2492         int count = -1;
2493         /* Check requested ID to delete */
2494         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE _id=%d", ACCOUNT_TABLE, account_id);
2495
2496         count = _account_get_record_count(g_hAccountDB, query);
2497
2498         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2499                 pthread_mutex_unlock(&account_mutex);
2500                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2501                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2502         }
2503
2504         if (count <= 0) {
2505                 ACCOUNT_ERROR("account id(%d) is not exist. count(%d)\n", account_id, count);
2506                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
2507         }
2508
2509         /* Check permission of requested appid */
2510         char* current_appid = NULL;
2511         char *package_name = NULL;
2512
2513         current_appid = _account_get_current_appid(pid, uid);
2514
2515         error_code = _account_get_package_name_from_account_id(account_id, &package_name);
2516
2517         if (error_code != _ACCOUNT_ERROR_NONE) {
2518                 ACCOUNT_ERROR("No package name with account_id\n");
2519                 _ACCOUNT_FREE(current_appid);
2520                 _ACCOUNT_FREE(package_name);
2521                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
2522         }
2523         ACCOUNT_DEBUG("DELETE:account_id[%d],current_appid[%s]package_name[%s]", account_id, current_appid, package_name);
2524
2525         error_code = _account_check_appid_group_with_package_name(current_appid, package_name, uid);
2526
2527         _ACCOUNT_FREE(current_appid);
2528         _ACCOUNT_FREE(package_name);
2529
2530         if (error_code != _ACCOUNT_ERROR_NONE) {
2531                 ACCOUNT_ERROR("No permission to delete\n");
2532                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2533         }
2534
2535         /* transaction control required*/
2536         ret_transaction = _account_begin_transaction(g_hAccountDB);
2537
2538         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2539                 pthread_mutex_unlock(&account_mutex);
2540                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2541                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2542         }
2543
2544         if (ret_transaction == _ACCOUNT_ERROR_DATABASE_BUSY) {
2545                 ACCOUNT_ERROR("database busy(%s)", _account_db_err_msg(g_hAccountDB));
2546                 pthread_mutex_unlock(&account_mutex);
2547                 return _ACCOUNT_ERROR_DATABASE_BUSY;
2548         }
2549
2550         if (ret_transaction != _ACCOUNT_ERROR_NONE) {
2551                 ACCOUNT_ERROR("account_delete:_account_begin_transaction fail %d\n", ret_transaction);
2552                 pthread_mutex_unlock(&account_mutex);
2553                 return ret_transaction;
2554         }
2555
2556         /* capability table */
2557         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
2558         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE account_id = %d", CAPABILITY_TABLE, account_id);
2559
2560         hstmt = _account_prepare_query(g_hAccountDB, query);
2561
2562         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2563                 pthread_mutex_unlock(&account_mutex);
2564                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2565                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2566         }
2567
2568         ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, _ACCOUNT_ERROR_DB_FAILED,
2569                         ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg(g_hAccountDB)));
2570
2571         rc = _account_query_step(hstmt);
2572         ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
2573
2574         rc = _account_query_finalize(hstmt);
2575
2576         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2577         hstmt = NULL;
2578
2579         /* account table */
2580         ACCOUNT_MEMSET(query, 0, sizeof(query));
2581         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE _id = %d", ACCOUNT_TABLE, account_id);
2582
2583         hstmt = _account_prepare_query(g_hAccountDB, query);
2584         ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, _ACCOUNT_ERROR_DB_FAILED,
2585                         ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg(g_hAccountDB)));
2586
2587         rc = _account_query_step(hstmt);
2588         ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found. id=%d, rc=%d\n", account_id, rc));
2589
2590         rc = _account_query_finalize(hstmt);
2591         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2592         hstmt = NULL;
2593
2594         /* delete custom data */
2595         ACCOUNT_MEMSET(query, 0, sizeof(query));
2596         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AccountId = %d", ACCOUNT_CUSTOM_TABLE, account_id);
2597
2598         hstmt = _account_prepare_query(g_hAccountDB, query);
2599
2600         ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, _ACCOUNT_ERROR_DB_FAILED,
2601                         ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg(g_hAccountDB)));
2602
2603         rc = _account_query_step(hstmt);
2604         ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found. id=%d, rc=%d\n", account_id, rc));
2605
2606         rc = _account_query_finalize(hstmt);
2607         ACCOUNT_CATCH_ERROR(rc == _ACCOUNT_ERROR_NONE, {}, rc, ("finalize error", account_id, rc));
2608         hstmt = NULL;
2609
2610         is_success = TRUE;
2611
2612 CATCH:
2613         if (hstmt != NULL) {
2614                 rc = _account_query_finalize(hstmt);
2615                 if (rc != _ACCOUNT_ERROR_NONE) {
2616                         ACCOUNT_ERROR("rc (%d)", rc);
2617                         is_success = FALSE;
2618                 }
2619
2620                 hstmt = NULL;
2621         }
2622
2623         ret_transaction = _account_end_transaction(g_hAccountDB, is_success);
2624
2625         if (ret_transaction != _ACCOUNT_ERROR_NONE) {
2626                 ACCOUNT_ERROR("account_delete:_account_end_transaction fail %d, is_success=%d\n", ret_transaction, is_success);
2627         } else {
2628                 if (is_success == true) {
2629                         char buf[64] = {0,};
2630                         ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", _ACCOUNT_NOTI_NAME_DELETE, account_id);
2631                         _account_insert_delete_update_notification_send(buf);
2632                 }
2633         }
2634
2635         pthread_mutex_unlock(&account_mutex);
2636
2637         return error_code;
2638 }
2639
2640 static int _account_query_account_by_username_and_package(const char* username, const char* package_name, account_s *account)
2641 {
2642         //FIXME
2643         //return -1;
2644         int                             error_code = _ACCOUNT_ERROR_NONE;
2645         account_stmt    hstmt = NULL;
2646         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
2647         int                             rc = 0;
2648         int                             binding_count = 1;
2649
2650         ACCOUNT_RETURN_VAL((username != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("username IS NULL"));
2651         ACCOUNT_RETURN_VAL((package_name != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("package_name IS NULL"));
2652         ACCOUNT_RETURN_VAL((account != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT IS NULL"));
2653         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2654
2655         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
2656
2657         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE user_name = ? and package_name = ?", ACCOUNT_TABLE);
2658         hstmt = _account_prepare_query(g_hAccountDB, query);
2659
2660         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2661                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2662                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2663         }
2664
2665         _account_query_bind_text(hstmt, binding_count++, username);
2666         _account_query_bind_text(hstmt, binding_count++, package_name);
2667
2668         rc = _account_query_step(hstmt);
2669         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
2670
2671         account_s *account_record = account;
2672
2673         while (rc == SQLITE_ROW) {
2674                 _account_convert_column_to_account(hstmt, account_record);
2675                 rc = _account_query_step(hstmt);
2676         }
2677
2678         rc = _account_query_finalize(hstmt);
2679         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2680         _account_query_capability_by_account_id(g_hAccountDB, _account_add_capability_to_account_cb, account_record->id, (void*)account_record);
2681         _account_query_custom_by_account_id(g_hAccountDB, _account_add_custom_to_account_cb, account_record->id, (void*)account_record);
2682
2683         hstmt = NULL;
2684         error_code = _ACCOUNT_ERROR_NONE;
2685
2686 CATCH:
2687         if (hstmt != NULL) {
2688                 rc = _account_query_finalize(hstmt);
2689                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2690                 hstmt = NULL;
2691         }
2692
2693         pthread_mutex_unlock(&account_mutex);
2694
2695         return error_code;
2696 }
2697
2698 int _account_create(account_s **account)
2699 {
2700         if (!account) {
2701                 ACCOUNT_SLOGE("(%s)-(%d) account is NULL.\n", __FUNCTION__, __LINE__);
2702                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
2703         }
2704
2705         account_s *data = (account_s*)malloc(sizeof(account_s));
2706
2707         if (data == NULL) {
2708                 ACCOUNT_FATAL("Memory Allocation Failed");
2709                 return _ACCOUNT_ERROR_OUT_OF_MEMORY;
2710         }
2711         ACCOUNT_MEMSET(data, 0, sizeof(account_s));
2712
2713         /*Setting account as visible by default*/
2714         //data->secret = _ACCOUNT_SECRECY_VISIBLE;
2715
2716         /*Setting account as not supporting sync by default*/
2717         //data->sync_support = _ACCOUNT_SYNC_NOT_SUPPORT;
2718
2719         *account = data;
2720
2721         return _ACCOUNT_ERROR_NONE;
2722 }
2723
2724 int _account_destroy(account_s *account)
2725 {
2726         account_s *data = account;
2727
2728         ACCOUNT_RETURN_VAL((data != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Account handle is null!"));
2729
2730         _account_free_account_with_items(data);
2731
2732         return _ACCOUNT_ERROR_NONE;
2733 }
2734
2735 int _account_get_account_id(account_s* account, int *account_id)
2736 {
2737         if (!account)
2738                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
2739
2740         if (!account_id)
2741                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
2742
2743         *account_id = account->id;
2744
2745         return _ACCOUNT_ERROR_NONE;
2746 }
2747
2748 int _account_delete_from_db_by_user_name(int pid, uid_t uid, const char *user_name, const char *package_name)
2749 {
2750         _INFO("[%s][%s]", user_name, package_name);
2751
2752         int                             error_code = _ACCOUNT_ERROR_NONE;
2753         account_stmt    hstmt = NULL;
2754         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
2755         int                             rc = 0;
2756         int                             ret_transaction = 0;
2757         bool                    is_success = FALSE;
2758         account_s               *account = NULL;
2759         int                             binding_count = 1;
2760         int                             account_id = -1;
2761
2762         ACCOUNT_RETURN_VAL((user_name != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("user_name is null!"));
2763         ACCOUNT_RETURN_VAL((package_name != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("package_name is null!"));
2764         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2765
2766         /* Check permission of requested appid */
2767         char* current_appid = NULL;
2768         char* package_name_temp = NULL;
2769
2770         current_appid = _account_get_current_appid(pid, uid);
2771
2772         package_name_temp = _account_dup_text(package_name);
2773
2774         ACCOUNT_DEBUG("DELETE:user_name[%s],current_appid[%s], package_name[%s]", user_name, current_appid, package_name_temp);
2775
2776         error_code = _account_check_appid_group_with_package_name(current_appid, package_name_temp, uid);
2777
2778         _ACCOUNT_FREE(current_appid);
2779         _ACCOUNT_FREE(package_name_temp);
2780
2781         if (error_code != _ACCOUNT_ERROR_NONE) {
2782                 ACCOUNT_ERROR("No permission to delete\n");
2783                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2784         }
2785
2786         rc = _account_create(&account);
2787         rc = _account_query_account_by_username_and_package(user_name, package_name, account);
2788
2789         _INFO("");
2790
2791         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2792                 _account_destroy(account);
2793                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2794                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2795         }
2796
2797         _INFO("");
2798         account_s* account_data = (account_s*)account;
2799
2800         rc = _account_get_account_id(account_data, &account_id);
2801
2802         rc = _account_destroy(account);
2803
2804         /* transaction control required*/
2805         ret_transaction = _account_begin_transaction(g_hAccountDB);
2806
2807         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2808                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2809                 pthread_mutex_unlock(&account_mutex);
2810                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2811         }
2812
2813         _INFO("");
2814         if (ret_transaction == _ACCOUNT_ERROR_DATABASE_BUSY) {
2815                 ACCOUNT_ERROR("database busy(%s)", _account_db_err_msg(g_hAccountDB));
2816                 pthread_mutex_unlock(&account_mutex);
2817                 return _ACCOUNT_ERROR_DATABASE_BUSY;
2818         } else if (ret_transaction != _ACCOUNT_ERROR_NONE) {
2819                 ACCOUNT_ERROR("account_delete:_account_begin_transaction fail %d\n", ret_transaction);
2820                 pthread_mutex_unlock(&account_mutex);
2821                 return ret_transaction;
2822         }
2823
2824         /* delete custom data */
2825         ACCOUNT_MEMSET(query, 0, sizeof(query));
2826         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AccountId = ?", ACCOUNT_CUSTOM_TABLE);
2827
2828         hstmt = _account_prepare_query(g_hAccountDB, query);
2829
2830         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2831                 _account_end_transaction(g_hAccountDB, FALSE);
2832                 pthread_mutex_unlock(&account_mutex);
2833                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2834                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2835         }
2836
2837         ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, _ACCOUNT_ERROR_DB_FAILED,
2838                         ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg(g_hAccountDB)));
2839
2840         _account_query_bind_int(hstmt, binding_count++, account_id);
2841
2842         rc = _account_query_step(hstmt);
2843         ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
2844
2845         rc = _account_query_finalize(hstmt);
2846         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2847         hstmt = NULL;
2848
2849         /* delete capability */
2850         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE user_name = ? and package_name = ?", CAPABILITY_TABLE);
2851
2852         hstmt = _account_prepare_query(g_hAccountDB, query);
2853
2854         ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, _ACCOUNT_ERROR_DB_FAILED,
2855                         ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg(g_hAccountDB)));
2856
2857         binding_count = 1;
2858         _account_query_bind_text(hstmt, binding_count++, user_name);
2859         _account_query_bind_text(hstmt, binding_count++, package_name);
2860
2861         rc = _account_query_step(hstmt);
2862         ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
2863
2864         rc = _account_query_finalize(hstmt);
2865         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2866         hstmt = NULL;
2867
2868         ACCOUNT_MEMSET(query, 0, sizeof(query));
2869
2870         _INFO("");
2871         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE user_name = ? and package_name = ?", ACCOUNT_TABLE);
2872
2873         hstmt = _account_prepare_query(g_hAccountDB, query);
2874         ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, _ACCOUNT_ERROR_DB_FAILED,
2875                         ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg(g_hAccountDB)));
2876
2877         _INFO("");
2878         binding_count = 1;
2879         _account_query_bind_text(hstmt, binding_count++, user_name);
2880         _account_query_bind_text(hstmt, binding_count++, package_name);
2881
2882         rc = _account_query_step(hstmt);
2883         ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found. user_name=%s, package_name=%s, rc=%d\n", user_name, package_name, rc));
2884
2885         rc = _account_query_finalize(hstmt);
2886         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2887         is_success = TRUE;
2888
2889         hstmt = NULL;
2890
2891 CATCH:
2892         if (hstmt != NULL) {
2893                 rc = _account_query_finalize(hstmt);
2894                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2895                 hstmt = NULL;
2896         }
2897
2898         ret_transaction = _account_end_transaction(g_hAccountDB, is_success);
2899
2900         if (ret_transaction != _ACCOUNT_ERROR_NONE) {
2901                 ACCOUNT_ERROR("account_svc_delete:_account_svc_end_transaction fail %d, is_success=%d\n", ret_transaction, is_success);
2902         } else {
2903                 if (is_success == true) {
2904                         char buf[64] = {0,};
2905                         ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", _ACCOUNT_NOTI_NAME_DELETE, account_id);
2906                         _account_insert_delete_update_notification_send(buf);
2907                 }
2908         }
2909
2910         pthread_mutex_unlock(&account_mutex);
2911
2912         return error_code;
2913 }
2914
2915
2916 int _account_get_total_count_from_db(gboolean include_hidden, int *count)
2917 {
2918         if (!count) {
2919                 ACCOUNT_SLOGE("(%s)-(%d) count is NULL.\n", __FUNCTION__, __LINE__);
2920                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
2921         }
2922
2923         if (!g_hAccountDB) {
2924                 ACCOUNT_ERROR("DB is not opened\n");
2925                 return _ACCOUNT_ERROR_DB_NOT_OPENED;
2926         }
2927
2928         char query[1024] = {0, };
2929         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
2930
2931         if (include_hidden)
2932                 ACCOUNT_SNPRINTF(query, sizeof(query), "select count(*) from %s", ACCOUNT_TABLE);
2933         else
2934                 ACCOUNT_SNPRINTF(query, sizeof(query), "select count(*) from %s where secret = %d", ACCOUNT_TABLE, _ACCOUNT_SECRECY_VISIBLE);
2935
2936         *count = _account_get_record_count(g_hAccountDB, query);
2937
2938         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2939                 pthread_mutex_unlock(&account_mutex);
2940                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2941                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2942         }
2943
2944         int rc = -1;
2945         int ncount = 0;
2946         account_stmt pStmt = NULL;
2947
2948         rc = sqlite3_prepare_v2(g_hAccountDB, query, strlen(query), &pStmt, NULL);
2949         if (SQLITE_OK != rc) {
2950                 ACCOUNT_SLOGE("sqlite3_prepare_v2() failed(%d, %s).", rc, _account_db_err_msg(g_hAccountDB));
2951                 sqlite3_finalize(pStmt);
2952                 return _ACCOUNT_ERROR_DB_FAILED;
2953         }
2954
2955         rc = sqlite3_step(pStmt);
2956         if (SQLITE_ROW != rc) {
2957                 ACCOUNT_ERROR("[ERROR] sqlite3_step() failed\n");
2958                 sqlite3_finalize(pStmt);
2959                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
2960         }
2961
2962         ncount = sqlite3_column_int(pStmt, 0);
2963
2964         *count = ncount;
2965
2966         sqlite3_finalize(pStmt);
2967
2968         if (ncount < 0) {
2969                 ACCOUNT_ERROR("[ERROR] Number of account : %d, End", ncount);
2970                 return _ACCOUNT_ERROR_DB_FAILED;
2971         }
2972
2973         return _ACCOUNT_ERROR_NONE;
2974 }
2975
2976
2977 int account_server_query_app_id_exist(const char* app_id)
2978 {
2979         _INFO("account_server_query_app_id_exist start app_id=[%s]", app_id);
2980         int ret = _ACCOUNT_ERROR_NONE;
2981
2982         ret = _account_type_query_app_id_exist_from_all_db(g_hAccountDB, g_hAccountGlobalDB, app_id);
2983
2984         _INFO("account_server_query_app_id_exist end error_code=[%d]", ret);
2985
2986         return ret;
2987 }
2988
2989 int account_server_insert_account_type_to_user_db(account_type_s *account_type, int *account_type_id, uid_t uid)
2990 {
2991         ACCOUNT_RETURN_VAL((account_type != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT TYPE HANDLE IS NULL"));
2992         ACCOUNT_RETURN_VAL((account_type->app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID OF ACCOUNT TYPE IS NULL"));
2993         ACCOUNT_RETURN_VAL((account_type_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT TYPE ID IS NULL"));
2994
2995         _INFO("account_server_insert_account_type_to_user_db start uid=[%d]", uid);
2996         int ret = _ACCOUNT_ERROR_NONE;
2997
2998         if (_account_type_check_duplicated(g_hAccountDB, account_type->app_id) ||
2999                         _account_type_check_duplicated(g_hAccountGlobalDB, account_type->app_id)) {
3000                 *account_type_id = -1;
3001                 return _ACCOUNT_ERROR_DUPLICATED;
3002         }
3003
3004         ret = _account_type_insert_to_db(g_hAccountDB, account_type, account_type_id);
3005         _INFO("account_server_insert_account_type_to_user_db end error_code=[%d]", ret);
3006
3007         return ret;
3008 }
3009
3010 int account_server_delete_account_type_by_app_id_from_user_db(const char * app_id)
3011 {
3012         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID OF ACCOUNT TYPE IS NULL"));
3013
3014         _INFO("account_server_delete_account_type_by_app_id_from_user_db start");
3015         int ret = _ACCOUNT_ERROR_NONE;
3016
3017         ret = _account_type_delete_by_app_id(g_hAccountDB, app_id);
3018         _INFO("account_server_delete_account_type_by_app_id_from_user_db end error_code=[%d]", ret);
3019
3020         return ret;
3021 }
3022
3023 GSList* _account_type_query_provider_feature_by_app_id_from_global_db(const char* app_id, int *error_code)
3024 {
3025         _INFO("_account_type_query_provider_feature_by_app_id_in_global_db app_id=%s", app_id);
3026         account_stmt hstmt = NULL;
3027         char query[ACCOUNT_SQL_LEN_MAX] = {0, };
3028         int rc = 0, binding_count = 1;
3029         GSList* feature_list = NULL;
3030
3031         ACCOUNT_RETURN_VAL((app_id != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; }, NULL, ("APP ID IS NULL"));
3032         ACCOUNT_RETURN_VAL((error_code != NULL), {_ERR("error_code pointer is NULL"); }, NULL, (""));
3033         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; _ERR("The database isn't connected."); }, NULL, ("The database isn't connected."));
3034
3035         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3036
3037         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE app_id = ?", PROVIDER_FEATURE_TABLE);
3038         _INFO("account query=[%s]", query);
3039
3040         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
3041
3042         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
3043                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
3044                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
3045                 return NULL;
3046         }
3047
3048         _INFO("before _account_query_bind_text");
3049         _account_query_bind_text(hstmt, binding_count++, app_id);
3050
3051         rc = _account_query_step(hstmt);
3052
3053         ACCOUNT_CATCH_ERROR_P(rc == SQLITE_ROW, { *error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND; _ERR("The record isn't found from global db. rc=[%d]", rc); }, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
3054
3055         provider_feature_s* feature_record = NULL;
3056
3057         while (rc == SQLITE_ROW) {
3058
3059                 feature_record = (provider_feature_s*) malloc(sizeof(provider_feature_s));
3060
3061                 if (feature_record == NULL) {
3062                         ACCOUNT_FATAL("malloc Failed");
3063                         break;
3064                 }
3065
3066                 ACCOUNT_MEMSET(feature_record, 0x00, sizeof(provider_feature_s));
3067
3068                 _account_type_convert_column_to_provider_feature(hstmt, feature_record);
3069
3070                 _INFO("Adding account feature_list");
3071                 feature_list = g_slist_append(feature_list, feature_record);
3072
3073                 rc = _account_query_step(hstmt);
3074         }
3075
3076         *error_code = _ACCOUNT_ERROR_NONE;
3077
3078 CATCH:
3079         if (hstmt != NULL) {
3080                 rc = _account_query_finalize(hstmt);
3081                 if (rc != _ACCOUNT_ERROR_NONE) {
3082                         *error_code = rc;
3083                         _ERR("global db fianlize error");
3084                 }
3085         }
3086
3087         if (*error_code != _ACCOUNT_ERROR_NONE)
3088                 _account_type_gslist_feature_free(feature_list);
3089
3090         _INFO("Returning account feature_list from global db");
3091
3092         return feature_list;
3093 }
3094
3095 GSList* _account_type_query_provider_feature_by_app_id(const char* app_id, int *error_code)
3096 {
3097         _INFO("_account_type_query_provider_feature_by_app_id app_id=%s", app_id);
3098         account_stmt hstmt = NULL;
3099         char query[ACCOUNT_SQL_LEN_MAX] = {0, };
3100         int rc = 0, binding_count = 1;
3101         GSList* feature_list = NULL;
3102
3103         ACCOUNT_RETURN_VAL((app_id != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; }, NULL, ("APP ID IS NULL"));
3104         ACCOUNT_RETURN_VAL((error_code != NULL), {_ERR("error_code pointer is NULL"); }, NULL, (""));
3105         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), { *error_code = _ACCOUNT_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
3106
3107         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3108
3109         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE app_id = ?", PROVIDER_FEATURE_TABLE);
3110         _INFO("account query=[%s]", query);
3111
3112         hstmt = _account_prepare_query(g_hAccountDB, query);
3113
3114         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
3115                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
3116                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
3117                 return NULL;
3118         }
3119
3120         _account_query_bind_text(hstmt, binding_count++, app_id);
3121
3122         rc = _account_query_step(hstmt);
3123
3124         ACCOUNT_CATCH_ERROR_P(rc == SQLITE_ROW, { *error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
3125                         _ERR("The record isn't found from user db. rc=[%d]", rc); },
3126                                 _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
3127
3128         provider_feature_s* feature_record = NULL;
3129
3130         while (rc == SQLITE_ROW) {
3131
3132                 feature_record = (provider_feature_s*) malloc(sizeof(provider_feature_s));
3133
3134                 if (feature_record == NULL) {
3135                         ACCOUNT_FATAL("malloc Failed");
3136                         break;
3137                 }
3138
3139                 ACCOUNT_MEMSET(feature_record, 0x00, sizeof(provider_feature_s));
3140
3141                 _account_type_convert_column_to_provider_feature(hstmt, feature_record);
3142
3143                 _INFO("Adding account feature_list");
3144                 feature_list = g_slist_append(feature_list, feature_record);
3145
3146                 rc = _account_query_step(hstmt);
3147         }
3148
3149         *error_code = _ACCOUNT_ERROR_NONE;
3150
3151         rc = _account_query_finalize(hstmt);
3152         ACCOUNT_CATCH_ERROR_P((rc == _ACCOUNT_ERROR_NONE), { *error_code = rc; }, rc, ("account finalize error"));
3153         hstmt = NULL;
3154
3155 CATCH:
3156         if (hstmt != NULL) {
3157                 rc = _account_query_finalize(hstmt);
3158                 if (rc != _ACCOUNT_ERROR_NONE) {
3159                         *error_code = rc;
3160                         _ERR("account fianlize error");
3161                 }
3162                 hstmt = NULL;
3163         }
3164         _INFO("*error_code=[%d]", *error_code);
3165
3166         if (*error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND)
3167                 feature_list = _account_type_query_provider_feature_by_app_id_from_global_db(app_id, error_code);
3168
3169         if (*error_code != _ACCOUNT_ERROR_NONE) {
3170                 _account_type_gslist_feature_free(feature_list);
3171                 return NULL;
3172         }
3173
3174         _INFO("Returning account feature_list");
3175
3176         return feature_list;
3177 }
3178
3179 int _account_type_query_provider_feature_cb_by_app_id_from_global_db(account_type_provider_feature_cb callback, const char* app_id, void *user_data)
3180 {
3181         int                             error_code = _ACCOUNT_ERROR_NONE;
3182         account_stmt    hstmt = NULL;
3183         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3184         int                             rc = 0, binding_count = 1;
3185
3186         _INFO("_account_type_query_provider_feature_cb_by_app_id_in_global_db start app_id=%s", app_id);
3187         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3188         ACCOUNT_RETURN_VAL((callback != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION"));
3189         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3190
3191         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3192
3193         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE app_id = ?", PROVIDER_FEATURE_TABLE);
3194         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
3195
3196         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
3197                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
3198                 ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_PERMISSION_DENIED, ("global db permission denied.\n"));
3199         }
3200
3201         _account_query_bind_text(hstmt, binding_count++, app_id);
3202
3203         rc = _account_query_step(hstmt);
3204         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {_ERR("The record isn't found. rc=[%d]", rc); }, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
3205
3206         provider_feature_s* feature_record = NULL;
3207
3208         while (rc == SQLITE_ROW) {
3209                 bool cb_ret = FALSE;
3210                 feature_record = (provider_feature_s*) malloc(sizeof(provider_feature_s));
3211
3212                 if (feature_record == NULL) {
3213                         ACCOUNT_FATAL("malloc Failed");
3214                         break;
3215                 }
3216
3217                 ACCOUNT_MEMSET(feature_record, 0x00, sizeof(provider_feature_s));
3218
3219                 _account_type_convert_column_to_provider_feature(hstmt, feature_record);
3220
3221                 cb_ret = callback(feature_record->app_id, feature_record->key, user_data);
3222
3223                 _account_type_free_feature_with_items(feature_record);
3224
3225                 ACCOUNT_CATCH_ERROR(cb_ret == TRUE, {}, _ACCOUNT_ERROR_NONE, ("Callback func returns FALSE, its iteration is stopped!!!!\n"));
3226
3227                 rc = _account_query_step(hstmt);
3228         }
3229
3230         error_code = _ACCOUNT_ERROR_NONE;
3231
3232 CATCH:
3233         if (hstmt != NULL) {
3234                 rc = _account_query_finalize(hstmt);
3235                 if (rc != _ACCOUNT_ERROR_NONE) {
3236                         error_code = rc;
3237                         _ERR("global db finalize error[%d]", rc);
3238                 }
3239                 hstmt = NULL;
3240         }
3241
3242         _INFO("_account_type_query_provider_feature_cb_by_app_id_in_global_db end. error_code=[%d]", error_code);
3243
3244         return error_code;
3245 }
3246
3247 int _account_type_query_provider_feature_cb_by_app_id(account_type_provider_feature_cb callback, const char* app_id, void *user_data)
3248 {
3249         int                             error_code = _ACCOUNT_ERROR_NONE;
3250         account_stmt    hstmt = NULL;
3251         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3252         int                             rc = 0, binding_count = 1;
3253
3254         _INFO("_account_type_query_provider_feature_cb_by_app_id start app_id=%s", app_id);
3255         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3256         ACCOUNT_RETURN_VAL((callback != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION"));
3257         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3258
3259         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3260
3261         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE app_id = ?", PROVIDER_FEATURE_TABLE);
3262         hstmt = _account_prepare_query(g_hAccountDB, query);
3263
3264         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
3265                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
3266                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
3267         }
3268
3269         _account_query_bind_text(hstmt, binding_count++, app_id);
3270
3271         rc = _account_query_step(hstmt);
3272         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found in user db.\n"));
3273
3274         provider_feature_s* feature_record = NULL;
3275
3276         while (rc == SQLITE_ROW) {
3277                 bool cb_ret = FALSE;
3278                 feature_record = (provider_feature_s*) malloc(sizeof(provider_feature_s));
3279
3280                 if (feature_record == NULL) {
3281                         ACCOUNT_FATAL("malloc Failed");
3282                         break;
3283                 }
3284
3285                 ACCOUNT_MEMSET(feature_record, 0x00, sizeof(provider_feature_s));
3286
3287                 _account_type_convert_column_to_provider_feature(hstmt, feature_record);
3288
3289                 cb_ret = callback(feature_record->app_id, feature_record->key, user_data);
3290
3291                 _account_type_free_feature_with_items(feature_record);
3292
3293                 ACCOUNT_CATCH_ERROR(cb_ret == TRUE, {}, _ACCOUNT_ERROR_NONE, ("Callback func returs FALSE, its iteration is stopped!!!!\n"));
3294
3295                 rc = _account_query_step(hstmt);
3296         }
3297
3298         rc = _account_query_finalize(hstmt);
3299         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3300         hstmt = NULL;
3301
3302         error_code = _ACCOUNT_ERROR_NONE;
3303
3304 CATCH:
3305         if (hstmt != NULL) {
3306                 rc = _account_query_finalize(hstmt);
3307                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3308                 hstmt = NULL;
3309         }
3310 /*
3311         if (error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND)
3312                 error_code = _account_type_query_provider_feature_cb_by_app_id_from_global_db(callback, app_id, user_data);
3313 */
3314         _INFO("_account_type_query_provider_feature_cb_by_app_id end");
3315
3316         return error_code;
3317 }
3318
3319 int account_type_query_provider_feature_cb_by_app_id(account_type_provider_feature_cb callback, const char* app_id, void *user_data)
3320 {
3321         int                             error_code = _ACCOUNT_ERROR_NONE;
3322
3323         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3324         ACCOUNT_RETURN_VAL((callback != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION"));
3325         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3326
3327         error_code = _account_type_query_provider_feature_cb_by_app_id(callback, app_id, user_data);
3328
3329         if (error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND)
3330                 error_code = _account_type_query_provider_feature_cb_by_app_id_from_global_db(callback, app_id, user_data);
3331
3332         return error_code;
3333 }
3334
3335 bool _account_type_query_supported_feature_from_global_db(const char* app_id, const char* capability, int *error_code)
3336 {
3337         _INFO("_account_type_query_supported_feature_in_global_db start");
3338         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3339
3340         *error_code = _ACCOUNT_ERROR_NONE;
3341
3342         char query[ACCOUNT_SQL_LEN_MAX] = {0, };
3343         int record_count = 0;
3344
3345         if (app_id == NULL || capability == NULL) {
3346                 *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER;
3347                 return false;
3348         }
3349
3350         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s where app_id='%s' and key='%s'", PROVIDER_FEATURE_TABLE, app_id, capability);
3351
3352         record_count = _account_get_record_count(g_hAccountGlobalDB, query);
3353
3354         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
3355                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
3356                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
3357         }
3358
3359         if (record_count <= 0) {
3360                 *error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
3361                 return false;
3362         }
3363
3364         _INFO("_account_type_query_supported_feature_in_global_db end");
3365
3366         return true;
3367 }
3368
3369 bool _account_type_query_supported_feature(const char* app_id, const char* capability, int *error_code)
3370 {
3371         _INFO("_account_type_query_supported_feature start");
3372
3373         *error_code = _ACCOUNT_ERROR_NONE;
3374
3375         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3376         int                             record_count = 0;
3377
3378         if (app_id == NULL || capability == NULL) {
3379                 *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER;
3380                 return false;
3381         }
3382
3383         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s where app_id='%s' and key='%s'", PROVIDER_FEATURE_TABLE, app_id, capability);
3384
3385         record_count = _account_get_record_count(g_hAccountDB, query);
3386
3387         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
3388                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
3389                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
3390                 return false;
3391         }
3392
3393         if (record_count <= 0) {
3394                 bool is_exist = false;
3395                 is_exist = _account_type_query_supported_feature_from_global_db(app_id, capability, error_code);
3396                 if (!is_exist)
3397                         return false;
3398         }
3399
3400         _INFO("_account_type_query_supported_feature end");
3401
3402         return true;
3403 }
3404
3405
3406 static int _account_type_update_provider_feature(sqlite3 *account_db_handle, account_type_s *account_type, const char* app_id)
3407 {
3408         int                             rc, count = 1;
3409         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3410         account_stmt    hstmt = NULL;
3411
3412         ACCOUNT_RETURN_VAL((account_type != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL"));
3413
3414         if (g_slist_length(account_type->provider_feature_list) == 0) {
3415                 ACCOUNT_ERROR("no feature\n");
3416                 return _ACCOUNT_ERROR_NONE;
3417         }
3418
3419         ACCOUNT_DEBUG("app id", app_id);
3420
3421         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
3422
3423         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE app_id=? ", PROVIDER_FEATURE_TABLE);
3424         hstmt = _account_prepare_query(account_db_handle, query);
3425
3426         if (_account_db_err_code(account_db_handle) == SQLITE_PERM) {
3427                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(account_db_handle));
3428                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
3429         }
3430
3431         count = 1;
3432         _account_query_bind_text(hstmt, count++, app_id);
3433         rc = _account_query_step(hstmt);
3434
3435         if (rc != SQLITE_DONE) {
3436                 ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(account_db_handle));
3437                 return _ACCOUNT_ERROR_DB_FAILED;
3438         }
3439         rc = _account_query_finalize(hstmt);
3440         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3441         hstmt = NULL;
3442
3443         GSList *iter;
3444
3445         for (iter = account_type->provider_feature_list; iter != NULL; iter = g_slist_next(iter)) {
3446                 int ret;
3447                 count = 1;
3448                 ACCOUNT_MEMSET(query, 0x00, sizeof(query));
3449                 ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(app_id, key) VALUES "
3450                                 "(?, ?) ", PROVIDER_FEATURE_TABLE);
3451
3452                 hstmt = _account_prepare_query(account_db_handle, query);
3453
3454                 ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query() failed(%s).\n", _account_db_err_msg(account_db_handle)));
3455
3456                 provider_feature_s* feature_data = NULL;
3457                 feature_data = (provider_feature_s*)iter->data;
3458
3459                 ret = _account_query_bind_text(hstmt, count++, account_type->app_id);
3460                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
3461                 ret = _account_query_bind_text(hstmt, count++, feature_data->key);
3462                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
3463
3464                 rc = _account_query_step(hstmt);
3465
3466                 if (rc != SQLITE_DONE) {
3467                         ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(account_db_handle));
3468                         break;
3469                 }
3470                 rc = _account_query_finalize(hstmt);
3471                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3472                 hstmt = NULL;
3473         }
3474
3475         return _ACCOUNT_ERROR_NONE;
3476 }
3477
3478 static int _account_type_update_label(sqlite3 *account_db_handle, account_type_s *account_type, const char* app_id)
3479 {
3480         int                             rc, count = 1;
3481         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3482         account_stmt    hstmt = NULL;
3483
3484         ACCOUNT_RETURN_VAL((account_type != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL"));
3485
3486         if (g_slist_length(account_type->label_list) == 0)
3487                 return _ACCOUNT_ERROR_NONE;
3488
3489         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
3490
3491         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AppId=? ", LABEL_TABLE);
3492         hstmt = _account_prepare_query(account_db_handle, query);
3493
3494         if (_account_db_err_code(account_db_handle) == SQLITE_PERM) {
3495                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(account_db_handle));
3496                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
3497         }
3498
3499         count = 1;
3500         _account_query_bind_text(hstmt, count++, app_id);
3501         rc = _account_query_step(hstmt);
3502
3503         if (rc != SQLITE_DONE) {
3504                 ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(account_db_handle));
3505                 return _ACCOUNT_ERROR_DB_FAILED;
3506         }
3507         rc = _account_query_finalize(hstmt);
3508         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3509         hstmt = NULL;
3510
3511         GSList *iter;
3512
3513         for (iter = account_type->label_list; iter != NULL; iter = g_slist_next(iter)) {
3514                 int ret;
3515                 count = 1;
3516                 ACCOUNT_MEMSET(query, 0x00, sizeof(query));
3517                 ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(AppId, Label, Locale) VALUES "
3518                                 "(?, ?, ?) ", LABEL_TABLE);
3519
3520                 hstmt = _account_prepare_query(account_db_handle, query);
3521
3522                 ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query() failed(%s).\n", _account_db_err_msg(account_db_handle)));
3523
3524                 label_s* label_data = NULL;
3525                 label_data = (label_s*)iter->data;
3526
3527                 ret = _account_query_bind_text(hstmt, count++, account_type->app_id);
3528                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
3529                 ret = _account_query_bind_text(hstmt, count++, label_data->label);
3530                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
3531                 ret = _account_query_bind_text(hstmt, count++, label_data->locale);
3532                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
3533
3534                 rc = _account_query_step(hstmt);
3535
3536                 if (rc != SQLITE_DONE) {
3537                         ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(account_db_handle));
3538                         break;
3539                 }
3540                 rc = _account_query_finalize(hstmt);
3541                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3542                 hstmt = NULL;
3543         }
3544
3545         return _ACCOUNT_ERROR_NONE;
3546 }
3547
3548
3549 static int _account_type_update_account(sqlite3 *account_db_handle, account_type_s *account_type, const char* app_id)
3550 {
3551         int                             rc = 0, binding_count = 1;
3552         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3553         int                             error_code = _ACCOUNT_ERROR_NONE;
3554         account_stmt    hstmt = NULL;
3555
3556         if (!account_type->app_id) {
3557                 ACCOUNT_ERROR("app id is mandetory field, it can not be NULL!!!!\n");
3558                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
3559         }
3560
3561         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
3562         ACCOUNT_SNPRINTF(query, sizeof(query), "UPDATE %s SET AppId=?, ServiceProviderId=?, IconPath=?, "
3563                         "SmallIconPath=?, MultipleAccountSupport=? WHERE AppId=? ", ACCOUNT_TYPE_TABLE);
3564
3565         hstmt = _account_prepare_query(account_db_handle, query);
3566
3567         if (_account_db_err_code(account_db_handle) == SQLITE_PERM) {
3568                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(account_db_handle));
3569                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
3570         } else if (_account_db_err_code(account_db_handle) == SQLITE_BUSY) {
3571                 ACCOUNT_ERROR("database busy(%s)", _account_db_err_msg(account_db_handle));
3572                 return _ACCOUNT_ERROR_DATABASE_BUSY;
3573         }
3574
3575         ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_svc_query_prepare() failed(%s).\n", _account_db_err_msg(account_db_handle)));
3576
3577         binding_count = _account_type_convert_account_to_sql(account_type, hstmt, query);
3578         _account_query_bind_text(hstmt, binding_count++, app_id);
3579
3580         rc = _account_query_step(hstmt);
3581         if (rc != SQLITE_DONE)
3582                 ACCOUNT_ERROR("account_db_query_step() failed(%d, %s)", rc, _account_db_err_msg(account_db_handle));
3583
3584         rc = _account_query_finalize(hstmt);
3585         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3586         hstmt = NULL;
3587
3588         /*update label*/
3589         error_code = _account_type_update_label(account_db_handle, account_type, app_id);
3590         /* update provider feature */
3591         error_code = _account_type_update_provider_feature(account_db_handle, account_type, app_id);
3592
3593         return error_code;
3594 }
3595
3596 int _account_type_update_to_db_by_app_id(account_type_s* account_type, const char* app_id)
3597 {
3598         int     error_code = _ACCOUNT_ERROR_NONE;
3599
3600         ACCOUNT_RETURN_VAL((account_type != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("DATA IS NULL"));
3601         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3602         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3603
3604         account_type_s* data = account_type;
3605
3606         pthread_mutex_lock(&account_mutex);
3607
3608         error_code = _account_type_update_account(g_hAccountDB, data, app_id);
3609
3610         pthread_mutex_unlock(&account_mutex);
3611
3612         return error_code;
3613 }
3614
3615 GSList* _account_type_get_label_list_by_app_id_from_global_db(const char* app_id, int *error_code)
3616 {
3617         *error_code = _ACCOUNT_ERROR_NONE;
3618         account_stmt    hstmt = NULL;
3619         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3620         int                             rc = 0, binding_count = 1;
3621         GSList* label_list = NULL;
3622
3623         ACCOUNT_RETURN_VAL((app_id != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; }, NULL, ("APP ID IS NULL"));
3624         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3625
3626         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3627
3628         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ?", LABEL_TABLE);
3629         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
3630
3631         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
3632                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
3633                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
3634
3635                 goto CATCH;
3636         }
3637
3638         _account_query_bind_text(hstmt, binding_count++, app_id);
3639
3640         rc = _account_query_step(hstmt);
3641         ACCOUNT_CATCH_ERROR_P((rc == SQLITE_ROW), {_ERR("The record isn't found. rc=[%d] done", rc); }, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
3642
3643         label_s* label_record = NULL;
3644
3645         while (rc == SQLITE_ROW) {
3646                 label_record = (label_s*) malloc(sizeof(label_s));
3647
3648                 if (label_record == NULL) {
3649                         ACCOUNT_FATAL("malloc Failed");
3650                         break;
3651                 }
3652
3653                 ACCOUNT_MEMSET(label_record, 0x00, sizeof(label_s));
3654
3655                 _account_type_convert_column_to_label(hstmt, label_record);
3656
3657                 _INFO("Adding account label_list");
3658                 label_list = g_slist_append(label_list, label_record);
3659
3660                 rc = _account_query_step(hstmt);
3661         }
3662
3663         *error_code = _ACCOUNT_ERROR_NONE;
3664
3665 CATCH:
3666         if (hstmt != NULL) {
3667                 rc = _account_query_finalize(hstmt);
3668                 if (rc != _ACCOUNT_ERROR_NONE)
3669                         _ERR("global db finalize error[%d]", rc);
3670                 hstmt = NULL;
3671         }
3672
3673         _INFO("Returning account global label_list");
3674
3675         return label_list;
3676 }
3677
3678 GSList* _account_type_get_label_list_by_app_id(const char* app_id, int *error_code)
3679 {
3680         *error_code = _ACCOUNT_ERROR_NONE;
3681         account_stmt    hstmt = NULL;
3682         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3683         int                             rc = 0, binding_count = 1;
3684         GSList* label_list = NULL;
3685
3686         ACCOUNT_RETURN_VAL((app_id != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; }, NULL, ("APP ID IS NULL"));
3687         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), { *error_code = _ACCOUNT_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
3688
3689         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3690
3691         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ?", LABEL_TABLE);
3692         hstmt = _account_prepare_query(g_hAccountDB, query);
3693
3694         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
3695                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
3696                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
3697                 return NULL;
3698         }
3699
3700         _account_query_bind_text(hstmt, binding_count++, app_id);
3701
3702         rc = _account_query_step(hstmt);
3703         ACCOUNT_CATCH_ERROR_P(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
3704
3705         label_s* label_record = NULL;
3706
3707         while (rc == SQLITE_ROW) {
3708                 label_record = (label_s*) malloc(sizeof(label_s));
3709
3710                 if (label_record == NULL) {
3711                         ACCOUNT_FATAL("malloc Failed");
3712                         break;
3713                 }
3714
3715                 ACCOUNT_MEMSET(label_record, 0x00, sizeof(label_s));
3716
3717                 _account_type_convert_column_to_label(hstmt, label_record);
3718
3719                 _INFO("Adding account label_list");
3720                 label_list = g_slist_append(label_list, label_record);
3721
3722                 rc = _account_query_step(hstmt);
3723         }
3724
3725         rc = _account_query_finalize(hstmt);
3726         if (rc != _ACCOUNT_ERROR_NONE) {
3727                         _account_type_gslist_label_free(label_list);
3728                         *error_code = rc;
3729                         _ERR("finalize error");
3730                         return NULL;
3731                 }
3732         hstmt = NULL;
3733
3734         *error_code = _ACCOUNT_ERROR_NONE;
3735
3736 CATCH:
3737         if (hstmt != NULL) {
3738                 rc = _account_query_finalize(hstmt);
3739                 if (rc != _ACCOUNT_ERROR_NONE) {
3740                         _account_type_gslist_label_free(label_list);
3741                         *error_code = rc;
3742                         _ERR("finalize error");
3743                         return NULL;
3744                 }
3745                 hstmt = NULL;
3746         }
3747
3748         if (*error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND)
3749                 label_list = _account_type_get_label_list_by_app_id_from_global_db(app_id, error_code);
3750
3751         _INFO("Returning account label_list");
3752
3753         return label_list;
3754 }
3755
3756 int _account_type_query_label_by_app_id_from_global_db(account_type_label_cb callback, const char* app_id, void *user_data)
3757 {
3758         int                             error_code = _ACCOUNT_ERROR_NONE;
3759         account_stmt    hstmt = NULL;
3760         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3761         int                             rc = 0, binding_count = 1;
3762
3763         _INFO("account_type_query_label_by_app_id_from_global_db start");
3764
3765         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3766         ACCOUNT_RETURN_VAL((callback != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION"));
3767         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3768
3769         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3770
3771         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ?", LABEL_TABLE);
3772         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
3773
3774         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
3775                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
3776                 error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
3777                 goto CATCH;
3778         }
3779
3780         _account_query_bind_text(hstmt, binding_count++, app_id);
3781
3782         rc = _account_query_step(hstmt);
3783         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
3784
3785         label_s* label_record = NULL;
3786
3787         while (rc == SQLITE_ROW) {
3788                 bool cb_ret = FALSE;
3789                 label_record = (label_s*) malloc(sizeof(label_s));
3790
3791                 if (label_record == NULL) {
3792                         ACCOUNT_FATAL("malloc Failed");
3793                         break;
3794                 }
3795
3796                 ACCOUNT_MEMSET(label_record, 0x00, sizeof(label_s));
3797
3798                 _account_type_convert_column_to_label(hstmt, label_record);
3799
3800                 cb_ret = callback(label_record->app_id, label_record->label , label_record->locale, user_data);
3801
3802                 _account_type_free_label_with_items(label_record);
3803
3804                 ACCOUNT_CATCH_ERROR(cb_ret == TRUE, {}, _ACCOUNT_ERROR_NONE, ("Callback func returs FALSE, its iteration is stopped!!!!\n"));
3805
3806                 rc = _account_query_step(hstmt);
3807         }
3808
3809         error_code = _ACCOUNT_ERROR_NONE;
3810
3811 CATCH:
3812         if (hstmt != NULL) {
3813                 rc = _account_query_finalize(hstmt);
3814                 if (rc != _ACCOUNT_ERROR_NONE)
3815                         _ERR("global db finalize error[%d]", rc);
3816                 hstmt = NULL;
3817         }
3818
3819         _INFO("account_type_query_label_by_app_id_from_global_db end [%d]", error_code);
3820
3821         return error_code;
3822 }
3823
3824 int _account_type_query_label_by_app_id(account_type_label_cb callback, const char* app_id, void *user_data)
3825 {
3826         int                             error_code = _ACCOUNT_ERROR_NONE;
3827         account_stmt    hstmt = NULL;
3828         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3829         int                             rc = 0, binding_count = 1;
3830
3831         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3832         ACCOUNT_RETURN_VAL((callback != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION"));
3833         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3834
3835         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3836
3837         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ?", LABEL_TABLE);
3838         hstmt = _account_prepare_query(g_hAccountDB, query);
3839
3840         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
3841                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
3842                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
3843         }
3844
3845         _account_query_bind_text(hstmt, binding_count++, app_id);
3846
3847         rc = _account_query_step(hstmt);
3848         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
3849
3850         label_s* label_record = NULL;
3851
3852         while (rc == SQLITE_ROW) {
3853                 bool cb_ret = FALSE;
3854                 label_record = (label_s*) malloc(sizeof(label_s));
3855
3856                 if (label_record == NULL) {
3857                         ACCOUNT_FATAL("malloc Failed");
3858                         break;
3859                 }
3860
3861                 ACCOUNT_MEMSET(label_record, 0x00, sizeof(label_s));
3862
3863                 _account_type_convert_column_to_label(hstmt, label_record);
3864
3865                 cb_ret = callback(label_record->app_id, label_record->label , label_record->locale, user_data);
3866
3867                 _account_type_free_label_with_items(label_record);
3868
3869                 //ACCOUNT_CATCH_ERROR(cb_ret == TRUE, {}, _ACCOUNT_ERROR_NONE, ("Callback func returs FALSE, its iteration is stopped!!!!\n"));
3870                 if (cb_ret != TRUE) {
3871                         _INFO("Callback func returs FALSE, its iteration is stopped!!!!\n");
3872                         break;
3873                 }
3874
3875                 rc = _account_query_step(hstmt);
3876         }
3877
3878         rc = _account_query_finalize(hstmt);
3879         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3880         hstmt = NULL;
3881
3882         error_code = _ACCOUNT_ERROR_NONE;
3883
3884 CATCH:
3885         if (hstmt != NULL) {
3886                 rc = _account_query_finalize(hstmt);
3887                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3888                 hstmt = NULL;
3889         }
3890 /*
3891         if (error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND) {
3892                 error_code = account_type_query_label_by_app_id_from_global_db(callback, app_id, user_data);
3893         }
3894 */
3895         return error_code;
3896 }
3897
3898 int account_type_query_label_by_app_id(account_type_label_cb callback, const char* app_id, void *user_data)
3899 {
3900         int error_code = _ACCOUNT_ERROR_NONE;
3901
3902         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3903         ACCOUNT_RETURN_VAL((callback != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION"));
3904         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3905
3906         error_code = _account_type_query_label_by_app_id(callback, app_id, user_data);
3907
3908         if (error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND)
3909                 error_code = _account_type_query_label_by_app_id_from_global_db(callback, app_id, user_data);
3910
3911         return error_code;
3912 }
3913
3914 bool _account_get_label_text_cb(char* app_id, char* label, char* locale, void *user_data)
3915 {
3916         account_type_s *data = (account_type_s*)user_data;
3917
3918         label_s *label_data = (label_s*)malloc(sizeof(label_s));
3919
3920         if (label_data == NULL) {
3921                 ACCOUNT_FATAL("_account_get_label_text_cb : MALLOC FAIL\n");
3922                 return FALSE;
3923         }
3924         ACCOUNT_MEMSET(label_data, 0, sizeof(label_s));
3925
3926         label_data->app_id = _account_dup_text(app_id);
3927         label_data->label = _account_dup_text(label);
3928         label_data->locale = _account_dup_text(locale);
3929
3930         data->label_list = g_slist_append(data->label_list, (gpointer)label_data);
3931
3932         return TRUE;
3933 }
3934
3935 bool _account_get_provider_feature_cb(char* app_id, char* key, void* user_data)
3936 {
3937         account_type_s *data = (account_type_s*)user_data;
3938
3939         provider_feature_s *feature_data = (provider_feature_s*)malloc(sizeof(provider_feature_s));
3940
3941         if (feature_data == NULL) {
3942                 ACCOUNT_FATAL("_account_get_provider_feature_cb : MALLOC FAIL\n");
3943                 return FALSE;
3944         }
3945         ACCOUNT_MEMSET(feature_data, 0, sizeof(provider_feature_s));
3946
3947         feature_data->app_id = _account_dup_text(app_id);
3948         feature_data->key = _account_dup_text(key);
3949
3950         data->provider_feature_list = g_slist_append(data->provider_feature_list, (gpointer)feature_data);
3951
3952         return TRUE;
3953 }
3954
3955 int _account_type_query_by_app_id_from_global_db(const char* app_id, account_type_s** account_type_record)
3956 {
3957         _INFO("_account_type_query_by_app_id_from_global_db start");
3958
3959         int                             error_code = _ACCOUNT_ERROR_NONE;
3960         account_stmt    hstmt = NULL;
3961         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3962         int                             rc = 0, binding_count = 1;
3963
3964         ACCOUNT_RETURN_VAL((app_id != 0), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3965         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3966         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3967
3968         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3969
3970         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ?", ACCOUNT_TYPE_TABLE);
3971         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
3972
3973         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
3974                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
3975                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
3976         }
3977
3978         _account_query_bind_text(hstmt, binding_count++, app_id);
3979
3980         rc = _account_query_step(hstmt);
3981         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
3982
3983         *account_type_record = create_empty_account_type_instance();
3984
3985         while (rc == SQLITE_ROW) {
3986                 _account_type_convert_column_to_account_type(hstmt, *account_type_record);
3987                 rc = _account_query_step(hstmt);
3988         }
3989
3990         rc = _account_query_finalize(hstmt);
3991         ACCOUNT_CATCH_ERROR((rc == _ACCOUNT_ERROR_NONE), {_ERR("global db finalize error rc=[%d]", rc); }, rc, ("finalize error"));
3992         _account_type_query_label_by_app_id_from_global_db(_account_get_label_text_cb, app_id, (void*)(*account_type_record));
3993         _account_type_query_provider_feature_cb_by_app_id_from_global_db(_account_get_provider_feature_cb, app_id, (void*)(*account_type_record));
3994
3995         hstmt = NULL;
3996         error_code = _ACCOUNT_ERROR_NONE;
3997
3998 CATCH:
3999         if (hstmt != NULL) {
4000                 rc = _account_query_finalize(hstmt);
4001                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4002                 hstmt = NULL;
4003         }
4004
4005         _INFO("_account_type_query_by_app_id_from_global_db end [%d]", error_code);
4006
4007         return error_code;
4008 }
4009
4010 int _account_type_query_by_app_id(const char* app_id, account_type_s** account_type_record)
4011 {
4012         _INFO("_account_type_query_by_app_id start");
4013
4014         int                             error_code = _ACCOUNT_ERROR_NONE;
4015         account_stmt    hstmt = NULL;
4016         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
4017         int                             rc = 0, binding_count = 1;
4018
4019         ACCOUNT_RETURN_VAL((app_id != 0), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
4020         ACCOUNT_RETURN_VAL((account_type_record != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("account type record(account_type_s**) is NULL"));
4021         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
4022
4023         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
4024
4025         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ?", ACCOUNT_TYPE_TABLE);
4026         hstmt = _account_prepare_query(g_hAccountDB, query);
4027
4028         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
4029                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
4030                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
4031         }
4032
4033         _account_query_bind_text(hstmt, binding_count++, app_id);
4034
4035         rc = _account_query_step(hstmt);
4036         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
4037
4038         *account_type_record = create_empty_account_type_instance();
4039         if (*account_type_record == NULL) {
4040                 _ERR("Out of Memory");
4041                 error_code = _ACCOUNT_ERROR_OUT_OF_MEMORY;
4042                 goto CATCH;
4043         }
4044
4045         while (rc == SQLITE_ROW) {
4046                 _account_type_convert_column_to_account_type(hstmt, *account_type_record);
4047                 rc = _account_query_step(hstmt);
4048         }
4049
4050         rc = _account_query_finalize(hstmt);
4051         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4052         _account_type_query_label_by_app_id(_account_get_label_text_cb, app_id, (void*)(*account_type_record));
4053         _account_type_query_provider_feature_cb_by_app_id(_account_get_provider_feature_cb, app_id, (void*)(*account_type_record));
4054
4055         hstmt = NULL;
4056         error_code = _ACCOUNT_ERROR_NONE;
4057
4058 CATCH:
4059         if (hstmt != NULL) {
4060                 rc = _account_query_finalize(hstmt);
4061                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4062                 hstmt = NULL;
4063         }
4064
4065         if (error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND)
4066                 error_code = _account_type_query_by_app_id_from_global_db(app_id, account_type_record);
4067
4068         _INFO("_account_type_query_by_app_id end [%d]", error_code);
4069
4070         return error_code;
4071 }
4072
4073 int _account_type_query_by_provider_feature_from_global_db(const char* key, GSList **account_type_list_all)
4074 {
4075         int error_code = _ACCOUNT_ERROR_NONE;
4076         account_stmt    hstmt = NULL;
4077         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
4078         int                             rc = 0;
4079         GSList                  *account_type_list = NULL;
4080
4081         _INFO("_account_type_query_by_provider_feature_from_global_db start key=%s", key);
4082         if (key == NULL) {
4083                 ACCOUNT_ERROR("capability_type IS NULL.");
4084                 error_code = _ACCOUNT_ERROR_INVALID_PARAMETER;
4085                 goto CATCH;
4086         }
4087
4088         if (g_hAccountGlobalDB == NULL) {
4089                 ACCOUNT_ERROR("The database isn't connected.");
4090                 error_code = _ACCOUNT_ERROR_DB_NOT_OPENED;
4091                 goto CATCH;
4092         }
4093
4094         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
4095
4096         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId IN (SELECT app_id from %s WHERE key=?)", ACCOUNT_TYPE_TABLE, PROVIDER_FEATURE_TABLE);
4097
4098         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
4099
4100         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
4101                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
4102                 error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
4103                 goto CATCH;
4104         }
4105
4106         int binding_count = 1;
4107         _account_query_bind_text(hstmt, binding_count++, key);
4108
4109         rc = _account_query_step(hstmt);
4110
4111         account_type_s *account_type_record = NULL;
4112
4113         if (rc != SQLITE_ROW) {
4114                 ACCOUNT_ERROR("The record isn't found. rc=[%d]", rc);
4115                 error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
4116                 goto CATCH;
4117         }
4118
4119         while (rc == SQLITE_ROW) {
4120                 account_type_record = (account_type_s*) malloc(sizeof(account_type_s));
4121
4122                 if (account_type_record == NULL) {
4123                         ACCOUNT_FATAL("malloc Failed");
4124                         break;
4125                 }
4126
4127                 ACCOUNT_MEMSET(account_type_record, 0x00, sizeof(account_type_s));
4128                 _account_type_convert_column_to_account_type(hstmt, account_type_record);
4129                 account_type_list = g_slist_append(account_type_list, account_type_record);
4130                 rc = _account_query_step(hstmt);
4131         }
4132
4133         rc = _account_query_finalize(hstmt);
4134         if (rc != _ACCOUNT_ERROR_NONE) {
4135                 _account_type_gslist_account_type_free(account_type_list);
4136                 ACCOUNT_ERROR("finalize error(%s)", rc);
4137                 error_code = rc;
4138                 goto CATCH;
4139         }
4140         hstmt = NULL;
4141
4142         GSList* iter;
4143
4144         for (iter = account_type_list; iter != NULL; iter = g_slist_next(iter)) {
4145                 account_type_s *account_type = NULL;
4146                 account_type = (account_type_s*)iter->data;
4147                 _account_type_query_label_by_app_id_from_global_db(_account_get_label_text_cb, account_type->app_id, (void*)account_type);
4148                 _account_type_query_provider_feature_cb_by_app_id_from_global_db(_account_get_provider_feature_cb, account_type->app_id, (void*)account_type);
4149                 _INFO("add label & provider_feature");
4150         }
4151
4152         for (iter = account_type_list; iter != NULL; iter = g_slist_next(iter)) {
4153
4154                 account_type_s *account_type = NULL;
4155                 account_type = (account_type_s*)iter->data;
4156                 *account_type_list_all = g_slist_append(*account_type_list_all, account_type);
4157                 _INFO("add account_type");
4158         }
4159         g_slist_free(account_type_list);
4160
4161         error_code = _ACCOUNT_ERROR_NONE;
4162
4163 CATCH:
4164         if (hstmt != NULL) {
4165                 rc = _account_query_finalize(hstmt);
4166                 if (rc != _ACCOUNT_ERROR_NONE) {
4167                         ACCOUNT_ERROR("finalize error(%s)", rc);
4168                         return rc;
4169                 }
4170                 hstmt = NULL;
4171         }
4172
4173         _INFO("_account_type_query_by_provider_feature_from_global_db end. error_code=[%d]", error_code);
4174
4175         return error_code;
4176 }
4177
4178 GSList* _account_type_query_by_provider_feature(const char* key, int *error_code)
4179 {
4180         *error_code = _ACCOUNT_ERROR_NONE;
4181         account_stmt hstmt = NULL;
4182         char query[ACCOUNT_SQL_LEN_MAX] = {0, };
4183         int rc = 0;
4184         GSList *account_type_list = NULL;
4185
4186         _INFO("account_type_query_by_provider_feature start key=%s", key);
4187         if (key == NULL) {
4188                 ACCOUNT_ERROR("capability_type IS NULL.");
4189                 *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER;
4190                 goto CATCH;
4191         }
4192
4193         if (g_hAccountDB == NULL) {
4194                 ACCOUNT_ERROR("The database isn't connected.");
4195                 *error_code = _ACCOUNT_ERROR_DB_NOT_OPENED;
4196                 goto CATCH;
4197         }
4198
4199         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
4200
4201         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId IN (SELECT app_id from %s WHERE key=?)", ACCOUNT_TYPE_TABLE, PROVIDER_FEATURE_TABLE);
4202
4203         hstmt = _account_prepare_query(g_hAccountDB, query);
4204
4205         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
4206                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
4207                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
4208                 goto CATCH;
4209         }
4210
4211         int binding_count = 1;
4212         _account_query_bind_text(hstmt, binding_count++, key);
4213
4214         rc = _account_query_step(hstmt);
4215
4216         account_type_s *account_type_record = NULL;
4217
4218         if (rc != SQLITE_ROW) {
4219                 ACCOUNT_ERROR("The record isn't found. rc=[%d]", rc);
4220                 *error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
4221                 goto CATCH;
4222         }
4223
4224         while (rc == SQLITE_ROW) {
4225                 account_type_record = (account_type_s*) malloc(sizeof(account_type_s));
4226
4227                 if (account_type_record == NULL) {
4228                         ACCOUNT_FATAL("malloc Failed");
4229                         break;
4230                 }
4231
4232                 ACCOUNT_MEMSET(account_type_record, 0x00, sizeof(account_type_s));
4233                 _account_type_convert_column_to_account_type(hstmt, account_type_record);
4234                 account_type_list = g_slist_append(account_type_list, account_type_record);
4235                 rc = _account_query_step(hstmt);
4236         }
4237
4238         rc = _account_query_finalize(hstmt);
4239         if (rc != _ACCOUNT_ERROR_NONE) {
4240                 _account_type_gslist_account_type_free(account_type_list);
4241                 ACCOUNT_ERROR("finalize error(%s)", rc);
4242                 *error_code = rc;
4243                 goto CATCH;
4244         }
4245         hstmt = NULL;
4246
4247         GSList* iter;
4248
4249         for (iter = account_type_list; iter != NULL; iter = g_slist_next(iter)) {
4250                 account_type_s *account_type = NULL;
4251                 account_type = (account_type_s*)iter->data;
4252                 _account_type_query_label_by_app_id(_account_get_label_text_cb, account_type->app_id, (void*)account_type);
4253                 _account_type_query_provider_feature_cb_by_app_id(_account_get_provider_feature_cb, account_type->app_id, (void*)account_type);
4254         }
4255
4256         *error_code = _ACCOUNT_ERROR_NONE;
4257
4258 CATCH:
4259         if (hstmt != NULL) {
4260                 rc = _account_query_finalize(hstmt);
4261                 if (rc != _ACCOUNT_ERROR_NONE) {
4262                         *error_code = rc;
4263                         return NULL;
4264                 }
4265                 hstmt = NULL;
4266         }
4267
4268         if (*error_code == _ACCOUNT_ERROR_NONE || *error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND) {
4269                 rc = _account_type_query_by_provider_feature_from_global_db(key, &account_type_list);
4270                 if (rc != _ACCOUNT_ERROR_NONE && rc != _ACCOUNT_ERROR_RECORD_NOT_FOUND) {
4271                         ACCOUNT_ERROR("_account_type_query_by_provider_feature_from_global_db fail=[%d]", rc);
4272                         _account_type_gslist_account_type_free(account_type_list);
4273                         return NULL;
4274                 }
4275                 if (rc == _ACCOUNT_ERROR_NONE)
4276                         *error_code = rc;
4277         }
4278
4279         _INFO("account_type_query_by_provider_feature end");
4280
4281         return account_type_list;
4282 }
4283
4284 int _account_type_query_all_from_global_db(GSList **account_type_list_all)
4285 {
4286         account_stmt    hstmt = NULL;
4287         char query[ACCOUNT_SQL_LEN_MAX] = {0, };
4288         int rc = _ACCOUNT_ERROR_NONE;
4289         int error_code = _ACCOUNT_ERROR_NONE;
4290         GSList *account_type_list = NULL;
4291
4292         _INFO("_account_type_query_all_in_global_db start");
4293         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), {}, NULL, ("The database isn't connected."));
4294
4295         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
4296
4297         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s ", ACCOUNT_TYPE_TABLE);
4298         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
4299
4300         rc = _account_query_step(hstmt);
4301
4302         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
4303                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
4304                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
4305         }
4306
4307         account_type_s *account_type_record = NULL;
4308
4309         if (rc != SQLITE_ROW) {
4310                 _INFO("[_ACCOUNT_ERROR_RECORD_NOT_FOUND]The record isn't found.");
4311                 error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
4312                 goto CATCH;
4313         }
4314
4315         while (rc == SQLITE_ROW) {
4316                 account_type_record = (account_type_s*) malloc(sizeof(account_type_s));
4317
4318                 if (account_type_record == NULL) {
4319                         ACCOUNT_FATAL("malloc Failed");
4320                         break;
4321                 }
4322
4323                 ACCOUNT_MEMSET(account_type_record, 0x00, sizeof(account_type_s));
4324                 _account_type_convert_column_to_account_type(hstmt, account_type_record);
4325                 account_type_list = g_slist_append(account_type_list, account_type_record);
4326                 rc = _account_query_step(hstmt);
4327         }
4328
4329         rc = _account_query_finalize(hstmt);
4330         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {_account_type_gslist_account_type_free(account_type_list); }, rc, ("finalize error"));
4331         hstmt = NULL;
4332
4333         GSList* iter;
4334
4335         for (iter = account_type_list; iter != NULL; iter = g_slist_next(iter)) {
4336                 account_type_s *account_type = NULL;
4337                 account_type = (account_type_s*)iter->data;
4338                 _account_type_query_label_by_app_id_from_global_db(_account_get_label_text_cb, account_type->app_id, (void*)account_type);
4339                 _account_type_query_provider_feature_cb_by_app_id_from_global_db(_account_get_provider_feature_cb, account_type->app_id, (void*)account_type);
4340         }
4341
4342         for (iter = account_type_list; iter != NULL; iter = g_slist_next(iter)) {
4343                 account_type_s *account_type = NULL;
4344                 account_type = (account_type_s*)iter->data;
4345                 *account_type_list_all = g_slist_append(*account_type_list_all, account_type);
4346         }
4347         g_slist_free(account_type_list);
4348
4349         error_code = _ACCOUNT_ERROR_NONE;
4350
4351 CATCH:
4352         if (hstmt != NULL) {
4353                 rc = _account_query_finalize(hstmt);
4354                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {_account_type_gslist_account_type_free(account_type_list); }, rc, ("finalize error"));
4355                 hstmt = NULL;
4356         }
4357
4358         _INFO("_account_type_query_all_in_global_db end");
4359
4360         return error_code;
4361 }
4362
4363 GSList* _account_type_query_all(void)
4364 {
4365         account_stmt hstmt = NULL;
4366         char query[ACCOUNT_SQL_LEN_MAX] = {0, };
4367         int rc = 0;
4368         int error_code = _ACCOUNT_ERROR_NONE;
4369         GSList *account_type_list = NULL;
4370
4371         _INFO("_account_type_query_all start");
4372         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, NULL, ("The database isn't connected."));
4373
4374         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
4375
4376         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s ", ACCOUNT_TYPE_TABLE);
4377         hstmt = _account_prepare_query(g_hAccountDB, query);
4378
4379         rc = _account_query_step(hstmt);
4380
4381         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
4382                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
4383                 return NULL;
4384         }
4385
4386         account_type_s *account_type_record = NULL;
4387
4388         if (rc != SQLITE_ROW) {
4389                 _INFO("[_ACCOUNT_ERROR_RECORD_NOT_FOUND]The record isn't found.");
4390                 error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
4391                 goto CATCH;
4392         }
4393
4394         while (rc == SQLITE_ROW) {
4395                 account_type_record = (account_type_s*) malloc(sizeof(account_type_s));
4396
4397                 if (account_type_record == NULL) {
4398                         ACCOUNT_FATAL("malloc Failed");
4399                         break;
4400                 }
4401
4402                 ACCOUNT_MEMSET(account_type_record, 0x00, sizeof(account_type_s));
4403                 _account_type_convert_column_to_account_type(hstmt, account_type_record);
4404                 account_type_list = g_slist_append(account_type_list, account_type_record);
4405                 rc = _account_query_step(hstmt);
4406         }
4407
4408         rc = _account_query_finalize(hstmt);
4409         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {_account_type_gslist_account_type_free(account_type_list); }, NULL, ("finalize error"));
4410         hstmt = NULL;
4411
4412         GSList* iter;
4413
4414         for (iter = account_type_list; iter != NULL; iter = g_slist_next(iter)) {
4415                 account_type_s *account_type = NULL;
4416                 account_type = (account_type_s*)iter->data;
4417                 _account_type_query_label_by_app_id(_account_get_label_text_cb, account_type->app_id, (void*)account_type);
4418                 _account_type_query_provider_feature_cb_by_app_id(_account_get_provider_feature_cb, account_type->app_id, (void*)account_type);
4419         }
4420
4421         error_code = _ACCOUNT_ERROR_NONE;
4422
4423 CATCH:
4424         if (hstmt != NULL) {
4425                 rc = _account_query_finalize(hstmt);
4426                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {_account_type_gslist_account_type_free(account_type_list); }, NULL, ("finalize error"));
4427                 hstmt = NULL;
4428         }
4429
4430         if (error_code == _ACCOUNT_ERROR_NONE || error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND) {
4431                 error_code = _account_type_query_all_from_global_db(&account_type_list);
4432                 if (rc != _ACCOUNT_ERROR_NONE && rc != _ACCOUNT_ERROR_RECORD_NOT_FOUND) {
4433                         ACCOUNT_ERROR("_account_type_query_all_from_global_db fail=[%d]", rc);
4434                         _account_type_gslist_account_type_free(account_type_list);
4435                         return NULL;
4436                 }
4437         }
4438
4439         _INFO("_account_type_query_all end");
4440
4441         return account_type_list;
4442 }
4443
4444 // output parameter label must be free
4445 int _account_type_query_label_by_locale_from_global_db(const char* app_id, const char* locale, char **label)
4446 {
4447         int                             error_code = _ACCOUNT_ERROR_NONE;
4448         account_stmt    hstmt = NULL;
4449         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
4450         int                             rc = 0, binding_count = 1;
4451         char*                   converted_locale = NULL;
4452
4453         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO APP ID"));
4454         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
4455         ACCOUNT_RETURN_VAL((label != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("label char is null"));
4456         ACCOUNT_RETURN_VAL((locale != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("locale char is null"));
4457         //Making label newly created
4458
4459         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
4460
4461         converted_locale = _account_dup_text(locale);
4462         gchar** tokens = g_strsplit(converted_locale, "-", 2);
4463
4464         if (tokens != NULL) {
4465                 if ((char*)(tokens[1]) != NULL) {
4466                         char* upper_token = g_ascii_strup(tokens[1], strlen(tokens[1]));
4467                         if (upper_token != NULL) {
4468                                 _ACCOUNT_FREE(converted_locale);
4469                                 converted_locale = g_strdup_printf("%s_%s", tokens[0], upper_token);
4470                         }
4471                         _ACCOUNT_FREE(upper_token);
4472                 }
4473         }
4474         g_strfreev(tokens);
4475
4476         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ? AND Locale = '%s' ", LABEL_TABLE, converted_locale);
4477         _ACCOUNT_FREE(converted_locale);
4478
4479         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
4480
4481         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
4482                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
4483                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
4484         }
4485
4486         _account_query_bind_text(hstmt, binding_count++, app_id);
4487
4488         rc = _account_query_step(hstmt);
4489         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
4490
4491         label_s* label_record = NULL;
4492
4493         while (rc == SQLITE_ROW) {
4494                 label_record = (label_s*) malloc(sizeof(label_s));
4495
4496                 if (label_record == NULL) {
4497                         ACCOUNT_FATAL("malloc Failed");
4498                         break;
4499                 }
4500
4501                 ACCOUNT_MEMSET(label_record, 0x00, sizeof(label_s));
4502
4503                 _account_type_convert_column_to_label(hstmt, label_record);
4504
4505                 _ACCOUNT_FREE(*label);
4506                 //Making label newly created
4507                 *label = _account_dup_text(label_record->label);
4508
4509                 _account_type_free_label_with_items(label_record);
4510
4511                 rc = _account_query_step(hstmt);
4512         }
4513
4514         rc = _account_query_finalize(hstmt);
4515         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4516         hstmt = NULL;
4517
4518         error_code = _ACCOUNT_ERROR_NONE;
4519
4520 CATCH:
4521         if (hstmt != NULL) {
4522                 rc = _account_query_finalize(hstmt);
4523                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4524                 hstmt = NULL;
4525         }
4526
4527         _INFO("_account_type_query_label_by_locale_from_global_db() end : error_code = %d", error_code);
4528
4529         return error_code;
4530 }
4531
4532 // output parameter label must be free
4533 int _account_type_query_label_by_locale(const char* app_id, const char* locale, char **label)
4534 {
4535         int                             error_code = _ACCOUNT_ERROR_NONE;
4536         account_stmt    hstmt = NULL;
4537         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
4538         int                             rc = 0, binding_count = 1;
4539         char*                   converted_locale = NULL;
4540
4541         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO APP ID"));
4542         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
4543         ACCOUNT_RETURN_VAL((label != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("label char is null"));
4544         ACCOUNT_RETURN_VAL((locale != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("locale char is null"));
4545         //Making label newly created
4546
4547         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
4548
4549         converted_locale = _account_dup_text(locale);
4550         gchar** tokens = g_strsplit(converted_locale, "-", 2);
4551
4552         if (tokens != NULL) {
4553                 if ((char*)(tokens[1]) != NULL) {
4554                         char* upper_token = g_ascii_strup(tokens[1], strlen(tokens[1]));
4555                         if (upper_token != NULL) {
4556                                 _ACCOUNT_FREE(converted_locale);
4557                                 converted_locale = g_strdup_printf("%s_%s", tokens[0], upper_token);
4558                         }
4559                         _ACCOUNT_FREE(upper_token);
4560                 }
4561         }
4562         g_strfreev(tokens);
4563
4564         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ? AND Locale = '%s' ", LABEL_TABLE, converted_locale);
4565         _ACCOUNT_FREE(converted_locale);
4566
4567         hstmt = _account_prepare_query(g_hAccountDB, query);
4568
4569         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
4570                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
4571                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
4572         }
4573
4574         _account_query_bind_text(hstmt, binding_count++, app_id);
4575
4576         rc = _account_query_step(hstmt);
4577         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
4578
4579         label_s* label_record = NULL;
4580
4581         while (rc == SQLITE_ROW) {
4582                 label_record = (label_s*) malloc(sizeof(label_s));
4583
4584                 if (label_record == NULL) {
4585                         ACCOUNT_FATAL("malloc Failed");
4586                         break;
4587                 }
4588
4589                 ACCOUNT_MEMSET(label_record, 0x00, sizeof(label_s));
4590
4591                 _account_type_convert_column_to_label(hstmt, label_record);
4592
4593                 _ACCOUNT_FREE(*label);
4594                 //Making label newly created
4595                 *label = _account_dup_text(label_record->label);
4596
4597                 _account_type_free_label_with_items(label_record);
4598
4599                 rc = _account_query_step(hstmt);
4600         }
4601
4602         rc = _account_query_finalize(hstmt);
4603         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4604         hstmt = NULL;
4605
4606         error_code = _ACCOUNT_ERROR_NONE;
4607
4608 CATCH:
4609         if (hstmt != NULL) {
4610                 rc = _account_query_finalize(hstmt);
4611                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4612                 hstmt = NULL;
4613         }
4614
4615         if (error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND)
4616                 error_code = _account_type_query_label_by_locale_from_global_db(app_id, locale, label);
4617
4618         _INFO("_account_type_query_label_by_locale() end : error_code = %d", error_code);
4619
4620         return error_code;
4621 }
4622
4623 static int _account_insert_custom(account_s *account, int account_id)
4624 {
4625         _INFO("_account_insert_custom start");
4626
4627         int                             rc, count = 1;
4628         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
4629         account_stmt    hstmt = NULL;
4630
4631         ACCOUNT_RETURN_VAL((account != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL"));
4632
4633         if (g_slist_length(account->custom_list) == 0) {
4634                 ACCOUNT_DEBUG("_account_insert_custom, no custom data\n");
4635                 return _ACCOUNT_ERROR_NONE;
4636         }
4637
4638         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where _id=%d", ACCOUNT_TABLE, account_id);
4639
4640         rc = _account_get_record_count(g_hAccountDB, query);
4641
4642         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
4643                 ACCOUNT_ERROR("Access failed(%d, %s)", _account_db_err_msg(g_hAccountDB));
4644                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
4645         }
4646
4647         if (rc <= 0) {
4648                 ACCOUNT_SLOGE("_account_insert_custom : related account item is not existed rc=%d , %s", rc, _account_db_err_msg(g_hAccountDB));
4649                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
4650         }
4651
4652         /* insert query*/
4653
4654         GSList *iter;
4655
4656         for (iter = account->custom_list; iter != NULL; iter = g_slist_next(iter)) {
4657                 int ret;
4658                 count = 1;
4659                 ACCOUNT_MEMSET(query, 0x00, sizeof(query));
4660                 ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s (AccountId, AppId, Key, Value) VALUES "
4661                                 "(?, ?, ?, ?) ", ACCOUNT_CUSTOM_TABLE);
4662
4663                 hstmt = _account_prepare_query(g_hAccountDB, query);
4664
4665                 if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
4666                         ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
4667                         return _ACCOUNT_ERROR_PERMISSION_DENIED;
4668                 }
4669
4670                 ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query(g_hAccountDB, ) failed(%s).\n", _account_db_err_msg(g_hAccountDB)));
4671
4672                 account_custom_s* custom_data = NULL;
4673                 custom_data = (account_custom_s*)iter->data;
4674
4675                 ret = _account_query_bind_int(hstmt, count++, account_id);
4676                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Int binding fail"));
4677                 ret = _account_query_bind_text(hstmt, count++, account->package_name);
4678                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
4679                 ret = _account_query_bind_text(hstmt, count++, (char*)custom_data->key);
4680                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
4681                 ret = _account_query_bind_text(hstmt, count++, (char*)custom_data->value);
4682                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
4683
4684                 rc = _account_query_step(hstmt);
4685
4686                 if (rc != SQLITE_DONE) {
4687                         ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
4688                         break;
4689                 }
4690
4691                 rc = _account_query_finalize(hstmt);
4692                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4693                 hstmt = NULL;
4694
4695         }
4696
4697         _INFO("_account_insert_custom end");
4698
4699         return _ACCOUNT_ERROR_NONE;
4700 }
4701
4702 static int _account_update_custom(account_s *account, int account_id)
4703 {
4704         int                             rc, count = 1;
4705         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
4706         account_stmt    hstmt = NULL;
4707
4708         ACCOUNT_RETURN_VAL((account != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL"));
4709
4710         if (g_slist_length(account->custom_list) == 0) {
4711                 ACCOUNT_DEBUG("_account_update_custom, no custom data\n");
4712                 return _ACCOUNT_ERROR_NONE;
4713         }
4714
4715         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where _id=%d", ACCOUNT_TABLE, account_id);
4716
4717         rc = _account_get_record_count(g_hAccountDB, query);
4718
4719         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
4720                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
4721                 pthread_mutex_unlock(&account_mutex);
4722                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
4723         } else if (_account_db_err_code(g_hAccountDB) == SQLITE_BUSY) {
4724                 ACCOUNT_ERROR("database busy(%s)", _account_db_err_msg(g_hAccountDB));
4725                 pthread_mutex_unlock(&account_mutex);
4726                 return _ACCOUNT_ERROR_DATABASE_BUSY;
4727         }
4728
4729         if (rc <= 0) {
4730                 ACCOUNT_SLOGE("_account_update_custom : related account item is not existed rc=%d , %s", rc, _account_db_err_msg(g_hAccountDB));
4731                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
4732         }
4733
4734         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
4735
4736         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AccountId=? ", ACCOUNT_CUSTOM_TABLE);
4737         hstmt = _account_prepare_query(g_hAccountDB, query);
4738         count = 1;
4739         _account_query_bind_int(hstmt, count++, (int)account_id);
4740         rc = _account_query_step(hstmt);
4741
4742         if (rc == SQLITE_BUSY) {
4743                 ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
4744                 return _ACCOUNT_ERROR_DATABASE_BUSY;
4745         } else if (rc != SQLITE_DONE) {
4746                 ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
4747                 return _ACCOUNT_ERROR_DB_FAILED;
4748         }
4749
4750         rc = _account_query_finalize(hstmt);
4751         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4752         hstmt = NULL;
4753
4754         GSList *iter;
4755
4756         for (iter = account->custom_list; iter != NULL; iter = g_slist_next(iter)) {
4757                 int ret;
4758                 count = 1;
4759                 ACCOUNT_MEMSET(query, 0x00, sizeof(query));
4760                 ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(AccountId, AppId, Key, Value) VALUES "
4761                                 "(?, ?, ?, ?) ", ACCOUNT_CUSTOM_TABLE);
4762
4763                 hstmt = _account_prepare_query(g_hAccountDB, query);
4764
4765                 if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
4766                         ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
4767                         return _ACCOUNT_ERROR_PERMISSION_DENIED;
4768                 }
4769
4770                 ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query(g_hAccountDB, ) failed(%s).\n", _account_db_err_msg(g_hAccountDB)));
4771
4772                 account_custom_s* custom_data = NULL;
4773                 custom_data = (account_custom_s*)iter->data;
4774
4775                 ret = _account_query_bind_int(hstmt, count++, (int)account_id);
4776                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Int binding fail"));
4777                 ret = _account_query_bind_text(hstmt, count++, (char*)account->package_name);
4778                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
4779                 ret = _account_query_bind_text(hstmt, count++, (char*)custom_data->key);
4780                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
4781                 ret = _account_query_bind_text(hstmt, count++, (char*)custom_data->value);
4782                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
4783
4784                 rc = _account_query_step(hstmt);
4785
4786                 if (rc != SQLITE_DONE) {
4787                         ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
4788                         break;
4789                 }
4790
4791                 rc = _account_query_finalize(hstmt);
4792                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4793                 hstmt = NULL;
4794
4795         }
4796
4797         return _ACCOUNT_ERROR_NONE;
4798 }
4799