src/framework/data-adapter/agent_handler_manager.c

   1 /*
   2  * sync-agent
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   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 #include "utility/sync_util.h"
  19
  20 #include "data-adapter/agent.h"
  21
  22 #include "data-adapter/agent_handler_manager.h"
  23 #include "data-adapter/agent_handler_manager_internal.h"
  24
  25 #include "data-adapter/interface_service_item.h"
  26
  27 #ifndef EXPORT_API
  28 #define EXPORT_API __attribute__ ((visibility("default")))
  29 #endif
  30
  31 #ifndef SYNC_AGENT_LOG
  32 #undef LOG_TAG
  33 #define LOG_TAG "AF_DACI"
  34 #endif
  35
  36 static sync_agent_da_handler_mgr_s *agent_db_handler_mgr = 0;
  37
  38 /* static function define */
  39 static sync_agent_da_return_e _free_agent_dc_handler_table(void);
  40 static sync_agent_da_return_e _free_agent_dc_handler_table_mutex(void);
  41 static sync_agent_da_return_e _create_agent_db_handler_mgr_info(void);
  42 static sync_agent_da_return_e __alloc_agent_dc_handler_table(void);
  43 static sync_agent_da_return_e __alloc_agent_dc_handler_table_mutex(void);
  44 static void ___destroy_agent_db_hashtable_value(void *handler);
  45 static void ___destory_agent_db_hashtable_key(void *key);
  46
  47 /* general function implementation */
  48 /*
  49  * ==================================
  50  * external API (1. about agent db handler mgr)
  51  * ==================================
  52  */
  53 sync_agent_da_return_e da_alloc_agentdb_handler_mgr()
  54 {
  55         _EXTERN_FUNC_ENTER;
  56
  57         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
  58
  59         /* alloc the agentDBHandlerMgr */
  60         agent_db_handler_mgr = (sync_agent_da_handler_mgr_s *) calloc(1, sizeof(sync_agent_da_handler_mgr_s));
  61         if (agent_db_handler_mgr == NULL)
  62                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
  63         _DEBUG_INFO("[%s] pAgentDBHandlerMgr alloc success !\n", __func__);
  64
  65         /* alloc the agentDBHandlerMgr information */
  66         ret = _create_agent_db_handler_mgr_info();
  67         if (ret != SYNC_AGENT_DA_SUCCESS)
  68                 _DEBUG_INFO("[%s] _da_create_agent_db_handler_mgr_info alloc fail !\n", __func__);
  69         else
  70                 _DEBUG_INFO("[%s] _da_create_agent_db_handler_mgr_info alloc success !\n", __func__);
  71
  72         _EXTERN_FUNC_EXIT;
  73
  74         return ret;
  75 }
  76
  77 sync_agent_da_return_e da_free_agentdb_handler_mgr()
  78 {
  79         _EXTERN_FUNC_ENTER;
  80
  81         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
  82
  83         if (agent_db_handler_mgr != NULL) {
  84
  85                 ret = _free_agent_dc_handler_table_mutex();
  86                 if (ret != SYNC_AGENT_DA_SUCCESS)
  87                         return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
  88
  89                 ret = _free_agent_dc_handler_table();
  90                 if (ret != SYNC_AGENT_DA_SUCCESS)
  91                         return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
  92
  93         }
  94
  95         _EXTERN_FUNC_EXIT;
  96
  97         return ret;
  98 }
  99
 100 /*
 101  * ==================================
 102  * external API (2. about agent db )
 103  * ==================================
 104  */
 105 sync_agent_da_return_e da_clear_all_database_account()
 106 {
 107         _EXTERN_FUNC_ENTER;
 108
 109         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 110         int *account_Id_list = 0;
 111         int count = 0;
 112         int i = 0;
 113
 114         account_Id_list = da_get_account_id_list(&count);
 115         if (account_Id_list == NULL) {
 116                 _DEBUG_ERROR("accountIdList empty");
 117                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 118         } else {
 119                 _DEBUG_INFO("accountListCount : %d", count);
 120         }
 121
 122         for (i = 0; i < count; i++) {
 123                 ret = da_delete_all_database_account(account_Id_list[i]);
 124                 if (ret != SYNC_AGENT_DA_SUCCESS)
 125                         break;
 126         }
 127
 128         /* memory free */
 129         if (account_Id_list != NULL)
 130                 free(account_Id_list);
 131
 132         _EXTERN_FUNC_EXIT;
 133
 134         return ret;
 135 }
 136
 137 sync_agent_da_return_e da_delete_all_database_account(int account_id)
 138 {
 139         _EXTERN_FUNC_ENTER;
 140
 141         sync_agent_da_return_e ret = 0;
 142
 143         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 144         if (daci_handler == NULL) {
 145                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 146                 return SYNC_AGENT_DA_ERRORS;
 147         }
 148
 149         int data_count = 0;
 150 /*      if (da_is_exist_account_id(accountId) && DACI_Delete_EmailAccount(accountId) &&
 151                         DACI_Delete_ContactAccount(accountId) && DACI_Delete_CalendarAccount(accountId) &&
 152                         (da_delete_account_id(accountId) == SYNC_AGENT_DA_SUCCESS)) {*/
 153
 154         if (da_is_exist_account_id(account_id) && (da_delete_fw_account_id(account_id) == SYNC_AGENT_DA_SUCCESS)) {
 155                 /* all of the deleted account */
 156                 data_count = da_get_account_count(daci_handler);
 157                 if (data_count == 0)
 158                         ret = SYNC_AGENT_DA_ERR_DELETE_LAST_ACCOUNT;
 159                 else
 160                         ret = SYNC_AGENT_DA_SUCCESS;
 161
 162         } else {
 163                 ret = SYNC_AGENT_DA_ERRORS;
 164         }
 165
 166         _EXTERN_FUNC_EXIT;
 167
 168         return ret;
 169 }
 170
 171 EXPORT_API sync_agent_da_return_e sync_agent_open_agent()
 172 {
 173         _EXTERN_FUNC_ENTER;
 174
 175         int ret = 0;
 176
 177         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 178         if (daci_handler == NULL) {
 179
 180                 _DEBUG_INFO("daci_handler is 0");
 181                 _DEBUG_INFO("should register agent_handler to agent_handler_hash_table");
 182                 ret = da_open_agent(&daci_handler);
 183                 if (ret != SYNC_AGENT_DA_SUCCESS)
 184                         return ret;
 185
 186                 if (daci_handler != NULL) {
 187                         /* add agentDB handler to agentDBHandleMgr */
 188                         ret = da_add_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID, daci_handler);
 189                         if (ret != SYNC_AGENT_DA_SUCCESS)
 190                                 return ret;
 191                 }
 192
 193         } else {
 194                 _DEBUG_INFO("daci_handler is not null");
 195                 _DEBUG_INFO("should not register mo_handler to mo_handler_hash_table");
 196         }
 197
 198         _DEBUG_INFO("agent_db_agent_open_success");
 199
 200         _EXTERN_FUNC_EXIT;
 201
 202         return SYNC_AGENT_DA_SUCCESS;
 203 }
 204
 205 EXPORT_API sync_agent_da_return_e sync_agent_close_agent()
 206 {
 207         _EXTERN_FUNC_ENTER;
 208
 209         int ret = 0;
 210
 211         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 212         if (daci_handler != NULL) {
 213
 214                 /* remove agentDB handler to agentDBHandleMgr */
 215                 ret = da_remove_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 216                 if (ret != SYNC_AGENT_DA_SUCCESS)
 217                         return ret;
 218
 219                 _DEBUG_INFO("agent_db_agent_close_success");
 220         }
 221
 222         _EXTERN_FUNC_EXIT;
 223
 224         return SYNC_AGENT_DA_SUCCESS;
 225 }
 226
 227 sync_agent_da_return_e da_create_agent_default_table_wrapper()
 228 {
 229         _EXTERN_FUNC_ENTER;
 230
 231         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 232
 233         _EXTERN_FUNC_EXIT;
 234
 235         return da_create_agent_default_table(daci_handler);
 236 }
 237
 238 EXPORT_API sync_agent_da_return_e sync_agent_empty_agent_default_table(sync_agent_da_table_name_e table_name)
 239 {
 240         _EXTERN_FUNC_ENTER;
 241
 242         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 243
 244         _EXTERN_FUNC_EXIT;
 245
 246         return da_empty_agent_default_table(daci_handler, table_name);
 247 }
 248
 249 EXPORT_API sync_agent_da_return_e sync_agent_empty_all_agent_default_table()
 250 {
 251         _EXTERN_FUNC_ENTER;
 252
 253         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 254
 255         _EXTERN_FUNC_EXIT;
 256
 257         return da_empty_all_agent_table(daci_handler);
 258 }
 259
 260 EXPORT_API sync_agent_da_return_e sync_agent_begin_transaction()
 261 {
 262         _EXTERN_FUNC_ENTER;
 263
 264         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 265         if (daci_handler == NULL) {
 266                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 267                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 268         }
 269
 270         _EXTERN_FUNC_EXIT;
 271
 272         return da_begin_transaction(daci_handler);
 273 }
 274
 275 EXPORT_API sync_agent_da_return_e sync_agent_end_transaction(sync_agent_da_transaction_e transaction)
 276 {
 277         _EXTERN_FUNC_ENTER;
 278
 279         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 280         if (daci_handler == NULL) {
 281                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 282                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 283         }
 284
 285         _EXTERN_FUNC_EXIT;
 286
 287         return da_end_transaction(daci_handler, transaction);
 288 }
 289
 290 int da_add_fw_account_id(sync_agent_fw_account_s * account)
 291 {
 292         _EXTERN_FUNC_ENTER;
 293
 294         retvm_if(account == NULL, -1, "sync_agent_fw_account_s is NULL !!");
 295
 296         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 297         if (daci_handler == NULL) {
 298                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 299                 return -1;
 300         }
 301
 302         _EXTERN_FUNC_EXIT;
 303
 304         return da_add_fw_account(daci_handler, account);
 305 }
 306
 307 sync_agent_da_return_e da_update_fw_account_id(sync_agent_fw_account_s * account)
 308 {
 309         _EXTERN_FUNC_ENTER;
 310
 311         retvm_if(account == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_fw_account_s is NULL !!");
 312
 313         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 314         if (daci_handler == NULL) {
 315                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 316                 return -1;
 317         }
 318
 319         _EXTERN_FUNC_EXIT;
 320
 321         return da_update_fw_account(daci_handler, account);
 322 }
 323
 324 sync_agent_da_return_e da_delete_fw_account_id(int account_id)
 325 {
 326         _EXTERN_FUNC_ENTER;
 327
 328         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 329         if (daci_handler == NULL) {
 330                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 331                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 332         }
 333
 334         _EXTERN_FUNC_EXIT;
 335
 336         return da_delete_fw_account(daci_handler, account_id);
 337 }
 338
 339 sync_agent_da_return_e da_get_fw_account_info(int account_id, sync_agent_fw_account_s ** account)
 340 {
 341         _EXTERN_FUNC_ENTER;
 342
 343         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 344         if (daci_handler == NULL) {
 345                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 346                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 347         }
 348
 349         _EXTERN_FUNC_EXIT;
 350
 351         return da_get_fw_account(daci_handler, account_id, account);
 352 }
 353
 354 sync_agent_da_return_e da_get_all_fw_account_info(GList ** list)
 355 {
 356         _EXTERN_FUNC_ENTER;
 357
 358         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 359         if (daci_handler == NULL) {
 360                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 361                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 362         }
 363
 364         _EXTERN_FUNC_EXIT;
 365
 366         return da_get_all_fw_account(daci_handler, list);
 367 }
 368
 369 sync_agent_da_return_e da_get_fw_account_info_by_access_name(char *access_name, GList ** list)
 370 {
 371         _EXTERN_FUNC_ENTER;
 372
 373         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 374         if (daci_handler == NULL) {
 375                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 376                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 377         }
 378
 379         _EXTERN_FUNC_EXIT;
 380
 381         return da_get_fw_account_by_access_name(daci_handler, access_name, list);
 382 }
 383
 384 int *da_get_account_id_list(int *count)
 385 {
 386         _EXTERN_FUNC_ENTER;
 387
 388         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 389         if (daci_handler == NULL) {
 390                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 391                 return 0;
 392         }
 393
 394         _EXTERN_FUNC_EXIT;
 395
 396         return da_get_account_account_id_list(daci_handler, count);
 397 }
 398
 399 int da_is_exist_account_id(int account_id)
 400 {
 401         _EXTERN_FUNC_ENTER;
 402
 403         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 404         if (daci_handler == NULL) {
 405                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 406                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 407         }
 408
 409         _EXTERN_FUNC_EXIT;
 410
 411         return da_is_exist_account(daci_handler, account_id);
 412 }
 413
 414 sync_agent_da_return_e da_add_folder_internal(sync_agent_da_folder_s * folder, int count)
 415 {
 416         _EXTERN_FUNC_ENTER;
 417
 418         retvm_if(folder == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_folder_s is NULL !!");
 419
 420         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 421         if (daci_handler == NULL) {
 422                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 423                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 424         }
 425
 426         _EXTERN_FUNC_EXIT;
 427
 428         return da_add_folder(daci_handler, folder, count);
 429 }
 430
 431 sync_agent_da_return_e da_delete_folder_by_folder_id_wrapper(char *folder_id)
 432 {
 433         _EXTERN_FUNC_ENTER;
 434
 435         retvm_if(folder_id == NULL, SYNC_AGENT_DA_ERRORS, "folder id is NULL !!");
 436
 437         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 438         if (daci_handler == NULL) {
 439                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 440                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 441         }
 442
 443         _EXTERN_FUNC_EXIT;
 444
 445         return da_delete_folder_by_folder_id(daci_handler, folder_id);
 446 }
 447
 448 char *da_get_folder_id_by_service_id_wrapper(int account_id, int item_type_id, char *service_id, int folder_type_id)
 449 {
 450         _EXTERN_FUNC_ENTER;
 451
 452         retvm_if(service_id == NULL, NULL, "service id is NULL !!");
 453
 454         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 455         if (daci_handler == NULL) {
 456                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 457                 return 0;
 458         }
 459
 460         _EXTERN_FUNC_EXIT;
 461
 462         return da_get_folder_folder_id_by_service_id(daci_handler, account_id, item_type_id, service_id, folder_type_id);
 463 }
 464
 465 sync_agent_da_id_list_s *da_get_folder_id_by_folder_type_id_internal(int account_id, int item_type_id, int folder_type_id)
 466 {
 467         _EXTERN_FUNC_ENTER;
 468
 469         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 470         if (daci_handler == NULL) {
 471                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 472                 return NULL;
 473         }
 474
 475         _EXTERN_FUNC_EXIT;
 476
 477         return da_get_folder_folder_id_by_folder_type_id(daci_handler, account_id, item_type_id, folder_type_id);
 478 }
 479
 480 sync_agent_da_id_list_s *da_get_folder_id_list_by_item_type_id_internal(int account_id, int item_type_id)
 481 {
 482         _EXTERN_FUNC_ENTER;
 483
 484         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 485         if (daci_handler == NULL) {
 486                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 487                 return NULL;
 488         }
 489
 490         _EXTERN_FUNC_EXIT;
 491
 492         return da_get_folder_folder_id_list_by_item_type_id(daci_handler, account_id, item_type_id);
 493 }
 494
 495 sync_agent_da_folder_s *da_get_item_mapping_service_id_by_folder_id_internal(int account_id, char *folder_id, int *count)
 496 {
 497         _EXTERN_FUNC_ENTER;
 498
 499         retvm_if(folder_id == NULL, NULL, "folder id id is NULL !!");
 500
 501         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 502         if (daci_handler == NULL) {
 503                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 504                 return NULL;
 505         }
 506
 507         _EXTERN_FUNC_EXIT;
 508
 509         return da_get_folder_mapping_service_id(daci_handler, account_id, folder_id, count);
 510 }
 511
 512 sync_agent_da_return_e da_add_item_internal(sync_agent_da_item_s * item, int count)
 513 {
 514         _EXTERN_FUNC_ENTER;
 515
 516         retvm_if(item == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_s is NULL !!");
 517
 518         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 519         if (daci_handler == NULL) {
 520                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 521                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 522         }
 523
 524         _EXTERN_FUNC_EXIT;
 525
 526         return da_add_item(daci_handler, item, count);
 527 }
 528
 529 sync_agent_da_return_e da_update_item_internal(char *fw_id, char *parent_id)
 530 {
 531         _EXTERN_FUNC_ENTER;
 532         retvm_if(fw_id == NULL, SYNC_AGENT_DA_ERRORS, "fw_id is NULL !!");
 533         retvm_if(parent_id == NULL, SYNC_AGENT_DA_ERRORS, "parent_id is NULL !!");
 534
 535         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 536         if (daci_handler == NULL) {
 537                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 538                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 539         }
 540
 541         _EXTERN_FUNC_EXIT;
 542         return da_update_item(daci_handler, fw_id, parent_id);
 543 }
 544
 545
 546 sync_agent_da_return_e sync_agent_add_item_new(sync_agent_da_item_s * item, int count, char **item_id)
 547 {
 548         _EXTERN_FUNC_ENTER;
 549
 550         retvm_if(item == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_s is NULL !!");
 551
 552         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 553         if (daci_handler == NULL) {
 554                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 555                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 556         }
 557
 558         _EXTERN_FUNC_EXIT;
 559
 560         return da_add_item_new(daci_handler, item, count, item_id);
 561 }
 562
 563 sync_agent_da_return_e da_delete_item_by_item_id_internal(char *item_id)
 564 {
 565         _EXTERN_FUNC_ENTER;
 566
 567         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
 568
 569         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 570         if (daci_handler == NULL) {
 571                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 572                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 573         }
 574
 575         _EXTERN_FUNC_EXIT;
 576
 577         return da_delete_item_by_Item_id(daci_handler, item_id);
 578 }
 579
 580 sync_agent_da_return_e da_delete_item_by_item_type_id_internal(int account_id, int item_type_id)
 581 {
 582         _EXTERN_FUNC_ENTER;
 583
 584         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 585         if (daci_handler == NULL) {
 586                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 587                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 588         }
 589
 590         _EXTERN_FUNC_EXIT;
 591
 592         return da_delete_item_by_item_type_id(daci_handler, account_id, item_type_id);
 593 }
 594
 595 sync_agent_da_return_e da_delete_all_child_item_internal(char *parent_service_id)
 596 {
 597         _EXTERN_FUNC_ENTER;
 598
 599         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 600         if (daci_handler == NULL) {
 601                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 602                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 603         }
 604
 605         _EXTERN_FUNC_EXIT;
 606         return da_delete_all_child_item(daci_handler, parent_service_id);
 607 }
 608
 609 sync_agent_da_return_e da_delete_child_item_internal(char *parent_service_id, char *child_service_id)
 610 {
 611         _EXTERN_FUNC_ENTER;
 612
 613         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 614         if (daci_handler == NULL) {
 615                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 616                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 617         }
 618
 619         _EXTERN_FUNC_EXIT;
 620         return da_delete_child_item(daci_handler, parent_service_id, child_service_id);
 621 }
 622
 623
 624 sync_agent_da_return_e da_delete_item_and_changelog_by_item_type_id_internal(int account_id, int item_type_id)
 625 {
 626         _EXTERN_FUNC_ENTER;
 627
 628         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 629         if (daci_handler == NULL) {
 630                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 631                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 632         }
 633
 634         _EXTERN_FUNC_EXIT;
 635
 636         return da_delete_item_by_item_type_id_and_delete_changelog(daci_handler, account_id, item_type_id);
 637 }
 638
 639 char *da_get_item_id_internal(int account_id, char *service_id, int item_type_id)
 640 {
 641         _EXTERN_FUNC_ENTER;
 642
 643         retvm_if(service_id == NULL, NULL, "service id is NULL !!");
 644
 645         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 646         if (daci_handler == NULL) {
 647                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 648                 return NULL;
 649         }
 650
 651         _EXTERN_FUNC_EXIT;
 652
 653         return da_get_item_item_id(daci_handler, account_id, service_id, item_type_id);
 654 }
 655
 656 sync_agent_da_item_s *da_get_item_internal(char *item_id)
 657 {
 658         _EXTERN_FUNC_ENTER;
 659
 660         retvm_if(item_id == NULL, NULL, "item id is NULL !!");
 661
 662         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 663         if (daci_handler == NULL) {
 664                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 665                 return NULL;
 666         }
 667
 668         _EXTERN_FUNC_EXIT;
 669
 670         return da_get_item(daci_handler, item_id);
 671 }
 672
 673 sync_agent_da_id_list_s *da_get_all_item_id_wrapper()
 674 {
 675         _EXTERN_FUNC_ENTER;
 676
 677         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 678         if (daci_handler == NULL) {
 679                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 680                 return NULL;
 681         }
 682
 683         _EXTERN_FUNC_EXIT;
 684
 685         return da_get_all_item_id(daci_handler);
 686 }
 687
 688 sync_agent_da_id_list_s *da_get_item_id_list_internal(char *folder_id, sync_agent_da_column_name_e column_name)
 689 {
 690         _EXTERN_FUNC_ENTER;
 691
 692         retvm_if(folder_id == NULL, NULL, "folder id is NULL !!");
 693
 694         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 695         if (daci_handler == NULL) {
 696                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 697                 return NULL;
 698         }
 699
 700         _EXTERN_FUNC_EXIT;
 701
 702         return da_get_item_id_list(daci_handler, folder_id, column_name);
 703 }
 704
 705 sync_agent_da_item_s *da_get_item_by_account_id_internal(int account_id, int item_type_id, int *count)
 706 {
 707         _EXTERN_FUNC_ENTER;
 708
 709         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 710         if (daci_handler == NULL) {
 711                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 712                 return NULL;
 713         }
 714
 715         _EXTERN_FUNC_EXIT;
 716
 717         return da_get_item_by_account_id(daci_handler, account_id, item_type_id, count);
 718 }
 719
 720 sync_agent_da_item_info_s *da_get_item_info_by_item_type_id_internal(int account_id, int item_type_id, int *count)
 721 {
 722         _EXTERN_FUNC_ENTER;
 723
 724         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 725         if (daci_handler == NULL) {
 726                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 727                 return NULL;
 728         }
 729
 730         _EXTERN_FUNC_EXIT;
 731
 732         return da_get_item_info_by_item_type_id(daci_handler, account_id, item_type_id, count);
 733 }
 734
 735 sync_agent_da_item_s *da_get_item_mapping_service_id_by_item_id_internal(int account_id, char *item_id, int *count)
 736 {
 737         _EXTERN_FUNC_ENTER;
 738
 739         retvm_if(item_id == NULL, NULL, "item id is NULL !!");
 740
 741         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 742         if (daci_handler == NULL) {
 743                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 744                 return NULL;
 745         }
 746
 747         _EXTERN_FUNC_EXIT;
 748
 749         return da_get_item_mapping_service_id(daci_handler, account_id, item_id, count);
 750 }
 751
 752 sync_agent_da_id_list_s *da_get_item_id_list_by_data_store_id_internal(int data_store_id)
 753 {
 754         _EXTERN_FUNC_ENTER;
 755
 756         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 757         if (daci_handler == NULL) {
 758                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 759                 return NULL;
 760         }
 761
 762         _EXTERN_FUNC_EXIT;
 763
 764         return da_get_item_id_list_by_datastore_id(daci_handler, data_store_id);
 765 }
 766
 767 sync_agent_da_id_list_s *da_get_item_id_list_by_data_store_id_with_account_id_internal(int account_id, int data_store_id)
 768 {
 769         _EXTERN_FUNC_ENTER;
 770
 771         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 772         if (daci_handler == NULL) {
 773                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 774                 return NULL;
 775         }
 776
 777         _EXTERN_FUNC_EXIT;
 778
 779         return da_get_item_id_list_by_datastore_id_with_account_id(daci_handler, account_id, data_store_id);
 780 }
 781
 782 sync_agent_da_id_list_s *da_get_item_id_list_by_operation_id_internal(int account_id, int data_store_id, int operation_id)
 783 {
 784         _EXTERN_FUNC_ENTER;
 785
 786         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 787         if (daci_handler == NULL) {
 788                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 789                 return NULL;
 790         }
 791
 792         _EXTERN_FUNC_EXIT;
 793
 794         return da_get_item_id_list_by_operation_id(daci_handler, account_id, data_store_id, operation_id);
 795 }
 796
 797 sync_agent_da_id_list_s *da_get_item_id_list_by_operation_id_and_folder_id_internal(int account_id, char *folder_id, int data_store_id, int operation_id)
 798 {
 799         _EXTERN_FUNC_ENTER;
 800
 801         retvm_if(folder_id == NULL, NULL, "folder id is NULL !!");
 802
 803         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 804         if (daci_handler == NULL) {
 805                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 806                 return NULL;
 807         }
 808
 809         _EXTERN_FUNC_EXIT;
 810
 811         return da_get_item_id_list_by_operation_id_and_folder_id(daci_handler, account_id, folder_id, data_store_id, operation_id);
 812 }
 813
 814 int da_is_exist_item_wrapper(char *item_id)
 815 {
 816         _EXTERN_FUNC_ENTER;
 817
 818         retvm_if(item_id == NULL, 0, "item id is NULL !!");
 819
 820         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 821         if (daci_handler == NULL) {
 822                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 823                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 824         }
 825
 826         _EXTERN_FUNC_EXIT;
 827
 828         return da_is_exist_item(daci_handler, item_id);
 829 }
 830
 831 //sync_agent_da_return_e sync_agent_add_config(sync_agent_da_config_s *config)
 832 //{
 833 //      SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 834 //      if (daci_handler == NULL) {
 835 //              _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 836 //              return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 837 //      }
 838 //
 839 //      return add_config(daci_handler, config);
 840 //}
 841
 842 //sync_agent_da_return_e sync_agent_delete_config_by_key(int config_id, char *key)
 843 //{
 844 //      SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 845 //      if (daci_handler == NULL) {
 846 //              _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 847 //              return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 848 //      }
 849 //
 850 //      return da_delete_config_by_key(daci_handler, config_id, key);
 851 //}
 852
 853 //sync_agent_da_config_s *sync_agent_get_config_by_config_id(int config_id, int *count)
 854 //{
 855 //      SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 856 //      if (daci_handler == NULL) {
 857 //              _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 858 //              return NULL;
 859 //      }
 860 //
 861 //      return da_get_config_by_config_id(daci_handler, config_id, count);
 862 //}
 863
 864 //sync_agent_da_return_e sync_agent_get_config_by_key(sync_agent_da_config_s *config)
 865 //{
 866 //      SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 867 //      if (daci_handler == NULL) {
 868 //              _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 869 //              return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 870 //      }
 871 //
 872 //      return da_get_config_by_key(daci_handler, config);
 873 //}
 874
 875 //int sync_agent_is_exist_config(int config_id, char *key)
 876 //{
 877 //      SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 878 //      if (daci_handler == NULL) {
 879 //              _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 880 //              return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 881 //      }
 882 //
 883 //      return da_is_exist_config(daci_handler, config_id, key);
 884 //}
 885
 886 //sync_agent_da_return_e sync_agent_update_config(sync_agent_da_config_s *config, int count)
 887 //{
 888 //      SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 889 //      if (daci_handler == NULL) {
 890 //              _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 891 //              return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 892 //      }
 893 //
 894 //      return da_update_config(daci_handler, config, count);
 895 //}
 896
 897 sync_agent_da_return_e da_add_item_changelog_wrapper(int account_id, sync_agent_da_item_changelog_s * item_changelog, int count)
 898 {
 899         _EXTERN_FUNC_ENTER;
 900
 901         retvm_if(item_changelog == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_changelog_s is NULL !!");
 902
 903         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 904         if (daci_handler == NULL) {
 905                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 906                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 907         }
 908
 909         _EXTERN_FUNC_EXIT;
 910
 911         return da_add_item_changelog(daci_handler, account_id, item_changelog, count);
 912 }
 913
 914 sync_agent_da_return_e da_delete_item_changelog_by_item_id_internal(int account_id, char *item_id)
 915 {
 916         _EXTERN_FUNC_ENTER;
 917
 918         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
 919
 920         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 921         if (daci_handler == NULL) {
 922                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 923                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 924         }
 925
 926         _EXTERN_FUNC_EXIT;
 927
 928         return da_delete_item_changelog_by_item_id(daci_handler, account_id, item_id);
 929 }
 930
 931 sync_agent_da_return_e da_delete_item_changelog_by_item_id_list_internal(int account_id, char **item_id_list, int count)
 932 {
 933         _EXTERN_FUNC_ENTER;
 934
 935         retvm_if(item_id_list == NULL, SYNC_AGENT_DA_ERRORS, "item id list is NULL !!");
 936
 937         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 938         if (daci_handler == NULL) {
 939                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 940                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 941         }
 942
 943         _EXTERN_FUNC_EXIT;
 944
 945         return da_delete_item_changelog_by_item_id_list(daci_handler, account_id, item_id_list, count);
 946 }
 947
 948 sync_agent_da_return_e da_delete_item_changelog_by_item_type_id_internal(int account_id, int item_type_id)
 949 {
 950         _EXTERN_FUNC_ENTER;
 951
 952         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 953         if (daci_handler == NULL) {
 954                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 955                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 956         }
 957
 958         _EXTERN_FUNC_EXIT;
 959
 960         return da_delete_item_changelog_by_item_type_id(daci_handler, account_id, item_type_id);
 961 }
 962
 963 sync_agent_da_return_e da_set_item_changelog_operation_id_wrapper(int account_id, sync_agent_da_item_changelog_s * item_changelog)
 964 {
 965         _EXTERN_FUNC_ENTER;
 966
 967         retvm_if(item_changelog == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_changelog_s is NULL !!");
 968
 969         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 970         if (daci_handler == NULL) {
 971                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 972                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 973         }
 974
 975         _EXTERN_FUNC_EXIT;
 976
 977         return da_set_item_changelog_operation_id(daci_handler, account_id, item_changelog);
 978 }
 979
 980 sync_agent_da_return_e da_set_item_changelog_sync_status_internal(int account_id, sync_agent_da_item_changelog_s * item_changelog)
 981 {
 982         _EXTERN_FUNC_ENTER;
 983
 984         retvm_if(item_changelog == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_changelog_s is NULL !!");
 985
 986         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 987         if (daci_handler == NULL) {
 988                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 989                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 990         }
 991
 992         _EXTERN_FUNC_EXIT;
 993
 994         return da_set_item_changelog_sync_status(daci_handler, account_id, item_changelog);
 995 }
 996
 997 sync_agent_da_return_e da_set_item_changelog_wait_status_internal(int account_id, char **folder_id_list, int folder_id_count, int *item_type_id_list, int item_type_id_count)
 998 {
 999         _EXTERN_FUNC_ENTER;
1000
1001         retvm_if(item_type_id_list == NULL, SYNC_AGENT_DA_ERRORS, "item type id list is NULL !!");
1002
1003         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1004         if (daci_handler == NULL) {
1005                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1006                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1007         }
1008
1009         _EXTERN_FUNC_EXIT;
1010
1011         return da_set_item_changelog_wait_status(daci_handler, account_id, folder_id_list, folder_id_count, item_type_id_list, item_type_id_count);
1012
1013 }
1014
1015 sync_agent_da_return_e sync_agent_get_item_changelog_by_item_id(int account_id, sync_agent_da_item_changelog_s * item_changelog)
1016 {
1017         _EXTERN_FUNC_ENTER;
1018
1019         retvm_if(item_changelog == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_changelog_s is NULL !!");
1020
1021         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1022         if (daci_handler == NULL) {
1023                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1024                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1025         }
1026
1027         _EXTERN_FUNC_EXIT;
1028
1029         return da_get_item_changelog_by_item_id(daci_handler, account_id, item_changelog);
1030 }
1031
1032 int da_is_exist_item_changelog_wrapper(int account_id, char *item_id)
1033 {
1034         _EXTERN_FUNC_ENTER;
1035
1036         retvm_if(item_id == NULL, 0, "item id is NULL !!");
1037
1038         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1039         if (daci_handler == NULL) {
1040                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1041                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1042         }
1043
1044         _EXTERN_FUNC_EXIT;
1045
1046         return da_is_exist_item_changelog(daci_handler, account_id, item_id);
1047 }
1048
1049 sync_agent_da_return_e da_add_last_anchor_internal(sync_agent_da_last_anchor_s * last_anchor)
1050 {
1051         _EXTERN_FUNC_ENTER;
1052
1053         retvm_if(last_anchor == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_last_anchor_s is NULL !!");
1054
1055         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1056         if (daci_handler == NULL) {
1057                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1058                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1059         }
1060
1061         _EXTERN_FUNC_EXIT;
1062
1063         return da_add_last_anchor(daci_handler, last_anchor);
1064 }
1065
1066 sync_agent_da_return_e DACI_Delete_Last_Anchor_By_Account_Id(int account_id)
1067 {
1068         _EXTERN_FUNC_ENTER;
1069
1070         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1071         if (daci_handler == NULL) {
1072                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1073                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1074         }
1075
1076         _EXTERN_FUNC_EXIT;
1077
1078         return da_delete_last_anchor_by_account_id(daci_handler, account_id);
1079 }
1080
1081 sync_agent_da_return_e DACI_Delete_Last_Anchor_By_Item_Type_Id(int account_id, int item_type_id)
1082 {
1083         _EXTERN_FUNC_ENTER;
1084
1085         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1086         if (daci_handler == NULL) {
1087                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1088                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1089         }
1090
1091         _EXTERN_FUNC_EXIT;
1092
1093         return da_delete_last_anchor_by_item_type_id(daci_handler, account_id, item_type_id);
1094 }
1095
1096 sync_agent_da_return_e da_set_last_anchor_internal(sync_agent_da_last_anchor_s * last_anchor)
1097 {
1098         _EXTERN_FUNC_ENTER;
1099
1100         retvm_if(last_anchor == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_last_anchor_s is NULL !!");
1101
1102         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1103         if (daci_handler == NULL) {
1104                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1105                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1106         }
1107
1108         _EXTERN_FUNC_EXIT;
1109
1110         return da_set_last_anchor(daci_handler, last_anchor);
1111 }
1112
1113 sync_agent_da_last_anchor_s *DACI_Get_Last_Anchor_By_Account_Id(int account_id, int *count)
1114 {
1115         _EXTERN_FUNC_ENTER;
1116
1117         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1118         if (daci_handler == NULL) {
1119                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1120                 return NULL;
1121         }
1122
1123         _EXTERN_FUNC_EXIT;
1124
1125         return da_get_last_anchor_by_account_id(daci_handler, account_id, count);
1126 }
1127
1128 sync_agent_da_last_anchor_s *da_get_last_anchor_by_item_type_id_internal(int account_id, int item_type_id, int *count)
1129 {
1130         _EXTERN_FUNC_ENTER;
1131
1132         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1133         if (daci_handler == NULL) {
1134                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1135                 return NULL;
1136         }
1137
1138         _EXTERN_FUNC_EXIT;
1139
1140         return da_get_last_anchor_by_item_type_id(daci_handler, account_id, item_type_id, count);
1141 }
1142
1143 int DACI_IsExist_Last_Anchor(int accountId, int item_type_id)
1144 {
1145         _EXTERN_FUNC_ENTER;
1146
1147         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1148         if (daci_handler == NULL) {
1149                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1150                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1151         }
1152
1153         _EXTERN_FUNC_EXIT;
1154
1155         return da_is_exist_last_anchor(daci_handler, accountId, item_type_id);
1156 }
1157
1158 sync_agent_da_return_e da_add_mapping_internal(sync_agent_da_mapping_s * mapping)
1159 {
1160         _EXTERN_FUNC_ENTER;
1161
1162         retvm_if(mapping == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_mapping_s is NULL !!");
1163
1164         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1165         if (daci_handler == NULL) {
1166                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1167                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1168         }
1169
1170         _EXTERN_FUNC_EXIT;
1171
1172         return da_add_mapping(daci_handler, mapping);
1173 }
1174
1175 sync_agent_da_return_e da_delete_mapping_by_account_id_internal(int account_id)
1176 {
1177         _EXTERN_FUNC_ENTER;
1178
1179         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1180         if (daci_handler == NULL) {
1181                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1182                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1183         }
1184
1185         _EXTERN_FUNC_EXIT;
1186
1187         return da_delete_mapping_by_account_id(daci_handler, account_id);
1188 }
1189
1190 sync_agent_da_return_e da_delete_mapping_by_luid_internal(int account_id, char *luid)
1191 {
1192         _EXTERN_FUNC_ENTER;
1193
1194         retvm_if(luid == NULL, SYNC_AGENT_DA_ERRORS, "luid is NULL !!");
1195
1196         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1197         if (daci_handler == NULL) {
1198                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1199                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1200         }
1201
1202         _EXTERN_FUNC_EXIT;
1203
1204         return da_delete_mapping_by_luid(daci_handler, account_id, luid);
1205 }
1206
1207 sync_agent_da_mapping_s *da_get_mapping_by_account_id_internal(int account_id, int *count)
1208 {
1209         _EXTERN_FUNC_ENTER;
1210
1211         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1212         if (daci_handler == NULL) {
1213                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1214                 return NULL;
1215         }
1216
1217         _EXTERN_FUNC_EXIT;
1218
1219         return da_get_mapping_by_account_id(daci_handler, account_id, count);
1220 }
1221
1222 char *da_get_mapping_guid_internal(int account_id, char *luid)
1223 {
1224         _EXTERN_FUNC_ENTER;
1225
1226         retvm_if(luid == NULL, NULL, "luid is NULL !!");
1227
1228         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1229         if (daci_handler == NULL) {
1230                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1231                 return NULL;
1232         }
1233
1234         _EXTERN_FUNC_EXIT;
1235
1236         return da_get_mapping_guid(daci_handler, account_id, luid);
1237 }
1238
1239 int DACI_IsExist_Mapping_By_Luid(int account_id, char *luid)
1240 {
1241         _EXTERN_FUNC_ENTER;
1242
1243         retvm_if(luid == NULL, 0, "luid is NULL !!");
1244
1245         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1246         if (daci_handler == NULL) {
1247                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1248                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1249         }
1250
1251         _EXTERN_FUNC_EXIT;
1252
1253         return da_is_exist_mapping_by_luid(daci_handler, account_id, luid);
1254 }
1255
1256 sync_agent_da_return_e da_add_id_provider_wrapper(sync_agent_da_id_provider_s * id_provider)
1257 {
1258         _EXTERN_FUNC_ENTER;
1259
1260         retvm_if(id_provider == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_id_provider_s is NULL !!");
1261
1262         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1263         if (daci_handler == NULL) {
1264                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1265                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1266         }
1267
1268         _EXTERN_FUNC_EXIT;
1269
1270         return da_add_id_provider(daci_handler, id_provider);
1271 }
1272
1273 sync_agent_da_return_e da_get_id_provider_wrapper(unsigned int id_provider_code, sync_agent_da_id_provider_s ** id_provider)
1274 {
1275         _EXTERN_FUNC_ENTER;
1276
1277         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1278         if (daci_handler == NULL) {
1279                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1280                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1281         }
1282
1283         _EXTERN_FUNC_EXIT;
1284
1285         return da_get_id_provider(daci_handler, id_provider_code, id_provider);
1286 }
1287
1288 sync_agent_da_return_e da_update_id_provider_wrapper(sync_agent_da_id_provider_s * id_provider)
1289 {
1290         _EXTERN_FUNC_ENTER;
1291
1292         retvm_if(id_provider == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_id_provider_s is NULL !!");
1293
1294         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1295         if (daci_handler == NULL) {
1296                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1297                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1298         }
1299
1300         _EXTERN_FUNC_EXIT;
1301
1302         return da_update_id_provider(daci_handler, id_provider);
1303 }
1304
1305 sync_agent_da_return_e da_add_id_page_wrapper(sync_agent_da_id_page_s * id_page, unsigned int page_byte_size)
1306 {
1307         _EXTERN_FUNC_ENTER;
1308
1309         retvm_if(id_page == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_id_page_s is NULL !!");
1310
1311         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1312         if (daci_handler == NULL) {
1313                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1314                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1315         }
1316
1317         _EXTERN_FUNC_EXIT;
1318
1319         return da_add_id_page(daci_handler, id_page, page_byte_size);
1320 }
1321
1322 sync_agent_da_return_e da_delete_id_page_wrapper(unsigned int id_provider_code, unsigned int page_index)
1323 {
1324         _EXTERN_FUNC_ENTER;
1325
1326         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1327         if (daci_handler == NULL) {
1328                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1329                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1330         }
1331
1332         _EXTERN_FUNC_EXIT;
1333
1334         return da_delete_id_page(daci_handler, id_provider_code, page_index);
1335 }
1336
1337 sync_agent_da_return_e da_get_id_page_wrapper(unsigned int id_provider_code, unsigned int page_index, char **page_bit)
1338 {
1339         _EXTERN_FUNC_ENTER;
1340
1341         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1342         if (daci_handler == NULL) {
1343                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1344                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1345         }
1346
1347         _EXTERN_FUNC_EXIT;
1348
1349         return da_get_id_page(daci_handler, id_provider_code, page_index, page_bit);
1350 }
1351
1352 sync_agent_da_return_e da_get_id_page_index_wrapper(unsigned int id_provider_code, int *count)
1353 {
1354         _EXTERN_FUNC_ENTER;
1355
1356         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1357         if (daci_handler == NULL) {
1358                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1359                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1360         }
1361
1362         _EXTERN_FUNC_EXIT;
1363
1364         return da_get_id_page_index(daci_handler, id_provider_code, count);
1365 }
1366
1367 sync_agent_da_return_e da_update_id_page_wrapper(sync_agent_da_id_page_s * id_page, unsigned int page_byte_size)
1368 {
1369         _EXTERN_FUNC_ENTER;
1370
1371         retvm_if(id_page == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_id_page_s is NULL !!");
1372
1373         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
1374         if (daci_handler == NULL) {
1375                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
1376                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1377         }
1378
1379         _EXTERN_FUNC_EXIT;
1380
1381         return da_update_id_page(daci_handler, id_page, page_byte_size);
1382 }
1383
1384 /*
1385  * ==================================
1386  * Data connector module internal API
1387  * ==================================
1388  */
1389 sync_agent_da_return_e da_add_agent_handler(unsigned int key, SYNC_AGENT_DA_HANDLER * handler)
1390 {
1391         _EXTERN_FUNC_ENTER;
1392
1393         retvm_if(handler == NULL, SYNC_AGENT_DA_ERR_DB_HANDLER_MGR, "SYNC_AGENT_DA_HANDLER is NULL !!");
1394
1395         if (agent_db_handler_mgr == NULL || agent_db_handler_mgr->daci_handlerTable_mutex == NULL) {
1396                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1397         }
1398
1399         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1400
1401         unsigned int *key_copy = (unsigned int *)malloc(sizeof(unsigned int));
1402         if (key_copy == NULL)
1403                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1404
1405         *key_copy = key;
1406
1407         pthread_mutex_lock(agent_db_handler_mgr->daci_handlerTable_mutex);
1408         if (agent_db_handler_mgr->daci_handlerTable == NULL) {
1409                 ret = __alloc_agent_dc_handler_table();
1410                 if (ret != SYNC_AGENT_DA_SUCCESS)
1411                         goto addagentHandler;
1412         }
1413
1414         /* insert to handler */
1415         _DEBUG_INFO("[%s] Key  =  %d, Handler  =  %p  !\n", __func__, key, handler);
1416         g_hash_table_insert(agent_db_handler_mgr->daci_handlerTable, key_copy, handler);
1417
1418 #ifdef DC_PRINT
1419         /* For test log */
1420         __print_agentDBHashTableLog();
1421 #endif
1422         pthread_mutex_unlock(agent_db_handler_mgr->daci_handlerTable_mutex);
1423         _EXTERN_FUNC_EXIT;
1424         return ret;
1425
1426  addagentHandler:
1427         pthread_mutex_unlock(agent_db_handler_mgr->daci_handlerTable_mutex);
1428         if(key_copy != NULL) {
1429                 free(key_copy);
1430         }
1431         _EXTERN_FUNC_EXIT;
1432         return ret;
1433 }
1434
1435 sync_agent_da_return_e da_remove_agent_handler(unsigned int key)
1436 {
1437         _EXTERN_FUNC_ENTER;
1438
1439         if (agent_db_handler_mgr == NULL || agent_db_handler_mgr->daci_handlerTable_mutex == NULL || agent_db_handler_mgr->daci_handlerTable == NULL) {
1440                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1441         }
1442
1443         /* remove the handler to hash table */
1444         pthread_mutex_lock(agent_db_handler_mgr->daci_handlerTable_mutex);
1445         int is_success = g_hash_table_remove(agent_db_handler_mgr->daci_handlerTable, &key);
1446         pthread_mutex_unlock(agent_db_handler_mgr->daci_handlerTable_mutex);
1447
1448 #ifdef DC_PRINT
1449         /* for test log */
1450         __print_agentDBHashTableLog();
1451 #endif
1452
1453         _EXTERN_FUNC_EXIT;
1454
1455         if (is_success == true)
1456                 return SYNC_AGENT_DA_SUCCESS;
1457
1458         return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1459 }
1460
1461 SYNC_AGENT_DA_HANDLER *da_get_agent_handler(unsigned int key)
1462 {
1463         _EXTERN_FUNC_ENTER;
1464
1465         if (agent_db_handler_mgr == NULL || agent_db_handler_mgr->daci_handlerTable_mutex == NULL || agent_db_handler_mgr->daci_handlerTable == NULL) {
1466                 _DEBUG_INFO("[%s] SYNC_AGENT_DA_ERR_DB_HANDLER_MGR !\n", __func__);
1467                 return NULL;
1468         }
1469
1470         /* get the handler to hash table */
1471         pthread_mutex_lock(agent_db_handler_mgr->daci_handlerTable_mutex);
1472         SYNC_AGENT_DA_HANDLER *pHandler = g_hash_table_lookup(agent_db_handler_mgr->daci_handlerTable, &key);
1473         pthread_mutex_unlock(agent_db_handler_mgr->daci_handlerTable_mutex);
1474
1475 #ifdef DC_PRINT
1476         if (pHandler != NULL) {
1477                 _DEBUG_INFO("[%s] ######### > Value Search Success(key = %d, handler = %p)\n", __func__, key, pHandler);
1478         } else {
1479                 _DEBUG_INFO("[%s] ######### > Value Search Fail(key = %d, handler = %p)\n", __func__, key, pHandler);
1480         }
1481 #endif
1482
1483         _EXTERN_FUNC_EXIT;
1484
1485         return pHandler;
1486 }
1487
1488 /* static function implementation */
1489 static sync_agent_da_return_e __alloc_agent_dc_handler_table(void)
1490 {
1491         _INNER_FUNC_ENTER;
1492
1493         if (agent_db_handler_mgr != NULL) {
1494                 agent_db_handler_mgr->daci_handlerTable = g_hash_table_new_full(g_int_hash, g_int_equal, ___destory_agent_db_hashtable_key, ___destroy_agent_db_hashtable_value);
1495                 if (agent_db_handler_mgr->daci_handlerTable == NULL) {
1496                         _DEBUG_VERBOSE("[%s] Not Create agent dc handler hash table \n", __func__);
1497                         return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1498                 } else {
1499                         _DEBUG_VERBOSE("[%SYNC_AGENT_DA_ERR_DB_HANDLER_MGRent dc handler hash table \n", __func__);
1500                 }
1501         }
1502
1503         _INNER_FUNC_EXIT;
1504
1505         return SYNC_AGENT_DA_SUCCESS;
1506 }
1507
1508 static sync_agent_da_return_e __alloc_agent_dc_handler_table_mutex()
1509 {
1510         _INNER_FUNC_ENTER;
1511
1512         if (agent_db_handler_mgr != NULL) {
1513
1514                 agent_db_handler_mgr->daci_handlerTable_mutex = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));
1515                 if (agent_db_handler_mgr->daci_handlerTable_mutex == NULL) {
1516                         _DEBUG_VERBOSE("[%s] Not Create agent dc handler hash table mutex \n", __func__);
1517                         return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1518                 } else {
1519
1520                         if (0 != pthread_mutex_init(agent_db_handler_mgr->daci_handlerTable_mutex, 0)) {
1521                                 _DEBUG_VERBOSE("[%s] Not init agent dc handler hash table mutex\n", __func__);
1522                                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1523                         }
1524                         _DEBUG_VERBOSE("[%s] Init agent dc handler hash table mutex\n", __func__);
1525                 }
1526         }
1527
1528         _INNER_FUNC_EXIT;
1529
1530         return SYNC_AGENT_DA_SUCCESS;
1531 }
1532
1533 static sync_agent_da_return_e _free_agent_dc_handler_table(void)
1534 {
1535         _INNER_FUNC_ENTER;
1536
1537         if (agent_db_handler_mgr != NULL && agent_db_handler_mgr->daci_handlerTable != NULL) {
1538                 g_hash_table_destroy(agent_db_handler_mgr->daci_handlerTable);
1539                 _DEBUG_TRACE("[%s] daci_handlerTable free success !\n", __func__);
1540                 agent_db_handler_mgr->daci_handlerTable = 0;;
1541         }
1542
1543         _INNER_FUNC_EXIT;
1544
1545         return SYNC_AGENT_DA_SUCCESS;
1546 }
1547
1548 static sync_agent_da_return_e _free_agent_dc_handler_table_mutex(void)
1549 {
1550         _INNER_FUNC_ENTER;
1551
1552         if (agent_db_handler_mgr != NULL && agent_db_handler_mgr->daci_handlerTable_mutex != NULL) {
1553
1554                 int ret = pthread_mutex_destroy(agent_db_handler_mgr->daci_handlerTable_mutex);
1555                 if (ret != 0) {
1556                         _DEBUG_TRACE("[%s] daci_handlerTable_mutex free error !\n", __func__);
1557                         return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1558                 } else {
1559                         free(agent_db_handler_mgr->daci_handlerTable_mutex);
1560                         agent_db_handler_mgr->daci_handlerTable_mutex = 0;
1561                         _DEBUG_TRACE("[%s] daci_handlerTable_mutex free success !\n", __func__);
1562                 }
1563         }
1564
1565         _INNER_FUNC_EXIT;
1566
1567         return SYNC_AGENT_DA_SUCCESS;
1568 }
1569
1570 static sync_agent_da_return_e _create_agent_db_handler_mgr_info(void)
1571 {
1572         _INNER_FUNC_ENTER;
1573
1574         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1575
1576         if (agent_db_handler_mgr != NULL) {
1577
1578                 /* alloc agent db hander hash table */
1579                 ret = __alloc_agent_dc_handler_table();
1580                 if (ret != SYNC_AGENT_DA_SUCCESS)
1581                         goto allocAgentDBHandlerMgrInfoErr;
1582
1583                 /* alloc agent db hander hash table mutex */
1584                 ret = __alloc_agent_dc_handler_table_mutex();
1585                 if (ret != SYNC_AGENT_DA_SUCCESS)
1586                         goto allocAgentDBHandlerMgrInfoErr;
1587         }
1588
1589         _INNER_FUNC_EXIT;
1590
1591         return SYNC_AGENT_DA_SUCCESS;
1592
1593  allocAgentDBHandlerMgrInfoErr:
1594         da_free_agentdb_handler_mgr();
1595         return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
1596 }
1597
1598 static void ___destroy_agent_db_hashtable_value(void *handler)
1599 {
1600         _INNER_FUNC_ENTER;
1601
1602         retm_if(handler == NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
1603
1604         _DEBUG_VERBOSE("[%s] start \n", __func__);
1605         if (handler != NULL) {
1606                 da_close_Agent((SYNC_AGENT_DA_HANDLER *) handler);
1607         }
1608         _DEBUG_VERBOSE("[%s] end \n", __func__);
1609
1610         _INNER_FUNC_EXIT;
1611 }
1612
1613 static void ___destory_agent_db_hashtable_key(void *key)
1614 {
1615         _INNER_FUNC_ENTER;
1616
1617         retm_if(key == NULL, "key is NULL !!");
1618
1619         _DEBUG_VERBOSE("[%s] start \n", __func__);
1620         if (key != NULL)
1621                 free(key);
1622         _DEBUG_VERBOSE("[%s] end \n", __func__);
1623
1624         _INNER_FUNC_EXIT;
1625 }