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, false);
 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, false);
 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, false);
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, false);
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, false);
1764                 _account_query_custom_by_account_id(g_hAccountDB, _account_add_custom_to_account_cb, account->id, (void*)account, false);
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_query_account_by_account_id(int pid, uid_t uid, int account_db_id, account_s *account_record, bool query_del_acc)
1861 {
1862         _INFO("_account_query_account_by_account_id() start, account_db_id=[%d], query_del_acc=[%d]", account_db_id, query_del_acc);
1863
1864         int error_code = _ACCOUNT_ERROR_NONE;
1865         account_stmt hstmt = NULL;
1866         char query[ACCOUNT_SQL_LEN_MAX] = {0, };
1867         int rc = 0;
1868
1869         ACCOUNT_RETURN_VAL((account_db_id > 0), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT INDEX IS LESS THAN 0"));
1870         ACCOUNT_RETURN_VAL(account_record != NULL, {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT IS NULL"));
1871         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
1872
1873         ACCOUNT_DEBUG("starting db operations");
1874
1875         /* prepare query for account-table */
1876         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
1877         if (!query_del_acc)
1878                 ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE _id = %d", ACCOUNT_TABLE, account_db_id);
1879         else
1880                 ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE _id = %d", DELETED_ACCOUNT_TABLE, account_db_id);
1881
1882         _INFO("after _account_prepare_query, rc=[%d]", rc);
1883
1884         hstmt = _account_prepare_query(g_hAccountDB, query);
1885
1886         rc = _account_db_err_code(g_hAccountDB);
1887         if (rc == SQLITE_PERM) {
1888                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
1889                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
1890         }
1891
1892         ACCOUNT_DEBUG("before _account_query_step");
1893
1894         rc = _account_query_step(hstmt);
1895
1896         ACCOUNT_DEBUG("after _account_query_step returned [%d]", rc);
1897
1898         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
1899
1900         while (rc == SQLITE_ROW) {
1901                 ACCOUNT_DEBUG("before _account_convert_column_to_account");
1902                 _account_convert_column_to_account(hstmt, account_record);
1903                 ACCOUNT_DEBUG("after _account_convert_column_to_account");
1904                 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]);
1905                 rc = _account_query_step(hstmt);
1906         }
1907
1908         ACCOUNT_DEBUG("account_record->id=[%d]", account_record->id);
1909
1910         rc = _account_query_finalize(hstmt);
1911         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
1912
1913         ACCOUNT_DEBUG("before _account_query_capability_by_account_id");
1914         _account_query_capability_by_account_id(g_hAccountDB, _account_add_capability_to_account_cb, account_record->id, (void*)account_record, query_del_acc);
1915         ACCOUNT_DEBUG("after _account_query_capability_by_account_id");
1916
1917         ACCOUNT_DEBUG("before _account_query_custom_by_account_id");
1918         _account_query_custom_by_account_id(g_hAccountDB, _account_add_custom_to_account_cb, account_record->id, (void*)account_record, query_del_acc);
1919         ACCOUNT_DEBUG("after _account_query_custom_by_account_id");
1920
1921         hstmt = NULL;
1922         error_code = _ACCOUNT_ERROR_NONE;
1923
1924 CATCH:
1925         if (hstmt != NULL) {
1926                 rc = _account_query_finalize(hstmt);
1927                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
1928                 hstmt = NULL;
1929         }
1930
1931         if (account_record)
1932                 _remove_sensitive_info_from_non_owning_account(account_record, pid, uid);
1933
1934         pthread_mutex_unlock(&account_mutex);
1935         ACCOUNT_DEBUG("_account_query_account_by_account_id end [%d]", error_code);
1936
1937         return error_code;
1938 }
1939
1940 GList* _account_query_account_by_user_name(int pid, uid_t uid, const char *user_name, int *error_code)
1941 {
1942         *error_code = _ACCOUNT_ERROR_NONE;
1943         account_stmt    hstmt = NULL;
1944         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
1945         int                             rc = 0;
1946         account_s *account_head = NULL;
1947
1948         if (user_name == NULL) {
1949                 _ERR("USER NAME IS NULL");
1950                 *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER;
1951                 goto CATCH;
1952         }
1953
1954         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
1955
1956         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE user_name = ?", ACCOUNT_TABLE);
1957
1958         hstmt = _account_prepare_query(g_hAccountDB, query);
1959
1960         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
1961                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
1962                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
1963                 goto CATCH;
1964         }
1965
1966         int binding_count = 1;
1967         _account_query_bind_text(hstmt, binding_count++, user_name);
1968
1969         rc = _account_query_step(hstmt);
1970
1971         if (rc != SQLITE_ROW) {
1972                 _ERR("The record isn't found");
1973                 *error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
1974                 goto CATCH;
1975         }
1976
1977         int tmp = 0;
1978
1979         account_head = (account_s*) malloc(sizeof(account_s));
1980         if (account_head == NULL) {
1981                 ACCOUNT_FATAL("malloc Failed");
1982                 if (hstmt != NULL) {
1983                         rc = _account_query_finalize(hstmt);
1984                         if (rc != _ACCOUNT_ERROR_NONE) {
1985                                 _ERR("finalize error");
1986                                 *error_code = rc;
1987                                 goto CATCH;
1988                         }
1989                         hstmt = NULL;
1990                 }
1991                 *error_code = _ACCOUNT_ERROR_OUT_OF_MEMORY;
1992                 goto CATCH;
1993         }
1994         ACCOUNT_MEMSET(account_head, 0x00, sizeof(account_s));
1995
1996         while (rc == SQLITE_ROW) {
1997                 account_s* account_record = NULL;
1998
1999                 account_record = (account_s*) malloc(sizeof(account_s));
2000
2001                 if (account_record == NULL) {
2002                         ACCOUNT_FATAL("malloc Failed");
2003                         break;
2004                 }
2005                 ACCOUNT_MEMSET(account_record, 0x00, sizeof(account_s));
2006
2007                 _account_convert_column_to_account(hstmt, account_record);
2008
2009                 account_head->account_list = g_list_append(account_head->account_list, account_record);
2010
2011                 rc = _account_query_step(hstmt);
2012                 tmp++;
2013         }
2014
2015         rc = _account_query_finalize(hstmt);
2016
2017         if (rc != _ACCOUNT_ERROR_NONE) {
2018                 _ERR("finalize error");
2019                 *error_code = rc;
2020                 goto CATCH;
2021         }
2022
2023         hstmt = NULL;
2024
2025         GList *iter;
2026
2027         tmp = g_list_length(account_head->account_list);
2028
2029         for (iter = account_head->account_list; iter != NULL; iter = g_list_next(iter)) {
2030                 //account_h account;
2031                 //account = (account_h)iter->data;
2032
2033                 account_s *testaccount = (account_s*)iter->data;
2034
2035                 _account_query_capability_by_account_id(g_hAccountDB, _account_add_capability_to_account_cb, testaccount->id, (void*)testaccount, false);
2036                 _account_query_custom_by_account_id(g_hAccountDB, _account_add_custom_to_account_cb, testaccount->id, (void*)testaccount, false);
2037         }
2038
2039         *error_code = _ACCOUNT_ERROR_NONE;
2040
2041 CATCH:
2042         if (hstmt != NULL) {
2043                 rc = _account_query_finalize(hstmt);
2044                 if (rc != _ACCOUNT_ERROR_NONE) {
2045                         _ERR("finalize error");
2046                         *error_code = rc;
2047                 }
2048                 hstmt = NULL;
2049         }
2050
2051         pthread_mutex_unlock(&account_mutex);
2052
2053         if (account_head) {
2054                 _remove_sensitive_info_from_non_owning_account_list(account_head->account_list, pid, uid);
2055                 GList* result = account_head->account_list;
2056                 _ACCOUNT_FREE(account_head);
2057                 return result;
2058         }
2059
2060         return NULL;
2061 }
2062
2063 GList*
2064 _account_query_account_by_capability(int pid, uid_t uid, const char* capability_type, const int capability_value, int *error_code)
2065 {
2066         *error_code = _ACCOUNT_ERROR_NONE;
2067         account_stmt    hstmt = NULL;
2068         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
2069         int                             rc = 0;
2070
2071         ACCOUNT_RETURN_VAL((capability_type != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; }, NULL, ("capability_type IS NULL"));
2072
2073         if ((capability_value  < 0) || (capability_value >= _ACCOUNT_CAPABILITY_STATE_MAX)) {
2074                 ACCOUNT_SLOGE("(%s)-(%d) capability_value is not equal to 0 or 1.\n", __FUNCTION__, __LINE__);
2075                 *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER;
2076                 return NULL;
2077         }
2078
2079         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), { *error_code = _ACCOUNT_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
2080
2081         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
2082
2083         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE _id IN (SELECT account_id from %s WHERE key=? AND value=?)", ACCOUNT_TABLE, CAPABILITY_TABLE);
2084
2085         hstmt = _account_prepare_query(g_hAccountDB, query);
2086
2087         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2088                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2089                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
2090                 return NULL;
2091         }
2092
2093         int binding_count = 1;
2094         _account_query_bind_text(hstmt, binding_count++, capability_type);
2095         _account_query_bind_int(hstmt, binding_count++, capability_value);
2096
2097         rc = _account_query_step(hstmt);
2098
2099         account_s* account_head = NULL;
2100
2101         ACCOUNT_CATCH_ERROR_P(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
2102
2103         int tmp = 0;
2104
2105         account_head = (account_s*) malloc(sizeof(account_s));
2106         if (account_head == NULL) {
2107                 ACCOUNT_FATAL("malloc Failed");
2108                 if (hstmt != NULL) {
2109                         rc = _account_query_finalize(hstmt);
2110                         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), { *error_code = rc; }, NULL, ("finalize error"));
2111                         hstmt = NULL;
2112                 }
2113                 *error_code = _ACCOUNT_ERROR_OUT_OF_MEMORY;
2114                 return NULL;
2115         }
2116         ACCOUNT_MEMSET(account_head, 0x00, sizeof(account_s));
2117
2118         while (rc == SQLITE_ROW) {
2119                 account_s* account_record = NULL;
2120
2121                 account_record = (account_s*) malloc(sizeof(account_s));
2122
2123                 if (account_record == NULL) {
2124                         ACCOUNT_FATAL("malloc Failed");
2125                         break;
2126                 }
2127                 ACCOUNT_MEMSET(account_record, 0x00, sizeof(account_s));
2128
2129                 _account_convert_column_to_account(hstmt, account_record);
2130
2131                 account_head->account_list = g_list_append(account_head->account_list, account_record);
2132
2133                 rc = _account_query_step(hstmt);
2134                 tmp++;
2135         }
2136
2137         rc = _account_query_finalize(hstmt);
2138         ACCOUNT_CATCH_ERROR_P((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2139         hstmt = NULL;
2140
2141         GList *iter;
2142
2143
2144         tmp = g_list_length(account_head->account_list);
2145
2146         for (iter = account_head->account_list; iter != NULL; iter = g_list_next(iter)) {
2147                 //account_h account = NULL;
2148                 //account = (account_h)iter->data;
2149                 account_s* testaccount = (account_s*)iter->data;
2150
2151                 _account_query_capability_by_account_id(g_hAccountDB, _account_add_capability_to_account_cb, testaccount->id, (void*)testaccount, false);
2152                 _account_query_custom_by_account_id(g_hAccountDB, _account_add_custom_to_account_cb, testaccount->id, (void*)testaccount, false);
2153
2154         }
2155
2156         *error_code = _ACCOUNT_ERROR_NONE;
2157
2158 CATCH:
2159         if (hstmt != NULL) {
2160                 rc = _account_query_finalize(hstmt);
2161                 if (rc != _ACCOUNT_ERROR_NONE) {
2162                         *error_code = rc;
2163                         _ERR("finalize error");
2164                 }
2165                 hstmt = NULL;
2166         }
2167
2168         if (*error_code != _ACCOUNT_ERROR_NONE && account_head) {
2169                 _account_glist_account_free(account_head->account_list);
2170                 _ACCOUNT_FREE(account_head);
2171                 account_head = NULL;
2172         }
2173
2174         pthread_mutex_unlock(&account_mutex);
2175
2176         if (account_head) {
2177                 _remove_sensitive_info_from_non_owning_account_list(account_head->account_list, pid, uid);
2178                 GList* result = account_head->account_list;
2179                 _ACCOUNT_FREE(account_head);
2180                 return result;
2181         }
2182
2183         return NULL;
2184 }
2185
2186 GList* _account_query_account_by_capability_type(int pid, uid_t uid, const char* capability_type, int *error_code)
2187 {
2188         *error_code = _ACCOUNT_ERROR_NONE;
2189         account_stmt    hstmt = NULL;
2190         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
2191         int                             rc = 0;
2192
2193         ACCOUNT_RETURN_VAL((capability_type != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; }, NULL, ("capability_type IS NULL"));
2194         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), { *error_code = _ACCOUNT_ERROR_DB_NOT_OPENED; },
2195                                            NULL, ("The database isn't connected."));
2196
2197         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
2198
2199         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE _id IN (SELECT account_id from %s WHERE key=?)", ACCOUNT_TABLE, CAPABILITY_TABLE);
2200
2201         hstmt = _account_prepare_query(g_hAccountDB, query);
2202
2203         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2204                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2205                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
2206                 return NULL;
2207         }
2208
2209         int binding_count = 1;
2210         _account_query_bind_text(hstmt, binding_count++, capability_type);
2211
2212         rc = _account_query_step(hstmt);
2213
2214         account_s* account_head = NULL;
2215
2216         ACCOUNT_CATCH_ERROR_P(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
2217
2218         int tmp = 0;
2219
2220         account_head = (account_s*) malloc(sizeof(account_s));
2221         if (account_head == NULL) {
2222                 ACCOUNT_FATAL("malloc Failed");
2223                 if (hstmt != NULL) {
2224                         rc = _account_query_finalize(hstmt);
2225                         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), { *error_code = rc; }, NULL, ("finalize error"));
2226                         hstmt = NULL;
2227                 }
2228                 *error_code = _ACCOUNT_ERROR_OUT_OF_MEMORY;
2229                 return NULL;
2230         }
2231         ACCOUNT_MEMSET(account_head, 0x00, sizeof(account_s));
2232
2233         while (rc == SQLITE_ROW) {
2234                 account_s* account_record = NULL;
2235
2236                 account_record = (account_s*) malloc(sizeof(account_s));
2237
2238                 if (account_record == NULL) {
2239                         ACCOUNT_FATAL("malloc Failed");
2240                         break;
2241                 }
2242                 ACCOUNT_MEMSET(account_record, 0x00, sizeof(account_s));
2243
2244                 _account_convert_column_to_account(hstmt, account_record);
2245
2246                 account_head->account_list = g_list_append(account_head->account_list, account_record);
2247
2248                 rc = _account_query_step(hstmt);
2249                 tmp++;
2250         }
2251
2252         rc = _account_query_finalize(hstmt);
2253         ACCOUNT_CATCH_ERROR_P((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2254         hstmt = NULL;
2255
2256         GList *iter;
2257
2258
2259         tmp = g_list_length(account_head->account_list);
2260
2261         for (iter = account_head->account_list; iter != NULL; iter = g_list_next(iter)) {
2262                 account_s* testaccount = (account_s*)iter->data;
2263
2264                 _account_query_capability_by_account_id(g_hAccountDB, _account_add_capability_to_account_cb, testaccount->id, (void*)testaccount, false);
2265                 _account_query_custom_by_account_id(g_hAccountDB, _account_add_custom_to_account_cb, testaccount->id, (void*)testaccount, false);
2266
2267         }
2268
2269         *error_code = _ACCOUNT_ERROR_NONE;
2270
2271 CATCH:
2272         if (hstmt != NULL) {
2273                 rc = _account_query_finalize(hstmt);
2274                 if (rc != _ACCOUNT_ERROR_NONE) {
2275                         *error_code = rc;
2276                         _ERR("finalize error");
2277                 }
2278                 hstmt = NULL;
2279         }
2280
2281         if ((*error_code != _ACCOUNT_ERROR_NONE) && account_head) {
2282                 _account_glist_account_free(account_head->account_list);
2283                 _ACCOUNT_FREE(account_head);
2284                 account_head = NULL;
2285         }
2286
2287         pthread_mutex_unlock(&account_mutex);
2288
2289         if (account_head) {
2290                 _remove_sensitive_info_from_non_owning_account_list(account_head->account_list, pid, uid);
2291                 GList* result = account_head->account_list;
2292                 _ACCOUNT_FREE(account_head);
2293                 return result;
2294         }
2295
2296         return NULL;
2297 }
2298
2299 GList* account_server_query_account_by_package_name(const char* package_name, int *error_code, int pid, uid_t uid)
2300 {
2301         _INFO("account_server_query_account_by_package_name start");
2302
2303         GList * account_list = NULL;
2304         *error_code = _ACCOUNT_ERROR_NONE;
2305
2306         ACCOUNT_RETURN_VAL((package_name != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; }, NULL, ("PACKAGE NAME IS NULL"));
2307         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), { *error_code = _ACCOUNT_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
2308
2309         account_list = _account_query_account_by_package_name(g_hAccountDB, package_name, error_code, pid, uid);
2310
2311         _INFO("account_server_query_account_by_package_name end");
2312
2313         return account_list;
2314 }
2315
2316 int account_server_delete_account_by_package_name(const char* package_name, bool permission, int pid, uid_t uid)
2317 {
2318         _INFO("account_db_delete_account_by_package_name");
2319
2320         int error_code = _ACCOUNT_ERROR_NONE;
2321
2322         ACCOUNT_RETURN_VAL((package_name != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("PACKAGE NAME IS NULL"));
2323         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2324
2325         error_code = _account_delete_account_by_package_name(g_hAccountDB, package_name, permission, pid, uid);
2326
2327         _INFO("account_server_delete_account_by_package_name end");
2328
2329         return error_code;
2330 }
2331
2332 int _account_delete(int pid, uid_t uid, int account_id)
2333 {
2334         int error_code = _ACCOUNT_ERROR_NONE;
2335         account_stmt    hstmt = NULL;
2336         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
2337         int                             rc = 0;
2338         int                             ret_transaction = 0;
2339         bool                    is_success = FALSE;
2340
2341         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2342
2343         int count = -1;
2344         /* Check requested ID to delete */
2345         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE _id=%d", ACCOUNT_TABLE, account_id);
2346
2347         count = _account_get_record_count(g_hAccountDB, query);
2348
2349         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2350                 pthread_mutex_unlock(&account_mutex);
2351                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2352                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2353         }
2354
2355         if (count <= 0) {
2356                 ACCOUNT_ERROR("account id(%d) is not exist. count(%d)\n", account_id, count);
2357                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
2358         }
2359
2360         /* Check permission of requested appid */
2361         char* current_appid = NULL;
2362         char *package_name = NULL;
2363
2364         current_appid = _account_get_current_appid(pid, uid);
2365
2366         error_code = _account_get_package_name_from_account_id(account_id, &package_name);
2367
2368         if (error_code != _ACCOUNT_ERROR_NONE) {
2369                 ACCOUNT_ERROR("No package name with account_id\n");
2370                 _ACCOUNT_FREE(current_appid);
2371                 _ACCOUNT_FREE(package_name);
2372                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
2373         }
2374         ACCOUNT_DEBUG("DELETE:account_id[%d],current_appid[%s]package_name[%s]", account_id, current_appid, package_name);
2375
2376         error_code = _account_check_appid_group_with_package_name(current_appid, package_name, uid);
2377
2378         _ACCOUNT_FREE(current_appid);
2379         _ACCOUNT_FREE(package_name);
2380
2381         if (error_code != _ACCOUNT_ERROR_NONE) {
2382                 ACCOUNT_ERROR("No permission to delete\n");
2383                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2384         }
2385
2386         /* transaction control required*/
2387         ret_transaction = _account_begin_transaction(g_hAccountDB);
2388
2389         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2390                 pthread_mutex_unlock(&account_mutex);
2391                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2392                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2393         }
2394
2395         if (ret_transaction == _ACCOUNT_ERROR_DATABASE_BUSY) {
2396                 ACCOUNT_ERROR("database busy(%s)", _account_db_err_msg(g_hAccountDB));
2397                 pthread_mutex_unlock(&account_mutex);
2398                 return _ACCOUNT_ERROR_DATABASE_BUSY;
2399         }
2400
2401         if (ret_transaction != _ACCOUNT_ERROR_NONE) {
2402                 ACCOUNT_ERROR("account_delete:_account_begin_transaction fail %d\n", ret_transaction);
2403                 pthread_mutex_unlock(&account_mutex);
2404                 return ret_transaction;
2405         }
2406
2407         /* capability table */
2408         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
2409         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE account_id = %d", CAPABILITY_TABLE, account_id);
2410
2411         hstmt = _account_prepare_query(g_hAccountDB, query);
2412
2413         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2414                 pthread_mutex_unlock(&account_mutex);
2415                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2416                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2417         }
2418
2419         ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, _ACCOUNT_ERROR_DB_FAILED,
2420                         ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg(g_hAccountDB)));
2421
2422         rc = _account_query_step(hstmt);
2423         ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
2424
2425         rc = _account_query_finalize(hstmt);
2426
2427         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2428         hstmt = NULL;
2429
2430         /* account table */
2431         ACCOUNT_MEMSET(query, 0, sizeof(query));
2432         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE _id = %d", ACCOUNT_TABLE, account_id);
2433
2434         hstmt = _account_prepare_query(g_hAccountDB, query);
2435         ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, _ACCOUNT_ERROR_DB_FAILED,
2436                         ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg(g_hAccountDB)));
2437
2438         rc = _account_query_step(hstmt);
2439         ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found. id=%d, rc=%d\n", account_id, rc));
2440
2441         rc = _account_query_finalize(hstmt);
2442         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2443         hstmt = NULL;
2444
2445         /* delete custom data */
2446         ACCOUNT_MEMSET(query, 0, sizeof(query));
2447         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AccountId = %d", ACCOUNT_CUSTOM_TABLE, account_id);
2448
2449         hstmt = _account_prepare_query(g_hAccountDB, query);
2450
2451         ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, _ACCOUNT_ERROR_DB_FAILED,
2452                         ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg(g_hAccountDB)));
2453
2454         rc = _account_query_step(hstmt);
2455         ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found. id=%d, rc=%d\n", account_id, rc));
2456
2457         rc = _account_query_finalize(hstmt);
2458         ACCOUNT_CATCH_ERROR(rc == _ACCOUNT_ERROR_NONE, {}, rc, ("finalize error", account_id, rc));
2459         hstmt = NULL;
2460
2461         is_success = TRUE;
2462
2463 CATCH:
2464         if (hstmt != NULL) {
2465                 rc = _account_query_finalize(hstmt);
2466                 if (rc != _ACCOUNT_ERROR_NONE) {
2467                         ACCOUNT_ERROR("rc (%d)", rc);
2468                         is_success = FALSE;
2469                 }
2470
2471                 hstmt = NULL;
2472         }
2473
2474         ret_transaction = _account_end_transaction(g_hAccountDB, is_success);
2475
2476         if (ret_transaction != _ACCOUNT_ERROR_NONE) {
2477                 ACCOUNT_ERROR("account_delete:_account_end_transaction fail %d, is_success=%d\n", ret_transaction, is_success);
2478         } else {
2479                 if (is_success == true) {
2480                         char buf[64] = {0,};
2481                         ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", _ACCOUNT_NOTI_NAME_DELETE, account_id);
2482                         _account_insert_delete_update_notification_send(buf);
2483                 }
2484         }
2485
2486         pthread_mutex_unlock(&account_mutex);
2487
2488         return error_code;
2489 }
2490
2491 static int _account_query_account_by_username_and_package(const char* username, const char* package_name, account_s *account)
2492 {
2493         //FIXME
2494         //return -1;
2495         int                             error_code = _ACCOUNT_ERROR_NONE;
2496         account_stmt    hstmt = NULL;
2497         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
2498         int                             rc = 0;
2499         int                             binding_count = 1;
2500
2501         ACCOUNT_RETURN_VAL((username != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("username IS NULL"));
2502         ACCOUNT_RETURN_VAL((package_name != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("package_name IS NULL"));
2503         ACCOUNT_RETURN_VAL((account != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT IS NULL"));
2504         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2505
2506         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
2507
2508         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE user_name = ? and package_name = ?", ACCOUNT_TABLE);
2509         hstmt = _account_prepare_query(g_hAccountDB, query);
2510
2511         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2512                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2513                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2514         }
2515
2516         _account_query_bind_text(hstmt, binding_count++, username);
2517         _account_query_bind_text(hstmt, binding_count++, package_name);
2518
2519         rc = _account_query_step(hstmt);
2520         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
2521
2522         account_s *account_record = account;
2523
2524         while (rc == SQLITE_ROW) {
2525                 _account_convert_column_to_account(hstmt, account_record);
2526                 rc = _account_query_step(hstmt);
2527         }
2528
2529         rc = _account_query_finalize(hstmt);
2530         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2531         _account_query_capability_by_account_id(g_hAccountDB, _account_add_capability_to_account_cb, account_record->id, (void*)account_record, false);
2532         _account_query_custom_by_account_id(g_hAccountDB, _account_add_custom_to_account_cb, account_record->id, (void*)account_record, false);
2533
2534         hstmt = NULL;
2535         error_code = _ACCOUNT_ERROR_NONE;
2536
2537 CATCH:
2538         if (hstmt != NULL) {
2539                 rc = _account_query_finalize(hstmt);
2540                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2541                 hstmt = NULL;
2542         }
2543
2544         pthread_mutex_unlock(&account_mutex);
2545
2546         return error_code;
2547 }
2548
2549 int _account_create(account_s **account)
2550 {
2551         if (!account) {
2552                 ACCOUNT_SLOGE("(%s)-(%d) account is NULL.\n", __FUNCTION__, __LINE__);
2553                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
2554         }
2555
2556         account_s *data = (account_s*)malloc(sizeof(account_s));
2557
2558         if (data == NULL) {
2559                 ACCOUNT_FATAL("Memory Allocation Failed");
2560                 return _ACCOUNT_ERROR_OUT_OF_MEMORY;
2561         }
2562         ACCOUNT_MEMSET(data, 0, sizeof(account_s));
2563
2564         /*Setting account as visible by default*/
2565         //data->secret = _ACCOUNT_SECRECY_VISIBLE;
2566
2567         /*Setting account as not supporting sync by default*/
2568         //data->sync_support = _ACCOUNT_SYNC_NOT_SUPPORT;
2569
2570         *account = data;
2571
2572         return _ACCOUNT_ERROR_NONE;
2573 }
2574
2575 int _account_destroy(account_s *account)
2576 {
2577         account_s *data = account;
2578
2579         ACCOUNT_RETURN_VAL((data != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Account handle is null!"));
2580
2581         _account_free_account_with_items(data);
2582
2583         return _ACCOUNT_ERROR_NONE;
2584 }
2585
2586 int _account_get_account_id(account_s* account, int *account_id)
2587 {
2588         if (!account)
2589                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
2590
2591         if (!account_id)
2592                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
2593
2594         *account_id = account->id;
2595
2596         return _ACCOUNT_ERROR_NONE;
2597 }
2598
2599 int _account_delete_from_db_by_user_name(int pid, uid_t uid, const char *user_name, const char *package_name)
2600 {
2601         _INFO("[%s][%s]", user_name, package_name);
2602
2603         int                             error_code = _ACCOUNT_ERROR_NONE;
2604         account_stmt    hstmt = NULL;
2605         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
2606         int                             rc = 0;
2607         int                             ret_transaction = 0;
2608         bool                    is_success = FALSE;
2609         account_s               *account = NULL;
2610         int                             binding_count = 1;
2611         int                             account_id = -1;
2612
2613         ACCOUNT_RETURN_VAL((user_name != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("user_name is null!"));
2614         ACCOUNT_RETURN_VAL((package_name != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("package_name is null!"));
2615         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
2616
2617         /* Check permission of requested appid */
2618         char* current_appid = NULL;
2619         char* package_name_temp = NULL;
2620
2621         current_appid = _account_get_current_appid(pid, uid);
2622
2623         package_name_temp = _account_dup_text(package_name);
2624
2625         ACCOUNT_DEBUG("DELETE:user_name[%s],current_appid[%s], package_name[%s]", user_name, current_appid, package_name_temp);
2626
2627         error_code = _account_check_appid_group_with_package_name(current_appid, package_name_temp, uid);
2628
2629         _ACCOUNT_FREE(current_appid);
2630         _ACCOUNT_FREE(package_name_temp);
2631
2632         if (error_code != _ACCOUNT_ERROR_NONE) {
2633                 ACCOUNT_ERROR("No permission to delete\n");
2634                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2635         }
2636
2637         rc = _account_create(&account);
2638         rc = _account_query_account_by_username_and_package(user_name, package_name, account);
2639
2640         _INFO("");
2641
2642         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2643                 _account_destroy(account);
2644                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2645                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2646         }
2647
2648         _INFO("");
2649         account_s* account_data = (account_s*)account;
2650
2651         rc = _account_get_account_id(account_data, &account_id);
2652
2653         rc = _account_destroy(account);
2654
2655         /* transaction control required*/
2656         ret_transaction = _account_begin_transaction(g_hAccountDB);
2657
2658         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2659                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2660                 pthread_mutex_unlock(&account_mutex);
2661                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2662         }
2663
2664         _INFO("");
2665         if (ret_transaction == _ACCOUNT_ERROR_DATABASE_BUSY) {
2666                 ACCOUNT_ERROR("database busy(%s)", _account_db_err_msg(g_hAccountDB));
2667                 pthread_mutex_unlock(&account_mutex);
2668                 return _ACCOUNT_ERROR_DATABASE_BUSY;
2669         } else if (ret_transaction != _ACCOUNT_ERROR_NONE) {
2670                 ACCOUNT_ERROR("account_delete:_account_begin_transaction fail %d\n", ret_transaction);
2671                 pthread_mutex_unlock(&account_mutex);
2672                 return ret_transaction;
2673         }
2674
2675         /* delete custom data */
2676         ACCOUNT_MEMSET(query, 0, sizeof(query));
2677         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AccountId = ?", ACCOUNT_CUSTOM_TABLE);
2678
2679         hstmt = _account_prepare_query(g_hAccountDB, query);
2680
2681         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2682                 _account_end_transaction(g_hAccountDB, FALSE);
2683                 pthread_mutex_unlock(&account_mutex);
2684                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2685                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2686         }
2687
2688         ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, _ACCOUNT_ERROR_DB_FAILED,
2689                         ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg(g_hAccountDB)));
2690
2691         _account_query_bind_int(hstmt, binding_count++, account_id);
2692
2693         rc = _account_query_step(hstmt);
2694         ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
2695
2696         rc = _account_query_finalize(hstmt);
2697         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2698         hstmt = NULL;
2699
2700         /* delete capability */
2701         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE user_name = ? and package_name = ?", CAPABILITY_TABLE);
2702
2703         hstmt = _account_prepare_query(g_hAccountDB, query);
2704
2705         ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, _ACCOUNT_ERROR_DB_FAILED,
2706                         ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg(g_hAccountDB)));
2707
2708         binding_count = 1;
2709         _account_query_bind_text(hstmt, binding_count++, user_name);
2710         _account_query_bind_text(hstmt, binding_count++, package_name);
2711
2712         rc = _account_query_step(hstmt);
2713         ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
2714
2715         rc = _account_query_finalize(hstmt);
2716         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2717         hstmt = NULL;
2718
2719         ACCOUNT_MEMSET(query, 0, sizeof(query));
2720
2721         _INFO("");
2722         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE user_name = ? and package_name = ?", ACCOUNT_TABLE);
2723
2724         hstmt = _account_prepare_query(g_hAccountDB, query);
2725         ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, _ACCOUNT_ERROR_DB_FAILED,
2726                         ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg(g_hAccountDB)));
2727
2728         _INFO("");
2729         binding_count = 1;
2730         _account_query_bind_text(hstmt, binding_count++, user_name);
2731         _account_query_bind_text(hstmt, binding_count++, package_name);
2732
2733         rc = _account_query_step(hstmt);
2734         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));
2735
2736         rc = _account_query_finalize(hstmt);
2737         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2738         is_success = TRUE;
2739
2740         hstmt = NULL;
2741
2742 CATCH:
2743         if (hstmt != NULL) {
2744                 rc = _account_query_finalize(hstmt);
2745                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
2746                 hstmt = NULL;
2747         }
2748
2749         ret_transaction = _account_end_transaction(g_hAccountDB, is_success);
2750
2751         if (ret_transaction != _ACCOUNT_ERROR_NONE) {
2752                 ACCOUNT_ERROR("account_svc_delete:_account_svc_end_transaction fail %d, is_success=%d\n", ret_transaction, is_success);
2753         } else {
2754                 if (is_success == true) {
2755                         char buf[64] = {0,};
2756                         ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", _ACCOUNT_NOTI_NAME_DELETE, account_id);
2757                         _account_insert_delete_update_notification_send(buf);
2758                 }
2759         }
2760
2761         pthread_mutex_unlock(&account_mutex);
2762
2763         return error_code;
2764 }
2765
2766
2767 int _account_get_total_count_from_db(gboolean include_hidden, int *count)
2768 {
2769         if (!count) {
2770                 ACCOUNT_SLOGE("(%s)-(%d) count is NULL.\n", __FUNCTION__, __LINE__);
2771                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
2772         }
2773
2774         if (!g_hAccountDB) {
2775                 ACCOUNT_ERROR("DB is not opened\n");
2776                 return _ACCOUNT_ERROR_DB_NOT_OPENED;
2777         }
2778
2779         char query[1024] = {0, };
2780         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
2781
2782         if (include_hidden)
2783                 ACCOUNT_SNPRINTF(query, sizeof(query), "select count(*) from %s", ACCOUNT_TABLE);
2784         else
2785                 ACCOUNT_SNPRINTF(query, sizeof(query), "select count(*) from %s where secret = %d", ACCOUNT_TABLE, _ACCOUNT_SECRECY_VISIBLE);
2786
2787         *count = _account_get_record_count(g_hAccountDB, query);
2788
2789         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2790                 pthread_mutex_unlock(&account_mutex);
2791                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2792                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
2793         }
2794
2795         int rc = -1;
2796         int ncount = 0;
2797         account_stmt pStmt = NULL;
2798
2799         rc = sqlite3_prepare_v2(g_hAccountDB, query, strlen(query), &pStmt, NULL);
2800         if (SQLITE_OK != rc) {
2801                 ACCOUNT_SLOGE("sqlite3_prepare_v2() failed(%d, %s).", rc, _account_db_err_msg(g_hAccountDB));
2802                 sqlite3_finalize(pStmt);
2803                 return _ACCOUNT_ERROR_DB_FAILED;
2804         }
2805
2806         rc = sqlite3_step(pStmt);
2807         if (SQLITE_ROW != rc) {
2808                 ACCOUNT_ERROR("[ERROR] sqlite3_step() failed\n");
2809                 sqlite3_finalize(pStmt);
2810                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
2811         }
2812
2813         ncount = sqlite3_column_int(pStmt, 0);
2814
2815         *count = ncount;
2816
2817         sqlite3_finalize(pStmt);
2818
2819         if (ncount < 0) {
2820                 ACCOUNT_ERROR("[ERROR] Number of account : %d, End", ncount);
2821                 return _ACCOUNT_ERROR_DB_FAILED;
2822         }
2823
2824         return _ACCOUNT_ERROR_NONE;
2825 }
2826
2827
2828 int account_server_query_app_id_exist(const char* app_id)
2829 {
2830         _INFO("account_server_query_app_id_exist start app_id=[%s]", app_id);
2831         int ret = _ACCOUNT_ERROR_NONE;
2832
2833         ret = _account_type_query_app_id_exist_from_all_db(g_hAccountDB, g_hAccountGlobalDB, app_id);
2834
2835         _INFO("account_server_query_app_id_exist end error_code=[%d]", ret);
2836
2837         return ret;
2838 }
2839
2840 int account_server_insert_account_type_to_user_db(account_type_s *account_type, int *account_type_id, uid_t uid)
2841 {
2842         ACCOUNT_RETURN_VAL((account_type != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT TYPE HANDLE IS NULL"));
2843         ACCOUNT_RETURN_VAL((account_type->app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID OF ACCOUNT TYPE IS NULL"));
2844         ACCOUNT_RETURN_VAL((account_type_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT TYPE ID IS NULL"));
2845
2846         _INFO("account_server_insert_account_type_to_user_db start uid=[%d]", uid);
2847         int ret = _ACCOUNT_ERROR_NONE;
2848
2849         if (_account_type_check_duplicated(g_hAccountDB, account_type->app_id) ||
2850                         _account_type_check_duplicated(g_hAccountGlobalDB, account_type->app_id)) {
2851                 *account_type_id = -1;
2852                 return _ACCOUNT_ERROR_DUPLICATED;
2853         }
2854
2855         ret = _account_type_insert_to_db(g_hAccountDB, account_type, account_type_id);
2856         _INFO("account_server_insert_account_type_to_user_db end error_code=[%d]", ret);
2857
2858         return ret;
2859 }
2860
2861 int account_server_delete_account_type_by_app_id_from_user_db(const char * app_id)
2862 {
2863         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID OF ACCOUNT TYPE IS NULL"));
2864
2865         _INFO("account_server_delete_account_type_by_app_id_from_user_db start");
2866         int ret = _ACCOUNT_ERROR_NONE;
2867
2868         ret = _account_type_delete_by_app_id(g_hAccountDB, app_id);
2869         _INFO("account_server_delete_account_type_by_app_id_from_user_db end error_code=[%d]", ret);
2870
2871         return ret;
2872 }
2873
2874 GSList* _account_type_query_provider_feature_by_app_id_from_global_db(const char* app_id, int *error_code)
2875 {
2876         _INFO("_account_type_query_provider_feature_by_app_id_in_global_db app_id=%s", app_id);
2877         account_stmt hstmt = NULL;
2878         char query[ACCOUNT_SQL_LEN_MAX] = {0, };
2879         int rc = 0, binding_count = 1;
2880         GSList* feature_list = NULL;
2881
2882         ACCOUNT_RETURN_VAL((app_id != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; }, NULL, ("APP ID IS NULL"));
2883         ACCOUNT_RETURN_VAL((error_code != NULL), {_ERR("error_code pointer is NULL"); }, NULL, (""));
2884         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; _ERR("The database isn't connected."); }, NULL, ("The database isn't connected."));
2885
2886         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
2887
2888         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE app_id = ?", PROVIDER_FEATURE_TABLE);
2889         _INFO("account query=[%s]", query);
2890
2891         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
2892
2893         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
2894                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2895                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
2896                 return NULL;
2897         }
2898
2899         _INFO("before _account_query_bind_text");
2900         _account_query_bind_text(hstmt, binding_count++, app_id);
2901
2902         rc = _account_query_step(hstmt);
2903
2904         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"));
2905
2906         provider_feature_s* feature_record = NULL;
2907
2908         while (rc == SQLITE_ROW) {
2909
2910                 feature_record = (provider_feature_s*) malloc(sizeof(provider_feature_s));
2911
2912                 if (feature_record == NULL) {
2913                         ACCOUNT_FATAL("malloc Failed");
2914                         break;
2915                 }
2916
2917                 ACCOUNT_MEMSET(feature_record, 0x00, sizeof(provider_feature_s));
2918
2919                 _account_type_convert_column_to_provider_feature(hstmt, feature_record);
2920
2921                 _INFO("Adding account feature_list");
2922                 feature_list = g_slist_append(feature_list, feature_record);
2923
2924                 rc = _account_query_step(hstmt);
2925         }
2926
2927         *error_code = _ACCOUNT_ERROR_NONE;
2928
2929 CATCH:
2930         if (hstmt != NULL) {
2931                 rc = _account_query_finalize(hstmt);
2932                 if (rc != _ACCOUNT_ERROR_NONE) {
2933                         *error_code = rc;
2934                         _ERR("global db fianlize error");
2935                 }
2936         }
2937
2938         if (*error_code != _ACCOUNT_ERROR_NONE)
2939                 _account_type_gslist_feature_free(feature_list);
2940
2941         _INFO("Returning account feature_list from global db");
2942
2943         return feature_list;
2944 }
2945
2946 GSList* _account_type_query_provider_feature_by_app_id(const char* app_id, int *error_code)
2947 {
2948         _INFO("_account_type_query_provider_feature_by_app_id app_id=%s", app_id);
2949         account_stmt hstmt = NULL;
2950         char query[ACCOUNT_SQL_LEN_MAX] = {0, };
2951         int rc = 0, binding_count = 1;
2952         GSList* feature_list = NULL;
2953
2954         ACCOUNT_RETURN_VAL((app_id != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; }, NULL, ("APP ID IS NULL"));
2955         ACCOUNT_RETURN_VAL((error_code != NULL), {_ERR("error_code pointer is NULL"); }, NULL, (""));
2956         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), { *error_code = _ACCOUNT_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
2957
2958         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
2959
2960         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE app_id = ?", PROVIDER_FEATURE_TABLE);
2961         _INFO("account query=[%s]", query);
2962
2963         hstmt = _account_prepare_query(g_hAccountDB, query);
2964
2965         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
2966                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
2967                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
2968                 return NULL;
2969         }
2970
2971         _account_query_bind_text(hstmt, binding_count++, app_id);
2972
2973         rc = _account_query_step(hstmt);
2974
2975         ACCOUNT_CATCH_ERROR_P(rc == SQLITE_ROW, { *error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
2976                         _ERR("The record isn't found from user db. rc=[%d]", rc); },
2977                                 _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
2978
2979         provider_feature_s* feature_record = NULL;
2980
2981         while (rc == SQLITE_ROW) {
2982
2983                 feature_record = (provider_feature_s*) malloc(sizeof(provider_feature_s));
2984
2985                 if (feature_record == NULL) {
2986                         ACCOUNT_FATAL("malloc Failed");
2987                         break;
2988                 }
2989
2990                 ACCOUNT_MEMSET(feature_record, 0x00, sizeof(provider_feature_s));
2991
2992                 _account_type_convert_column_to_provider_feature(hstmt, feature_record);
2993
2994                 _INFO("Adding account feature_list");
2995                 feature_list = g_slist_append(feature_list, feature_record);
2996
2997                 rc = _account_query_step(hstmt);
2998         }
2999
3000         *error_code = _ACCOUNT_ERROR_NONE;
3001
3002         rc = _account_query_finalize(hstmt);
3003         ACCOUNT_CATCH_ERROR_P((rc == _ACCOUNT_ERROR_NONE), { *error_code = rc; }, rc, ("account finalize error"));
3004         hstmt = NULL;
3005
3006 CATCH:
3007         if (hstmt != NULL) {
3008                 rc = _account_query_finalize(hstmt);
3009                 if (rc != _ACCOUNT_ERROR_NONE) {
3010                         *error_code = rc;
3011                         _ERR("account fianlize error");
3012                 }
3013                 hstmt = NULL;
3014         }
3015         _INFO("*error_code=[%d]", *error_code);
3016
3017         if (*error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND)
3018                 feature_list = _account_type_query_provider_feature_by_app_id_from_global_db(app_id, error_code);
3019
3020         if (*error_code != _ACCOUNT_ERROR_NONE) {
3021                 _account_type_gslist_feature_free(feature_list);
3022                 return NULL;
3023         }
3024
3025         _INFO("Returning account feature_list");
3026
3027         return feature_list;
3028 }
3029
3030 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)
3031 {
3032         int                             error_code = _ACCOUNT_ERROR_NONE;
3033         account_stmt    hstmt = NULL;
3034         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3035         int                             rc = 0, binding_count = 1;
3036
3037         _INFO("_account_type_query_provider_feature_cb_by_app_id_in_global_db start app_id=%s", app_id);
3038         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3039         ACCOUNT_RETURN_VAL((callback != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION"));
3040         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3041
3042         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3043
3044         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE app_id = ?", PROVIDER_FEATURE_TABLE);
3045         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
3046
3047         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
3048                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
3049                 ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_PERMISSION_DENIED, ("global db permission denied.\n"));
3050         }
3051
3052         _account_query_bind_text(hstmt, binding_count++, app_id);
3053
3054         rc = _account_query_step(hstmt);
3055         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"));
3056
3057         provider_feature_s* feature_record = NULL;
3058
3059         while (rc == SQLITE_ROW) {
3060                 bool cb_ret = FALSE;
3061                 feature_record = (provider_feature_s*) malloc(sizeof(provider_feature_s));
3062
3063                 if (feature_record == NULL) {
3064                         ACCOUNT_FATAL("malloc Failed");
3065                         break;
3066                 }
3067
3068                 ACCOUNT_MEMSET(feature_record, 0x00, sizeof(provider_feature_s));
3069
3070                 _account_type_convert_column_to_provider_feature(hstmt, feature_record);
3071
3072                 cb_ret = callback(feature_record->app_id, feature_record->key, user_data);
3073
3074                 _account_type_free_feature_with_items(feature_record);
3075
3076                 ACCOUNT_CATCH_ERROR(cb_ret == TRUE, {}, _ACCOUNT_ERROR_NONE, ("Callback func returns FALSE, its iteration is stopped!!!!\n"));
3077
3078                 rc = _account_query_step(hstmt);
3079         }
3080
3081         error_code = _ACCOUNT_ERROR_NONE;
3082
3083 CATCH:
3084         if (hstmt != NULL) {
3085                 rc = _account_query_finalize(hstmt);
3086                 if (rc != _ACCOUNT_ERROR_NONE) {
3087                         error_code = rc;
3088                         _ERR("global db finalize error[%d]", rc);
3089                 }
3090                 hstmt = NULL;
3091         }
3092
3093         _INFO("_account_type_query_provider_feature_cb_by_app_id_in_global_db end. error_code=[%d]", error_code);
3094
3095         return error_code;
3096 }
3097
3098 int _account_type_query_provider_feature_cb_by_app_id(account_type_provider_feature_cb callback, const char* app_id, void *user_data)
3099 {
3100         int                             error_code = _ACCOUNT_ERROR_NONE;
3101         account_stmt    hstmt = NULL;
3102         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3103         int                             rc = 0, binding_count = 1;
3104
3105         _INFO("_account_type_query_provider_feature_cb_by_app_id start app_id=%s", app_id);
3106         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3107         ACCOUNT_RETURN_VAL((callback != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION"));
3108         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3109
3110         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3111
3112         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE app_id = ?", PROVIDER_FEATURE_TABLE);
3113         hstmt = _account_prepare_query(g_hAccountDB, query);
3114
3115         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
3116                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
3117                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
3118         }
3119
3120         _account_query_bind_text(hstmt, binding_count++, app_id);
3121
3122         rc = _account_query_step(hstmt);
3123         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found in user db.\n"));
3124
3125         provider_feature_s* feature_record = NULL;
3126
3127         while (rc == SQLITE_ROW) {
3128                 bool cb_ret = FALSE;
3129                 feature_record = (provider_feature_s*) malloc(sizeof(provider_feature_s));
3130
3131                 if (feature_record == NULL) {
3132                         ACCOUNT_FATAL("malloc Failed");
3133                         break;
3134                 }
3135
3136                 ACCOUNT_MEMSET(feature_record, 0x00, sizeof(provider_feature_s));
3137
3138                 _account_type_convert_column_to_provider_feature(hstmt, feature_record);
3139
3140                 cb_ret = callback(feature_record->app_id, feature_record->key, user_data);
3141
3142                 _account_type_free_feature_with_items(feature_record);
3143
3144                 ACCOUNT_CATCH_ERROR(cb_ret == TRUE, {}, _ACCOUNT_ERROR_NONE, ("Callback func returs FALSE, its iteration is stopped!!!!\n"));
3145
3146                 rc = _account_query_step(hstmt);
3147         }
3148
3149         rc = _account_query_finalize(hstmt);
3150         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3151         hstmt = NULL;
3152
3153         error_code = _ACCOUNT_ERROR_NONE;
3154
3155 CATCH:
3156         if (hstmt != NULL) {
3157                 rc = _account_query_finalize(hstmt);
3158                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3159                 hstmt = NULL;
3160         }
3161 /*
3162         if (error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND)
3163                 error_code = _account_type_query_provider_feature_cb_by_app_id_from_global_db(callback, app_id, user_data);
3164 */
3165         _INFO("_account_type_query_provider_feature_cb_by_app_id end");
3166
3167         return error_code;
3168 }
3169
3170 int account_type_query_provider_feature_cb_by_app_id(account_type_provider_feature_cb callback, const char* app_id, void *user_data)
3171 {
3172         int                             error_code = _ACCOUNT_ERROR_NONE;
3173
3174         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3175         ACCOUNT_RETURN_VAL((callback != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION"));
3176         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3177
3178         error_code = _account_type_query_provider_feature_cb_by_app_id(callback, app_id, user_data);
3179
3180         if (error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND)
3181                 error_code = _account_type_query_provider_feature_cb_by_app_id_from_global_db(callback, app_id, user_data);
3182
3183         return error_code;
3184 }
3185
3186 bool _account_type_query_supported_feature_from_global_db(const char* app_id, const char* capability, int *error_code)
3187 {
3188         _INFO("_account_type_query_supported_feature_in_global_db start");
3189         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3190
3191         *error_code = _ACCOUNT_ERROR_NONE;
3192
3193         char query[ACCOUNT_SQL_LEN_MAX] = {0, };
3194         int record_count = 0;
3195
3196         if (app_id == NULL || capability == NULL) {
3197                 *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER;
3198                 return false;
3199         }
3200
3201         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s where app_id='%s' and key='%s'", PROVIDER_FEATURE_TABLE, app_id, capability);
3202
3203         record_count = _account_get_record_count(g_hAccountGlobalDB, query);
3204
3205         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
3206                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
3207                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
3208         }
3209
3210         if (record_count <= 0) {
3211                 *error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
3212                 return false;
3213         }
3214
3215         _INFO("_account_type_query_supported_feature_in_global_db end");
3216
3217         return true;
3218 }
3219
3220 bool _account_type_query_supported_feature(const char* app_id, const char* capability, int *error_code)
3221 {
3222         _INFO("_account_type_query_supported_feature start");
3223
3224         *error_code = _ACCOUNT_ERROR_NONE;
3225
3226         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3227         int                             record_count = 0;
3228
3229         if (app_id == NULL || capability == NULL) {
3230                 *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER;
3231                 return false;
3232         }
3233
3234         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s where app_id='%s' and key='%s'", PROVIDER_FEATURE_TABLE, app_id, capability);
3235
3236         record_count = _account_get_record_count(g_hAccountDB, query);
3237
3238         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
3239                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
3240                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
3241                 return false;
3242         }
3243
3244         if (record_count <= 0) {
3245                 bool is_exist = false;
3246                 is_exist = _account_type_query_supported_feature_from_global_db(app_id, capability, error_code);
3247                 if (!is_exist)
3248                         return false;
3249         }
3250
3251         _INFO("_account_type_query_supported_feature end");
3252
3253         return true;
3254 }
3255
3256
3257 static int _account_type_update_provider_feature(sqlite3 *account_db_handle, account_type_s *account_type, const char* app_id)
3258 {
3259         int                             rc, count = 1;
3260         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3261         account_stmt    hstmt = NULL;
3262
3263         ACCOUNT_RETURN_VAL((account_type != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL"));
3264
3265         if (g_slist_length(account_type->provider_feature_list) == 0) {
3266                 ACCOUNT_ERROR("no feature\n");
3267                 return _ACCOUNT_ERROR_NONE;
3268         }
3269
3270         ACCOUNT_DEBUG("app id", app_id);
3271
3272         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
3273
3274         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE app_id=? ", PROVIDER_FEATURE_TABLE);
3275         hstmt = _account_prepare_query(account_db_handle, query);
3276
3277         if (_account_db_err_code(account_db_handle) == SQLITE_PERM) {
3278                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(account_db_handle));
3279                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
3280         }
3281
3282         count = 1;
3283         _account_query_bind_text(hstmt, count++, app_id);
3284         rc = _account_query_step(hstmt);
3285
3286         if (rc != SQLITE_DONE) {
3287                 ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(account_db_handle));
3288                 return _ACCOUNT_ERROR_DB_FAILED;
3289         }
3290         rc = _account_query_finalize(hstmt);
3291         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3292         hstmt = NULL;
3293
3294         GSList *iter;
3295
3296         for (iter = account_type->provider_feature_list; iter != NULL; iter = g_slist_next(iter)) {
3297                 int ret;
3298                 count = 1;
3299                 ACCOUNT_MEMSET(query, 0x00, sizeof(query));
3300                 ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(app_id, key) VALUES "
3301                                 "(?, ?) ", PROVIDER_FEATURE_TABLE);
3302
3303                 hstmt = _account_prepare_query(account_db_handle, query);
3304
3305                 ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query() failed(%s).\n", _account_db_err_msg(account_db_handle)));
3306
3307                 provider_feature_s* feature_data = NULL;
3308                 feature_data = (provider_feature_s*)iter->data;
3309
3310                 ret = _account_query_bind_text(hstmt, count++, account_type->app_id);
3311                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
3312                 ret = _account_query_bind_text(hstmt, count++, feature_data->key);
3313                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
3314
3315                 rc = _account_query_step(hstmt);
3316
3317                 if (rc != SQLITE_DONE) {
3318                         ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(account_db_handle));
3319                         break;
3320                 }
3321                 rc = _account_query_finalize(hstmt);
3322                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3323                 hstmt = NULL;
3324         }
3325
3326         return _ACCOUNT_ERROR_NONE;
3327 }
3328
3329 static int _account_type_update_label(sqlite3 *account_db_handle, account_type_s *account_type, const char* app_id)
3330 {
3331         int                             rc, count = 1;
3332         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3333         account_stmt    hstmt = NULL;
3334
3335         ACCOUNT_RETURN_VAL((account_type != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL"));
3336
3337         if (g_slist_length(account_type->label_list) == 0)
3338                 return _ACCOUNT_ERROR_NONE;
3339
3340         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
3341
3342         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AppId=? ", LABEL_TABLE);
3343         hstmt = _account_prepare_query(account_db_handle, query);
3344
3345         if (_account_db_err_code(account_db_handle) == SQLITE_PERM) {
3346                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(account_db_handle));
3347                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
3348         }
3349
3350         count = 1;
3351         _account_query_bind_text(hstmt, count++, app_id);
3352         rc = _account_query_step(hstmt);
3353
3354         if (rc != SQLITE_DONE) {
3355                 ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(account_db_handle));
3356                 return _ACCOUNT_ERROR_DB_FAILED;
3357         }
3358         rc = _account_query_finalize(hstmt);
3359         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3360         hstmt = NULL;
3361
3362         GSList *iter;
3363
3364         for (iter = account_type->label_list; iter != NULL; iter = g_slist_next(iter)) {
3365                 int ret;
3366                 count = 1;
3367                 ACCOUNT_MEMSET(query, 0x00, sizeof(query));
3368                 ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(AppId, Label, Locale) VALUES "
3369                                 "(?, ?, ?) ", LABEL_TABLE);
3370
3371                 hstmt = _account_prepare_query(account_db_handle, query);
3372
3373                 ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query() failed(%s).\n", _account_db_err_msg(account_db_handle)));
3374
3375                 label_s* label_data = NULL;
3376                 label_data = (label_s*)iter->data;
3377
3378                 ret = _account_query_bind_text(hstmt, count++, account_type->app_id);
3379                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
3380                 ret = _account_query_bind_text(hstmt, count++, label_data->label);
3381                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
3382                 ret = _account_query_bind_text(hstmt, count++, label_data->locale);
3383                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
3384
3385                 rc = _account_query_step(hstmt);
3386
3387                 if (rc != SQLITE_DONE) {
3388                         ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(account_db_handle));
3389                         break;
3390                 }
3391                 rc = _account_query_finalize(hstmt);
3392                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3393                 hstmt = NULL;
3394         }
3395
3396         return _ACCOUNT_ERROR_NONE;
3397 }
3398
3399
3400 static int _account_type_update_account(sqlite3 *account_db_handle, account_type_s *account_type, const char* app_id)
3401 {
3402         int                             rc = 0, binding_count = 1;
3403         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3404         int                             error_code = _ACCOUNT_ERROR_NONE;
3405         account_stmt    hstmt = NULL;
3406
3407         if (!account_type->app_id) {
3408                 ACCOUNT_ERROR("app id is mandetory field, it can not be NULL!!!!\n");
3409                 return _ACCOUNT_ERROR_INVALID_PARAMETER;
3410         }
3411
3412         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
3413         ACCOUNT_SNPRINTF(query, sizeof(query), "UPDATE %s SET AppId=?, ServiceProviderId=?, IconPath=?, "
3414                         "SmallIconPath=?, MultipleAccountSupport=? WHERE AppId=? ", ACCOUNT_TYPE_TABLE);
3415
3416         hstmt = _account_prepare_query(account_db_handle, query);
3417
3418         if (_account_db_err_code(account_db_handle) == SQLITE_PERM) {
3419                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(account_db_handle));
3420                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
3421         } else if (_account_db_err_code(account_db_handle) == SQLITE_BUSY) {
3422                 ACCOUNT_ERROR("database busy(%s)", _account_db_err_msg(account_db_handle));
3423                 return _ACCOUNT_ERROR_DATABASE_BUSY;
3424         }
3425
3426         ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_svc_query_prepare() failed(%s).\n", _account_db_err_msg(account_db_handle)));
3427
3428         binding_count = _account_type_convert_account_to_sql(account_type, hstmt, query);
3429         _account_query_bind_text(hstmt, binding_count++, app_id);
3430
3431         rc = _account_query_step(hstmt);
3432         if (rc != SQLITE_DONE)
3433                 ACCOUNT_ERROR("account_db_query_step() failed(%d, %s)", rc, _account_db_err_msg(account_db_handle));
3434
3435         rc = _account_query_finalize(hstmt);
3436         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3437         hstmt = NULL;
3438
3439         /*update label*/
3440         error_code = _account_type_update_label(account_db_handle, account_type, app_id);
3441         /* update provider feature */
3442         error_code = _account_type_update_provider_feature(account_db_handle, account_type, app_id);
3443
3444         return error_code;
3445 }
3446
3447 int _account_type_update_to_db_by_app_id(account_type_s* account_type, const char* app_id)
3448 {
3449         int     error_code = _ACCOUNT_ERROR_NONE;
3450
3451         ACCOUNT_RETURN_VAL((account_type != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("DATA IS NULL"));
3452         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3453         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3454
3455         account_type_s* data = account_type;
3456
3457         pthread_mutex_lock(&account_mutex);
3458
3459         error_code = _account_type_update_account(g_hAccountDB, data, app_id);
3460
3461         pthread_mutex_unlock(&account_mutex);
3462
3463         return error_code;
3464 }
3465
3466 GSList* _account_type_get_label_list_by_app_id_from_global_db(const char* app_id, int *error_code)
3467 {
3468         *error_code = _ACCOUNT_ERROR_NONE;
3469         account_stmt    hstmt = NULL;
3470         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3471         int                             rc = 0, binding_count = 1;
3472         GSList* label_list = NULL;
3473
3474         ACCOUNT_RETURN_VAL((app_id != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; }, NULL, ("APP ID IS NULL"));
3475         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3476
3477         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3478
3479         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ?", LABEL_TABLE);
3480         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
3481
3482         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
3483                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
3484                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
3485
3486                 goto CATCH;
3487         }
3488
3489         _account_query_bind_text(hstmt, binding_count++, app_id);
3490
3491         rc = _account_query_step(hstmt);
3492         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"));
3493
3494         label_s* label_record = NULL;
3495
3496         while (rc == SQLITE_ROW) {
3497                 label_record = (label_s*) malloc(sizeof(label_s));
3498
3499                 if (label_record == NULL) {
3500                         ACCOUNT_FATAL("malloc Failed");
3501                         break;
3502                 }
3503
3504                 ACCOUNT_MEMSET(label_record, 0x00, sizeof(label_s));
3505
3506                 _account_type_convert_column_to_label(hstmt, label_record);
3507
3508                 _INFO("Adding account label_list");
3509                 label_list = g_slist_append(label_list, label_record);
3510
3511                 rc = _account_query_step(hstmt);
3512         }
3513
3514         *error_code = _ACCOUNT_ERROR_NONE;
3515
3516 CATCH:
3517         if (hstmt != NULL) {
3518                 rc = _account_query_finalize(hstmt);
3519                 if (rc != _ACCOUNT_ERROR_NONE)
3520                         _ERR("global db finalize error[%d]", rc);
3521                 hstmt = NULL;
3522         }
3523
3524         _INFO("Returning account global label_list");
3525
3526         return label_list;
3527 }
3528
3529 GSList* _account_type_get_label_list_by_app_id(const char* app_id, int *error_code)
3530 {
3531         *error_code = _ACCOUNT_ERROR_NONE;
3532         account_stmt    hstmt = NULL;
3533         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3534         int                             rc = 0, binding_count = 1;
3535         GSList* label_list = NULL;
3536
3537         ACCOUNT_RETURN_VAL((app_id != NULL), { *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER; }, NULL, ("APP ID IS NULL"));
3538         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), { *error_code = _ACCOUNT_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
3539
3540         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3541
3542         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ?", LABEL_TABLE);
3543         hstmt = _account_prepare_query(g_hAccountDB, query);
3544
3545         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
3546                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
3547                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
3548                 return NULL;
3549         }
3550
3551         _account_query_bind_text(hstmt, binding_count++, app_id);
3552
3553         rc = _account_query_step(hstmt);
3554         ACCOUNT_CATCH_ERROR_P(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
3555
3556         label_s* label_record = NULL;
3557
3558         while (rc == SQLITE_ROW) {
3559                 label_record = (label_s*) malloc(sizeof(label_s));
3560
3561                 if (label_record == NULL) {
3562                         ACCOUNT_FATAL("malloc Failed");
3563                         break;
3564                 }
3565
3566                 ACCOUNT_MEMSET(label_record, 0x00, sizeof(label_s));
3567
3568                 _account_type_convert_column_to_label(hstmt, label_record);
3569
3570                 _INFO("Adding account label_list");
3571                 label_list = g_slist_append(label_list, label_record);
3572
3573                 rc = _account_query_step(hstmt);
3574         }
3575
3576         rc = _account_query_finalize(hstmt);
3577         if (rc != _ACCOUNT_ERROR_NONE) {
3578                         _account_type_gslist_label_free(label_list);
3579                         *error_code = rc;
3580                         _ERR("finalize error");
3581                         return NULL;
3582                 }
3583         hstmt = NULL;
3584
3585         *error_code = _ACCOUNT_ERROR_NONE;
3586
3587 CATCH:
3588         if (hstmt != NULL) {
3589                 rc = _account_query_finalize(hstmt);
3590                 if (rc != _ACCOUNT_ERROR_NONE) {
3591                         _account_type_gslist_label_free(label_list);
3592                         *error_code = rc;
3593                         _ERR("finalize error");
3594                         return NULL;
3595                 }
3596                 hstmt = NULL;
3597         }
3598
3599         if (*error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND)
3600                 label_list = _account_type_get_label_list_by_app_id_from_global_db(app_id, error_code);
3601
3602         _INFO("Returning account label_list");
3603
3604         return label_list;
3605 }
3606
3607 int _account_type_query_label_by_app_id_from_global_db(account_type_label_cb callback, const char* app_id, void *user_data)
3608 {
3609         int                             error_code = _ACCOUNT_ERROR_NONE;
3610         account_stmt    hstmt = NULL;
3611         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3612         int                             rc = 0, binding_count = 1;
3613
3614         _INFO("account_type_query_label_by_app_id_from_global_db start");
3615
3616         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3617         ACCOUNT_RETURN_VAL((callback != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION"));
3618         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3619
3620         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3621
3622         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ?", LABEL_TABLE);
3623         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
3624
3625         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
3626                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
3627                 error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
3628                 goto CATCH;
3629         }
3630
3631         _account_query_bind_text(hstmt, binding_count++, app_id);
3632
3633         rc = _account_query_step(hstmt);
3634         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
3635
3636         label_s* label_record = NULL;
3637
3638         while (rc == SQLITE_ROW) {
3639                 bool cb_ret = FALSE;
3640                 label_record = (label_s*) malloc(sizeof(label_s));
3641
3642                 if (label_record == NULL) {
3643                         ACCOUNT_FATAL("malloc Failed");
3644                         break;
3645                 }
3646
3647                 ACCOUNT_MEMSET(label_record, 0x00, sizeof(label_s));
3648
3649                 _account_type_convert_column_to_label(hstmt, label_record);
3650
3651                 cb_ret = callback(label_record->app_id, label_record->label , label_record->locale, user_data);
3652
3653                 _account_type_free_label_with_items(label_record);
3654
3655                 ACCOUNT_CATCH_ERROR(cb_ret == TRUE, {}, _ACCOUNT_ERROR_NONE, ("Callback func returs FALSE, its iteration is stopped!!!!\n"));
3656
3657                 rc = _account_query_step(hstmt);
3658         }
3659
3660         error_code = _ACCOUNT_ERROR_NONE;
3661
3662 CATCH:
3663         if (hstmt != NULL) {
3664                 rc = _account_query_finalize(hstmt);
3665                 if (rc != _ACCOUNT_ERROR_NONE)
3666                         _ERR("global db finalize error[%d]", rc);
3667                 hstmt = NULL;
3668         }
3669
3670         _INFO("account_type_query_label_by_app_id_from_global_db end [%d]", error_code);
3671
3672         return error_code;
3673 }
3674
3675 int _account_type_query_label_by_app_id(account_type_label_cb callback, const char* app_id, void *user_data)
3676 {
3677         int                             error_code = _ACCOUNT_ERROR_NONE;
3678         account_stmt    hstmt = NULL;
3679         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3680         int                             rc = 0, binding_count = 1;
3681
3682         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3683         ACCOUNT_RETURN_VAL((callback != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION"));
3684         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3685
3686         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3687
3688         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ?", LABEL_TABLE);
3689         hstmt = _account_prepare_query(g_hAccountDB, query);
3690
3691         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
3692                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
3693                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
3694         }
3695
3696         _account_query_bind_text(hstmt, binding_count++, app_id);
3697
3698         rc = _account_query_step(hstmt);
3699         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
3700
3701         label_s* label_record = NULL;
3702
3703         while (rc == SQLITE_ROW) {
3704                 bool cb_ret = FALSE;
3705                 label_record = (label_s*) malloc(sizeof(label_s));
3706
3707                 if (label_record == NULL) {
3708                         ACCOUNT_FATAL("malloc Failed");
3709                         break;
3710                 }
3711
3712                 ACCOUNT_MEMSET(label_record, 0x00, sizeof(label_s));
3713
3714                 _account_type_convert_column_to_label(hstmt, label_record);
3715
3716                 cb_ret = callback(label_record->app_id, label_record->label , label_record->locale, user_data);
3717
3718                 _account_type_free_label_with_items(label_record);
3719
3720                 //ACCOUNT_CATCH_ERROR(cb_ret == TRUE, {}, _ACCOUNT_ERROR_NONE, ("Callback func returs FALSE, its iteration is stopped!!!!\n"));
3721                 if (cb_ret != TRUE) {
3722                         _INFO("Callback func returs FALSE, its iteration is stopped!!!!\n");
3723                         break;
3724                 }
3725
3726                 rc = _account_query_step(hstmt);
3727         }
3728
3729         rc = _account_query_finalize(hstmt);
3730         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3731         hstmt = NULL;
3732
3733         error_code = _ACCOUNT_ERROR_NONE;
3734
3735 CATCH:
3736         if (hstmt != NULL) {
3737                 rc = _account_query_finalize(hstmt);
3738                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3739                 hstmt = NULL;
3740         }
3741 /*
3742         if (error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND) {
3743                 error_code = account_type_query_label_by_app_id_from_global_db(callback, app_id, user_data);
3744         }
3745 */
3746         return error_code;
3747 }
3748
3749 int account_type_query_label_by_app_id(account_type_label_cb callback, const char* app_id, void *user_data)
3750 {
3751         int error_code = _ACCOUNT_ERROR_NONE;
3752
3753         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3754         ACCOUNT_RETURN_VAL((callback != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION"));
3755         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3756
3757         error_code = _account_type_query_label_by_app_id(callback, app_id, user_data);
3758
3759         if (error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND)
3760                 error_code = _account_type_query_label_by_app_id_from_global_db(callback, app_id, user_data);
3761
3762         return error_code;
3763 }
3764
3765 bool _account_get_label_text_cb(char* app_id, char* label, char* locale, void *user_data)
3766 {
3767         account_type_s *data = (account_type_s*)user_data;
3768
3769         label_s *label_data = (label_s*)malloc(sizeof(label_s));
3770
3771         if (label_data == NULL) {
3772                 ACCOUNT_FATAL("_account_get_label_text_cb : MALLOC FAIL\n");
3773                 return FALSE;
3774         }
3775         ACCOUNT_MEMSET(label_data, 0, sizeof(label_s));
3776
3777         label_data->app_id = _account_dup_text(app_id);
3778         label_data->label = _account_dup_text(label);
3779         label_data->locale = _account_dup_text(locale);
3780
3781         data->label_list = g_slist_append(data->label_list, (gpointer)label_data);
3782
3783         return TRUE;
3784 }
3785
3786 bool _account_get_provider_feature_cb(char* app_id, char* key, void* user_data)
3787 {
3788         account_type_s *data = (account_type_s*)user_data;
3789
3790         provider_feature_s *feature_data = (provider_feature_s*)malloc(sizeof(provider_feature_s));
3791
3792         if (feature_data == NULL) {
3793                 ACCOUNT_FATAL("_account_get_provider_feature_cb : MALLOC FAIL\n");
3794                 return FALSE;
3795         }
3796         ACCOUNT_MEMSET(feature_data, 0, sizeof(provider_feature_s));
3797
3798         feature_data->app_id = _account_dup_text(app_id);
3799         feature_data->key = _account_dup_text(key);
3800
3801         data->provider_feature_list = g_slist_append(data->provider_feature_list, (gpointer)feature_data);
3802
3803         return TRUE;
3804 }
3805
3806 int _account_type_query_by_app_id_from_global_db(const char* app_id, account_type_s** account_type_record)
3807 {
3808         _INFO("_account_type_query_by_app_id_from_global_db start");
3809
3810         int                             error_code = _ACCOUNT_ERROR_NONE;
3811         account_stmt    hstmt = NULL;
3812         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3813         int                             rc = 0, binding_count = 1;
3814
3815         ACCOUNT_RETURN_VAL((app_id != 0), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3816         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3817         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3818
3819         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3820
3821         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ?", ACCOUNT_TYPE_TABLE);
3822         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
3823
3824         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
3825                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
3826                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
3827         }
3828
3829         _account_query_bind_text(hstmt, binding_count++, app_id);
3830
3831         rc = _account_query_step(hstmt);
3832         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
3833
3834         *account_type_record = create_empty_account_type_instance();
3835
3836         while (rc == SQLITE_ROW) {
3837                 _account_type_convert_column_to_account_type(hstmt, *account_type_record);
3838                 rc = _account_query_step(hstmt);
3839         }
3840
3841         rc = _account_query_finalize(hstmt);
3842         ACCOUNT_CATCH_ERROR((rc == _ACCOUNT_ERROR_NONE), {_ERR("global db finalize error rc=[%d]", rc); }, rc, ("finalize error"));
3843         _account_type_query_label_by_app_id_from_global_db(_account_get_label_text_cb, app_id, (void*)(*account_type_record));
3844         _account_type_query_provider_feature_cb_by_app_id_from_global_db(_account_get_provider_feature_cb, app_id, (void*)(*account_type_record));
3845
3846         hstmt = NULL;
3847         error_code = _ACCOUNT_ERROR_NONE;
3848
3849 CATCH:
3850         if (hstmt != NULL) {
3851                 rc = _account_query_finalize(hstmt);
3852                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3853                 hstmt = NULL;
3854         }
3855
3856         _INFO("_account_type_query_by_app_id_from_global_db end [%d]", error_code);
3857
3858         return error_code;
3859 }
3860
3861 int _account_type_query_by_app_id(const char* app_id, account_type_s** account_type_record)
3862 {
3863         _INFO("_account_type_query_by_app_id start");
3864
3865         int                             error_code = _ACCOUNT_ERROR_NONE;
3866         account_stmt    hstmt = NULL;
3867         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3868         int                             rc = 0, binding_count = 1;
3869
3870         ACCOUNT_RETURN_VAL((app_id != 0), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL"));
3871         ACCOUNT_RETURN_VAL((account_type_record != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("account type record(account_type_s**) is NULL"));
3872         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
3873
3874         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3875
3876         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ?", ACCOUNT_TYPE_TABLE);
3877         hstmt = _account_prepare_query(g_hAccountDB, query);
3878
3879         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
3880                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
3881                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
3882         }
3883
3884         _account_query_bind_text(hstmt, binding_count++, app_id);
3885
3886         rc = _account_query_step(hstmt);
3887         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
3888
3889         *account_type_record = create_empty_account_type_instance();
3890         if (*account_type_record == NULL) {
3891                 _ERR("Out of Memory");
3892                 error_code = _ACCOUNT_ERROR_OUT_OF_MEMORY;
3893                 goto CATCH;
3894         }
3895
3896         while (rc == SQLITE_ROW) {
3897                 _account_type_convert_column_to_account_type(hstmt, *account_type_record);
3898                 rc = _account_query_step(hstmt);
3899         }
3900
3901         rc = _account_query_finalize(hstmt);
3902         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3903         _account_type_query_label_by_app_id(_account_get_label_text_cb, app_id, (void*)(*account_type_record));
3904         _account_type_query_provider_feature_cb_by_app_id(_account_get_provider_feature_cb, app_id, (void*)(*account_type_record));
3905
3906         hstmt = NULL;
3907         error_code = _ACCOUNT_ERROR_NONE;
3908
3909 CATCH:
3910         if (hstmt != NULL) {
3911                 rc = _account_query_finalize(hstmt);
3912                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
3913                 hstmt = NULL;
3914         }
3915
3916         if (error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND)
3917                 error_code = _account_type_query_by_app_id_from_global_db(app_id, account_type_record);
3918
3919         _INFO("_account_type_query_by_app_id end [%d]", error_code);
3920
3921         return error_code;
3922 }
3923
3924 int _account_type_query_by_provider_feature_from_global_db(const char* key, GSList **account_type_list_all)
3925 {
3926         int error_code = _ACCOUNT_ERROR_NONE;
3927         account_stmt    hstmt = NULL;
3928         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
3929         int                             rc = 0;
3930         GSList                  *account_type_list = NULL;
3931
3932         _INFO("_account_type_query_by_provider_feature_from_global_db start key=%s", key);
3933         if (key == NULL) {
3934                 ACCOUNT_ERROR("capability_type IS NULL.");
3935                 error_code = _ACCOUNT_ERROR_INVALID_PARAMETER;
3936                 goto CATCH;
3937         }
3938
3939         if (g_hAccountGlobalDB == NULL) {
3940                 ACCOUNT_ERROR("The database isn't connected.");
3941                 error_code = _ACCOUNT_ERROR_DB_NOT_OPENED;
3942                 goto CATCH;
3943         }
3944
3945         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
3946
3947         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId IN (SELECT app_id from %s WHERE key=?)", ACCOUNT_TYPE_TABLE, PROVIDER_FEATURE_TABLE);
3948
3949         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
3950
3951         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
3952                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
3953                 error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
3954                 goto CATCH;
3955         }
3956
3957         int binding_count = 1;
3958         _account_query_bind_text(hstmt, binding_count++, key);
3959
3960         rc = _account_query_step(hstmt);
3961
3962         account_type_s *account_type_record = NULL;
3963
3964         if (rc != SQLITE_ROW) {
3965                 ACCOUNT_ERROR("The record isn't found. rc=[%d]", rc);
3966                 error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
3967                 goto CATCH;
3968         }
3969
3970         while (rc == SQLITE_ROW) {
3971                 account_type_record = (account_type_s*) malloc(sizeof(account_type_s));
3972
3973                 if (account_type_record == NULL) {
3974                         ACCOUNT_FATAL("malloc Failed");
3975                         break;
3976                 }
3977
3978                 ACCOUNT_MEMSET(account_type_record, 0x00, sizeof(account_type_s));
3979                 _account_type_convert_column_to_account_type(hstmt, account_type_record);
3980                 account_type_list = g_slist_append(account_type_list, account_type_record);
3981                 rc = _account_query_step(hstmt);
3982         }
3983
3984         rc = _account_query_finalize(hstmt);
3985         if (rc != _ACCOUNT_ERROR_NONE) {
3986                 _account_type_gslist_account_type_free(account_type_list);
3987                 ACCOUNT_ERROR("finalize error(%s)", rc);
3988                 error_code = rc;
3989                 goto CATCH;
3990         }
3991         hstmt = NULL;
3992
3993         GSList* iter;
3994
3995         for (iter = account_type_list; iter != NULL; iter = g_slist_next(iter)) {
3996                 account_type_s *account_type = NULL;
3997                 account_type = (account_type_s*)iter->data;
3998                 _account_type_query_label_by_app_id_from_global_db(_account_get_label_text_cb, account_type->app_id, (void*)account_type);
3999                 _account_type_query_provider_feature_cb_by_app_id_from_global_db(_account_get_provider_feature_cb, account_type->app_id, (void*)account_type);
4000                 _INFO("add label & provider_feature");
4001         }
4002
4003         for (iter = account_type_list; iter != NULL; iter = g_slist_next(iter)) {
4004
4005                 account_type_s *account_type = NULL;
4006                 account_type = (account_type_s*)iter->data;
4007                 *account_type_list_all = g_slist_append(*account_type_list_all, account_type);
4008                 _INFO("add account_type");
4009         }
4010         g_slist_free(account_type_list);
4011
4012         error_code = _ACCOUNT_ERROR_NONE;
4013
4014 CATCH:
4015         if (hstmt != NULL) {
4016                 rc = _account_query_finalize(hstmt);
4017                 if (rc != _ACCOUNT_ERROR_NONE) {
4018                         ACCOUNT_ERROR("finalize error(%s)", rc);
4019                         return rc;
4020                 }
4021                 hstmt = NULL;
4022         }
4023
4024         _INFO("_account_type_query_by_provider_feature_from_global_db end. error_code=[%d]", error_code);
4025
4026         return error_code;
4027 }
4028
4029 GSList* _account_type_query_by_provider_feature(const char* key, int *error_code)
4030 {
4031         *error_code = _ACCOUNT_ERROR_NONE;
4032         account_stmt hstmt = NULL;
4033         char query[ACCOUNT_SQL_LEN_MAX] = {0, };
4034         int rc = 0;
4035         GSList *account_type_list = NULL;
4036
4037         _INFO("account_type_query_by_provider_feature start key=%s", key);
4038         if (key == NULL) {
4039                 ACCOUNT_ERROR("capability_type IS NULL.");
4040                 *error_code = _ACCOUNT_ERROR_INVALID_PARAMETER;
4041                 goto CATCH;
4042         }
4043
4044         if (g_hAccountDB == NULL) {
4045                 ACCOUNT_ERROR("The database isn't connected.");
4046                 *error_code = _ACCOUNT_ERROR_DB_NOT_OPENED;
4047                 goto CATCH;
4048         }
4049
4050         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
4051
4052         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId IN (SELECT app_id from %s WHERE key=?)", ACCOUNT_TYPE_TABLE, PROVIDER_FEATURE_TABLE);
4053
4054         hstmt = _account_prepare_query(g_hAccountDB, query);
4055
4056         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
4057                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
4058                 *error_code = _ACCOUNT_ERROR_PERMISSION_DENIED;
4059                 goto CATCH;
4060         }
4061
4062         int binding_count = 1;
4063         _account_query_bind_text(hstmt, binding_count++, key);
4064
4065         rc = _account_query_step(hstmt);
4066
4067         account_type_s *account_type_record = NULL;
4068
4069         if (rc != SQLITE_ROW) {
4070                 ACCOUNT_ERROR("The record isn't found. rc=[%d]", rc);
4071                 *error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
4072                 goto CATCH;
4073         }
4074
4075         while (rc == SQLITE_ROW) {
4076                 account_type_record = (account_type_s*) malloc(sizeof(account_type_s));
4077
4078                 if (account_type_record == NULL) {
4079                         ACCOUNT_FATAL("malloc Failed");
4080                         break;
4081                 }
4082
4083                 ACCOUNT_MEMSET(account_type_record, 0x00, sizeof(account_type_s));
4084                 _account_type_convert_column_to_account_type(hstmt, account_type_record);
4085                 account_type_list = g_slist_append(account_type_list, account_type_record);
4086                 rc = _account_query_step(hstmt);
4087         }
4088
4089         rc = _account_query_finalize(hstmt);
4090         if (rc != _ACCOUNT_ERROR_NONE) {
4091                 _account_type_gslist_account_type_free(account_type_list);
4092                 ACCOUNT_ERROR("finalize error(%s)", rc);
4093                 *error_code = rc;
4094                 goto CATCH;
4095         }
4096         hstmt = NULL;
4097
4098         GSList* iter;
4099
4100         for (iter = account_type_list; iter != NULL; iter = g_slist_next(iter)) {
4101                 account_type_s *account_type = NULL;
4102                 account_type = (account_type_s*)iter->data;
4103                 _account_type_query_label_by_app_id(_account_get_label_text_cb, account_type->app_id, (void*)account_type);
4104                 _account_type_query_provider_feature_cb_by_app_id(_account_get_provider_feature_cb, account_type->app_id, (void*)account_type);
4105         }
4106
4107         *error_code = _ACCOUNT_ERROR_NONE;
4108
4109 CATCH:
4110         if (hstmt != NULL) {
4111                 rc = _account_query_finalize(hstmt);
4112                 if (rc != _ACCOUNT_ERROR_NONE) {
4113                         *error_code = rc;
4114                         return NULL;
4115                 }
4116                 hstmt = NULL;
4117         }
4118
4119         if (*error_code == _ACCOUNT_ERROR_NONE || *error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND) {
4120                 rc = _account_type_query_by_provider_feature_from_global_db(key, &account_type_list);
4121                 if (rc != _ACCOUNT_ERROR_NONE && rc != _ACCOUNT_ERROR_RECORD_NOT_FOUND) {
4122                         ACCOUNT_ERROR("_account_type_query_by_provider_feature_from_global_db fail=[%d]", rc);
4123                         _account_type_gslist_account_type_free(account_type_list);
4124                         return NULL;
4125                 }
4126                 if (rc == _ACCOUNT_ERROR_NONE)
4127                         *error_code = rc;
4128         }
4129
4130         _INFO("account_type_query_by_provider_feature end");
4131
4132         return account_type_list;
4133 }
4134
4135 int _account_type_query_all_from_global_db(GSList **account_type_list_all)
4136 {
4137         account_stmt    hstmt = NULL;
4138         char query[ACCOUNT_SQL_LEN_MAX] = {0, };
4139         int rc = _ACCOUNT_ERROR_NONE;
4140         int error_code = _ACCOUNT_ERROR_NONE;
4141         GSList *account_type_list = NULL;
4142
4143         _INFO("_account_type_query_all_in_global_db start");
4144         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), {}, NULL, ("The database isn't connected."));
4145
4146         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
4147
4148         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s ", ACCOUNT_TYPE_TABLE);
4149         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
4150
4151         rc = _account_query_step(hstmt);
4152
4153         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
4154                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
4155                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
4156         }
4157
4158         account_type_s *account_type_record = NULL;
4159
4160         if (rc != SQLITE_ROW) {
4161                 _INFO("[_ACCOUNT_ERROR_RECORD_NOT_FOUND]The record isn't found.");
4162                 error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
4163                 goto CATCH;
4164         }
4165
4166         while (rc == SQLITE_ROW) {
4167                 account_type_record = (account_type_s*) malloc(sizeof(account_type_s));
4168
4169                 if (account_type_record == NULL) {
4170                         ACCOUNT_FATAL("malloc Failed");
4171                         break;
4172                 }
4173
4174                 ACCOUNT_MEMSET(account_type_record, 0x00, sizeof(account_type_s));
4175                 _account_type_convert_column_to_account_type(hstmt, account_type_record);
4176                 account_type_list = g_slist_append(account_type_list, account_type_record);
4177                 rc = _account_query_step(hstmt);
4178         }
4179
4180         rc = _account_query_finalize(hstmt);
4181         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {_account_type_gslist_account_type_free(account_type_list); }, rc, ("finalize error"));
4182         hstmt = NULL;
4183
4184         GSList* iter;
4185
4186         for (iter = account_type_list; iter != NULL; iter = g_slist_next(iter)) {
4187                 account_type_s *account_type = NULL;
4188                 account_type = (account_type_s*)iter->data;
4189                 _account_type_query_label_by_app_id_from_global_db(_account_get_label_text_cb, account_type->app_id, (void*)account_type);
4190                 _account_type_query_provider_feature_cb_by_app_id_from_global_db(_account_get_provider_feature_cb, account_type->app_id, (void*)account_type);
4191         }
4192
4193         for (iter = account_type_list; iter != NULL; iter = g_slist_next(iter)) {
4194                 account_type_s *account_type = NULL;
4195                 account_type = (account_type_s*)iter->data;
4196                 *account_type_list_all = g_slist_append(*account_type_list_all, account_type);
4197         }
4198         g_slist_free(account_type_list);
4199
4200         error_code = _ACCOUNT_ERROR_NONE;
4201
4202 CATCH:
4203         if (hstmt != NULL) {
4204                 rc = _account_query_finalize(hstmt);
4205                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {_account_type_gslist_account_type_free(account_type_list); }, rc, ("finalize error"));
4206                 hstmt = NULL;
4207         }
4208
4209         _INFO("_account_type_query_all_in_global_db end");
4210
4211         return error_code;
4212 }
4213
4214 GSList* _account_type_query_all(void)
4215 {
4216         account_stmt hstmt = NULL;
4217         char query[ACCOUNT_SQL_LEN_MAX] = {0, };
4218         int rc = 0;
4219         int error_code = _ACCOUNT_ERROR_NONE;
4220         GSList *account_type_list = NULL;
4221
4222         _INFO("_account_type_query_all start");
4223         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, NULL, ("The database isn't connected."));
4224
4225         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
4226
4227         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s ", ACCOUNT_TYPE_TABLE);
4228         hstmt = _account_prepare_query(g_hAccountDB, query);
4229
4230         rc = _account_query_step(hstmt);
4231
4232         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
4233                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
4234                 return NULL;
4235         }
4236
4237         account_type_s *account_type_record = NULL;
4238
4239         if (rc != SQLITE_ROW) {
4240                 _INFO("[_ACCOUNT_ERROR_RECORD_NOT_FOUND]The record isn't found.");
4241                 error_code = _ACCOUNT_ERROR_RECORD_NOT_FOUND;
4242                 goto CATCH;
4243         }
4244
4245         while (rc == SQLITE_ROW) {
4246                 account_type_record = (account_type_s*) malloc(sizeof(account_type_s));
4247
4248                 if (account_type_record == NULL) {
4249                         ACCOUNT_FATAL("malloc Failed");
4250                         break;
4251                 }
4252
4253                 ACCOUNT_MEMSET(account_type_record, 0x00, sizeof(account_type_s));
4254                 _account_type_convert_column_to_account_type(hstmt, account_type_record);
4255                 account_type_list = g_slist_append(account_type_list, account_type_record);
4256                 rc = _account_query_step(hstmt);
4257         }
4258
4259         rc = _account_query_finalize(hstmt);
4260         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {_account_type_gslist_account_type_free(account_type_list); }, NULL, ("finalize error"));
4261         hstmt = NULL;
4262
4263         GSList* iter;
4264
4265         for (iter = account_type_list; iter != NULL; iter = g_slist_next(iter)) {
4266                 account_type_s *account_type = NULL;
4267                 account_type = (account_type_s*)iter->data;
4268                 _account_type_query_label_by_app_id(_account_get_label_text_cb, account_type->app_id, (void*)account_type);
4269                 _account_type_query_provider_feature_cb_by_app_id(_account_get_provider_feature_cb, account_type->app_id, (void*)account_type);
4270         }
4271
4272         error_code = _ACCOUNT_ERROR_NONE;
4273
4274 CATCH:
4275         if (hstmt != NULL) {
4276                 rc = _account_query_finalize(hstmt);
4277                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {_account_type_gslist_account_type_free(account_type_list); }, NULL, ("finalize error"));
4278                 hstmt = NULL;
4279         }
4280
4281         if (error_code == _ACCOUNT_ERROR_NONE || error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND) {
4282                 error_code = _account_type_query_all_from_global_db(&account_type_list);
4283                 if (rc != _ACCOUNT_ERROR_NONE && rc != _ACCOUNT_ERROR_RECORD_NOT_FOUND) {
4284                         ACCOUNT_ERROR("_account_type_query_all_from_global_db fail=[%d]", rc);
4285                         _account_type_gslist_account_type_free(account_type_list);
4286                         return NULL;
4287                 }
4288         }
4289
4290         _INFO("_account_type_query_all end");
4291
4292         return account_type_list;
4293 }
4294
4295 // output parameter label must be free
4296 int _account_type_query_label_by_locale_from_global_db(const char* app_id, const char* locale, char **label)
4297 {
4298         int                             error_code = _ACCOUNT_ERROR_NONE;
4299         account_stmt    hstmt = NULL;
4300         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
4301         int                             rc = 0, binding_count = 1;
4302         char*                   converted_locale = NULL;
4303
4304         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO APP ID"));
4305         ACCOUNT_RETURN_VAL((g_hAccountGlobalDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
4306         ACCOUNT_RETURN_VAL((label != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("label char is null"));
4307         ACCOUNT_RETURN_VAL((locale != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("locale char is null"));
4308         //Making label newly created
4309
4310         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
4311
4312         converted_locale = _account_dup_text(locale);
4313         gchar** tokens = g_strsplit(converted_locale, "-", 2);
4314
4315         if (tokens != NULL) {
4316                 if ((char*)(tokens[1]) != NULL) {
4317                         char* upper_token = g_ascii_strup(tokens[1], strlen(tokens[1]));
4318                         if (upper_token != NULL) {
4319                                 _ACCOUNT_FREE(converted_locale);
4320                                 converted_locale = g_strdup_printf("%s_%s", tokens[0], upper_token);
4321                         }
4322                         _ACCOUNT_FREE(upper_token);
4323                 }
4324         }
4325         g_strfreev(tokens);
4326
4327         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ? AND Locale = '%s' ", LABEL_TABLE, converted_locale);
4328         _ACCOUNT_FREE(converted_locale);
4329
4330         hstmt = _account_prepare_query(g_hAccountGlobalDB, query);
4331
4332         if (_account_db_err_code(g_hAccountGlobalDB) == SQLITE_PERM) {
4333                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountGlobalDB));
4334                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
4335         }
4336
4337         _account_query_bind_text(hstmt, binding_count++, app_id);
4338
4339         rc = _account_query_step(hstmt);
4340         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
4341
4342         label_s* label_record = NULL;
4343
4344         while (rc == SQLITE_ROW) {
4345                 label_record = (label_s*) malloc(sizeof(label_s));
4346
4347                 if (label_record == NULL) {
4348                         ACCOUNT_FATAL("malloc Failed");
4349                         break;
4350                 }
4351
4352                 ACCOUNT_MEMSET(label_record, 0x00, sizeof(label_s));
4353
4354                 _account_type_convert_column_to_label(hstmt, label_record);
4355
4356                 _ACCOUNT_FREE(*label);
4357                 //Making label newly created
4358                 *label = _account_dup_text(label_record->label);
4359
4360                 _account_type_free_label_with_items(label_record);
4361
4362                 rc = _account_query_step(hstmt);
4363         }
4364
4365         rc = _account_query_finalize(hstmt);
4366         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4367         hstmt = NULL;
4368
4369         error_code = _ACCOUNT_ERROR_NONE;
4370
4371 CATCH:
4372         if (hstmt != NULL) {
4373                 rc = _account_query_finalize(hstmt);
4374                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4375                 hstmt = NULL;
4376         }
4377
4378         _INFO("_account_type_query_label_by_locale_from_global_db() end : error_code = %d", error_code);
4379
4380         return error_code;
4381 }
4382
4383 // output parameter label must be free
4384 int _account_type_query_label_by_locale(const char* app_id, const char* locale, char **label)
4385 {
4386         int                             error_code = _ACCOUNT_ERROR_NONE;
4387         account_stmt    hstmt = NULL;
4388         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
4389         int                             rc = 0, binding_count = 1;
4390         char*                   converted_locale = NULL;
4391
4392         ACCOUNT_RETURN_VAL((app_id != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("NO APP ID"));
4393         ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, _ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
4394         ACCOUNT_RETURN_VAL((label != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("label char is null"));
4395         ACCOUNT_RETURN_VAL((locale != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("locale char is null"));
4396         //Making label newly created
4397
4398         ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX);
4399
4400         converted_locale = _account_dup_text(locale);
4401         gchar** tokens = g_strsplit(converted_locale, "-", 2);
4402
4403         if (tokens != NULL) {
4404                 if ((char*)(tokens[1]) != NULL) {
4405                         char* upper_token = g_ascii_strup(tokens[1], strlen(tokens[1]));
4406                         if (upper_token != NULL) {
4407                                 _ACCOUNT_FREE(converted_locale);
4408                                 converted_locale = g_strdup_printf("%s_%s", tokens[0], upper_token);
4409                         }
4410                         _ACCOUNT_FREE(upper_token);
4411                 }
4412         }
4413         g_strfreev(tokens);
4414
4415         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ? AND Locale = '%s' ", LABEL_TABLE, converted_locale);
4416         _ACCOUNT_FREE(converted_locale);
4417
4418         hstmt = _account_prepare_query(g_hAccountDB, query);
4419
4420         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
4421                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
4422                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
4423         }
4424
4425         _account_query_bind_text(hstmt, binding_count++, app_id);
4426
4427         rc = _account_query_step(hstmt);
4428         ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, _ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
4429
4430         label_s* label_record = NULL;
4431
4432         while (rc == SQLITE_ROW) {
4433                 label_record = (label_s*) malloc(sizeof(label_s));
4434
4435                 if (label_record == NULL) {
4436                         ACCOUNT_FATAL("malloc Failed");
4437                         break;
4438                 }
4439
4440                 ACCOUNT_MEMSET(label_record, 0x00, sizeof(label_s));
4441
4442                 _account_type_convert_column_to_label(hstmt, label_record);
4443
4444                 _ACCOUNT_FREE(*label);
4445                 //Making label newly created
4446                 *label = _account_dup_text(label_record->label);
4447
4448                 _account_type_free_label_with_items(label_record);
4449
4450                 rc = _account_query_step(hstmt);
4451         }
4452
4453         rc = _account_query_finalize(hstmt);
4454         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4455         hstmt = NULL;
4456
4457         error_code = _ACCOUNT_ERROR_NONE;
4458
4459 CATCH:
4460         if (hstmt != NULL) {
4461                 rc = _account_query_finalize(hstmt);
4462                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4463                 hstmt = NULL;
4464         }
4465
4466         if (error_code == _ACCOUNT_ERROR_RECORD_NOT_FOUND)
4467                 error_code = _account_type_query_label_by_locale_from_global_db(app_id, locale, label);
4468
4469         _INFO("_account_type_query_label_by_locale() end : error_code = %d", error_code);
4470
4471         return error_code;
4472 }
4473
4474 static int _account_insert_custom(account_s *account, int account_id)
4475 {
4476         _INFO("_account_insert_custom start");
4477
4478         int                             rc, count = 1;
4479         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
4480         account_stmt    hstmt = NULL;
4481
4482         ACCOUNT_RETURN_VAL((account != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL"));
4483
4484         if (g_slist_length(account->custom_list) == 0) {
4485                 ACCOUNT_DEBUG("_account_insert_custom, no custom data\n");
4486                 return _ACCOUNT_ERROR_NONE;
4487         }
4488
4489         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where _id=%d", ACCOUNT_TABLE, account_id);
4490
4491         rc = _account_get_record_count(g_hAccountDB, query);
4492
4493         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
4494                 ACCOUNT_ERROR("Access failed(%d, %s)", _account_db_err_msg(g_hAccountDB));
4495                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
4496         }
4497
4498         if (rc <= 0) {
4499                 ACCOUNT_SLOGE("_account_insert_custom : related account item is not existed rc=%d , %s", rc, _account_db_err_msg(g_hAccountDB));
4500                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
4501         }
4502
4503         /* insert query*/
4504
4505         GSList *iter;
4506
4507         for (iter = account->custom_list; iter != NULL; iter = g_slist_next(iter)) {
4508                 int ret;
4509                 count = 1;
4510                 ACCOUNT_MEMSET(query, 0x00, sizeof(query));
4511                 ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s (AccountId, AppId, Key, Value) VALUES "
4512                                 "(?, ?, ?, ?) ", ACCOUNT_CUSTOM_TABLE);
4513
4514                 hstmt = _account_prepare_query(g_hAccountDB, query);
4515
4516                 if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
4517                         ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
4518                         return _ACCOUNT_ERROR_PERMISSION_DENIED;
4519                 }
4520
4521                 ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query(g_hAccountDB, ) failed(%s).\n", _account_db_err_msg(g_hAccountDB)));
4522
4523                 account_custom_s* custom_data = NULL;
4524                 custom_data = (account_custom_s*)iter->data;
4525
4526                 ret = _account_query_bind_int(hstmt, count++, account_id);
4527                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Int binding fail"));
4528                 ret = _account_query_bind_text(hstmt, count++, account->package_name);
4529                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
4530                 ret = _account_query_bind_text(hstmt, count++, (char*)custom_data->key);
4531                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
4532                 ret = _account_query_bind_text(hstmt, count++, (char*)custom_data->value);
4533                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
4534
4535                 rc = _account_query_step(hstmt);
4536
4537                 if (rc != SQLITE_DONE) {
4538                         ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
4539                         break;
4540                 }
4541
4542                 rc = _account_query_finalize(hstmt);
4543                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4544                 hstmt = NULL;
4545
4546         }
4547
4548         _INFO("_account_insert_custom end");
4549
4550         return _ACCOUNT_ERROR_NONE;
4551 }
4552
4553 static int _account_update_custom(account_s *account, int account_id)
4554 {
4555         int                             rc, count = 1;
4556         char                    query[ACCOUNT_SQL_LEN_MAX] = {0, };
4557         account_stmt    hstmt = NULL;
4558
4559         ACCOUNT_RETURN_VAL((account != NULL), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL"));
4560
4561         if (g_slist_length(account->custom_list) == 0) {
4562                 ACCOUNT_DEBUG("_account_update_custom, no custom data\n");
4563                 return _ACCOUNT_ERROR_NONE;
4564         }
4565
4566         ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where _id=%d", ACCOUNT_TABLE, account_id);
4567
4568         rc = _account_get_record_count(g_hAccountDB, query);
4569
4570         if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
4571                 ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
4572                 pthread_mutex_unlock(&account_mutex);
4573                 return _ACCOUNT_ERROR_PERMISSION_DENIED;
4574         } else if (_account_db_err_code(g_hAccountDB) == SQLITE_BUSY) {
4575                 ACCOUNT_ERROR("database busy(%s)", _account_db_err_msg(g_hAccountDB));
4576                 pthread_mutex_unlock(&account_mutex);
4577                 return _ACCOUNT_ERROR_DATABASE_BUSY;
4578         }
4579
4580         if (rc <= 0) {
4581                 ACCOUNT_SLOGE("_account_update_custom : related account item is not existed rc=%d , %s", rc, _account_db_err_msg(g_hAccountDB));
4582                 return _ACCOUNT_ERROR_RECORD_NOT_FOUND;
4583         }
4584
4585         ACCOUNT_MEMSET(query, 0x00, sizeof(query));
4586
4587         ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AccountId=? ", ACCOUNT_CUSTOM_TABLE);
4588         hstmt = _account_prepare_query(g_hAccountDB, query);
4589         count = 1;
4590         _account_query_bind_int(hstmt, count++, (int)account_id);
4591         rc = _account_query_step(hstmt);
4592
4593         if (rc == SQLITE_BUSY) {
4594                 ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
4595                 return _ACCOUNT_ERROR_DATABASE_BUSY;
4596         } else if (rc != SQLITE_DONE) {
4597                 ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
4598                 return _ACCOUNT_ERROR_DB_FAILED;
4599         }
4600
4601         rc = _account_query_finalize(hstmt);
4602         ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4603         hstmt = NULL;
4604
4605         GSList *iter;
4606
4607         for (iter = account->custom_list; iter != NULL; iter = g_slist_next(iter)) {
4608                 int ret;
4609                 count = 1;
4610                 ACCOUNT_MEMSET(query, 0x00, sizeof(query));
4611                 ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(AccountId, AppId, Key, Value) VALUES "
4612                                 "(?, ?, ?, ?) ", ACCOUNT_CUSTOM_TABLE);
4613
4614                 hstmt = _account_prepare_query(g_hAccountDB, query);
4615
4616                 if (_account_db_err_code(g_hAccountDB) == SQLITE_PERM) {
4617                         ACCOUNT_ERROR("Access failed(%s)", _account_db_err_msg(g_hAccountDB));
4618                         return _ACCOUNT_ERROR_PERMISSION_DENIED;
4619                 }
4620
4621                 ACCOUNT_RETURN_VAL((hstmt != NULL), {}, _ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query(g_hAccountDB, ) failed(%s).\n", _account_db_err_msg(g_hAccountDB)));
4622
4623                 account_custom_s* custom_data = NULL;
4624                 custom_data = (account_custom_s*)iter->data;
4625
4626                 ret = _account_query_bind_int(hstmt, count++, (int)account_id);
4627                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Int binding fail"));
4628                 ret = _account_query_bind_text(hstmt, count++, (char*)account->package_name);
4629                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
4630                 ret = _account_query_bind_text(hstmt, count++, (char*)custom_data->key);
4631                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
4632                 ret = _account_query_bind_text(hstmt, count++, (char*)custom_data->value);
4633                 ACCOUNT_RETURN_VAL((ret == _ACCOUNT_ERROR_NONE), {}, _ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail"));
4634
4635                 rc = _account_query_step(hstmt);
4636
4637                 if (rc != SQLITE_DONE) {
4638                         ACCOUNT_ERROR("_account_query_step() failed(%d, %s)", rc, _account_db_err_msg(g_hAccountDB));
4639                         break;
4640                 }
4641
4642                 rc = _account_query_finalize(hstmt);
4643                 ACCOUNT_RETURN_VAL((rc == _ACCOUNT_ERROR_NONE), {}, rc, ("finalize error"));
4644                 hstmt = NULL;
4645
4646         }
4647
4648         return _ACCOUNT_ERROR_NONE;
4649 }
4650